fix: handle routes without a handler and do not crash when processing or routes fail

Author: thetutlage

src/code_scanners/routes_scanner/main.ts

@@ -243,7 +243,7 @@ export class RoutesScanner {
    */
   #processRouteWithoutController(route: RoutesListItem) {
     if (!route.name) {
-      debug(`skipping route "%s" as it does not have a name`, route.name)
+      debug(`skipping route "%s" as it does not have a name`, route.pattern)
       return
     }
 
@@ -275,7 +275,7 @@ export class RoutesScanner {
      * the case where someone imports the controllers and uses it by
      * reference
      */
-    if (!route.handler.importExpression) {
+    if (!route.handler || !route.handler.importExpression) {
       return this.#processRouteWithoutController(route)
     }
 

src/dev_server.ts

@@ -454,9 +454,14 @@ export class DevServer {
       return
     }
 
-    const invalidated = await this.#routesScanner.invalidate(filePath)
-    if (invalidated) {
-      await this.#hooks.runner('routesScanned').run(this, this.#routesScanner)
+    try {
+      const invalidated = await this.#routesScanner.invalidate(filePath)
+      if (invalidated) {
+        await this.#hooks.runner('routesScanned').run(this, this.#routesScanner)
+      }
+    } catch (error) {
+      this.ui.logger.error('Unable to rescan routes because of the following error')
+      this.ui.logger.fatal(error)
     }
   }
 
@@ -477,44 +482,49 @@ export class DevServer {
    * })
    */
   #processRoutes = throttle(async (routesFileLocation: string) => {
-    const scanRoutes = this.#hooks.has('routesScanning') || this.#hooks.has('routesScanned')
-    const shareRoutes = this.#hooks.has('routesCommitted')
+    try {
+      const scanRoutes = this.#hooks.has('routesScanning') || this.#hooks.has('routesScanned')
+      const shareRoutes = this.#hooks.has('routesCommitted')
 
-    /**
-     * Remove the routes file and return early when there are no
-     * hooks listening for routes related events
-     */
-    if (!scanRoutes && !shareRoutes) {
+      /**
+       * Remove the routes file and return early when there are no
+       * hooks listening for routes related events
+       */
+      if (!scanRoutes && !shareRoutes) {
+        unlink(routesFileLocation).catch(() => {})
+        return
+      }
+
+      /**
+       * Read routes JSON, parse it and remove the file
+       */
+      const routesJSON = await readFile(routesFileLocation, 'utf-8')
+      const routesList = JSON.parse(routesJSON)
       unlink(routesFileLocation).catch(() => {})
-      return
-    }
 
-    /**
-     * Read routes JSON, parse it and remove the file
-     */
-    const routesJSON = await readFile(routesFileLocation, 'utf-8')
-    const routesList = JSON.parse(routesJSON)
-    unlink(routesFileLocation).catch(() => {})
+      /**
+       * Notify about the existence of routes
+       */
+      if (shareRoutes) {
+        await this.#hooks.runner('routesCommitted').run(this, routesList)
+      }
 
-    /**
-     * Notify about the existence of routes
-     */
-    if (shareRoutes) {
-      await this.#hooks.runner('routesCommitted').run(this, routesList)
-    }
+      /**
+       * Scan routes and notify scanning and scanned hooks
+       */
+      if (scanRoutes) {
+        this.#routesScanner = new RoutesScanner(this.cwdPath, [])
+        await this.#hooks.runner('routesScanning').run(this, this.#routesScanner)
 
-    /**
-     * Scan routes and notify scanning and scanned hooks
-     */
-    if (scanRoutes) {
-      this.#routesScanner = new RoutesScanner(this.cwdPath, [])
-      await this.#hooks.runner('routesScanning').run(this, this.#routesScanner)
+        for (const domain of Object.keys(routesList)) {
+          await this.#routesScanner.scan(routesList[domain])
+        }
 
-      for (const domain of Object.keys(routesList)) {
-        await this.#routesScanner.scan(routesList[domain])
+        await this.#hooks.runner('routesScanned').run(this, this.#routesScanner)
       }
-
-      await this.#hooks.runner('routesScanned').run(this, this.#routesScanner)
+    } catch (error) {
+      this.ui.logger.error('Unable to process and scan routes because of the following error')
+      this.ui.logger.fatal(error)
     }
   }, 'processRoutes')
 

src/types/code_scanners.ts

@@ -189,12 +189,10 @@ export type RoutesListItem = {
   domain: string
   /** HTTP methods accepted by this route */
   methods: string[]
-  handler:
-    | Function
-    | {
-        method: string
-        importExpression: string | null
-      }
+  handler?: {
+    method: string
+    importExpression: string | null
+  }
   /** Parsed route tokens for URI construction */
   tokens: { val: string; old: string; type: 0 | 1 | 2 | 3; end: string }[]
 }

tests/code_scanners/routes_scanner.spec.ts

@@ -1424,4 +1424,81 @@ test.group('Routes scanner', () => {
       ]
     `)
   })
+
+  test('do not fail when route does not have a controller based handler', async ({
+    assert,
+    fs,
+  }) => {
+    await fs.createJson('package.json', {
+      imports: {
+        '#controllers/*': './app/controllers/*.ts',
+      },
+    })
+
+    const source = string.toUnixSlash(fs.basePath)
+    const scanner = new RoutesScanner(source, [])
+    scanner.pathsResolver.use((specifier) => {
+      const [namespace, ...rest] = specifier.split('/')
+      const fileName = rest.pop()
+      const resolvedPath = namespace === '#controllers' ? './app/controllers' : ''
+      return new URL([resolvedPath, ...rest, `${fileName}.ts`].join('/'), fs.baseUrl).href
+    })
+
+    await scanner.scan([
+      {
+        name: 'users.index',
+        domain: 'root',
+        methods: ['GET', 'HEAD'],
+        pattern: '/users',
+        tokens: [],
+      },
+    ])
+
+    assert.deepEqual(scanner.getControllers(), [])
+    assert.snapshot(scanner.getScannedRoutes()).matchInline(`
+      [
+        {
+          "domain": "root",
+          "methods": [
+            "GET",
+            "HEAD",
+          ],
+          "name": "users.index",
+          "pattern": "/users",
+          "request": undefined,
+          "response": undefined,
+          "tokens": [],
+        },
+      ]
+    `)
+  })
+
+  test('skip route if it does not have a name', async ({ assert, fs }) => {
+    await fs.createJson('package.json', {
+      imports: {
+        '#controllers/*': './app/controllers/*.ts',
+      },
+    })
+
+    const source = string.toUnixSlash(fs.basePath)
+    const scanner = new RoutesScanner(source, [])
+    scanner.pathsResolver.use((specifier) => {
+      const [namespace, ...rest] = specifier.split('/')
+      const fileName = rest.pop()
+      const resolvedPath = namespace === '#controllers' ? './app/controllers' : ''
+      return new URL([resolvedPath, ...rest, `${fileName}.ts`].join('/'), fs.baseUrl).href
+    })
+
+    await scanner.scan([
+      {
+        domain: 'root',
+        methods: ['GET', 'HEAD'],
+        pattern: '/users',
+        tokens: [],
+      },
+    ])
+
+    assert.deepEqual(scanner.getControllers(), [])
+    assert.snapshot(scanner.getScannedRoutes()).matchInline('[]')
+  })
 })