feat: add hasRoute method

Author: ivan-tymoshenko

README.md

@@ -389,6 +389,51 @@ router.off(['POST', 'GET'], '/example', { host: 'fastify.io' })
 router.off(['POST', 'GET'], '/example', {})
 ```
 
+#### findRoute (method, path, [constraints])
+
+Finds a route by server route's path (not like `find` which finds a route by the url). Returns the route object if found, otherwise returns `null`. `findRoute` does not compare routes paths directly, instead it compares only paths patters. This means that `findRoute` will return a route even if the path passed to it does not match the route's path exactly. For example, if a route is registered with the path `/example/:param1`, `findRoute` will return the route if the path passed to it is `/example/:param2`.
+
+```js
+const handler = (req, res, params) => {
+  res.end('Hello World!')
+}
+router.on('GET', '/:file(^\\S+).png', handler)
+
+router.findRoute('GET', '/:file(^\\S+).png')
+// => { handler: Function, store: Object }
+
+router.findRoute('GET', '/:file(^\\D+).jpg')
+// => null
+```
+
+```js
+const handler = (req, res, params) => {
+  res.end('Hello World!')
+}
+router.on('GET', '/:param1', handler)
+
+router.findRoute('GET', '/:param1')
+// => { handler: Function, store: Object }
+
+router.findRoute('GET', '/:param2')
+// => { handler: Function, store: Object }
+```
+
+#### hasRoute (method, path, [constraints])
+
+Checks if a route exists by server route's path (see `findRoute` for more details). Returns `true` if found, otherwise returns `false`.
+
+```js
+router.on('GET', '/:file(^\\S+).png', handler)
+
+router.hasRoute('GET', '/:file(^\\S+).png')
+// => true
+
+router.hasRoute('GET', '/:file(^\\D+).jpg')
+// => false
+```
+
+```js
 #### lookup(request, response, [context], [done])
 Start a new search, `request` and `response` are the server req/res objects.<br>
 If a route is found it will automatically call the handler, otherwise the default route will be called.<br>

index.d.ts

@@ -116,6 +116,11 @@ declare namespace Router {
     searchParams: { [k: string]: string };
   }
 
