Restful routing using resourceful and director.
npm install restful
Reflects RESTful Director routers from resourceful resources. Can be used as a stand-alone module or as a Flatiron plugin.
The restful project removes the process of writing boilerplate routing code for interacting with resourceful resources. Restful uses reflection to reflect an http router interface which maps all the restful routes needed to perform basic CRUD operations with resourceful. restful also has the ability to expose additional arbitrary remote resource methods in it's http router interface.
Through the removal of this boilerplate code, restful creates a robust, standardized, and re-usable http interface for any resourceful resource.
Remark: If you don't like REST and would prefer a socket, use the socketful library!
npm install restful
``js
var resourceful = require('resourceful'),
Creature = resourceful.define('creature');
Creature.property('type', String, { default: "dragon" });
Creature.property('life', Number, { default: 10, minimum: 0, maximum: 20 });
`
additional API documentation for defining resources
To use restful as a Flatiron plugin you will have to:
- Define resource(s) in your Flatiron app
- Use the restful plugin in your Flatiron app
- Set restful=true on the resource to let Flatiron know to expose it
Here is a code example of using restful as a Flatiron plugin: https://github.com/flatiron/restful/blob/master/examples/app.js
To use restful as a stand-alone server you will have to:
- Define resource(s)
- Create a new server based on the resource(s) using restful.createServer
Here is a code example of using restful as a stand-alone server: https://github.com/flatiron/restful/blob/master/examples/standalone-server.js
To use restful as a HTTP req res processing middleware you will have to:
- Define resource(s)
- Create a new router based on the resource(s) using restful.createRouter
- Use the newly created router inside an existing HTTP server
Here is a code example of using restful in a server: https://github.com/flatiron/restful/blob/master/examples/server.js
By default, restful will map the following Resourceful methods.
Verb Path Action Notes
GET /creature => Creature.all()
POST /creature => Creature.create() Create with no-id, id is auto-generated
POST /creature/1 => Creature.create() Create with id "1"
GET /creature/1 => Creature.show()
PUT /creature/1 => Creature.update()
DELETE /creature/1 => Creature.destroy()
POST /creature/1/update => Creature.update()
POST /creature/1/destroy => Creature.destroy()
The Director router will dispatch all incoming RESTFul urls to the Creature resource and respond back with the appropriate result.
You'll notice that some of the routes defined above are not 100% restful ( such as POST /creature/1/update ).
Since not all HTTP clients support PUT and DELETE Verbs ( such as forms in web browsers ), restful maps additional "non-strict" rest mappings to make your life slightly easier.
If you prefer to not use this option, set { strict: true }.
You might also want to consider using a rails-like approach which uses the convention of a reserved
To define relational data in restful you will have to:
- Define the relationship in the resource itself using the resourceful Resource.parent() API
- Create a new router based on the resource(s)
restful will then properly reflect the relational properties of your resources into the routing layer.
Here is a simple code example of using restful with Albums and Songs: https://github.com/flatiron/restful/blob/master/examples/server.js
Protip: You'll want to browse the restful server using the HTML API explorer in order to see which routes will be created.
restful comes with a built-in HTML API explorer. If you wish to view the current routing map for the router as HTML, simply start the restful server and visit http://localhost:8000/ in your browser.
If you prefer to not use this option, set { explore: false }.
Note: The API explorer is powered by director-explorer, which will work for ANY director router.
In many cases, you'll want to expose additional methods on a Resource through the router outside of the included CRUD operations: create, all, show, update, destroy.
restful has built in support for easily exposing arbitrary remote resource methods.
Consider the example of a Creature. We've already defined all the restful CRUD routes, but a Creature also needs to eat!
Simply create a new method on the Creature resource called feed.
`js`
Creature.feed = function (_id, options, callback) {
callback(null, 'I have been fed');
}
This method is consider private by default, in that it will not be exposed to the web unless it's set to a remote function. To set a resource method to remote, simply:
`js`
Creature.feed.remote = true
It's easy as that! By setting the feed method to remote, the following routes will exist in the Director router.
POST /creature/1/feed => Creature.feed()
GET /creature/1/feed => Creature.feed()
There are several ways to provide security and authorization for accessing resource methods exposed with restful. The recommended pattern for authorization is to use resourceful's ability for before and after hooks. In these hooks, you can add additional business logic to restrict access to the resource's methods.
It is not recommended to place authorization logic in the routing layer, as in an ideal world the router will be a reflected interface of the resource. In theory, the security of the router itself should be somewhat irrelevant since the resource could have multiple reflected interfaces that all required the same business logic.
TL;DR; For security and authorization, you should use resourceful's before and after hooks.
Restful provides access to a Director.router object. This router is created by the heavily used Director library.
If you need to override a generated route, or create an ad-hoc route, or make any customization, the API is exactly the same as the Director API.
customize a reflected router interface:
`js
app.router.get('/', function(){
this.res.end('home page');
});
//
// Overrides /creature/larry but won't override,/creature/:id
// any other captures.
//
app.router.get('/creature/larry', function(){
this.res.end('larry is special!');
});
`
Like most of Flatiron's reflection libraries, restful is built to solve 90% of use-cases. If you hit a case where restful is causing a problem, you can simply drop into Director.
Reflection is highly encouraged, but most definitely optional.
npm test
- Full resourceful property type support ( numeric, boolean, array, object )resourceful
- Full nested property schema supporterrs` library
- Add ability to specify schemas for remote method argument payloads
- Implement and document browser support
- Improve Tests
- Add better error support via