Base for Waterline models containing a GeoJSON geographic field.

It provides methods for performing geo queries on the GeoJSON field – findWithin() selects records that lie within specified coordinates, and findIntersects() selects records that intersect.

To implement the geo queries, the GeoJSON data must be indexed. And because the MongoDB 2dsphere index can handle only GeoJSON geometry features, the index is applied to a derived features field that contains just the geometry features from the primary GeoJSON field.

The GeoModel provides the machinery for keeping the features field synchronized with the primary GeoJSON field. It also attempts to ensure the features field is well-formed and has a consistent organization. For Polygon objects, it discards duplicate points, closes open paths and ensures clockwise winding order. It combines Geometry objects so there is at most one of each geometry type: Polygon/MultiPolygon, Point/MultiPoint and LineString/MultiLineString.

The createGeoIndex() method should be invoked to ensure the index is created. Typically, after the startup lifecycle phase.

Configuration is through these model properties:

  • geometryField (string) - Name of the primary GeoJSON field (default is geo).
  • geometryFeatureField (string) - Name of the geometry features field (default is geoFeatures). Both of these fields must also be defined as model attributes with type json.
Static Members
getGeometry(record, types)

The HasModels class is a Base class for defining helper classes with Models. All models contained in a ./models directory will be registered automatically, and are the default list of model identities made available in the this.models object. You may override or extend this list of model identities, or a mapping of model identities to variable names, by overriding .modelNames()

new HasModels()

Extends NxusModule

Instance Members

Storage Module

Build Status

A storage framework for Nxus applications using waterline.


"config": {
  "storage": {
    "adapter": {
      "default": "sails-mongo"
    "connections": {
      "default": {
        "adapter": "default",
        "url": "mongodb://...."
    "modelsDir": "./src/models"

Creating models

Inherit your models from BaseModel

import {BaseModel} from '@nxus/storage'

var User = BaseModel.extend({
  identity: 'user',
  attributes: {
    name: 'string'

Register models

Either import your model class and pass it to model():


Or register all models in a directory with modelDir():


Model events

The storage model emits events for create, update, and destroy, you can register a handler for all events:

  storage.on('model.create', (identity, record) => {})
  storage.on('model.update', (identity, record) => {})
  storage.on('model.destroy', (identity, record) => {})

Or just a specific model identity:

  storage.on('model.create.user', (identity, record) => {})
  storage.on('model.update.user', (identity, record) => {})
  storage.on('model.destroy.user', (identity, record) => {})

Lifecycle notes

  • load

    • Models should be registered during load, e.g. var User = BaseModel.extend({ identity: 'user', ... }); application.get('storage').model(User)
  • startup

    • The configured database is connected during load.after

    • You can query models from startup and beyond, retrieve the model by the 'identity':

      application.get('storage').getModel('user').then((User) => {


Storage provides a common interface for defining models. Uses the Waterline ORM.

new Storage()

Extends NxusModule

Instance Members