collection.store #

• {Store}

The backing persistence abstraction layer. Supports saving and reading data from a database. See Store for more info.

collection.validate(body, create) #

Validate the request body against the Collection's properties and return an object containing any errors.

• body {Object}

The object to validate

• create {Boolean}

Should validate a new object being created

• return errors {Object}

collection.sanitize(body) #

Sanitize the request body against the Collection's properties object and return an object containing only properties that exist in the collection.config.properties object.

• body {Object}
• return sanitized {Object}

collection.sanitizeQuery(query) #

Sanitize the request query against the collection.properties and return an object containing only properties that exist in the collection.properties object.

• query {Object}
• return sanitizedQuery {Object}

collection.parseId(ctx) #

Parse the ctx.url for an id. Override this to change how an object's id is parsed out of a url.

• ctx {Context}

collection.find(ctx, fn) #

Find all the objects in a collection that match the given ctx.query. Then execute a get event script, if one exists, using each object found. Finally call fn(err) passing an error if one occurred.

• ctx {Context}
• fn(err)

collection.remove(ctx, fn) #

Execute a delete event script, if one exists, using each object found. Then remove a single object that matches the ctx.query.id. Finally call fn(err) passing an error if one occurred.

• ctx {Context}
• fn(err)

collection.save(ctx, fn) #

First execute a validate event script if one exists. If the event does not error, try to save the ctx.body into the store. If ctx.body.id exists, perform an update and execute the put event script. Otherwise perform an insert and execute the post event script. Finally call fn(err), passing an error if one occurred.

• ctx {Context}
• fn(err)

script.run(ctx, domain, [fn]) #

• ctx {Context}

A Context with a session, query, req and res.

• domain {Object}

An Object containing functions to be injected into the Scripts sandbox. This will override any existing functions or objects in the Scripts sandbox / global scope.

This example domain provides a log function to a script.

var script = new Script('log("hello world")');
var context = {};
var domain = {};
var msg;

domain.log = function(str) {
  console.log(msg = str);
}

script.run(ctx, domain, function(err) {
  console.log(msg); // 'hello world'
});

• fn(err) optional

If a callback is provided the script will be run in async mode. The callback will receive any error even if the error occurs asynchronously. Otherwise it will be called without any arguments when the script is finished executing (see: async mode).

var s = new Script('setTimeout(function() { throw "test err" }, 22)');

// give the script access to setTimeout
var domain = {setTimeout: setTimeout};

s.run({}, domain, function (e) {
  console.log(e); // test err
});

Script.load(path, fn) #

• path {String}

• fn(err, script)

Load a new script at the given file path. Runs the callback with an error if one occurred, or a new Script loaded from the contents of the file.

resource.handle(ctx, next) #

Handle an incoming request. This gets called by the router.

The resource can either handle this context and call ctx.done(err, obj) with an error or result JSON object, or call next() to give the context back to the router. If a resource calls next() the router might find another match for the request, or respond with a 404.

• ctx {Context}

The http context created by the Router. This provides an abstraction between the actual request and response. A Resource should call ctx.done or pipe to ctx.res if it can handle a request. Otherwise it should call next().

Override the handle method to return a string:

function MyResource(settings) {
  Resource.apply(this, arguments);
}
util.inherits(MyResource, Resource);

MyResource.prototype.handle = function (ctx, next) {
  // respond with the file contents (or an error if one occurs)
  fs.readFile('myfile.txt', ctx.done);
}

resource.load(fn) #

Load any dependencies and call fn(err) with any errors that occur. This is automatically called by the runtime to support asynchronous construction of a resource (such as loading files).

Note: If this method is overridden, the super method must be called to support loading of the MyResource.events array.

resource.clientGeneration #

If true, ensures that this resource is included in dpd.js.

MyResource.prototype.clientGeneration = true;

resource.config #

The instance configuration object; used to access the resource's configuration from member functions.

MyResource.prototype.handle = function (ctx, next) {
  fs.readFile(this.config.filePath, ctx.done);
}

Resource.events #

• {Array}

If a Resource constructor includes an array of events, it will try to load the scripts in its instance folder (eg. /my-project/resources/my-resource/get.js) using resource.loadScripts(eventNames, fn).

MyResource.events = ['get'];

