For example, the following creates a DataSource, and waits for a connection callback. var dataSource = new DataSource('mysql', { database: 'myapp_test' }); dataSource.define(...); dataSource.on('connected', function () { // work with database });

Define readonly property on object

Define a hidden property

Attach an existing model to a data source.

Drop each model table and re-create. This method applies only to SQL connectors.

Update existing database tables. This method make sense only for sql connectors.

Return column metadata for specified modelName and propertyName

Return column name for specified modelName and propertyName

Return column names for specified modelName

Define a model class. Simple example:

var User = dataSource.createModel('User', {
    email: String,
    password: String,
    birthDate: Date,
    activated: Boolean
});

More advanced example

var User = dataSource.createModel('User', {
    email: { type: String, limit: 150, index: true },
    password: { type: String, limit: 50 },
    birthDate: Date,
    registrationDate: {type: Date, default: function () { return new Date }},
    activated: { type: Boolean, default: false }
});

You can also define an ACL when you create a new data source with the DataSource.create() method. For example:

var Customer = ds.createModel('Customer', {
      name: {
        type: String,
        acls: [
          {principalType: ACL.USER, principalId: 'u001', accessType: ACL.WRITE, permission: ACL.DENY},
          {principalType: ACL.USER, principalId: 'u001', accessType: ACL.ALL, permission: ACL.ALLOW}
        ]
      }
    }, {
      acls: [
        {principalType: ACL.USER, principalId: 'u001', accessType: ACL.ALL, permission: ACL.ALLOW}
      ]
    });

Define foreign key to another model

Define an operation to the data source

Define single property named prop on model

Disable remote access to a data source operation. Each connector has its own set of set enabled and disabled operations. To list the operations, call dataSource.operations().

var oracle = loopback.createDataSource({
  connector: require('loopback-connector-oracle'),
  host: '...',
  ...
});
oracle.disableRemote('destroyAll');

Notes:

• Disabled operations will not be added to attached models.
  • Disabling the remoting for a method only affects client access (it will still be available from server models).
  • Data sources must enable / disable operations before attaching or creating models.

Close database connection

Discover and build models from the given owner/modelName

options

 {String} owner/schema - The database owner/schema name
 {Boolean} relations - If relations (primary key/foreign key) are navigated
 {Boolean} all - If all owners are included
 {Boolean} views - If views are included

Discover and build models from the given owner/modelName synchronously

options

 {String} owner/schema - The database owner/schema name
 {Boolean} relations - If relations (primary key/foreign key) are navigated
 {Boolean} all - If all owners are included
 {Boolean} views - If views are included

Retrieves a description of the foreign key columns that reference the given table's primary key columns (the foreign keys exported by a table). They are ordered by fkTableOwner, fkTableName, and keySeq.

foreign key description

 fkOwner {String} => foreign key table schema (may be null)
 fkName {String} => foreign key name (may be null)
 fkTableName {String} => foreign key table name
 fkColumnName {String} => foreign key column name
 keySeq {Number} => sequence number within a foreign key( a value of 1 represents the first column of the foreign key, a value of 2 would represent the second column within the foreign key).
 pkOwner {String} => primary key table schema being imported (may be null)
 pkName {String} => primary key name (may be null)
 pkTableName {String} => primary key table name being imported
 pkColumnName {String} => primary key column name being imported

options

 owner/schema The database owner/schema

The synchronous version of discoverExportedForeignKeys

Discover foreign keys for a given owner/modelName

foreign key description

 fkOwner String => foreign key table schema (may be null)
 fkName String => foreign key name (may be null)
 fkTableName String => foreign key table name
 fkColumnName String => foreign key column name
 keySeq Number => sequence number within a foreign key( a value of 1 represents the first column of the foreign key, a value of 2 would represent the second column within the foreign key).
 pkOwner String => primary key table schema being imported (may be null)
 pkName String => primary key name (may be null)
 pkTableName String => primary key table name being imported
 pkColumnName String => primary key column name being imported

options

 owner/schema The database owner/schema

The synchronous version of discoverForeignKeys

Discover existing database tables. This method returns an array of model objects, including {type, name, onwer}

The synchronous version of discoverModelDefinitions

Discover properties for a given model.

property description:

Options:

• owner/schema The database owner/schema

The synchronous version of discoverModelProperties

Discover primary keys for a given owner/modelName.

Each primary key column description has the following columns:

• owner {String} => table schema (may be null)
• tableName {String} => table name
• columnName {String} => column name
• keySeq {Number} => sequence number within primary key( a value of 1 represents the first column of the primary key, a value of 2 would represent the second column within the primary key).
• pkName {String} => primary key name (may be null)

The owner defaults to current user.

Options:

• owner/schema The database owner/schema

The synchronous version of discoverPrimaryKeys

Discover one schema from the given model without following the relations. Example schema from oracle connector:*

    {
      "name": "Product",
      "options": {
        "idInjection": false,
        "oracle": {
          "schema": "BLACKPOOL",
          "table": "PRODUCT"
        }
      },
      "properties": {
        "id": {
          "type": "String",
          "required": true,
          "length": 20,
          "id": 1,
          "oracle": {
            "columnName": "ID",
            "dataType": "VARCHAR2",
            "dataLength": 20,
            "nullable": "N"
          }
        },
        "name": {
          "type": "String",
          "required": false,
          "length": 64,
          "oracle": {
            "columnName": "NAME",
            "dataType": "VARCHAR2",
            "dataLength": 64,
            "nullable": "Y"
          }
        },
...
        "fireModes": {
          "type": "String",
          "required": false,
          "length": 64,
          "oracle": {
            "columnName": "FIRE_MODES",
            "dataType": "VARCHAR2",
            "dataLength": 64,
            "nullable": "Y"
          }
        }
      }
    }

Discover schema from a given modelName/view

options

 {String} owner/schema - The database owner/schema name
 {Boolean} relations - If relations (primary key/foreign key) are navigated
 {Boolean} all - If all owners are included
 {Boolean} views - If views are included

Discover schema from a given table/view synchronously

options

 {String} owner/schema - The database owner/schema name
 {Boolean} relations - If relations (primary key/foreign key) are navigated
 {Boolean} all - If all owners are included
 {Boolean} views - If views are included

Enable remote access to a data source operation. Each connector has its own set of set remotely enabled and disabled operations. To list the operations, call dataSource.operations().

Freeze dataSource. Behavior depends on connector

See ModelBuilder.getModel

See ModelBuilder.getModelDefinition

Get an operation's metadata.

Get the data source types

Find the ID column name

Find the ID property name

Find the ID property names sorted by the index

Find the id property definition

Check whether migrations needed This method make sense only for sql connectors.

Check if the backend is a relational DB

Mixin DataAccessObject methods.

Return JSON object describing all operations.

Example return value:

{
 find: {
   remoteEnabled: true,
   accepts: [...],
   returns: [...]
   enabled: true
},
 save: {
   remoteEnabled: true,
   prototype: true,
   accepts: [...],
   returns: [...],
   enabled: true
 },
 ...
}

Check if the data source is ready. Returns a Boolean value.

Check the data source supports the specified types.

Return table name for specified modelName

The GeoPoint object represents a physical location.

For example:

var here = new GeoPoint({lat: 10.32424, lng: 5.84978});

Embed a latitude / longitude point in a model.

var CoffeeShop = loopback.createModel('coffee-shop', {
  location: 'GeoPoint'
});

You can query LoopBack models with a GeoPoint property and an attached data source using geo-spatial filters and sorting. For example, the following code finds the three nearest coffee shops.

CoffeeShop.attachTo(oracle);
var here = new GeoPoint({lat: 10.32424, lng: 5.84978});
CoffeeShop.find( {where: {location: {near: here}}, limit:3}, function(err, nearbyShops) {
  console.info(nearbyShops); // [CoffeeShop, ...]
});

Determine the spherical distance between two GeoPoints. Specify units of measurement with the 'type' property in options object. Type can be:

• miles (default)
• radians
• kilometers
• meters
• miles
• feet
• degrees

Determine the spherical distance to the given point. Example:

var here = new GeoPoint({lat: 10, lng: 10});
var there = new GeoPoint({lat: 5, lng: 5});
GeoPoint.distanceBetween(here, there, {type: 'miles'}) // 438

Simple serialization.

Base class for all persistent objects. Provides a common API to access any database connector. This class describes only abstract behavior. Refer to the specific connector (lib/connectors/*.js) for details.

DataAccessObject mixes Inclusion classes methods.

Return count of matched records

Create new instance of Model class, saved in database. The callback function is called with arguments:

• err (null or Error)
• instance (null or Model)

Check whether a model instance exists in database

Find all instances of Model, matched by query make sure you have marked as index: true fields for filter or sort

Find object by id

Find one record, same as all, limited by 1 and return object, not collection

Find one record, same as all, limited by 1 and return object, not collection, if not found, create using data provided as second argument

Destroy all matching records

Delete the record with the specified ID. Aliases are destroyById and deleteById.

Define a scope for the model class. Scopes enable you to specify commonly-used queries that you can reference as method calls on a model.

Update or insert a model instance. updateOrCreate is an alias

Reload object from persistence Requires id member of object to be able to call find

Save instance. If the instance does not have an ID, call create instead. Triggers: validate, save, update or create.

Update a single attribute. Equivalent to updateAttributes({name: value}, cb)

Update saet of attributes. Performs validation before updating.

Model class: base class for all persistent objects.

ModelBaseClass mixes Validatable and Hookable classes methods

Define a property on the model.

Return string representation of class This overrides the default toString() method

Checks is property changed based on current property and initial value

Reset dirty attributes. This method does not perform any database operations; it just resets the object to its initial state.

Convert model instance to a plain JSON object. Returns a canonical object representation (no getters and setters).

ModelBuilder - A builder to define data models.

Register a property for the model class

Introspect the JSON document to build a corresponding model.

Build models from schema definitions

schemas can be one of the following:

1. An array of named schema definition JSON objects
2. A schema definition JSON object
3. A list of property definitions (anonymous)

Define a model class. Simple example:

var User = modelBuilder.define('User', {
    email: String,
    password: String,
    birthDate: Date,
    activated: Boolean
});

More advanced example:

var User = modelBuilder.define('User', {
    email: { type: String, limit: 150, index: true },
    password: { type: String, limit: 50 },
    birthDate: Date,
    registrationDate: {type: Date, default: function () { return new Date }},
    activated: { type: Boolean, default: false }
});

Define single property named propertyName on model

Extend existing model with bunch of properties

Example: Instead of doing amending the content model with competition attributes like this:

    db.defineProperty('Content', 'competitionType', { type: String });
    db.defineProperty('Content', 'expiryDate', { type: Date, index: true });
    db.defineProperty('Content', 'isExpired', { type: Boolean, index: true });

The extendModel() method enables you to extend the content model with competition attributes.

    db.extendModel('Content', {
      competitionType: String,
      expiryDate: { type: Date, index: true },
      isExpired: { type: Boolean, index: true }
    });

Get a model by name.

Get the model definition by name

Get the schema name

Resolve the type string to be a function, for example, 'String' to String. Returns {Function} if the type is resolved

Inclusion - Model mixin.

Enables you to load relations of several objects and optimize numbers of requests.

Examples:

Load all users' posts with only one additional request: User.include(users, 'posts', function() {}); Or User.include(users, ['posts'], function() {});

Load all users posts and passports with two additional requests: User.include(users, ['posts', 'passports'], function() {});

Load all passports owner (users), and all posts of each owner loaded: Passport.include(passports, {owner: 'posts'}, function() {}); Passport.include(passports, {owner: ['posts', 'passports']}); ``` Passport.include(passports, {owner: [{posts: 'images'}, 'passports']});

Relations class

Add the target model instance to the 'hasMany' relation

Declare "belongsTo" relation.

Examples

Suppose the model Post has a belongsTo relationship with User (the author of the post). You could declare it this way:

Post.belongsTo(User, {as: 'author', foreignKey: 'userId'});

When a post is loaded, you can load the related author with:

post.author(function(err, user) {
    // the user variable is your user object
});

The related object is cached, so if later you try to get again the author, no additional request will be made. But there is an optional boolean parameter in first position that set whether or not you want to reload the cache:

post.author(true, function(err, user) {
    // The user is reloaded, even if it was already cached.
});

This optional parameter default value is false, so the related object will be loaded from cache if available.

Many-to-many relation

For example, this creates connection model 'PostTag':

Post.hasAndBelongsToMany('tags');

Declare "hasMany" relation. Example: User.hasMany(Post, {as: 'posts', foreignKey: 'authorId'});

Find the relation by foreign key

Remove the target model instance from the 'hasMany' relation

Validation mixins for LoopBack models.

This class provides methods that add validation cababilities to models. Each of this validations run when obj.isValid() method called.

Each configurator can accept n params (n-1 field names and one config). Config is {Object} depends on specific validation, but all of them has one common part: message member. It can be just string, when only one situation possible, e.g. Post.validatesPresenceOf('title', { message: 'can not be blank' });

In more complicated cases it can be {Hash} of messages (for each case): User.validatesLengthOf('password', { min: 6, max: 20, message: {min: 'too short', max: 'too long'}});

Return true when v is undefined, blank array, null or empty string otherwise returns false

Custom validator

Exclusion validator

Format validator

Inclusion validator

Length validator

Numericality validator

Presence validator

Uniqueness validator

This method performs validation, triggers validation hooks. Before validation obj.errors collection cleaned. Each validation can add errors to obj.errors collection. If collection is not blank, validation failed.