The App object represents a Loopback application.

The App object extends Express and supports Express / Connect middleware. See Express documentation for details.

var loopback = require('loopback');
var app = loopback();

app.get('/', function(req, res){
  res.send('hello world');
});

app.listen(3000);

Register a connector.

When a new data-source is being added via app.dataSource, the connector name is looked up in the registered connectors first.

Connectors are required to be explicitly registered only for applications using browserify, because browserify does not support dynamic require, which is used by LoopBack to automatically load the connector module.

Define a DataSource.

Enable app wide authentication.

Listen for connections and update the configured port.

When there are no parameters or there is only one callback parameter, the server will listen on app.get('host') and app.get('port').

// listen on host/port configured in app config
app.listen();

Otherwise all arguments are forwarded to http.Server.listen.

// listen on the specified port and all hosts, ignore app config
app.listen(80);

The function also installs a listening callback that calls app.set('port') with the value returned by server.address().port. This way the port param contains always the real port number, even when listen was called with port number 0.

Attach a model to the app. The Model will be available on the app.models object.

// Attach an existing model
var User = loopback.User;
app.model(User);

// Attach an existing model, alter some aspects of the model
var User = loopback.User;
app.model(User, { dataSource: 'db' });

// LoopBack 1.x way: create and attach a new model (deprecated)
var Widget = app.model('Widget', {
  dataSource: 'db',
  properties: {
    name: 'string'
  }
});

Get the models exported by the app. Returns only models defined using app.model()

There are two ways to access models:

1. Call app.models() to get a list of all models.

var models = app.models();

models.forEach(function (Model) {
 console.log(Model.modelName); // color
});

**2. Use app.model to access a model by name. app.model has properties for all defined models.

The following example illustrates accessing the Product and CustomerReceipt models using the models object.

var loopback = require('loopback');
 var app = loopback();
 app.boot({
  dataSources: {
    db: {connector: 'memory'}
  }
});

app.model('product', {dataSource: 'db'});
app.model('customer-receipt', {dataSource: 'db'});

// available based on the given name
var Product = app.models.Product;

// also available as camelCase
var product = app.models.product;

// multi-word models are avaiable as pascal cased
var CustomerReceipt = app.models.CustomerReceipt;

// also available as camelCase
var customerReceipt = app.models.customerReceipt;

Get all remote objects.

Lazily load a set of remote objects.

NOTE: Calling app.remotes() more than once returns only a single set of remote objects.

Main entry for LoopBack core module. It provides static properties and methods to create models and data sources. The module itself is a function that creates loopback app. For example,

var loopback = require('loopback');
var app = loopback();

Add a remote method to a model.

Create a template helper.

var render = loopback.template('foo.ejs');
var html = render({foo: 'bar'});

True if running in a browser environment; false otherwise.

True if running in a server environment; false otherwise.

Create a named vanilla JavaScript class constructor with an attached set of properties and options.

This function comes with two variants:

• loopback.createModel(name, properties, options)
• loopback.createModel(config)

In the second variant, the parameters name, properties and options are provided in the config object. Any additional config entries are interpreted as options, i.e. the following two configs are identical:

{ name: 'Customer', base: 'User' }
{ name: 'Customer', options: { base: 'User' } }

Example

Create an Author model using the three-parameter variant:

loopback.createModel(
  'Author',
  {
    firstName: 'string',
    lastName: 'string
  },
  {
    relations: {
      books: {
        model: 'Book',
        type: 'hasAndBelongsToMany'
      }
    }
  }
);

Create the same model using a config object:

loopback.createModel({
  name: 'Author',
  properties: {
    firstName: 'string',
    lastName: 'string
  },
  relations: {
    books: {
      model: 'Book',
      type: 'hasAndBelongsToMany'
    }
  }
});

Alter an existing Model class.

Look up a model class by name from all models created by loopback.createModel()

Look up a model class by name from all models created by loopback.createModel(). Throw an error when no such model exists.

Look up a model class by the base model class. The method can be used by LoopBack to find configured models in models.json over the base model.

Create a data source with passing the provided options to the connector.

Get an in-memory data source. Use one if it already exists.

Set the default dataSource for a given type.

Get the default dataSource for a given type.

Attach any model that does not have a dataSource to the default dataSource for the type the Model requests

