Merge branch 'release/4.0.20'

CHANGELOG.md

@@ -1,3 +1,13 @@
+<a name="4.0.20"></a>
+## [4.0.20](https://github.com/adonisjs/adonis-framework/compare/v4.0.19...v4.0.20) (2017-09-24)
+
+
+### Bug Fixes
+
+* **route:** wildcard bug after regexp upgrade ([c7ebb4d](https://github.com/adonisjs/adonis-framework/commit/c7ebb4d))
+
+
+
 <a name="4.0.19"></a>
 ## [4.0.19](https://github.com/adonisjs/adonis-framework/compare/v4.0.18...v4.0.19) (2017-09-23)
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adonisjs/framework",
-  "version": "4.0.19",
+  "version": "4.0.20",
   "description": "Adonis framework makes it easy for you to write webapps with less code",
   "main": "index.js",
   "scripts": {

src/Route/Resource.js

@@ -242,7 +242,7 @@ class RouteResource extends Macroable {
    *
    * @method middleware
    *
-   * @param  {...Spread} middleware
+   * @param  {Array|Map} middleware
    *
    * @chainable
    *
@@ -252,36 +252,39 @@ class RouteResource extends Macroable {
    *   .resource()
    *   .middleware(['auth'])
    *
-   * // or
-   *
+   * // or use ES6 maps
    * Route
-   *   .resource()
-   *   .middleware((route) => {
-   *     if (['store', 'update', 'delete'].indexOf(route.name) > -1) {
-   *       return ['auth']
-   *     }
-   *
-   *     return []
-   *   })
+   *   .resource('user', 'UserController')
+   *   .middleware(new Map([
+   *     ['auth', ['user.store', 'user.update', 'user.delete']]
+   *   ]))
    * ```
    */
-  middleware (...middleware) {
+  middleware (middleware) {
+    const middlewareMap = middleware instanceof Map ? {} : {
+      '*': _.castArray(middleware)
+    }
+
     /**
-     * If first argument is a function, we consider it as
-     * the closure to define dynamic middleware based
-     * upon some logic.
-     *
-     * The closure will be executed for each route and return
-     * value must be an array and used as the middleware for
-     * the route.
+     * if middleware are defined as ES6 map, then we need
+     * to sort them as objects with key/value pair of
+     * single route names and an array of middleware
      */
-    const middlewareClosure = middleware[0]
+    if (middleware instanceof Map === true) {
+      for (const [routeNames, middlewareList] of middleware) {
+        _.castArray(routeNames).forEach((name) => {
+          middlewareMap[name] = (middlewareMap[name] || []).concat(_.castArray(middlewareList))
+        })
+      }
+    }
 
+    /**
+     * Finally apply the middleware to the routes
+     */
     _.each(this._routes, (route) => {
-      if (typeof (middlewareClosure) === 'function') {
-        route.routeInstance.middleware(middlewareClosure(route.routeInstance.toJSON()))
-      } else {
-        route.routeInstance.middleware(_.flatten(middleware))
+      const middlewareHash = _.flatten(middlewareMap['*'] || middlewareMap[route.routeInstance._name] || [])
+      if (_.size(middlewareHash)) {
+        route.routeInstance.middleware(middlewareHash)
       }
     })
 

src/Route/index.js

@@ -115,7 +115,7 @@ class Route extends Macroable {
     this._validateHandler(handler)
 
     route = `/${route.replace(/^\/|\/$/g, '')}`
-    this._route = route
+    this._route = route === '/*' ? '/(.*)' : route
     this._verbs = verbs
     this._handler = handler
     this._name = route

test/integration/specs/route.spec.js

@@ -205,12 +205,12 @@ test.group('Route', (group) => {
 
     Route
       .resource('users', 'UserController')
-      .middleware(() => {
-        return async function ({ response }, next) {
+      .middleware([
+        async ({ response }, next) => {
           await next()
           response._lazyBody.content = response._lazyBody.content + ' via middleware'
         }
-      })
+      ])
 
     assert.equal((await supertest(appUrl).get('/users').expect(200)).text, 'all via middleware')
     assert.equal((await supertest(appUrl).get('/users/create').expect(200)).text, 'form via middleware')
@@ -226,4 +226,16 @@ test.group('Route', (group) => {
     Route.on('/').render('user', { name: 'virk' })
     assert.equal((await supertest(appUrl).get('/').expect(200)).text.trim(), 'Hello virk')
   })
+
+  test('respond to all routes via *', async (assert) => {
+    const Route = use('Route')
+    Route.any('(.*)', ({ request }) => request.url())
+    assert.equal((await supertest(appUrl).get('/users').expect(200)).text, '/users')
+    assert.equal((await supertest(appUrl).get('/users/create').expect(200)).text, '/users/create')
+    assert.equal((await supertest(appUrl).post('/users').expect(200)).text, '/users')
+    assert.equal((await supertest(appUrl).get('/users/1').expect(200)).text, '/users/1')
+    assert.equal((await supertest(appUrl).get('/users/1/edit').expect(200)).text, '/users/1/edit')
+    assert.equal((await supertest(appUrl).put('/users/1').expect(200)).text, '/users/1')
+    assert.equal((await supertest(appUrl).delete('/users/1').expect(200)).text, '/users/1')
+  })
 })

test/unit/route.spec.js

@@ -134,6 +134,11 @@ test.group('Route | Register', () => {
     assert.equal(route._regexp.exec('/users.json')[1], '.json')
     assert.equal(route._regexp.exec('/users.html')[1], '.html')
   })
+
+  test('register proper regex when route is a *', (assert) => {
+    const route = new Route('*', function () {})
+    assert.equal(route._route, '/(.*)')
+  })
 })
 
 test.group('Route | Resolve', () => {
@@ -460,18 +465,89 @@ test.group('Route | Resource', (group) => {
     })
   })
 
-  test('define different middleware on different routes', (assert) => {
+  test('define resource middleware via ES6 map', (assert) => {
+    assert.plan(7)
     const resource = new RouteResource('users', 'UsersController')
-    resource.middleware(function (route) {
-      if (['create', 'edit', 'update', 'delete'].indexOf(route.name) > -1) {
-        return ['auth']
+    resource.middleware(new Map([
+      [['users.create', 'users.edit', 'users.update', 'users.destroy'], ['auth']]
+    ]))
+
+    RouteStore.list().forEach((route) => {
+      if (['users.create', 'users.edit', 'users.update', 'users.destroy'].indexOf(route._name) > -1) {
+        assert.deepEqual(route._middleware, ['auth'])
+      } else {
+        assert.deepEqual(route._middleware, [])
       }
-      return []
     })
+  })
+
+  test('define resource middleware via ES6 map where middleware is a string', (assert) => {
+    assert.plan(7)
+    const resource = new RouteResource('users', 'UsersController')
+    resource.middleware(new Map([
+      [['users.create', 'users.edit', 'users.update', 'users.destroy'], 'auth']
+    ]))
+
+    RouteStore.list().forEach((route) => {
+      if (['users.create', 'users.edit', 'users.update', 'users.destroy'].indexOf(route._name) > -1) {
+        assert.deepEqual(route._middleware, ['auth'])
+      } else {
+        assert.deepEqual(route._middleware, [])
+      }
+    })
+  })
+
+  test('define resource middleware via ES6 map where name is a string', (assert) => {
+    assert.plan(7)
+    const resource = new RouteResource('users', 'UsersController')
+    resource.middleware(new Map([
+      ['users.destroy', ['auth']]
+    ]))
+
+    RouteStore.list().forEach((route) => {
+      if (['users.destroy'].indexOf(route._name) > -1) {
+        assert.deepEqual(route._middleware, ['auth'])
+      } else {
+        assert.deepEqual(route._middleware, [])
+      }
+    })
+  })
+
+  test('define resource middleware via ES6 map where middleware and name are strings', (assert) => {
+    assert.plan(7)
+    const resource = new RouteResource('users', 'UsersController')
+    resource.middleware(new Map([
+      ['users.create', 'auth']
+    ]))
+
+    RouteStore.list().forEach((route) => {
+      if (['users.create'].indexOf(route._name) > -1) {
+        assert.deepEqual(route._middleware, ['auth'])
+      } else {
+        assert.deepEqual(route._middleware, [])
+      }
+    })
+  })
+
+  test('define resource middleware via ES6 maps containing different middleware inside each row', (assert) => {
+    assert.plan(7)
+    const resource = new RouteResource('users', 'UsersController')
+
+    resource.middleware(new Map([
+      [['users.destroy'], ['auth', 'acl:superAdmin']],
+      [['users.create', 'users.update'], ['auth', 'acl:admin']],
+      [['users.index', 'users.show'], ['auth']]
+    ]))
 
     RouteStore.list().forEach((route) => {
-      if (['create', 'edit', 'update', 'delete'].indexOf(route.name) > -1) {
+      if (['users.destroy'].indexOf(route._name) > -1) {
+        assert.deepEqual(route._middleware, ['auth', 'acl:superAdmin'])
+      } else if (['users.create', 'users.update'].indexOf(route._name) > -1) {
+        assert.deepEqual(route._middleware, ['auth', 'acl:admin'])
+      } else if (['users.index', 'users.show'].indexOf(route._name) > -1) {
         assert.deepEqual(route._middleware, ['auth'])
+      } else {
+        assert.deepEqual(route._middleware, [])
       }
     })
   })