This will be available to each instance of this resource as this.events.

/my-project/node_modules/my-resource.js

MyResource.prototype.handle = function(ctx, next) {
  if(this.events && this.events.get) {
    var domain = {
      say: function(msg) {
        console.log(msg); // 'hello world'
      }
    }
    this.events.get.run(ctx, domain, ctx.done);
  }
}

/my-project/resources/my-resource/get.js

say('hello world');

Resource.label #

The resource type's name as it appears in the dashboard. If this is not set, it will appear with its constructor name.

Hello.label = 'Hello World';

Resource.defaultPath #

The default path suggested to users creating a resource. If this is not set, it will use the constructor's name in lowercase.

Hello.defaultPath = '/hello-world'; 

Collection.basicDashboard #

Set this property to an object to create a custom configuration page for your resource type.

• settings - An array of objects describing which properties to display.
• name - The name of the property. This is how the value will be passed into the config object, so make sure it's something JavaScript-friendly, e.g. maxItems.
• type - The type of control to edit this property. Allowed types are text, textarea, number, and checkbox.
• description (Optional) - Explanatory text to appear below the field.

Hello.basicDashboard = {
  settings: [{
      name: 'propertyName',
      type: 'text',
      description: "This description appears below the text field"
  }, {
      name: 'longTextProperty',
      type: 'textarea'
  }, {
      name: 'numericProperty',
      type: 'number'
  }, {
      name: 'booleanProperty',
      type: 'checkbox'
  }]
};

The above sample will produce the following dashboard page:

Collection.dashboard #

A resource can describe the dependencies of a fully custom dashboard editor UI. This will be passed to the dashboard during rendering to create a custom UI.

This example creates the custom dashboard for the Collection resource. It automatically includes pages and page-specific scripts:

Collection.dashboard = {
    path: path.join(__dirname, 'dashboard')
  , pages: ['Properties', 'Data', 'Events', 'API']
  , scripts: [
      '/js/ui.js'
    , '/js/util.js'
  ]
}

• path {String}

The absolute path to this resource's dashboard

• pages {Array} (optional)

An array of pages to appear in the sidebar. If this is not provided, the only page available will be "Config" (and "Events", if MyResource.events is set).

The dashboard will load content from [current-page].html and js/[current-page].js.

Note: The "Config" page will load from index.html and js/index.js.

• scripts {Array} (optional)

An array of extra JavaScript files to load with the dashboard pages.

<div id="event-editor" class="default-editor"></div>

//Automatically generated by Deployd:
window.Context = {
  resourceId: '/hello', // The id of the current resource
  resourceType: 'Hello', // The type of the current resource
  page: 'properties', // The current page, in multi-page dashboards
  basicDashboard: {} // The configuration of the basic dashboard
};

dpd(Context.resourceId).get(function(result, err) {
  //Do something
});

// Get the config for the current resource
dpd('__resources').get(Context.resourceId, function(result, err) {
  //Do something
});

// Set a property for the current resource
dpd('__resources').put(Context.resourceId, {someProperty: true}, function(result, err) {
  //Do something
});

// Set all properties for the current resource, deleting any that are not provided
dpd('__resources').put(Context.resourceId, {someProperty: true, $setAll: true}, function(result, err) {
  //Do something
});

// Save another file, which will be loaded by the resource
dpd('__resources').post(Context.resourceId + '/content.md', {value: "# Hello World!"}, function(result, err)) {
  //Do something
});

Server.listen([port], [host]) #

Load any configuration and start listening for incoming connections.

var dpd = require('deployd')
  , server = dpd()

dpd.listen();
dpd.on('listening', function() {
  console.log(server.options.port); // 2403
});

Server.createStore(namespace) #

Create a new Store for persisting data using the database info that was passed to the server when it was created.

// Create a new server
var server = new Server({port: 3000, db: {host: 'localhost', port: 27015, name: 'my-db'}});

// Attach a store to the server
var todos = server.createStore('todos');

// Use the store to CRUD data
todos.insert({name: 'go to the store', done: true}, ...); // see `Store` for more info

Server.sockets #

The socket.io sockets Manager object (view source).

Server.sessions #

The server's SessionStore.

Server.router #

The server's Router.

Server.resources #

An Array of the server's Resource instances. These are built from the config and type loaders.