The base class for all models.

Inheriting from Model

var properties = {...};
var options = {...};
var MyModel = loopback.Model.extend('MyModel', properties, options);

Options

• trackChanges - If true, changes to the model will be tracked. Required for replication.

Events

Event: changed

Emitted after a model has been successfully created, saved, or updated.

MyModel.on('changed', function(inst) {
  console.log('model with id %s has been changed', inst.id);
  // => model with id 1 has been changed
});

Event: deleted

Emitted after an individual model has been deleted.

MyModel.on('deleted', function(inst) {
  console.log('model with id %s has been deleted', inst.id);
  // => model with id 1 has been deleted
});

Event: deletedAll

Emitted after an individual model has been deleted.

MyModel.on('deletedAll', function(where) {
  if(where) {
    console.log('all models where', where, 'have been deleted');
    // => all models where
    // => {price: {gt: 100}}
    // => have been deleted
  }
});

Event: attached

Emitted after a Model has been attached to an app.

Event: dataSourceAttached

Emitted after a Model has been attached to a DataSource.

Check if the given access token can invoke the method

Get the Application the Model is attached to.

Enable remote invocation for the method with the given name.

Extends Model with basic query and CRUD support.

Change Event

Listen for model changes using the change event.

MyPersistedModel.on('changed', function(obj) {
   console.log(obj) // => the changed model
});

Apply an update list.

Note: this is not atomic

Get the changes to a model since a given checkpoint. Provide a filter object to reduce the number of results returned.

Create a checkpoint.

Return count of matched records

Create new instance of Model class, saved in database

Create an update list (for Model.bulkUpdate()) from a delta list (result of Change.diff()).

Get the current checkpoint id.

Get a set of deltas and conflicts since the given checkpoint.

See Change.diff() for details.

Enable the tracking of changes made to the model. Usually for replication.

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 find, limited by 1 and return object, not collection, if not found, create using data provided as second argument

Get the Change model.

Get the id property name of the constructor.

Get the source identifier for this model / dataSource.

Handle a change error. Override this method in a subclassing model to customize change error handling.

Tell loopback that a change to the model with the given id has occurred.

Destroy all matching records

Destroy a record by id

Replicate changes since the given checkpoint to the given target model.

Update multiple instances that match the where clause

Example:

Employee.update({managerId: 'x001'}, {managerId: 'x002'}, function(err) {
    ...
});

Update or insert a model instance

Get the id value for the PersistedModel.

Get the id property name of the constructor.

Determine if the data model is new.

Reload object from persistence

Save instance. When instance haven't id, create method called instead. Triggers: validate, save, update | create

Set the correct id property for the PersistedModel. If a Connector defines a setId method it will be used. Otherwise the default lookup is used. You should override this method to handle complex ids.

Update single attribute

