feat(route-resource): added support for nested resources and resources filters

now one can add nested resources and can filter then using methods as,except,only

Author: thetutlage

src/Route/helpers.js

@@ -21,6 +21,7 @@ let RouterHelper = exports = module.exports = {}
  * @public
  */
 RouterHelper.construct = function (route, verb, handler, group) {
+  route = route.startsWith('/') ? route : `/${route}`
   let pattern = RouterHelper.makeRoutePattern(route)
   let middlewares = []
   let subdomain = null

src/Route/index.js

@@ -8,6 +8,7 @@
 
 const helpers = require('./helpers')
 const Group = require('./group')
+const Resource = require('./resource')
 const subdomains = require('./subdomains')
 const _ = require('lodash')
 
@@ -171,19 +172,30 @@ Route.any = function (route, handler) {
  * @public
  */
 Route.as = function (name) {
-  let lastRoute = _.last(routes)
+  let lastRoute = Route.lastRoute()
   lastRoute.name = name
   return this
 }
 
+/**
+ * @description returns last route registered inside
+ * the route store
+ * @method lastRoute
+ * @return {Object}
+ * @public
+ */
+Route.lastRoute = function () {
+  return _.last(routes)
+}
+
 /**
  * @description assign array of named middlewares to route
  * @method middlewares
  * @param  {Array} arrayOfNamedMiddleware
  * @public
  */
 Route.middlewares = function (arrayOfNamedMiddleware) {
-  let lastRoute = _.last(routes)
+  let lastRoute = Route.lastRoute()
   helpers.appendMiddleware(lastRoute, arrayOfNamedMiddleware)
   return this
 }
@@ -232,19 +244,7 @@ Route.resolve = function (urlPath, verb, host) {
  * @public
  */
 Route.resource = function (pattern, handler) {
-  /**
-   * avoiding multiple / when route itself is a base
-   * route.
-   * @type {String}
-   */
-  const seperator = pattern === '/' ? '' : '/'
-
-  Route.options(pattern, '')
-  Route.get(pattern, `${handler}.index`)
-  Route.post(pattern, `${handler}.store`)
-  Route.get(`${pattern}${seperator}:id`, `${handler}.show`)
-  Route.put(`${pattern}${seperator}:id`, `${handler}.update`)
-  Route.delete(`${pattern}${seperator}:id`, `${handler}.destroy`)
+  return new Resource(Route, pattern, handler)
 }
 
 /**
@@ -270,3 +270,15 @@ Route.url = function (pattern, params) {
   }
   return helpers.compileRouteToUrl(pattern, params)
 }
+
+/**
+ * @description removes a route using it's name
+ * @method remove
+ * @param  {String} name
+ * @return {void}
+ * @public
+ */
+Route.remove = function (name) {
+  const index = _.findIndex(routes, {name})
+  routes.splice(index, 1)
+}

src/Route/resource.js

@@ -0,0 +1,135 @@
+'use strict'
+
+/**
+ * adonis-framework
+ * Copyright(c) 2015-2015 Harminder Virk
+ * MIT Licensed
+*/
+
+const _ = require('lodash')
+
+class Resource {
+
+  constructor (RouteHelper, pattern, handler) {
+    this.RouteHelper = RouteHelper
+    this.routes = []
+    this.basename = pattern.replace(/\\/g, '')
+    this._buildRoutes(pattern, handler)
+    return this
+  }
+
+  /**
+   * @description register a route to the routes store
+   * and pushes it to local array to reference it
+   * later
+   * @method _registerRoute
+   * @param  {String}       verb
+   * @param  {String}       route
+   * @param  {String}       handler
+   * @param  {String}       name
+   * @return {void}
+   * @public
+   */
+  _registerRoute (verb, route, handler, name) {
+    this.RouteHelper[verb](route, `${handler}.${name}`).as(`${this.basename}.${name}`)
+    this.routes.push(this.RouteHelper.lastRoute())
+  }
+
+  /**
+   * @description builds all routes for a given pattern
+   * @method _buildRoutes
+   * @param  {String}     pattern
+   * @param  {String}     handler
+   * @return {void}
+   * @public
+   */
+  _buildRoutes (pattern, handler) {
+    pattern = pattern.replace(/(\w+)\./g, function (index, group) {
+      return `${group}/:${group}_id/`
+    })
+    const seperator = pattern.endsWith('/') ? '' : '/'
+
+    this._registerRoute('get', pattern, handler, 'index')
+    this._registerRoute('get', `${pattern}${seperator}create`, handler, 'create')
+    this._registerRoute('post', `${pattern}`, handler, 'store')
+    this._registerRoute('get', `${pattern}${seperator}:id`, handler, 'show')
+    this._registerRoute('get', `${pattern}${seperator}:id/edit`, handler, 'edit')
+    this._registerRoute('put', `${pattern}${seperator}:id`, handler, 'update')
+    this._registerRoute('patch', `${pattern}${seperator}:id`, handler, 'update')
+    this._registerRoute('delete', `${pattern}${seperator}:id`, handler, 'destroy')
+  }
+
+  /**
+   * @description transform methods keys to resource route names
+   * @method _transformKeys
+   * @param  {Array}       pairKeys
+   * @return {Array}
+   */
+  _transformKeys (pairKeys) {
+    return pairKeys.map((item) => {
+      return `${this.basename}.${item}`
+    })
+  }
+
+  /**
+   * @description change names for defined routes mapped
+   * next to actions
+   * @method as
+   * @param  {Object} pairs
+   * @return {Object}
+   */
+  as (pairs) {
+    const pairKeys = _.keys(pairs)
+    const pairTransformedKeys = this._transformKeys(pairKeys)
+    _.each(this.routes, function (route) {
+      const pairIndex = pairTransformedKeys.indexOf(route.name)
+      if (pairIndex > -1) {
+        route.name = pairs[pairKeys[pairIndex]]
+      }
+    })
+    return this
+  }
+
+  /**
+   * @description removes all other actions from routes
+   * resources except the given array
+   * @method only
+   * @param  {Array} methods
+   * @return {Object}
+   * @public
+   */
+  only (methods) {
+    const transformedMethods = this._transformKeys(methods)
+    this.routes = _.filter(this.routes, (route) => {
+      if (transformedMethods.indexOf(route.name) <= -1) {
+        this.RouteHelper.remove(route.name)
+      } else {
+        return true
+      }
+    })
+    return this
+  }
+
+  /**
+   * @description removes actions defined inside given array
+   * from all resources routes
+   * @method except
+   * @param  {Array} methods
+   * @return {Object}
+   * @public
+   */
+  except (methods) {
+    const transformedMethods = this._transformKeys(methods)
+    this.routes = _.filter(this.routes, (route) => {
+      if (transformedMethods.indexOf(route.name) > -1) {
+        this.RouteHelper.remove(route.name)
+      } else {
+        return true
+      }
+    })
+    return this
+  }
+
+}
+
+module.exports = Resource