Auto generate resource routes.

Author: passabilities

README.md

@@ -65,29 +65,35 @@ Each route will need a couple things:
 
 The layout of each route will be in the following format:
 
-* `['{verb} {url}', '{controller}#{action}']`
+```
+['{verb} {url}', '({controller}#){action}' || [{subroutes}]]
+```
+
 * **verb**
-  * `get`, `post`, `put`, or `delete`
+  * `get`, `post`, `patch`, `put`, or `delete`
 * **url**
   * URL end point that begins at root (leading `/` is optional)
   * URLs are allowed to have parameters defined denoted using a colon (`:`)
     * Example: `users/:id`
-* **controller**
-  * The controller name is the prefix of the file it is defined in. For example you would use `users` for the controller `app/controllers/users_controller.js`
+* **controller** (optional)
+  * The controller name is the prefix of the file it is defined in. e.g. `users` for `app/controllers/users_controller.js`
+  * May be omitted to set the controller name to the first part of the route **url**. e.g. `users` for `['get users/all', 'getAll']`
 * **action**
-  * This is the name of the function to call defined in the controller.
+  * This is the name of the method to call defined in the controller.
+* **subroutes**
+  * Subroutes may be defined instead of a controller and action.
 
 There are a couple ways to define how routes work:
 
-1. All inline:
+1. Inline:
 
   ```javascript
     module.exports = [
       ['get users/all', 'users#getAll']
     ]
   ```
 
-1. Nested:
+1. With subroutes:
 
   ```javascript
     module.exports = [
@@ -109,6 +115,33 @@ There are a couple ways to define how routes work:
     ]
   ```
 
+1. [With `resources` verb](#resources):
+
+  ```javascript
+    module.exports = [
+      ['resources users']
+    ]
+  ```
+
+#### Resources
+
+Auto generate resource routes with the `['resources {name}']` route format.
+
+The **name** of the resource must be a single word.
+
+The following routes will be generated:
+
+```javascript
+  [{name}, [
+    [`get /`,       'fetchAll'],
+    [`get /:id`,    'fetch'],
+    [`post /`,      'create'],
+    [`patch /:id`,  'update'],
+    [`put /:id`,    'replace'],
+    [`delete /:id`, 'destroy']
+  ]]
+```
+
 ### Controllers
 
 Controllers are used to define the actions to take place on each request.

lib/routing/buildRoutes.js

@@ -22,12 +22,20 @@ _.each(glob.sync(`${process.cwd()}/${controllerPath}/*`), file => {
   controllers[name] = new Controller
 })
 
-let buildRoute = (router, path, to, root) => {
-  // A route path must contain an action method and url.
-  if(!/.+ .+/.test(path))
-    throw new Error('An action method AND url must be specified.')
-  let [method, url] = path.split(' ')
+let genResourceRoutes = root => {
+  return [
+    [root, [
+      [`get /`,       'fetchAll'],
+      [`get /:id`,    'fetch'],
+      [`post /`,      'create'],
+      [`patch /:id`,  'update'],
+      [`put /:id`,    'replace'],
+      [`delete /:id`, 'destroy']
+    ]]
+  ]
+}
 
+let buildRoute = (router, verb, url, to, root) => {
   // Check how action function is referenced.
   let cName, action
   if(/.+#.+/.test(to))
@@ -79,50 +87,59 @@ let buildRoute = (router, path, to, root) => {
     }
 
     // Check the existance of the action method. Else return error response.
-    let mainAction = controller[action].bind(controller)
+    let mainAction = controller[action]
     if(mainAction) {
-      mainAction(req, res)
+      mainAction.call(controller, req, res)
     } else {
       jsonProxy('Action does not exist.').status(404)
     }
   })
-  router[method].apply(router, args)
+  router[verb].apply(router, args)
 }
-let buildRoutes = (routes, router, root) => {
+let buildRoutes = (router, routes, root) => {
   // Loop each route defined.
   // NOTE: Routes must be defined in an array for proper initilizaion order.
   _.each(routes, route => {
-    // Each route must contain a path/URL to execute at and an action function/subroutes.
     let [ path, toAction ] = route
-    if(!toAction)
-      throw new Error('No action function is defined for a route. Please check proper route definitions.')
 
     // If `toAction` is an Array, expect it to be subroutes.
     if(Array.isArray(toAction)) {
       let baseRoot
       if(root) {
         baseRoot = root
       } else {
-        // Make sure that the root path for subroutes does not contain spaces.
-        if(/.+ .+/.test(path))
-          throw new Error('Routes that contain subroutes must not have a root path with spaces.')
+        if(!/^\w+$/.test(path))
+          throw new Error('Routes that contain subroutes must only be described by a single word.')
         baseRoot = path
       }
 
       // Build subroutes.
       let subRouter = Router({mergeParams: true})
-      buildRoutes(toAction, subRouter, baseRoot)
+      buildRoutes(subRouter, toAction, baseRoot)
 
       // Attach subrouter to parent router.
       router.use(`/${path}`, subRouter)
     } else {
-      // Build single route.
-      buildRoute(router, path, toAction, root)
+      let [ verb, url ] = path.split(' ')
+
+      if(verb === 'resources') {
+        if(!/^\w+$/.test(url))
+          throw new Error(`Resource routes must only be described by a single word. ("${url}")`)
+
+        // Build all resource routes.
+        buildRoutes(router, genResourceRoutes(url), root)
+      } else {
+        if(!toAction)
+          throw new Error(`No action method or subroutes are defined for route "${path}". Please check proper route definitions.`)
+
+        // Build single route.
+        buildRoute(router, verb, url, toAction, root)
+      }
     }
   })
 }
 // Initilize routes.
-buildRoutes(routes, mainRouter)
+buildRoutes(mainRouter, routes)
 
 module.exports = mainRouter