equals to `updateAttributes({name: value}, cb)

Update set of attributes

this method performs validation before updating

Expose models over REST.

For example:

app.use(loopback.rest());

For more information, see Exposing models over a REST API.

Return HTTP response with basic application status information: date the application was started and uptime, in JSON format. For example:

{
 "started": "2014-06-05T00:26:49.750Z",
 "uptime": 9.394
}

Check for an access token in cookies, headers, and query string parameters. This function always checks for the following:

• access_token (params only)
• X-Access-Token (headers only)
• authorization (headers and cookies)

It checks for these values in cookies, headers, and query string parameters in addition to the items specified in the options parameter.

NOTE: This function only checks for signed cookies.

The following example illustrates how to check for an accessToken in a custom cookie, query string parameter and header called foo-auth.

app.use(loopback.token({
  cookies: ['foo-auth'],
  headers: ['foo-auth', 'X-Foo-Auth'],
  params: ['foo-auth', 'foo_auth']
}));

Convert any request not handled so far to a 404 error to be handled by error-handling middleware.

Token based authentication and access control.

Create a cryptographically random access token id.

Find a token for the given ServerRequest.

Validate the token.

Name of the access type - READ/WRITE/EXEC

ALARM - Generate an alarm, in a system dependent way, the access specified in the permissions component of the ACL entry. ALLOW - Explicitly grants access to the resource. AUDIT - Log, in a system dependent way, the access specified in the permissions component of the ACL entry. DENY - Explicitly denies access to the resource.

Type of the principal - Application/User/Role

Id of the principal - such as appId, userId or roleId

A Model for access control meta data.

Check if the request has the permission to access.

Check if the given access token can invoke the method

Check if the given principal is allowed to access the model/property

Calculate the matching score for the given rule and request

Get matching score for the given AccessRequest.

Resource owner grants/delegates permissions to client applications

For a protected resource, does the client application have the authorization from the resource owner (user or system)?

Scope has many resource access entries

Check if the given scope is allowed to access the model/property

production or development mode. It denotes what default APNS servers to be used to send notifications

• true (production mode)
  • push: gateway.push.apple.com:2195
  • feedback: feedback.push.apple.com:2196
• false (development mode, the default)
  • push: gateway.sandbox.push.apple.com:2195
  • feedback: feedback.sandbox.push.apple.com:2196

Manage client applications and organize their users.

Authenticate the application id and key.

matched parameter is one of:

• clientKey
• javaScriptKey
• restApiKey
• windowsKey
• masterKey

Register a new application

Reset keys for a given application by the appId

Reset keys for the application instance

The Email Model.

Properties

• to - String (required)
• from - String (required)
• subject - String (required)
• text - String
• html - String

Send an email with the given options.

Example Options:

{
  from: "Fred Foo <foo@blurdybloop.com>", // sender address
  to: "bar@blurdybloop.com, baz@blurdybloop.com", // list of receivers
  subject: "Hello", // Subject line
  text: "Hello world", // plaintext body
  html: "<b>Hello world</b>" // html body
}

See https://github.com/andris9/Nodemailer for other supported options.

The Role Model

List roles for a given principal

Check if the user id is authenticated

Check if a given principal is in the role

Check if a given userId is the owner the model instance

Add custom handler for roles

The RoleMapping model extends from the built in loopback.Model type.

Get the application principal

Get the child role principal

Get the user principal

Extends from the built in loopback.Model type.

Default User ACLs.

• DENY EVERYONE *
• ALLOW EVERYONE create
• ALLOW OWNER deleteById
• ALLOW EVERYONE login
• ALLOW EVERYONE logout
• ALLOW EVERYONE findById
• ALLOW OWNER updateAttributes

Confirm the user's identity.

Login a user by with the given credentials.

   User.login({username: 'foo', password: 'bar'}, function (err, token) {
     console.log(token.id);
   });

Logout a user with the given accessToken id.

   User.logout('asd0a9f8dsj9s0s3223mk', function (err) {
     console.log(err || 'Logged out');
   });

Create a short lived acess token for temporary login. Allows users to change passwords if forgotten.

Create access token for the logged in user. This method can be overridden to customize how access tokens are generated

Compare the given password with the users hashed password.

Verify a user's identity by sending them a confirmation email.

   var options = {
     type: 'email',
     to: user.email,
     template: 'verify.ejs',
     redirect: '/'
   };

   user.verify(options, next);

Change list entry.

Are both changes deletes?

When two changes conflict a conflict is created.

**Note: call conflict.fetch() to get the target and source models.

Determine the differences for a given model since a given checkpoint.

The callback will contain an error or result.

result

{
  deltas: Array,
  conflicts: Array
}

deltas

An array of changes that differ from remoteChanges.

conflicts

An array of changes that conflict with remoteChanges.

Find or create a change for the given model.

Get the checkpoint model.

Create a hash of the given string with the options.hashAlgorithm. Default: sha1

Get an identifier for a given model.

Correct all change list entries.

Track the recent change of the given modelIds.

Get the revision string for the given object

Get the conflicting changes.

Does this change conflict with the given change.

Get a change's current revision based on current data.

Compare two changes.

Get the Model class for change.modelName.

Determine if the change is based on the given change.

Fetch the conflicting models.

Update (or create) the change with the current revision.

Resolve the conflict.

Get a change's type. Returns one of:

• Change.UPDATE
• Change.CREATE
• Change.DELETE
• Change.UNKNOWN

Determine the conflict type.

// possible results are
Change.UPDATE // => source and target models were updated
Change.DELETE // => the source and or target model was deleted
Change.UNKNOWN // => the conflict type is uknown or due to an error