# Class: Model ‹T

Constructor to build a model instance based on a schema and other options. Provides methods to handle documents of the current collection in the database

example

import { connect, model } from "ottoman";
connect("couchbase://localhost/travel-sample@admin:password");

// Create an `User` model
const User = model('User', { name: String });

# Type parameters

T

# Hierarchy

# Constructors

# constructor

+ new Model(data: unknown, options: object): Model

Overrides void

Creates a document from this model. Implements schema validations, defaults, methods, static and hooks

Parameters:

data: unknown

Default value options: object= {}

Name Type
skip? string[]
strategy? CAST_STRATEGY
strict? undefined | false | true

Returns: Model

# Methods

# _applyData

_applyData(data: any, strategy?: CAST_STRATEGY): void

Inherited from Document._applyData

Allows to easily apply data from an object to current document.

example

const user = new User({name: "John Doe"});

user._applyData({name: "Jane Doe"});
console.log(user) // {name: "Jane Doe"}

Parameters:

Name Type
data any
strategy? CAST_STRATEGY

Returns: void


# _depopulate

_depopulate(fieldsName: string | string[]): this

Inherited from Document._depopulate

Reverts population. Switches back document reference

example To get in context about the Card and Issue Models see the populate example.

const card = await Card.findById(cardId);
console.log(card.issues); // ['issueId']

await card._populate('issues')
console.log(card.issues); // [{id: 'issueId', title: 'Broken card'}]

card._depopulate('issues')
console.log(card.issues); // ['issueId']

Parameters:

Name Type
fieldsName string | string[]

Returns: this


# _getId

_getId(): string

Inherited from Document._getId

Returns id value, useful when working with dynamic ID_KEY

example

  console.log(user._getId()); // 'userId'
  console.log(user.id); // 'userId'

Returns: string


# _getIdField

_getIdField(): string

Inherited from Document._getIdField

Returns id key

Returns: string


# _populate

_populate(fieldsName: string | string[], deep: number): Promise‹this›

Inherited from Document._populate

Allows to load document references

example Getting context to explain populate.

const CardSchema = new Schema({
  number: String,
  zipCode: String,
  issues: [{ type: IssueSchema, ref: 'Issue' }],
});

const IssueSchema = new Schema({
  title: String,
  description: String,
});

const Card = model('Card', CardSchema);
const Issue = model('Issue', CardSchema);

const issue = await Issue.create({ title: 'Broken card' });

const card = await Card.create({
  cardNumber: '4242 4242 4242 4242',
  zipCode: '42424',
  issues: [issue.id],
});

Now we will see how the _populate methods works.

const card = await Card.findById(cardId);
console.log(card.issues); // ['issueId']

await card.populate('issues')
console.log(card.issues); // [{id: 'issueId', title: 'Broken card'}]

Parameters:

Name Type Default
fieldsName string | string[] -
deep number 1

Returns: Promise‹this›


# _populated

_populated(fieldName: string): boolean

Inherited from Document._populated

Allows to know if a document field is populated

example To get in context about the Card and Issue Models see the populate example.

const card = await Card.findById(cardId);
console.log(card.issues); // ['issueId']
console.log(card._populated('issues')); // false

await card._populate('issues')
console.log(card.issues); // [{id: 'issueId', title: 'Broken card'}]
console.log(card._populated('issues')); // true

Parameters:

Name Type
fieldName string

Returns: boolean


# _validate

_validate(): any

Inherited from Document._validate

Runs schema validations over current document

example

const user = new User({name: "John Doe"});

try {
  await user._validate()
} catch(errors) {
  console.log(errors)
}

Returns: any


# remove

remove(options: object): Promise‹any›

Inherited from Document.remove

Removes the document from database

example

const user = User.findById('userId')

await user.remove();

Parameters:

Name Type Default
options object {}

Returns: Promise‹any›


# save

save(onlyCreate: boolean): Promise‹this›

Inherited from Document.save

Saves or Updates the document

example

const user = new User({name: "John Doe"}); //user document created, it's not saved yet

await user.save(); // user saved into the DB

You also can force save function to only create new Documents by passing true as argument
await user.save(true); // ensure to execute a insert operation

Parameters:

Name Type Default
onlyCreate boolean false

Returns: Promise‹this›


# toJSON

toJSON(): this

Inherited from Document.toJSON

Returns a Javascript object to be serialized to JSON

Returns: this


# toObject

toObject(): this

Inherited from Document.toObject

Returns a Javascript object with data

Returns: this


# Static count

count(filter: LogicalWhereExpr, options: CountOptions): Promise‹any›

Returns the number of documents that match the query

example

User.count({name: {$like: "%Jane%"}})

Parameters:

Name Type Default
filter LogicalWhereExpr {}
options CountOptions {}

Returns: Promise‹any›


# Static create

create(doc: Record‹string, any›): Promise‹any›

Allows to create a new document

example

const user = await User.create({name: "John Doe"});

Parameters:

Name Type
doc Record‹string, any›

Returns: Promise‹any›


# Static createMany

createMany(docs: Record‹string, any›[] | Record‹string, any›): Promise‹ManyQueryResponse

