adapt-authoring-server 1.4.2 → 2.0.0

package/index.js

@@ -2,4 +2,5 @@
  * HTTP server functionality using Express.js
  * @namespace server
  */
+export { addExistenceProps, cacheRouteConfig, generateRouterMap, getAllRoutes, mapHandler } from './lib/utils.js'
 export { default } from './lib/ServerModule.js'

package/lib/Router.js

@@ -2,6 +2,9 @@ import _ from 'lodash'
 import { App } from 'adapt-authoring-core'
 import express from 'express'
 import ServerUtils from './ServerUtils.js'
+import { addExistenceProps } from './utils/addExistenceProps.js'
+import { cacheRouteConfig } from './utils/cacheRouteConfig.js'
+import { generateRouterMap } from './utils/generateRouterMap.js'
 /**
  * Handles the Express routing functionality
  * @memberof server
@@ -54,7 +57,7 @@ class Router {
      * @type {Array<Function>}
      */
     this.handlerMiddleware = [
-      ServerUtils.addExistenceProps,
+      addExistenceProps,
       ServerUtils.handleInternalRoutes,
       ...handlerMiddleware.filter(_.isFunction)
     ]
@@ -66,7 +69,7 @@ class Router {
    * @type {Object}
    */
   get map () {
-    return ServerUtils.generateRouterMap(this)
+    return generateRouterMap(this)
   }
 
   /**
@@ -226,7 +229,7 @@ class Router {
     if (this.routes.length) {
       this.routes.forEach(r => {
         Object.entries(r.handlers).forEach(([method, handler]) => {
-          this.expressRouter[method](r.route, ServerUtils.cacheRouteConfig(r), ...this.getHandlerMiddleware(), handler)
+          this.expressRouter[method](r.route, cacheRouteConfig(r), ...this.getHandlerMiddleware(), handler)
           this.log('verbose', 'ADD_ROUTE', method.toUpperCase(), `${this.path !== '/' ? this.path : ''}${r.route}`)
         })
       })

package/lib/ServerUtils.js

@@ -1,5 +1,6 @@
-import _ from 'lodash'
 import { App } from 'adapt-authoring-core'
+import { getAllRoutes } from './utils/getAllRoutes.js'
+
 /**
  * Server-related utilities
  * @memberof server
@@ -23,7 +24,7 @@ class ServerUtils {
    */
   static methodNotAllowedHandler (router) {
     const routePatterns = []
-    const routeMap = ServerUtils.getAllRoutes(router)
+    const routeMap = getAllRoutes(router)
 
     for (const [path, methods] of routeMap.entries()) {
       const pathPattern = path
@@ -75,55 +76,6 @@ class ServerUtils {
     res.status(App.instance.errors.NOT_FOUND.statusCode).end()
   }
 
-  /**
-   * Handler for returning an API map
-   * @param {Router} topRouter
-   * @return {Function} Middleware function
-   */
-  static mapHandler (topRouter) {
-    return (req, res) => res.json(topRouter.map)
-  }
-
-  /**
-   * Collects all registered routes with their methods across the router hierarchy
-   * @param {Router} router The router to traverse
-   * @return {Map<string, Set<string>>} Map of route paths to sets of allowed methods
-   */
-  static getAllRoutes (router) {
-    const routeMap = new Map()
-
-    router.flattenRouters().forEach(r => {
-      r.routes.forEach(route => {
-        const fullPath = `${r.path !== '/' ? r.path : ''}${route.route}`
-
-        if (!routeMap.has(fullPath)) {
-          routeMap.set(fullPath, new Set())
-        }
-
-        Object.keys(route.handlers).forEach(method => {
-          routeMap.get(fullPath).add(method.toUpperCase())
-        })
-      })
-    })
-
-    return routeMap
-  }
-
-  /**
-   * Generates a map for a given router
-   * @param {Router} topRouter
-   * @return {Object} The route map
-   */
-  static generateRouterMap (topRouter) {
-    return topRouter.flattenRouters()
-      .sort((a, b) => a.root.localeCompare(b.root))
-      .reduce((m, r) => {
-        const key = `${getRelativeRoute(topRouter, r)}endpoints`
-        const endpoints = getEndpoints(r)
-        return endpoints.length ? { ...m, [key]: endpoints } : m
-      }, {})
-  }
-
   /**
    * Adds extra properties to the request object to allow for easy translations
    * @param {Function} next
@@ -160,47 +112,6 @@ class ServerUtils {
     next()
   }
 
-  /**
-   * Adds extra properties to the request object to allow for easy existence checking of common request objects
-   * @param {external:ExpressRequest} req
-   * @param {external:ExpressResponse} res
-   * @param {Function} next
-   * @example
-   * "IMPORTANT NOTE: body data is completely ignored for GET requests, any code
-   * requiring it should switch to use POST."
-   *
-   * let req = { 'params': { 'foo':'bar' }, 'query': {}, 'body': {} };
-   * req.hasParams // true
-   * req.hasQuery // false
-   * req.hasBody // false
-   */
-  static addExistenceProps (req, res, next) {
-    if (req.method === 'GET') {
-      req.body = {}
-    }
-    const storeVal = (key, exists) => {
-      req[`has${_.capitalize(key)}`] = exists
-    }
-    ['body', 'params', 'query'].forEach(attr => {
-      if (!req[attr]) {
-        return storeVal(attr, false)
-      }
-      const entries = Object.entries(req[attr])
-      let deleted = 0
-      if (entries.length === 0) {
-        return storeVal(attr, false)
-      }
-      entries.forEach(([key, val]) => {
-        if (val === undefined || val === null) {
-          delete req[attr][key]
-          deleted++
-        }
-      })
-      storeVal(attr, deleted < entries.length)
-    })
-    next()
-  }
-
   /**
    * Handles restriction of routes marked as internal
    * @param {external:ExpressRequest} req
@@ -215,39 +126,6 @@ class ServerUtils {
     }
     next()
   }
-
-  /**
-   * Caches the route config on the incoming request
-   * @param {Route} routeConfig
-   * @return {Function}
-   */
-  static cacheRouteConfig (routeConfig) {
-    return (req, res, next) => {
-      req.routeConfig = routeConfig
-      next()
-    }
-  }
-}
-/** @ignore */ function getEndpoints (r) {
-  return r.routes.map(route => {
-    return {
-      url: `${r.url}${route.route}`,
-      accepted_methods: Object.keys(route.handlers).reduce((memo, method) => {
-        return {
-          ...memo,
-          [method]: route?.meta?.[method] ?? {}
-        }
-      }, {})
-    }
-  })
-}
-/** @ignore */ function getRelativeRoute (relFrom, relTo) {
-  if (relFrom === relTo) {
-    return `${relFrom.route}_`
-  }
-  let route = ''
-  for (let r = relTo; r !== relFrom; r = r.parentRouter) route = `${r.root}_${route}`
-  return route
 }
 
 export default ServerUtils

package/lib/utils/addExistenceProps.js

@@ -0,0 +1,43 @@
+import _ from 'lodash'
+
+/**
+ * Adds extra properties to the request object to allow for easy existence checking of common request objects
+ * @param {external:ExpressRequest} req
+ * @param {external:ExpressResponse} res
+ * @param {Function} next
+ * @memberof server
+ * @example
+ * "IMPORTANT NOTE: body data is completely ignored for GET requests, any code
+ * requiring it should switch to use POST."
+ *
+ * let req = { 'params': { 'foo':'bar' }, 'query': {}, 'body': {} };
+ * req.hasParams // true
+ * req.hasQuery // false
+ * req.hasBody // false
+ */
+export function addExistenceProps (req, res, next) {
+  if (req.method === 'GET') {
+    req.body = {}
+  }
+  const storeVal = (key, exists) => {
+    req[`has${_.capitalize(key)}`] = exists
+  }
+  ;['body', 'params', 'query'].forEach(attr => {
+    if (!req[attr]) {
+      return storeVal(attr, false)
+    }
+    const entries = Object.entries(req[attr])
+    let deleted = 0
+    if (entries.length === 0) {
+      return storeVal(attr, false)
+    }
+    entries.forEach(([key, val]) => {
+      if (val === undefined || val === null) {
+        delete req[attr][key]
+        deleted++
+      }
+    })
+    storeVal(attr, deleted < entries.length)
+  })
+  next()
+}

package/lib/utils/cacheRouteConfig.js

@@ -0,0 +1,12 @@
+/**
+ * Caches the route config on the incoming request
+ * @param {Route} routeConfig
+ * @return {Function}
+ * @memberof server
+ */
+export function cacheRouteConfig (routeConfig) {
+  return (req, res, next) => {
+    req.routeConfig = routeConfig
+    next()
+  }
+}

package/lib/utils/generateRouterMap.js

@@ -0,0 +1,40 @@
+/**
+ * Generates a map for a given router
+ * @param {Router} topRouter
+ * @return {Object} The route map
+ * @memberof server
+ */
+export function generateRouterMap (topRouter) {
+  return topRouter.flattenRouters()
+    .sort((a, b) => a.root.localeCompare(b.root))
+    .reduce((m, r) => {
+      const key = `${getRelativeRoute(topRouter, r)}endpoints`
+      const endpoints = getEndpoints(r)
+      return endpoints.length ? { ...m, [key]: endpoints } : m
+    }, {})
+}
+
+/** @ignore */
+function getEndpoints (r) {
+  return r.routes.map(route => {
+    return {
+      url: `${r.url}${route.route}`,
+      accepted_methods: Object.keys(route.handlers).reduce((memo, method) => {
+        return {
+          ...memo,
+          [method]: route?.meta?.[method] ?? {}
+        }
+      }, {})
+    }
+  })
+}
+
+/** @ignore */
+function getRelativeRoute (relFrom, relTo) {
+  if (relFrom === relTo) {
+    return `${relFrom.route}_`
+  }
+  let route = ''
+  for (let r = relTo; r !== relFrom; r = r.parentRouter) route = `${r.root}_${route}`
+  return route
+}

package/lib/utils/getAllRoutes.js

@@ -0,0 +1,25 @@
+/**
+ * Collects all registered routes with their methods across the router hierarchy
+ * @param {Router} router The router to traverse
+ * @return {Map<string, Set<string>>} Map of route paths to sets of allowed methods
+ * @memberof server
+ */
+export function getAllRoutes (router) {
+  const routeMap = new Map()
+
+  router.flattenRouters().forEach(r => {
+    r.routes.forEach(route => {
+      const fullPath = `${r.path !== '/' ? r.path : ''}${route.route}`
+
+      if (!routeMap.has(fullPath)) {
+        routeMap.set(fullPath, new Set())
+      }
+
+      Object.keys(route.handlers).forEach(method => {
+        routeMap.get(fullPath).add(method.toUpperCase())
+      })
+    })
+  })
+
+  return routeMap
+}

package/lib/utils/mapHandler.js

@@ -0,0 +1,9 @@
+/**
+ * Handler for returning an API map
+ * @param {Router} topRouter
+ * @return {Function} Middleware function
+ * @memberof server
+ */
+export function mapHandler (topRouter) {
+  return (req, res) => res.json(topRouter.map)
+}

package/lib/utils.js

@@ -0,0 +1,5 @@
+export { addExistenceProps } from './utils/addExistenceProps.js'
+export { cacheRouteConfig } from './utils/cacheRouteConfig.js'
+export { generateRouterMap } from './utils/generateRouterMap.js'
+export { getAllRoutes } from './utils/getAllRoutes.js'
+export { mapHandler } from './utils/mapHandler.js'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "adapt-authoring-server",
-  "version": "1.4.2",
+  "version": "2.0.0",
   "description": "Provides an Express application routing and more",
   "homepage": "https://github.com/adapt-security/adapt-authoring-server",
   "license": "GPL-3.0",
@@ -11,7 +11,7 @@
     "test": "node --test tests/**/*.spec.js"
   },
   "dependencies": {
-    "adapt-authoring-core": "^1.7.0",
+    "adapt-authoring-core": "^2.0.0",
     "express": "^5.1.0",
     "hbs": "^4.2.0",
     "lodash": "^4.17.21"

package/tests/ServerUtils.spec.js

@@ -16,104 +16,6 @@ describe('ServerUtils', () => {
     ServerUtils = (await import('../lib/ServerUtils.js')).default
   })
 
-  describe('#addExistenceProps()', () => {
-    it('should set hasBody, hasParams, hasQuery to false for empty objects', () => {
-      const req = { method: 'POST', body: {}, params: {}, query: {} }
-      const res = {}
-      let nextCalled = false
-      const next = () => { nextCalled = true }
-
-      ServerUtils.addExistenceProps(req, res, next)
-
-      assert.equal(req.hasBody, false)
-      assert.equal(req.hasParams, false)
-      assert.equal(req.hasQuery, false)
-      assert.equal(nextCalled, true)
-    })
-
-    it('should set hasBody, hasParams, hasQuery to true for populated objects', () => {
-      const req = { method: 'POST', body: { foo: 'bar' }, params: { id: '123' }, query: { search: 'test' } }
-      const res = {}
-      let nextCalled = false
-      const next = () => { nextCalled = true }
-
-      ServerUtils.addExistenceProps(req, res, next)
-
-      assert.equal(req.hasBody, true)
-      assert.equal(req.hasParams, true)
-      assert.equal(req.hasQuery, true)
-      assert.equal(nextCalled, true)
-    })
-
-    it('should remove undefined and null values from request objects', () => {
-      const req = { method: 'POST', body: { foo: 'bar', baz: undefined, qux: null }, params: {}, query: {} }
-      const res = {}
-      const next = () => {}
-
-      ServerUtils.addExistenceProps(req, res, next)
-
-      assert.equal(req.body.foo, 'bar')
-      assert.equal(req.body.baz, undefined)
-      assert.equal(req.body.qux, undefined)
-      assert.equal(req.hasBody, true)
-    })
-
-    it('should clear body for GET requests', () => {
-      const req = { method: 'GET', body: { foo: 'bar' }, params: {}, query: {} }
-      const res = {}
-      const next = () => {}
-
-      ServerUtils.addExistenceProps(req, res, next)
-
-      assert.deepEqual(req.body, {})
-      assert.equal(req.hasBody, false)
-    })
-
-    it('should handle falsy attr values (missing body/params/query)', () => {
-      const req = { method: 'POST', body: null, params: undefined, query: false }
-      const res = {}
-      const next = () => {}
-
-      ServerUtils.addExistenceProps(req, res, next)
-
-      assert.equal(req.hasBody, false)
-      assert.equal(req.hasParams, false)
-      assert.equal(req.hasQuery, false)
-    })
-
-    it('should mark has* false when all entries are null or undefined', () => {
-      const req = { method: 'POST', body: { a: null, b: undefined }, params: {}, query: {} }
-      const res = {}
-      const next = () => {}
-
-      ServerUtils.addExistenceProps(req, res, next)
-
-      assert.equal(req.hasBody, false)
-    })
-  })
-
-  describe('#cacheRouteConfig()', () => {
-    it('should cache route config on request object', () => {
-      const routeConfig = { route: '/test', handlers: {}, internal: false }
-      const middleware = ServerUtils.cacheRouteConfig(routeConfig)
-      const req = {}
-      const res = {}
-      let nextCalled = false
-      const next = () => { nextCalled = true }
-
-      middleware(req, res, next)
-
-      assert.equal(req.routeConfig, routeConfig)
-      assert.equal(nextCalled, true)
-    })
-
-    it('should return a middleware function', () => {
-      const middleware = ServerUtils.cacheRouteConfig({})
-
-      assert.equal(typeof middleware, 'function')
-    })
-  })
-
   describe('#addErrorHandler()', () => {
     it('should add sendError method to response object', () => {
       const req = {}
@@ -251,100 +153,6 @@ describe('ServerUtils', () => {
     })
   })
 
-  describe('#mapHandler()', () => {
-    it('should return a function', () => {
-      const mockRouter = { map: { test: 'data' } }
-      const handler = ServerUtils.mapHandler(mockRouter)
-
-      assert.equal(typeof handler, 'function')
-    })
-
-    it('should respond with router map', () => {
-      const mockRouter = { map: { test: 'data' } }
-      const handler = ServerUtils.mapHandler(mockRouter)
-      const req = {}
-      let responseData = null
-      const res = {
-        json: (data) => { responseData = data }
-      }
-
-      handler(req, res)
-
-      assert.deepEqual(responseData, { test: 'data' })
-    })
-  })
-
-  describe('#getAllRoutes()', () => {
-    it('should collect routes from router hierarchy', () => {
-      const mockRouter = {
-        path: '/api',
-        routes: [
-          { route: '/users', handlers: { get: () => {}, post: () => {} } },
-          { route: '/posts', handlers: { get: () => {} } }
-        ],
-        flattenRouters: () => [mockRouter]
-      }
-
-      const routeMap = ServerUtils.getAllRoutes(mockRouter)
-
-      assert.ok(routeMap instanceof Map)
-      assert.equal(routeMap.size, 2)
-      assert.ok(routeMap.has('/api/users'))
-      assert.ok(routeMap.has('/api/posts'))
-      assert.ok(routeMap.get('/api/users').has('GET'))
-      assert.ok(routeMap.get('/api/users').has('POST'))
-      assert.ok(routeMap.get('/api/posts').has('GET'))
-    })
-
-    it('should collect routes from multiple routers in hierarchy', () => {
-      const childRouter = {
-        path: '/api/v1',
-        routes: [
-          { route: '/items', handlers: { get: () => {} } }
-        ]
-      }
-      const parentRouter = {
-        path: '/api',
-        routes: [
-          { route: '/health', handlers: { get: () => {} } }
-        ],
-        flattenRouters: () => [parentRouter, childRouter]
-      }
-
-      const routeMap = ServerUtils.getAllRoutes(parentRouter)
-
-      assert.equal(routeMap.size, 2)
-      assert.ok(routeMap.has('/api/health'))
-      assert.ok(routeMap.has('/api/v1/items'))
-    })
-
-    it('should handle root path "/" by omitting it from the prefix', () => {
-      const mockRouter = {
-        path: '/',
-        routes: [
-          { route: '/status', handlers: { get: () => {} } }
-        ],
-        flattenRouters: () => [mockRouter]
-      }
-
-      const routeMap = ServerUtils.getAllRoutes(mockRouter)
-
-      assert.ok(routeMap.has('/status'))
-    })
-
-    it('should return empty map for router with no routes', () => {
-      const mockRouter = {
-        path: '/api',
-        routes: [],
-        flattenRouters: () => [mockRouter]
-      }
-
-      const routeMap = ServerUtils.getAllRoutes(mockRouter)
-
-      assert.equal(routeMap.size, 0)
-    })
-  })
-
   describe('#methodNotAllowedHandler()', () => {
     it('should return a middleware function', () => {
       const mockRouter = {
@@ -420,103 +228,6 @@ describe('ServerUtils', () => {
     })
   })
 
-  describe('#generateRouterMap()', () => {
-    it('should generate a router map', () => {
-      const mockRouter = {
-        root: 'api',
-        path: '/api',
-        url: 'http://localhost:5000/api',
-        routes: [
-          { route: '/test', handlers: { get: () => {} } }
-        ],
-        childRouters: [],
-        flattenRouters: function () {
-          return [this]
-        }
-      }
-
-      const map = ServerUtils.generateRouterMap(mockRouter)
-
-      assert.equal(typeof map, 'object')
-    })
-
-    it('should return empty object for router with no routes', () => {
-      const mockRouter = {
-        root: 'api',
-        path: '/api',
-        url: 'http://localhost:5000/api',
-        routes: [],
-        childRouters: [],
-        flattenRouters: function () {
-          return [this]
-        }
-      }
-
-      const map = ServerUtils.generateRouterMap(mockRouter)
-
-      assert.deepEqual(map, {})
-    })
-
-    it('should include endpoint URLs and accepted methods', () => {
-      const mockRouter = {
-        root: 'api',
-        route: '/api',
-        path: '/api',
-        url: 'http://localhost:5000/api',
-        routes: [
-          { route: '/users', handlers: { get: () => {}, post: () => {} }, meta: { get: { description: 'list users' } } }
-        ],
-        childRouters: [],
-        parentRouter: null,
-        flattenRouters: function () {
-          return [this]
-        }
-      }
-
-      const map = ServerUtils.generateRouterMap(mockRouter)
-      const keys = Object.keys(map)
-
-      assert.ok(keys.length > 0)
-      const endpoints = map[keys[0]]
-      assert.ok(Array.isArray(endpoints))
-      assert.equal(endpoints[0].url, 'http://localhost:5000/api/users')
-      assert.ok('get' in endpoints[0].accepted_methods)
-      assert.ok('post' in endpoints[0].accepted_methods)
-      assert.deepEqual(endpoints[0].accepted_methods.get, { description: 'list users' })
-      assert.deepEqual(endpoints[0].accepted_methods.post, {})
-    })
-
-    it('should use relative route keys for child routers', () => {
-      const childRouter = {
-        root: 'users',
-        path: '/api/users',
-        url: 'http://localhost:5000/api/users',
-        routes: [
-          { route: '/:id', handlers: { get: () => {} } }
-        ],
-        childRouters: [],
-        parentRouter: null
-      }
-      const mockRouter = {
-        root: 'api',
-        route: '/api',
-        path: '/api',
-        url: 'http://localhost:5000/api',
-        routes: [],
-        childRouters: [childRouter],
-        flattenRouters: function () {
-          return [this, childRouter]
-        }
-      }
-      childRouter.parentRouter = mockRouter
-
-      const map = ServerUtils.generateRouterMap(mockRouter)
-      const keys = Object.keys(map)
-
-      assert.ok(keys.some(k => k.includes('users')))
-    })
-  })
-
   describe('#rootNotFoundHandler()', () => {
     it('should respond with NOT_FOUND status code', () => {
       App.instance.errors = App.instance.errors || {}

package/tests/utils-addExistenceProps.spec.js

@@ -0,0 +1,90 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import { addExistenceProps } from '../lib/utils/addExistenceProps.js'
+
+describe('addExistenceProps()', () => {
+  it('should set hasBody, hasParams, hasQuery to false for empty objects', () => {
+    const req = { method: 'POST', body: {}, params: {}, query: {} }
+    const res = {}
+    let nextCalled = false
+    const next = () => { nextCalled = true }
+
+    addExistenceProps(req, res, next)
+
+    assert.equal(req.hasBody, false)
+    assert.equal(req.hasParams, false)
+    assert.equal(req.hasQuery, false)
+    assert.equal(nextCalled, true)
+  })
+
+  it('should set hasBody, hasParams, hasQuery to true for populated objects', () => {
+    const req = { method: 'POST', body: { foo: 'bar' }, params: { id: '123' }, query: { search: 'test' } }
+    const res = {}
+    let nextCalled = false
+    const next = () => { nextCalled = true }
+
+    addExistenceProps(req, res, next)
+
+    assert.equal(req.hasBody, true)
+    assert.equal(req.hasParams, true)
+    assert.equal(req.hasQuery, true)
+    assert.equal(nextCalled, true)
+  })
+
+  it('should remove undefined and null values from request objects', () => {
+    const req = { method: 'POST', body: { foo: 'bar', baz: undefined, qux: null }, params: {}, query: {} }
+    const res = {}
+    const next = () => {}
+
+    addExistenceProps(req, res, next)
+
+    assert.equal(req.body.foo, 'bar')
+    assert.equal(req.body.baz, undefined)
+    assert.equal(req.body.qux, undefined)
+    assert.equal(req.hasBody, true)
+  })
+
+  it('should clear body for GET requests', () => {
+    const req = { method: 'GET', body: { foo: 'bar' }, params: {}, query: {} }
+    const res = {}
+    const next = () => {}
+
+    addExistenceProps(req, res, next)
+
+    assert.deepEqual(req.body, {})
+    assert.equal(req.hasBody, false)
+  })
+
+  it('should handle falsy attr values (missing body/params/query)', () => {
+    const req = { method: 'POST', body: null, params: undefined, query: false }
+    const res = {}
+    const next = () => {}
+
+    addExistenceProps(req, res, next)
+
+    assert.equal(req.hasBody, false)
+    assert.equal(req.hasParams, false)
+    assert.equal(req.hasQuery, false)
+  })
+
+  it('should mark has* false when all entries are null or undefined', () => {
+    const req = { method: 'POST', body: { a: null, b: undefined }, params: {}, query: {} }
+    const res = {}
+    const next = () => {}
+
+    addExistenceProps(req, res, next)
+
+    assert.equal(req.hasBody, false)
+  })
+
+  it('should always call next()', () => {
+    const req = { method: 'POST', body: {}, params: {}, query: {} }
+    const res = {}
+    let nextCalled = false
+    const next = () => { nextCalled = true }
+
+    addExistenceProps(req, res, next)
+
+    assert.equal(nextCalled, true)
+  })
+})

package/tests/utils-cacheRouteConfig.spec.js

@@ -0,0 +1,48 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import { cacheRouteConfig } from '../lib/utils/cacheRouteConfig.js'
+
+describe('cacheRouteConfig()', () => {
+  it('should return a middleware function', () => {
+    const middleware = cacheRouteConfig({})
+
+    assert.equal(typeof middleware, 'function')
+  })
+
+  it('should cache route config on request object', () => {
+    const routeConfig = { route: '/test', handlers: {}, internal: false }
+    const middleware = cacheRouteConfig(routeConfig)
+    const req = {}
+    const res = {}
+    let nextCalled = false
+    const next = () => { nextCalled = true }
+
+    middleware(req, res, next)
+
+    assert.equal(req.routeConfig, routeConfig)
+    assert.equal(nextCalled, true)
+  })
+
+  it('should always call next()', () => {
+    const middleware = cacheRouteConfig({})
+    const req = {}
+    const res = {}
+    let nextCalled = false
+    const next = () => { nextCalled = true }
+
+    middleware(req, res, next)
+
+    assert.equal(nextCalled, true)
+  })
+
+  it('should store the exact config reference', () => {
+    const config = { route: '/specific', internal: true }
+    const middleware = cacheRouteConfig(config)
+    const req = {}
+
+    middleware(req, {}, () => {})
+
+    assert.equal(req.routeConfig, config)
+    assert.equal(req.routeConfig.internal, true)
+  })
+})

package/tests/utils-generateRouterMap.spec.js

@@ -0,0 +1,138 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import { generateRouterMap } from '../lib/utils/generateRouterMap.js'
+
+describe('generateRouterMap()', () => {
+  it('should generate a router map', () => {
+    const mockRouter = {
+      root: 'api',
+      path: '/api',
+      url: 'http://localhost:5000/api',
+      routes: [
+        { route: '/test', handlers: { get: () => {} } }
+      ],
+      childRouters: [],
+      flattenRouters: function () {
+        return [this]
+      }
+    }
+
+    const map = generateRouterMap(mockRouter)
+
+    assert.equal(typeof map, 'object')
+  })
+
+  it('should return empty object for router with no routes', () => {
+    const mockRouter = {
+      root: 'api',
+      path: '/api',
+      url: 'http://localhost:5000/api',
+      routes: [],
+      childRouters: [],
+      flattenRouters: function () {
+        return [this]
+      }
+    }
+
+    const map = generateRouterMap(mockRouter)
+
+    assert.deepEqual(map, {})
+  })
+
+  it('should include endpoint URLs and accepted methods', () => {
+    const mockRouter = {
+      root: 'api',
+      route: '/api',
+      path: '/api',
+      url: 'http://localhost:5000/api',
+      routes: [
+        { route: '/users', handlers: { get: () => {}, post: () => {} }, meta: { get: { description: 'list users' } } }
+      ],
+      childRouters: [],
+      parentRouter: null,
+      flattenRouters: function () {
+        return [this]
+      }
+    }
+
+    const map = generateRouterMap(mockRouter)
+    const keys = Object.keys(map)
+
+    assert.ok(keys.length > 0)
+    const endpoints = map[keys[0]]
+    assert.ok(Array.isArray(endpoints))
+    assert.equal(endpoints[0].url, 'http://localhost:5000/api/users')
+    assert.ok('get' in endpoints[0].accepted_methods)
+    assert.ok('post' in endpoints[0].accepted_methods)
+    assert.deepEqual(endpoints[0].accepted_methods.get, { description: 'list users' })
+    assert.deepEqual(endpoints[0].accepted_methods.post, {})
+  })
+
+  it('should use relative route keys for child routers', () => {
+    const childRouter = {
+      root: 'users',
+      path: '/api/users',
+      url: 'http://localhost:5000/api/users',
+      routes: [
+        { route: '/:id', handlers: { get: () => {} } }
+      ],
+      childRouters: [],
+      parentRouter: null
+    }
+    const mockRouter = {
+      root: 'api',
+      route: '/api',
+      path: '/api',
+      url: 'http://localhost:5000/api',
+      routes: [],
+      childRouters: [childRouter],
+      flattenRouters: function () {
+        return [this, childRouter]
+      }
+    }
+    childRouter.parentRouter = mockRouter
+
+    const map = generateRouterMap(mockRouter)
+    const keys = Object.keys(map)
+
+    assert.ok(keys.some(k => k.includes('users')))
+  })
+
+  it('should sort routers alphabetically by root', () => {
+    const routerB = {
+      root: 'b-router',
+      path: '/api/b-router',
+      url: 'http://localhost:5000/api/b-router',
+      routes: [{ route: '/data', handlers: { get: () => {} } }],
+      childRouters: [],
+      parentRouter: null
+    }
+    const routerA = {
+      root: 'a-router',
+      path: '/api/a-router',
+      url: 'http://localhost:5000/api/a-router',
+      routes: [{ route: '/data', handlers: { get: () => {} } }],
+      childRouters: [],
+      parentRouter: null
+    }
+    const mockRouter = {
+      root: 'api',
+      route: '/api',
+      path: '/api',
+      url: 'http://localhost:5000/api',
+      routes: [],
+      childRouters: [routerB, routerA],
+      flattenRouters: function () {
+        return [routerB, routerA]
+      }
+    }
+    routerA.parentRouter = mockRouter
+    routerB.parentRouter = mockRouter
+
+    const map = generateRouterMap(mockRouter)
+    const keys = Object.keys(map)
+
+    assert.ok(keys[0].includes('a-router'))
+    assert.ok(keys[1].includes('b-router'))
+  })
+})

package/tests/utils-getAllRoutes.spec.js

@@ -0,0 +1,113 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import { getAllRoutes } from '../lib/utils/getAllRoutes.js'
+
+describe('getAllRoutes()', () => {
+  it('should collect routes from a single router', () => {
+    const mockRouter = {
+      path: '/api',
+      routes: [
+        { route: '/users', handlers: { get: () => {}, post: () => {} } },
+        { route: '/posts', handlers: { get: () => {} } }
+      ],
+      flattenRouters: () => [mockRouter]
+    }
+
+    const routeMap = getAllRoutes(mockRouter)
+
+    assert.ok(routeMap instanceof Map)
+    assert.equal(routeMap.size, 2)
+    assert.ok(routeMap.has('/api/users'))
+    assert.ok(routeMap.has('/api/posts'))
+    assert.ok(routeMap.get('/api/users').has('GET'))
+    assert.ok(routeMap.get('/api/users').has('POST'))
+    assert.ok(routeMap.get('/api/posts').has('GET'))
+  })
+
+  it('should collect routes from multiple routers in hierarchy', () => {
+    const childRouter = {
+      path: '/api/v1',
+      routes: [
+        { route: '/items', handlers: { get: () => {} } }
+      ]
+    }
+    const parentRouter = {
+      path: '/api',
+      routes: [
+        { route: '/health', handlers: { get: () => {} } }
+      ],
+      flattenRouters: () => [parentRouter, childRouter]
+    }
+
+    const routeMap = getAllRoutes(parentRouter)
+
+    assert.equal(routeMap.size, 2)
+    assert.ok(routeMap.has('/api/health'))
+    assert.ok(routeMap.has('/api/v1/items'))
+  })
+
+  it('should handle root path "/" by omitting it from the prefix', () => {
+    const mockRouter = {
+      path: '/',
+      routes: [
+        { route: '/status', handlers: { get: () => {} } }
+      ],
+      flattenRouters: () => [mockRouter]
+    }
+
+    const routeMap = getAllRoutes(mockRouter)
+
+    assert.ok(routeMap.has('/status'))
+  })
+
+  it('should return empty map for router with no routes', () => {
+    const mockRouter = {
+      path: '/api',
+      routes: [],
+      flattenRouters: () => [mockRouter]
+    }
+
+    const routeMap = getAllRoutes(mockRouter)
+
+    assert.equal(routeMap.size, 0)
+  })
+
+  it('should uppercase method names', () => {
+    const mockRouter = {
+      path: '/api',
+      routes: [
+        { route: '/data', handlers: { get: () => {}, post: () => {}, delete: () => {} } }
+      ],
+      flattenRouters: () => [mockRouter]
+    }
+
+    const routeMap = getAllRoutes(mockRouter)
+    const methods = routeMap.get('/api/data')
+
+    assert.ok(methods.has('GET'))
+    assert.ok(methods.has('POST'))
+    assert.ok(methods.has('DELETE'))
+  })
+
+  it('should merge methods for duplicate paths across routers', () => {
+    const router1 = {
+      path: '/api',
+      routes: [{ route: '/users', handlers: { get: () => {} } }]
+    }
+    const router2 = {
+      path: '/api',
+      routes: [{ route: '/users', handlers: { post: () => {} } }]
+    }
+    const parentRouter = {
+      path: '/api',
+      routes: [],
+      flattenRouters: () => [router1, router2]
+    }
+
+    const routeMap = getAllRoutes(parentRouter)
+
+    assert.equal(routeMap.size, 1)
+    assert.ok(routeMap.get('/api/users').has('GET'))
+    assert.ok(routeMap.get('/api/users').has('POST'))
+  })
+})

package/tests/utils-mapHandler.spec.js

@@ -0,0 +1,42 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import { mapHandler } from '../lib/utils/mapHandler.js'
+
+describe('mapHandler()', () => {
+  it('should return a function', () => {
+    const mockRouter = { map: { test: 'data' } }
+    const handler = mapHandler(mockRouter)
+
+    assert.equal(typeof handler, 'function')
+  })
+
+  it('should respond with router map as JSON', () => {
+    const mockRouter = { map: { test: 'data' } }
+    const handler = mapHandler(mockRouter)
+    const req = {}
+    let responseData = null
+    const res = {
+      json: (data) => { responseData = data }
+    }
+
+    handler(req, res)
+
+    assert.deepEqual(responseData, { test: 'data' })
+  })
+
+  it('should return the current map value on each call', () => {
+    const mockRouter = { map: { initial: true } }
+    const handler = mapHandler(mockRouter)
+    const res = { json: () => {} }
+
+    let captured
+    res.json = (data) => { captured = data }
+
+    handler({}, res)
+    assert.deepEqual(captured, { initial: true })
+
+    mockRouter.map = { updated: true }
+    handler({}, res)
+    assert.deepEqual(captured, { updated: true })
+  })
+})