This module is made to simplify rest API creation. Supply the constructor with a mongoose model and an express router is generated from the plural name of the model. Given a model named Article, app.use(resource(Article)) will generate all the routes listed below. (With no authentication).

Controller to route relation

(models being the lowercase plural form of the given model name)

• show: GET /models/:id
• all: GET /models
• create: POST /models
• update: PUT /models/:id
• destroy: DELETE /models/:id

Dependencies

• body-parser or similar middleware

API

app.use(resourcePebble(Model:mongoose Model, [options:object]))

options.controller: class(Model: mongoose model)|function(Model:mongoose model)

Swap out the default controller with another controller. The constructor should accept a Model parameter, which is the model that will be used in the controller.

options.middleware

Example usage

var express = require('express');
var app = express();
var bodyParser = require('body-parser');
var resourcePebble = require('resource-pebble')

// body-parser or a similar middleware is required
app.use(bodyParser.urlencoded({ extended: false }));
app.use(bodyParser.json());

// Find a mongoose model for the resource
Article = require('./models/article');

var authMiddleware = require('./middleware/auth');

app.use(resourcePebble(Article), {

    // Optionally register middleware for routes
    middleware: {
        'create': authMiddleware,
        'update': authMiddleware
    },

    // Optionally restrict the number of methods to use
    only: ['show', 'create', 'update']
});

Responses

The default responses are on the form:

{
    "status": Number,
    "success": Boolean,
    "data": ANY
}

The responses can be changed by extending the express response object with a provide method. I am planning to develop response provider middleware for express. The functionality required for this is enabled in this module. To enable custom throughout your app you can use the stripped down implementation specified below.

Response API

Note: This is not enabled by by default, but will be used if available.

res.provide(responseType:String, data: ANY)

Stripped down implementation

var providers = {}; // Holds your response functions

function responseProvider(req, res, next) {
    res.provide = function (name, data) {
        var provider = providers[name](data);
        res.status(provider.status || 500);
        res.json(provider.data);
    }
    next();
}

app.use(responseProvider);

responses.error = function (data) {
    if (! process.env.DEBUG)
        data = null
    return {
        status: 500,
        data: data
    };
}

Required responses

• error
• success
• created

TODO

Default controller

• Create resource not found response for show-route
• Create nested resources
  • If model contains references to other models, create nested resources recursively
  • one -> many
    • create all endpoints
  • one -> one
    • create update and destroy endpoints

Resource pebble

• Create tests for middleware
• Enable multiple methods per middleware (as in middleware: { 'create update': authMiddleware })

Misc.

• Create response provider module