+  interface FindRouteResult<V extends HTTPVersion> {
+    handler: Handler<V>;
+    store: any;
+  }
+
   interface Instance<V extends HTTPVersion> {
     on(
       method: HTTPMethod | HTTPMethod[],
@@ -159,6 +164,18 @@ declare namespace Router {
       constraints?: { [key: string]: any }
     ): FindResult<V> | null;
 
+    findRoute(
+      method: HTTPMethod,
+      path: string,
+      constraints?: { [key: string]: any }
+    ): FindRouteResult<V> | null;
+
+    hasRoute(
+      method: HTTPMethod,
+      path: string,
+      constraints?: { [key: string]: any }
+    ): boolean;
+
     reset(): void;
     prettyPrint(): string;
     prettyPrint(opts: {

index.js

@@ -292,6 +292,156 @@ Router.prototype._on = function _on (method, path, opts, handler, store) {
   currentNode.addRoute(route, this.constrainer)
 }
 
+Router.prototype.hasRoute = function hasRoute (method, path, constraints) {
+  const route = this.findRoute(method, path, constraints)
+  return route !== null
+}
+
+Router.prototype.findRoute = function findNode (method, path, constraints = {}) {
+  if (this.trees[method] === undefined) {
+    return null
+  }
+
+  let pattern = path
+
+  let currentNode = this.trees[method]
+  let parentNodePathIndex = currentNode.prefix.length
+
+  const params = []
+  for (let i = 0; i <= pattern.length; i++) {
+    if (pattern.charCodeAt(i) === 58 && pattern.charCodeAt(i + 1) === 58) {
+      // It's a double colon
+      i++
+      continue
+    }
+
+    const isParametricNode = pattern.charCodeAt(i) === 58 && pattern.charCodeAt(i + 1) !== 58
+    const isWildcardNode = pattern.charCodeAt(i) === 42
+
+    if (isParametricNode || isWildcardNode || (i === pattern.length && i !== parentNodePathIndex)) {
+      let staticNodePath = pattern.slice(parentNodePathIndex, i)
+      if (!this.caseSensitive) {
+        staticNodePath = staticNodePath.toLowerCase()
+      }
+      staticNodePath = staticNodePath.split('::').join(':')
+      staticNodePath = staticNodePath.split('%').join('%25')
+      // add the static part of the route to the tree
+      currentNode = currentNode.getStaticChild(staticNodePath)
+      if (currentNode === null) {
+        return null
+      }
+    }
+
+    if (isParametricNode) {
+      let isRegexNode = false
+      const regexps = []
+
+      let lastParamStartIndex = i + 1
+      for (let j = lastParamStartIndex; ; j++) {
+        const charCode = pattern.charCodeAt(j)
+
+        const isRegexParam = charCode === 40
+        const isStaticPart = charCode === 45 || charCode === 46
+        const isEndOfNode = charCode === 47 || j === pattern.length
+
+        if (isRegexParam || isStaticPart || isEndOfNode) {
+          const paramName = pattern.slice(lastParamStartIndex, j)
+          params.push(paramName)
+
+          isRegexNode = isRegexNode || isRegexParam || isStaticPart
+
+          if (isRegexParam) {
+            const endOfRegexIndex = getClosingParenthensePosition(pattern, j)
+            const regexString = pattern.slice(j, endOfRegexIndex + 1)
+
+            if (!this.allowUnsafeRegex) {
+              assert(isRegexSafe(new RegExp(regexString)), `The regex '${regexString}' is not safe!`)
+            }
+
+            regexps.push(trimRegExpStartAndEnd(regexString))
+
+            j = endOfRegexIndex + 1
+          } else {
+            regexps.push('(.*?)')
+          }
+
+          const staticPartStartIndex = j
+          for (; j < pattern.length; j++) {
+            const charCode = pattern.charCodeAt(j)
+            if (charCode === 47) break
+            if (charCode === 58) {
+              const nextCharCode = pattern.charCodeAt(j + 1)
+              if (nextCharCode === 58) j++
+              else break
+            }
+          }
+
+          let staticPart = pattern.slice(staticPartStartIndex, j)
+          if (staticPart) {
+            staticPart = staticPart.split('::').join(':')
+            staticPart = staticPart.split('%').join('%25')
+            regexps.push(escapeRegExp(staticPart))
+          }
+
+          lastParamStartIndex = j + 1
+
+          if (isEndOfNode || pattern.charCodeAt(j) === 47 || j === pattern.length) {
+            const nodePattern = isRegexNode ? '()' + staticPart : staticPart
+            const nodePath = pattern.slice(i, j)
+
+            pattern = pattern.slice(0, i + 1) + nodePattern + pattern.slice(j)
+            i += nodePattern.length
+
+            const regex = isRegexNode ? new RegExp('^' + regexps.join('') + '$') : null
+            currentNode = currentNode.getParametricChild(regex, staticPart || null, nodePath)
+            if (currentNode === null) {
+              return null
+            }
+            parentNodePathIndex = i + 1
+            break
+          }
+        }
+      }
+    } else if (isWildcardNode) {
+      // add the wildcard parameter
+      params.push('*')
+      currentNode = currentNode.getWildcardChild()
+      if (currentNode === null) {
+        return null
+      }
+      parentNodePathIndex = i + 1
+
+      if (i !== pattern.length - 1) {
+        throw new Error('Wildcard must be the last character in the route')
+      }
+    }
+  }
+
+  if (!this.caseSensitive) {
+    pattern = pattern.toLowerCase()
+  }
+
+  if (pattern === '*') {
+    pattern = '/*'
+  }
+
+  for (const existRoute of this.routes) {
+    const routeConstraints = existRoute.opts.constraints || {}
+    if (
+      existRoute.method === method &&
+      existRoute.pattern === pattern &&
+      deepEqual(routeConstraints, constraints)
+    ) {
+      return {
+        handler: existRoute.handler,
+        store: existRoute.store
+      }
+    }
+  }
+
+  return null
+}
+
 Router.prototype.hasConstraintStrategy = function (strategyName) {
   return this.constrainer.hasConstraintStrategy(strategyName)
 }

lib/node.js

@@ -42,6 +42,19 @@ class ParentNode extends Node {
     return staticChild
   }
 
+  getStaticChild (path, pathIndex = 0) {
+    if (path.length === pathIndex) {
+      return this
+    }
+
+    const staticChild = this.findStaticMatchingChild(path, pathIndex)
+    if (staticChild) {
+      return staticChild.getStaticChild(path, pathIndex + staticChild.prefix.length)
+    }
+
+    return null
+  }
+
   createStaticChild (path) {
     if (path.length === 0) {
       return this
@@ -75,14 +88,23 @@ class StaticNode extends ParentNode {
     this._compilePrefixMatch()
   }
 
-  createParametricChild (regex, staticSuffix, nodePath) {
+  getParametricChild (regex) {
     const regexpSource = regex && regex.source
 
-    let parametricChild = this.parametricChildren.find(child => {
+    const parametricChild = this.parametricChildren.find(child => {
       const childRegexSource = child.regex && child.regex.source
       return childRegexSource === regexpSource
     })
 
+    if (parametricChild) {
+      return parametricChild
+    }
+
+    return null
+  }
+
+  createParametricChild (regex, staticSuffix, nodePath) {
+    let parametricChild = this.getParametricChild(regex)
     if (parametricChild) {
       parametricChild.nodePaths.add(nodePath)
       return parametricChild
@@ -106,12 +128,15 @@ class StaticNode extends ParentNode {
     return parametricChild
   }
 
-  createWildcardChild () {
+  getWildcardChild () {
     if (this.wildcardChild) {
       return this.wildcardChild
     }
+    return null
+  }
 
-    this.wildcardChild = new WildcardNode()
+  createWildcardChild () {
+    this.wildcardChild = this.getWildcardChild() || new WildcardNode()
     return this.wildcardChild
   }
 

package.json

@@ -40,6 +40,7 @@
     "chalk": "^4.1.2",
     "inquirer": "^8.2.4",
     "pre-commit": "^1.2.2",
+    "rfdc": "^1.3.0",
     "simple-git": "^3.7.1",
     "standard": "^14.3.4",
     "tap": "^16.0.1",