refactor: use correct ioc container global symbols

Author: thetutlage

package.json

@@ -77,7 +77,7 @@
   "dependencies": {
     "@poppinss/request": "^1.0.9",
     "@poppinss/response": "^1.0.8",
-    "@poppinss/utils": "^1.0.2",
+    "@poppinss/utils": "^1.0.3",
     "co-compose": "^5.1.1",
     "haye": "^2.0.2",
     "lodash": "^4.17.11",

src/Server/MiddlewareStore.ts

@@ -21,7 +21,7 @@ import {
   ResolvedMiddlewareNode,
 } from '../contracts'
 
-import { exceptionCodes } from '../helpers'
+import { exceptionCodes, iocMethods } from '../helpers'
 
 /**
  * Middleware store register and keep all the application middleware at one
@@ -63,7 +63,7 @@ export class MiddlewareStore<Context extends any> implements MiddlewareStoreCont
   private _resolveMiddlewareItem (middleware: MiddlewareNode<Context>): ResolvedMiddlewareNode<Context> {
     return typeof(middleware) === 'string' ? {
       type: 'class',
-      value: global['use'](middleware),
+      value: global[iocMethods.use](middleware),
       args: [],
     } : {
       type: 'function',

src/Server/finalMiddlewareHandler.ts

@@ -12,6 +12,7 @@
 */
 
 import { ResolvedMiddlewareNode } from '../contracts'
+import { iocMethods } from '../helpers'
 
 /**
  * Final middleware handler executes a middleware
@@ -27,5 +28,5 @@ export function finalMiddlewareHandler<Context> (
     return middleware.value(params[0], params[1], middleware.args)
   }
 
-  return global['make'](middleware.value).handle(params[0], params[1], middleware.args)
+  return global[iocMethods.make](middleware.value).handle(params[0], params[1], middleware.args)
 }

src/Server/finalRouteHandler.ts

@@ -13,6 +13,7 @@
 
 import { ResolvedControllerNode, HttpContextContract } from '../contracts'
 import { useReturnValue } from './useReturnValue'
+import { iocMethods } from '../helpers'
 
 /**
  * Final handler executes the route handler based on it's resolved
@@ -38,8 +39,8 @@ export async function finalRouteHandler<Context extends HttpContextContract> (ct
    * Otherwise lookup the controller inside the IoC container
    * and make the response
    */
-  const controllerInstance = global['make'](handler.namespace)
-  const returnValue = await global['iocCall'](controllerInstance, handler.method, [ctx])
+  const controllerInstance = global[iocMethods.make](handler.namespace)
+  const returnValue = await global[iocMethods.call](controllerInstance, handler.method, [ctx])
 
   if (useReturnValue(returnValue, ctx)) {
     ctx.response.send(returnValue)

src/Server/routePreProcessor.ts

@@ -12,7 +12,7 @@
 */
 
 import { Middleware } from 'co-compose'
-import { Exception } from '@poppinss/utils'
+import { parseIocReference } from '@poppinss/utils'
 import {
   RouteNode,
   HttpContextContract,
@@ -21,7 +21,6 @@ import {
 
 import { finalMiddlewareHandler } from './finalMiddlewareHandler'
 import { finalRouteHandler } from './finalRouteHandler'
-import { exceptionCodes } from '../helpers'
 
 /**
  * Executes the route middleware. This method is only invoked when route
@@ -54,30 +53,6 @@ export function routePreProcessor<Context> (
    * Resolve route handler before hand to keep HTTP layer performant
    */
   if (typeof (route.handler) === 'string') {
-    let handler = route.handler
-
-    /**
-     * 1. Do not prepend namespace, if `namespace` starts with `/`.
-     * 2. Else if `namespace` exists, then prepend the namespace
-     */
-    if (route.handler.startsWith('/')) {
-      handler = route.handler.substr(1)
-    } else if (route.meta.namespace) {
-      handler = `${route.meta.namespace.replace(/\/$/, '')}/${route.handler}`
-    }
-
-    /**
-     * Split the controller and method. Raise error if `method` is missing
-     */
-    const [ namespace, method ] = handler.split('.')
-    if (!method) {
-      throw new Exception(
-        `Missing controller method on \`${route.pattern}\` route`,
-        500,
-        exceptionCodes.E_INVALID_ROUTE_NAMESPACE,
-      )
-    }
-
     /**
      * Unlike middleware, we do not prefetch controller from the IoC container
      * since controllers in an app can grow to a huge number and lazy loading
@@ -86,11 +61,7 @@ export function routePreProcessor<Context> (
      * Sometime later, we can introduce `hot cache` in IoC container, which
      * avoids lookup cost within the IoC container.
      */
-    route.meta.resolvedHandler = {
-      type: 'iocReference',
-      namespace: namespace,
-      method,
-    }
+    route.meta.resolvedHandler = parseIocReference(route.handler, route.meta.namespace)
   } else {
     route.meta.resolvedHandler = {
       type: 'function',

src/helpers.ts

@@ -139,7 +139,14 @@ export const exceptionCodes = {
   E_DUPLICATE_ROUTE_NAME: 'E_DUPLICATE_ROUTE_NAME',
   E_MISSING_ROUTE_PARAM_VALUE: 'E_MISSING_ROUTE_PARAM_VALUE',
   E_ROUTE_NOT_FOUND: 'E_ROUTE_NOT_FOUND',
-  E_INVALID_MIDDLEWARE_TYPE: 'E_INVALID_MIDDLEWARE_TYPE',
   E_MISSING_NAMED_MIDDLEWARE: 'E_MISSING_NAMED_MIDDLEWARE',
-  E_INVALID_ROUTE_NAMESPACE: 'E_INVALID_ROUTE_NAMESPACE',
+}
+
+/**
+ * Symbols to use IoC container global methods.
+ */
+export const iocMethods = {
+  use: Symbol.for('ioc.use'),
+  make: Symbol.for('ioc.make'),
+  call: Symbol.for('ioc.call'),
 }

test/middleware-store.spec.ts

@@ -76,17 +76,17 @@ test.group('Middleware', () => {
 
     const ioc = new Ioc()
     ioc.bind('App/Middleware', () => new Middleware())
-    global['use'] = ioc.use.bind(ioc)
-    global['make'] = ioc.make.bind(ioc)
+    global[Symbol.for('ioc.use')] = ioc.use.bind(ioc)
+    global[Symbol.for('ioc.make')] = ioc.make.bind(ioc)
 
     const middleware = new MiddlewareStore()
     middleware.register(['App/Middleware'])
     await finalMiddlewareHandler(middleware.get()[0], [{}, async () => {}])
 
     assert.deepEqual(stack, ['middleware class'])
 
-    delete global['use']
-    delete global['make']
+    delete global[Symbol.for('ioc.use')]
+    delete global[Symbol.for('ioc.make')]
   })
 
   test('process route middleware using the store', async (assert) => {

test/route-pre-processor.spec.ts

@@ -16,8 +16,8 @@ import { routePreProcessor } from '../src/Server/routePreProcessor'
 
 test.group('Route pre processor', (group) => {
   group.afterEach(() => {
-    delete global['use']
-    delete global['make']
+    delete global[Symbol.for('ioc.use')]
+    delete global[Symbol.for('ioc.make')]
   })
 
   test('process route by resolving function based middleware', (assert) => {
@@ -63,7 +63,7 @@ test.group('Route pre processor', (group) => {
 
     const ioc = new Ioc()
     ioc.bind('App/Middleware/Auth', () => Auth)
-    global['use'] = ioc.use.bind(ioc)
+    global[Symbol.for('ioc.use')] = ioc.use.bind(ioc)
 
     middlewareStore.registerNamed({ auth: 'App/Middleware/Auth' })
 
@@ -102,7 +102,7 @@ test.group('Route pre processor', (group) => {
 
     const ioc = new Ioc()
     ioc.bind('App/Controllers/Http/UserController', () => UserController)
-    global['use'] = ioc.use.bind(ioc)
+    global[Symbol.for('ioc.use')] = ioc.use.bind(ioc)
 
     const route = router.get('/', 'UserController.store').toJSON()
     routePreProcessor(route, middlewareStore)
@@ -124,7 +124,7 @@ test.group('Route pre processor', (group) => {
 
     const ioc = new Ioc()
     ioc.bind('UserController', () => UserController)
-    global['use'] = ioc.use.bind(ioc)
+    global[Symbol.for('ioc.use')] = ioc.use.bind(ioc)
 
     const route = router.get('/', '/UserController.store').toJSON()
     routePreProcessor(route, middlewareStore)
@@ -146,12 +146,12 @@ test.group('Route pre processor', (group) => {
 
     const ioc = new Ioc()
     ioc.bind('UserController', () => UserController)
-    global['use'] = ioc.use.bind(ioc)
+    global[Symbol.for('ioc.use')] = ioc.use.bind(ioc)
 
     const route = router.get('/', '/UserController').toJSON()
     const fn = () => routePreProcessor(route, middlewareStore)
 
-    assert.throw(fn, 'Missing controller method on `/` route')
+    assert.throw(fn, 'E_INVALID_IOC_NAMESPACE: Missing method reference on {/UserController} namespace')
   })
 
   test('raise error when controller method is missing', (_assert) => {
@@ -163,7 +163,7 @@ test.group('Route pre processor', (group) => {
 
     const ioc = new Ioc()
     ioc.bind('App/Controllers/Http/UserController', () => UserController)
-    global['use'] = ioc.use.bind(ioc)
+    global[Symbol.for('ioc.use')] = ioc.use.bind(ioc)
 
     const route = router.get('/', '/UserController.store').toJSON()
     routePreProcessor(route, middlewareStore)

test/server.spec.ts

@@ -739,8 +739,9 @@ test.group('Server | error handler', () => {
 
 test.group('Server | all', (group) => {
   group.afterEach(() => {
-    delete global['use']
-    delete global['make']
+    delete global[Symbol.for('ioc.use')]
+    delete global[Symbol.for('ioc.call')]
+    delete global[Symbol.for('ioc.make')]
   })
 
   test('raise 404 when route is missing', async (assert) => {
@@ -769,8 +770,8 @@ test.group('Server | all', (group) => {
 
     const ioc = new Ioc()
     ioc.bind('App/Controllers/Http/HomeController', () => new HomeController())
-    global['make'] = ioc.make.bind(ioc)
-    global['iocCall'] = ioc.call.bind(ioc)
+    global[Symbol.for('ioc.make')] = ioc.make.bind(ioc)
+    global[Symbol.for('ioc.call')] = ioc.call.bind(ioc)
 
     router.get('/', 'HomeController.index')