feat: add getRoutes method to list registered routes

index.js

@@ -441,6 +441,27 @@ Router.prototype.route = function route (path) {
   return route
 }
 
+/**
+ * List all registered routes.
+ *
+ * @return {Array} An array of route paths
+ * @private
+ */
+Router.prototype._mapRoutes = function mapRoutes () {
+  const routes = []
+  const stack = this.stack
+  const routeMap = new Map()
+
+  collectRoutes(stack, '', routeMap)
+
+  // Convert Map to array of route objects
+  for (const [path, methods] of routeMap.entries()) {
+    routes.push({ path, methods })
+  }
+
+  return routes
+}
+
 // create Router#VERB functions
 methods.concat('all').forEach(function (method) {
   Router.prototype[method] = function (path) {
@@ -450,6 +471,83 @@ methods.concat('all').forEach(function (method) {
   }
 })
 
+/**
+ * Add a route to the map with the given path and methods.
+ * @param {Map} routeMap
+ * @param {string} path
+ * @param {Array} methods
+ * @private
+ */
+function addRouteToMap (routeMap, path, methods) {
+  if (routeMap.has(path)) {
+    const existingMethods = routeMap.get(path)
+    for (const method of methods) {
+      if (!existingMethods.includes(method)) {
+        existingMethods.push(method)
+      }
+    }
+  } else {
+    routeMap.set(path, [...methods])
+  }
+}
+
+/**
+ * Normalize a path by removing trailing slashes.
+ * @param {string} path
+ * @return {string} normalized path
+ * @private
+ */
+function normalizePath (path) {
+  if (typeof path !== 'string') {
+    return path
+  }
+
+  if (path.endsWith('/') && path.length > 1) {
+    return path.slice(0, -1)
+  }
+
+  return path
+}
+
+/**
+ * Collect routes from a router stack recursively.
+ *
+ * @param {Array} stack - The router stack to collect routes from
+ * @param {string} prefix - The path prefix to prepend to routes
+ * @param {Map} routeMap - The map to store collected routes
+ * @private
+ */
+function collectRoutes (stack, prefix, routeMap) {
+  for (const layer of stack) {
+    // for routes without a .use
+    if (layer.pathPatterns && layer.route) {
+      const methods = Object.keys(layer.route.methods).map((method) => method.toUpperCase())
+      if (Array.isArray(layer.pathPatterns)) {
+        for (const pathPattern of layer.pathPatterns) {
+          const fullPath = prefix + pathPattern
+          addRouteToMap(routeMap, fullPath, methods)
+        }
+      } else {
+        const fullPath = prefix + layer.pathPatterns
+        addRouteToMap(routeMap, fullPath, methods)
+      }
+    }
+
+    // for layers with a .use (mounted routers)
+    if (layer.pathPatterns && layer.handle && layer.handle.stack && !layer.route) {
+      if (Array.isArray(layer.pathPatterns)) {
+        for (const pathPattern of layer.pathPatterns) {
+          const pathPrefix = prefix + normalizePath(pathPattern)
+          collectRoutes(layer.handle.stack, pathPrefix, routeMap)
+        }
+      } else {
+        const pathPrefix = prefix + normalizePath(layer.pathPatterns)
+        collectRoutes(layer.handle.stack, pathPrefix, routeMap)
+      }
+    }
+  }
+}
+
 /**
  * Generate a callback that will make an OPTIONS response.
  *

lib/layer.js

@@ -43,7 +43,10 @@ function Layer (path, options, fn) {
   this.keys = []
   this.name = fn.name || '<anonymous>'
   this.params = undefined
+  // path is determinate in runtime execution
   this.path = undefined
+
+  this.pathPatterns = path
   this.slash = path === '/' && opts.end === false
 
   function matcher (_path) {

test/mapRoutes.js

@@ -0,0 +1,115 @@
+const { it, describe } = require('mocha')
+const Router = require('..')
+const utils = require('./support/utils')
+
+const assert = utils.assert
+
+describe('_mapRoutes', function () {
+  it('should return empty array for router with no registered routes', function () {
+    const router = new Router()
+
+    assert.deepStrictEqual(router._mapRoutes(), [])
+  })
+
+  it('should map different route types including strings, regex patterns, and parameter routes', function () {
+    const router = new Router()
+
+    router.all('/', noop)
+    router.route('/test2/')
+    router.route('/test/').get(noop)
+    router.all(/^\/[a-z]oo$/, noop)
+    router.get(['/foo', '/bar'], noop)
+    router.post('/:id/setting/:thing', noop)
+
+    assert.deepStrictEqual(router._mapRoutes(),
+      [
+        { path: '/', methods: ['_ALL'] },
+        { path: '/test2/', methods: [] },
+        { path: '/test/', methods: ['GET'] },
+        { path: '/^\\/[a-z]oo$/', methods: ['_ALL'] },
+        { path: '/foo', methods: ['GET'] },
+        { path: '/bar', methods: ['GET'] },
+        { path: '/:id/setting/:thing', methods: ['POST'] }
+      ])
+  })
+
+  it('should consolidate HTTP methods for routes registered multiple times', function () {
+    const router = new Router()
+    router.post(['/test', '/test2'], noop)
+
+    for (let i = 0; i < 20; i++) {
+      router.get(['/test', '/test3'], noop)
+    }
+
+    router.put('/test3', noop)
+
+    assert.deepStrictEqual(router._mapRoutes(), [
+      { path: '/test', methods: ['POST', 'GET'] },
+      { path: '/test2', methods: ['POST'] },
+      { path: '/test3', methods: ['GET', 'PUT'] }
+    ])
+  })
+
+  it('should deduplicate routes and flatten nested router paths correctly', function () {
+    const router = new Router()
+    const inner = new Router()
+    router.post('/test', noop)
+
+    for (let i = 0; i < 100; i++) {
+      router.get('/test', noop)
+    }
+
+    for (let i = 0; i < 20; i++) {
+      inner.get('/test', noop)
+    }
+
+    router.use(['/test/', '/test2', '/test3'], inner)
+    router.use('/test4/', inner)
+
+    assert.deepStrictEqual(router._mapRoutes(), [
+      { path: '/test', methods: ['POST', 'GET'] },
+      { path: '/test/test', methods: ['GET'] },
+      { path: '/test2/test', methods: ['GET'] },
+      { path: '/test3/test', methods: ['GET'] },
+      { path: '/test4/test', methods: ['GET'] }
+    ])
+  })
+
+  it('should handle complex nested router hierarchies with multiple mount points', function () {
+    const router = new Router()
+    const inner = new Router()
+    const subinner = new Router()
+
+    subinner.put('/t5', noop)
+    subinner.all(/^\/[a-z]oo$/, noop)
+    subinner.use(noop)
+
+    inner.use('/t3', subinner)
+    inner.all('/t4', noop)
+    inner.get('/', noop)
+    inner.use(noop)
+
+    router.use('/t2', inner)
+    router.use(['/t5', '/t7'], inner)
+
+    router.use(noop)
+    router.use('/test1', noop)
+
+    assert.deepStrictEqual(router._mapRoutes(), [
+      { path: '/t2/t3/t5', methods: ['PUT'] },
+      { path: '/t2/t3/^\\/[a-z]oo$/', methods: ['_ALL'] },
+      { path: '/t2/t4', methods: ['_ALL'] },
+      { path: '/t2/', methods: ['GET'] },
+      { path: '/t5/t3/t5', methods: ['PUT'] },
+      { path: '/t5/t3/^\\/[a-z]oo$/', methods: ['_ALL'] },
+      { path: '/t5/t4', methods: ['_ALL'] },
+      { path: '/t5/', methods: ['GET'] },
+      { path: '/t7/t3/t5', methods: ['PUT'] },
+      { path: '/t7/t3/^\\/[a-z]oo$/', methods: ['_ALL'] },
+      { path: '/t7/t4', methods: ['_ALL'] },
+      { path: '/t7/', methods: ['GET'] }
+    ])
+  })
+})
+
+function noop () {}