Node server for dynamic, fake JSON.

npm install -g dyson
dyson demo
# Check http://localhost:3000/features

Dyson allows you to define endpoints at a path and return JSON based on template object.

When developing client-side applications, usually either static JSON dummy files are used, or an actual server, backend, datastore, API, you name it. Sometimes static files are too static, and sometimes an actual server is not available, not accessible, or too tedious to setup.

This is where dyson comes in. Get a full fake server for your application up and running in minutes.

• Easy configuration, extensive options
• Dynamic responses
  • Base response on request path or parameters (e.g. simulate login scenario's based on username)
  • Respond with different status code (e.g. 404) for specific requests (e.g. 404 for ?id=999)
  • Includes random data generators
• Supports GET, POST, PUT, DELETE (and OPTIONS)
• Supports CORS

Configuration happens by simple objects. Here's a complete service configuration file:

module.exports = {
    path: '/user/:id',
    template: {
        id: function(params) {
            return params.id;
        },
        name: generator.name
    }
}

That's all. A request to /user/412 would return:

{
    "id": 412,
    "name": "John"
}

The path string is the usual argument provided to Express, as in app.get(path, callback);.

The template object is a hash of values that behave in the following way:

• function: the function will be invoked
  • with arguments (params, query)
  • in context of config instance object (created from template as prototype)
• object: will be recursively iterated
• anything else will be returned as-is (e.g. string, boolean, number, array)

Some data generators are included (examples behind):

• id - returns _.uniqueId();
• name - 'John', 'Olivia`
• address.city - 'Mexico City', 'Beijing'
• address.zipUS - '53142', '71238'
• address.zipNL - '4715 FW', '7551 VT'
• time.byQuarter - '14:45', '9:00'

Same as examples above, but override the collection property:

{
    path: '/users',
    collection: true,
    template: user.template
}

This will give a response with an array of users (default array length is random between 2 and 10):

[
    {
        "id": 412,
        "name": "John"
    },
    {
        "id": 218,
        "name": "Olivia"
    }
]

The default values for the configuration objects:

{
    cache: true,
    size: function() {
        return _.random(2,10);
    },
    collection: false,
    callback: handleRequest
};

• cache:true means that multiple requests to the same path will result in the same response
• size:function is the number of objects in the collection
• callback:function
  • the provided default function is doing the hard work for GET requests (but can be overridden)
  • it is used as middleware in Express
  • must set res.body and call next() to render response

The response data can be wrapped in a container object. Functions in the container object are invoked with arguments (params, query, data):

{
    path: '/users',
    template: user.template,
    container: {
        meta: function(params, query, data) {
            userCount: data.length
        },
        data: {
            here: function(params, query, data) {
                return data;
            }
        }
    }
}

And an example response:

{
    "meta": {
        "userCount": 2
    },
    "data": {
        "here": [
            {
                "id": 412,
                "name": "John"
            },
            {
                "id": 218,
                "name": "Olivia"
            }
        ]
    }
}

Basic support for "combined" requests is available, by means of a comma separated path fragment.

For example, a request to /user/5,13 will result in an array of the responses from /user/5 and /user/13.

Configuration objects are just like those for GET, but the callback (Express middleware) should be defined.

An example config object for /login:

{
    path: '/login',
    callback: function(req, res, next) {
        res.body = {
            "username": req.body.username,
            "success": req.body.password === 'password1'
        };
        next();
    }
}

By default, all responses are sent with a status code 200 (and the Content-Type: application/json header).

This can be completely overridden with the status property, e.g.:

path: '/feature/:foo?',
status: function(req, res) {
    if(req.params.foo === '999') {
        res.send(404, 'Feature not found');
    }
}

Would result in a 404 when requesting /feature/999.

npm install dyson -g
dyson init [dir]
dyson [dir] 3000
# Check http://localhost:3000/dummy

Copies a dummy instance at dir, including the /get, /post, /put, /delete subdirs, and one dummy config object in each. Dyson scans these folders for configuration files when started.

Or run dyson demo 3000 to play around and serve some demo JSON responses at these endpoints:

http://localhost:3000/employee/1
http://localhost:3000/users
http://localhost:3000/features