Allows to create many document at once.

The response status will be SUCCESS as long as no error occurs, otherwise it will be FAILURE.

example

const user = await User.createMany([{name: "John Doe"}, {name: "Jane Doe"}]);

Parameters:

Name Type
docs Record‹string, any›[] | Record‹string, any›

Returns: Promise‹ManyQueryResponse


# Static find

find(filter: LogicalWhereExpr, options: FindOptions): Promise‹any›

Finds documents.

example

User.find({name: "Jane"})
// will return a list of all users with the name "Jane"

User.find({name: "Jane"}, {limit: 10})
// will return a list of all users with the name "Jane" and limited to 10 items

const filter = {
$or: [{ price: { $gt: 'amount_val', $isNotNull: true } }, { auto: { $gt: 10 } }, { amount: 10 }],
$and: [
  { price2: { $gt: 1.99, $isNotNull: true } },
  { $or: [{ price3: { $gt: 1.99, $isNotNull: true } }, { id: '20' }] },
 ],
};
User.find(filter)
// Returns a list of the elements that match the applied filters.

Parameters:

Name Type Default
filter LogicalWhereExpr {}
options FindOptions {}

Returns: Promise‹any›


# Static findById

findById(id: string, options: FindByIdOptions): Promise‹any›

Allows to retrieve a document by id

example

User.findById('userId')
// will return the user document with the current id.

User.findById('userId', {select: 'name, cards', populate: 'cards'})
// will return the user document with the current id only with the fields name and cards populated

Parameters:

Name Type Default
id string -
options FindByIdOptions {}

Returns: Promise‹any›


# Static findOne

findOne(filter: LogicalWhereExpr, options: FindOptions): Promise‹any›

Finds a document.

example

User.findOne({name: "Jane"})
// will return a document with a User with the name "Jane" or null in case of not finding it

Parameters:

Name Type Default
filter LogicalWhereExpr {}
options FindOptions {}

Returns: Promise‹any›


# Static findOneAndUpdate

findOneAndUpdate(filter: LogicalWhereExpr, doc: Record‹string, unknown›, options: FindOneAndUpdateOption): Promise‹any›

Finds a document that matches the conditions of the collection and updates it.

example

const result = await User.findOneAndUpdate({ name: { $like: '%John Doe%' } }, { name: "John" })

Parameters:

Name Type Default Description
filter LogicalWhereExpr {} Filter Condition Where Expression
doc Record‹string, unknown› - Values for the fields to update.
options FindOneAndUpdateOption {} (/interfaces/findoneandupdateoption.html) Return a Model if at least one item matching the condition, otherwise an exception (opens new window) will be thrown. If options.new is true return the document after update otherwise by default return the document before update. If options.upsert is true insert a document if the document does not exist.

Returns: Promise‹any›


# Static fromData

fromData(data: any): Model‹any›

Creates a document from the given data Result will be the same that -> new Model(data)

example

const user = User.fromData({name: "John Doe"});
// we create a `user` document, but it isn't saved yet.

await user.save();
// Now user was persisted to DB

Parameters:

Name Type
data any

Returns: Model‹any›


# Static removeById

removeById(id: string): Promise‹any›

Allows to remove a document

example

const result = await User.removeById('userId');

Parameters:

Name Type
id string

Returns: Promise‹any›


# Static removeMany

removeMany(filter: LogicalWhereExpr, options: FindOptions): Promise‹ManyQueryResponse

Deletes all of the documents that match conditions from the collection.

The response status will be SUCCESS as long as no error occurs, otherwise it will be FAILURE.

example

const result = await User.removeMany({ name: { $like: '%John Doe%' } })

Parameters:

Name Type Default Description
filter LogicalWhereExpr {} Filter Condition Where Expression
options FindOptions {} (/classes/findoptions.html#class-findoptions)

Returns: Promise‹ManyQueryResponse


# Static replaceById

replaceById(id: string, data: any): Promise‹any›

Same as updateById,except replace the existing document with the given document.

example

const user = await User.replaceById('userId', {name: "John Doe"});

throws DocumentNotFoundError if the document not exist.

Parameters:

Name Type
id string
data any

Returns: Promise‹any›


# Static updateById

updateById(id: string, data: any): Promise‹any›

Allows to update a document

example

const user = await User.updateById('userId', {name: "John Doe"});

Parameters:

Name Type
id string
data any

Returns: Promise‹any›


# Static updateMany

updateMany(filter: LogicalWhereExpr, doc: Record‹string, unknown›, options: UpdateManyOptions): Promise‹ManyQueryResponse

Update all of the documents that match conditions from the collection.

The response status will be SUCCESS as long as no error occurs, otherwise it will be FAILURE.

example

const result = await User.updateMany({ name: { $like: '%John Doe%' } })

Parameters:

Name Type Default Description
filter LogicalWhereExpr {} Filter Condition Where Expression
doc Record‹string, unknown› - Values for the fields to update.
options UpdateManyOptions {} (/interfaces/updatemanyoptions.html)

Returns: Promise‹ManyQueryResponse