harperdb 3.1.3 → 3.1.4

package/node_modules/find-my-way/index.js

@@ -5,6 +5,7 @@
     '#': 35
     '*': 42
     '-': 45
+    '.': 46
     '/': 47
     ':': 58
     ';': 59
@@ -15,18 +16,23 @@ const assert = require('assert')
 const http = require('http')
 const fastDecode = require('fast-decode-uri-component')
 const isRegexSafe = require('safe-regex2')
-const { flattenNode, compressFlattenedNode, prettyPrintFlattenedNode } = require('./lib/pretty-print')
+const { flattenNode, compressFlattenedNode, prettyPrintFlattenedNode, prettyPrintRoutesArray } = require('./lib/pretty-print')
 const Node = require('./node')
 const Constrainer = require('./lib/constrainer')
 
 const NODE_TYPES = Node.prototype.types
 const httpMethods = http.METHODS
 const FULL_PATH_REGEXP = /^https?:\/\/.*?\//
+const OPTIONAL_PARAM_REGEXP = /(\/:[^/()]*?)\?(\/?)/
 
 if (!isRegexSafe(FULL_PATH_REGEXP)) {
   throw new Error('the FULL_PATH_REGEXP is not safe, update this module')
 }
 
+if (!isRegexSafe(OPTIONAL_PARAM_REGEXP)) {
+  throw new Error('the OPTIONAL_PARAM_REGEXP is not safe, update this module')
+}
+
 function Router (opts) {
   if (!(this instanceof Router)) {
     return new Router(opts)
@@ -47,6 +53,13 @@ function Router (opts) {
     this.onBadUrl = null
   }
 
+  if (opts.buildPrettyMeta) {
+    assert(typeof opts.buildPrettyMeta === 'function', 'buildPrettyMeta must be a function')
+    this.buildPrettyMeta = opts.buildPrettyMeta
+  } else {
+    this.buildPrettyMeta = defaultBuildPrettyMeta
+  }
+
   this.caseSensitive = opts.caseSensitive === undefined ? true : opts.caseSensitive
   this.ignoreTrailingSlash = opts.ignoreTrailingSlash || false
   this.maxParamLength = opts.maxParamLength || 100
@@ -71,6 +84,19 @@ Router.prototype.on = function on (method, path, opts, handler, store) {
   // handler validation
   assert(typeof handler === 'function', 'Handler should be a function')
 
+  // path ends with optional parameter
+  const optionalParamMatch = path.match(OPTIONAL_PARAM_REGEXP)
+  if (optionalParamMatch) {
+    assert(path.length === optionalParamMatch.index + optionalParamMatch[0].length, 'Optional Parameter needs to be the last parameter of the path')
+
+    const pathFull = path.replace(OPTIONAL_PARAM_REGEXP, '$1$2')
+    const pathOptional = path.replace(OPTIONAL_PARAM_REGEXP, '$2')
+
+    this.on(method, pathFull, opts, handler, store)
+    this.on(method, pathOptional, opts, handler, store)
+    return
+  }
+
   this._on(method, path, opts, handler, store)
 
   if (this.ignoreTrailingSlash && path !== '/' && !path.endsWith('*')) {
@@ -145,7 +171,7 @@ Router.prototype._on = function _on (method, path, opts, handler, store) {
         if (isRegex) {
           i = getClosingParenthensePosition(path, i) + 1
           break
-        } else if (path.charCodeAt(i) !== 45) {
+        } else if (path.charCodeAt(i) !== 45 && path.charCodeAt(i) !== 46) {
           i++
         } else {
           break
@@ -303,6 +329,19 @@ Router.prototype.off = function off (method, path) {
   assert(path.length > 0, 'The path could not be empty')
   assert(path[0] === '/' || path[0] === '*', 'The first character of a path should be `/` or `*`')
 
+  // path ends with optional parameter
+  const optionalParamMatch = path.match(OPTIONAL_PARAM_REGEXP)
+  if (optionalParamMatch) {
+    assert(path.length === optionalParamMatch.index + optionalParamMatch[0].length, 'Optional Parameter needs to be the last parameter of the path')
+
+    const pathFull = path.replace(OPTIONAL_PARAM_REGEXP, '$1$2')
+    const pathOptional = path.replace(OPTIONAL_PARAM_REGEXP, '$2')
+
+    this.off(method, pathFull)
+    this.off(method, pathOptional)
+    return
+  }
+
   // Rebuild tree without the specific route
   const ignoreTrailingSlash = this.ignoreTrailingSlash
   var newRoutes = self.routes.filter(function (route) {
@@ -408,7 +447,7 @@ Router.prototype.find = function find (method, path, derivedConstraints) {
     if (node === null) {
       node = currentNode.parametricBrother
       if (node === null) {
-        return this._getWildcardNode(wildcardNode, originalPath, pathLenWildcard)
+        return this._getWildcardNode(wildcardNode, originalPath, pathLenWildcard, derivedConstraints, params)
       }
 
       var goBack = previousPath.charCodeAt(0) === 47 ? previousPath : '/' + previousPath
@@ -440,7 +479,7 @@ Router.prototype.find = function find (method, path, derivedConstraints) {
     }
 
     if (len !== prefixLen) {
-      return this._getWildcardNode(wildcardNode, originalPath, pathLenWildcard)
+      return this._getWildcardNode(wildcardNode, originalPath, pathLenWildcard, derivedConstraints, params)
     }
 
     // if exist, save the wildcard child
@@ -512,7 +551,7 @@ Router.prototype.find = function find (method, path, derivedConstraints) {
         if (matchedParameter === null) return null
         i = matchedParameter[1].length
       } else {
-        while (i < pathLen && path.charCodeAt(i) !== 47 && path.charCodeAt(i) !== 45) i++
+        while (i < pathLen && path.charCodeAt(i) !== 47 && path.charCodeAt(i) !== 45 && path.charCodeAt(i) !== 46) i++
         if (i > maxParamLength) return null
       }
       decoded = fastDecode(originalPath.slice(idxInOriginalPath, idxInOriginalPath + i))
@@ -532,7 +571,7 @@ Router.prototype.find = function find (method, path, derivedConstraints) {
   }
 }
 
-Router.prototype._getWildcardNode = function (node, path, len) {
+Router.prototype._getWildcardNode = function (node, path, len, derivedConstraints, params) {
   if (node === null) return null
   var decoded = fastDecode(path.slice(-len))
   if (decoded === null) {
@@ -540,11 +579,25 @@ Router.prototype._getWildcardNode = function (node, path, len) {
       ? this._onBadUrl(path.slice(-len))
       : null
   }
-  var handle = node.handlers[0]
+
+  var handle = derivedConstraints !== undefined ? node.getMatchingHandler(derivedConstraints) : node.unconstrainedHandler
+
   if (handle !== null && handle !== undefined) {
+    var paramsObj = {}
+    if (handle.paramsLength > 0 && params !== null) {
+      var paramNames = handle.params
+
+      for (i = 0; i < handle.paramsLength; i++) {
+        paramsObj[paramNames[i]] = params[i]
+      }
+    }
+
+    // we must override params[*] to decoded
+    paramsObj['*'] = decoded
+
     return {
       handler: handle.handler,
-      params: { '*': decoded },
+      params: paramsObj,
       store: handle.store
     }
   }
@@ -571,7 +624,9 @@ Router.prototype._onBadUrl = function (path) {
   }
 }
 
-Router.prototype.prettyPrint = function () {
+Router.prototype.prettyPrint = function (opts = {}) {
+  opts.commonPrefix = opts.commonPrefix === undefined ? true : opts.commonPrefix // default to original behaviour
+  if (!opts.commonPrefix) return prettyPrintRoutesArray.call(this, this.routes, opts)
   const root = {
     prefix: '/',
     nodes: [],
@@ -586,7 +641,7 @@ Router.prototype.prettyPrint = function () {
 
   compressFlattenedNode(root)
 
-  return prettyPrintFlattenedNode(root, '', true)
+  return prettyPrintFlattenedNode.call(this, root, '', true, opts)
 }
 
 for (var i in http.METHODS) {
@@ -648,3 +703,10 @@ function getClosingParenthensePosition (path, idx) {
 
   throw new TypeError('Invalid regexp expression in "' + path + '"')
 }
+
+function defaultBuildPrettyMeta (route) {
+  // buildPrettyMeta function must return an object, which will be parsed into key/value pairs for display
+  if (!route) return {}
+  if (!route.store) return {}
+  return Object.assign({}, route.store)
+}

package/node_modules/find-my-way/lib/constrainer.js

@@ -24,6 +24,10 @@ class Constrainer {
         assert(strategy.deriveConstraint && typeof strategy.deriveConstraint === 'function', 'strategy.deriveConstraint function is required.')
         strategy.isCustom = true
         this.strategies[strategy.name] = strategy
+
+        if (strategy.mustMatchWhenDerived) {
+          this.noteUsage({ [kCustomStrategies[i]]: strategy })
+        }
       }
     }
   }
@@ -88,7 +92,7 @@ class Constrainer {
         if (key === 'version') {
           lines.push('   version: req.headers[\'accept-version\'],')
         } else if (key === 'host') {
-          lines.push('   host: req.headers.host,')
+          lines.push('   host: req.headers.host || req.headers[\':authority\'],')
         } else {
           throw new Error('unknown non-custom strategy for compiling constraint derivation function')
         }
@@ -104,7 +108,7 @@ class Constrainer {
     lines.push('}')
 
     // There are some constraints that can be derived and marked as "must match", where if they are derived, they only match routes that actually have a constraint on the value, like the SemVer version constraint.
-    // An example: a request comes in for version 1.x, and this node has a handler that maches the path, but there's no version constraint. For SemVer, the find-my-way semantics do not match this handler to that request.
+    // An example: a request comes in for version 1.x, and this node has a handler that matches the path, but there's no version constraint. For SemVer, the find-my-way semantics do not match this handler to that request.
     // This function is used by Nodes with handlers to match when they don't have any constrained routes to exclude request that do have must match derived constraints present.
     if (mustMatchKeys.length > 0) {
       lines.push(`derivedConstraints.__hasMustMatchValues = !!(${(mustMatchKeys.map(key => `derivedConstraints.${key}`).join(' || '))})`)

package/node_modules/find-my-way/lib/pretty-print.js

@@ -1,5 +1,192 @@
-function prettyPrintFlattenedNode (flattenedNode, prefix, tail) {
-  var paramName = ''
+'use strict'
+
+/* eslint-disable no-multi-spaces */
+const indent              = '    '
+const branchIndent        = '│   '
+const midBranchIndent     = '├── '
+const endBranchIndent     = '└── '
+const wildcardDelimiter   = '*'
+const pathDelimiter       = '/'
+const pathRegExp          = /(?=\/)/
+/* eslint-enable */
+
+function parseFunctionName (fn) {
+  let fName = fn.name || ''
+
+  fName = fName.replace('bound', '').trim()
+  fName = (fName || 'anonymous') + '()'
+  return fName
+}
+
+function parseMeta (meta) {
+  if (Array.isArray(meta)) return meta.map(m => parseMeta(m))
+  if (typeof meta === 'symbol') return meta.toString()
+  if (typeof meta === 'function') return parseFunctionName(meta)
+  return meta
+}
+
+function buildMetaObject (route, metaArray) {
+  const out = {}
+  const cleanMeta = this.buildPrettyMeta(route)
+  if (!Array.isArray(metaArray)) metaArray = cleanMeta ? Reflect.ownKeys(cleanMeta) : []
+  metaArray.forEach(m => {
+    const metaKey = typeof m === 'symbol' ? m.toString() : m
+    if (cleanMeta && cleanMeta[m]) {
+      out[metaKey] = parseMeta(cleanMeta[m])
+    }
+  })
+  return out
+}
+
+function prettyPrintRoutesArray (routeArray, opts = {}) {
+  if (!this.buildPrettyMeta) throw new Error('buildPrettyMeta not defined')
+  opts.includeMeta = opts.includeMeta || null // array of meta objects to display
+  const mergedRouteArray = []
+
+  let tree = ''
+
+  routeArray.sort((a, b) => {
+    if (!a.path || !b.path) return 0
+    return a.path.localeCompare(b.path)
+  })
+
+  // merge alike paths
+  for (let i = 0; i < routeArray.length; i++) {
+    const route = routeArray[i]
+    const pathExists = mergedRouteArray.find(r => route.path === r.path)
+    if (pathExists) {
+      // path already declared, add new method and break out of loop
+      pathExists.handlers.push({
+        method: route.method,
+        opts: route.opts.constraints || undefined,
+        meta: opts.includeMeta ? buildMetaObject.call(this, route, opts.includeMeta) : null
+      })
+      continue
+    }
+
+    const routeHandler = {
+      method: route.method,
+      opts: route.opts.constraints || undefined,
+      meta: opts.includeMeta ? buildMetaObject.call(this, route, opts.includeMeta) : null
+    }
+    mergedRouteArray.push({
+      path: route.path,
+      methods: [route.method],
+      opts: [route.opts],
+      handlers: [routeHandler]
+    })
+  }
+
+  // insert root level path if none defined
+  if (!mergedRouteArray.filter(r => r.path === pathDelimiter).length) {
+    const rootPath = {
+      path: pathDelimiter,
+      truncatedPath: '',
+      methods: [],
+      opts: [],
+      handlers: [{}]
+    }
+
+    // if wildcard route exists, insert root level after wildcard
+    if (mergedRouteArray.filter(r => r.path === wildcardDelimiter).length) {
+      mergedRouteArray.splice(1, 0, rootPath)
+    } else {
+      mergedRouteArray.unshift(rootPath)
+    }
+  }
+
+  // build tree
+  const routeTree = buildRouteTree(mergedRouteArray)
+
+  // draw tree
+  routeTree.forEach((rootBranch, idx) => {
+    tree += drawBranch(rootBranch, null, idx === routeTree.length - 1, false, true)
+    tree += '\n' // newline characters inserted at beginning of drawing function to allow for nested paths
+  })
+
+  return tree
+}
+
+function buildRouteTree (mergedRouteArray, rootPath) {
+  rootPath = rootPath || pathDelimiter
+
+  const result = []
+  const temp = { result }
+  mergedRouteArray.forEach((route, idx) => {
+    let splitPath = route.path.split(pathRegExp)
+
+    // add preceding slash for proper nesting
+    if (splitPath[0] !== pathDelimiter) {
+      // handle wildcard route
+      if (splitPath[0] !== wildcardDelimiter) splitPath = [pathDelimiter, splitPath[0].slice(1), ...splitPath.slice(1)]
+    }
+
+    // build tree
+    splitPath.reduce((acc, path, pidx) => {
+      if (!acc[path]) {
+        acc[path] = { result: [] }
+        const pathSeg = { path, children: acc[path].result }
+
+        if (pidx === splitPath.length - 1) pathSeg.handlers = route.handlers
+        acc.result.push(pathSeg)
+      }
+      return acc[path]
+    }, temp)
+  })
+
+  // unfold root object from array
+  return result
+}
+
+function drawBranch (pathSeg, prefix, endBranch, noPrefix, rootBranch) {
+  let branch = ''
+
+  if (!noPrefix && !rootBranch) branch += '\n'
+  if (!noPrefix) branch += `${prefix || ''}${endBranch ? endBranchIndent : midBranchIndent}`
+  branch += `${pathSeg.path}`
+
+  if (pathSeg.handlers) {
+    const flatHandlers = pathSeg.handlers.reduce((acc, curr) => {
+      const match = acc.findIndex(h => JSON.stringify(h.opts) === JSON.stringify(curr.opts))
+      if (match !== -1) {
+        acc[match].method = [acc[match].method, curr.method].join(', ')
+      } else {
+        acc.push(curr)
+      }
+      return acc
+    }, [])
+
+    flatHandlers.forEach((handler, idx) => {
+      if (idx > 0) branch += `${noPrefix ? '' : prefix || ''}${endBranch ? indent : branchIndent}${pathSeg.path}`
+      branch += ` (${handler.method || '-'})`
+      if (handler.opts && JSON.stringify(handler.opts) !== '{}') branch += ` ${JSON.stringify(handler.opts)}`
+      if (handler.meta) {
+        Reflect.ownKeys(handler.meta).forEach((m, hidx) => {
+          branch += `\n${noPrefix ? '' : prefix || ''}${endBranch ? indent : branchIndent}`
+          branch += `• (${m}) ${JSON.stringify(handler.meta[m])}`
+        })
+      }
+      if (flatHandlers.length > 1 && idx !== flatHandlers.length - 1) branch += '\n'
+    })
+  } else {
+    if (pathSeg.children.length > 1) branch += ' (-)'
+  }
+
+  if (!noPrefix) prefix = `${prefix || ''}${endBranch ? indent : branchIndent}`
+
+  pathSeg.children.forEach((child, idx) => {
+    const endBranch = idx === pathSeg.children.length - 1
+    const skipPrefix = (!pathSeg.handlers && pathSeg.children.length === 1)
+    branch += drawBranch(child, prefix, endBranch, skipPrefix)
+  })
+
+  return branch
+}
+
+function prettyPrintFlattenedNode (flattenedNode, prefix, tail, opts) {
+  if (!this.buildPrettyMeta) throw new Error('buildPrettyMeta not defined')
+  opts.includeMeta = opts.includeMeta || null // array of meta items to display
+  let paramName = ''
   const printHandlers = []
 
   for (const node of flattenedNode.nodes) {
@@ -8,41 +195,55 @@ function prettyPrintFlattenedNode (flattenedNode, prefix, tail) {
     }
   }
 
-  printHandlers.forEach((handler, index) => {
-    let suffix = `(${handler.method}`
-    if (Object.keys(handler.constraints).length > 0) {
-      suffix += ' ' + JSON.stringify(handler.constraints)
-    }
-    suffix += ')'
-
-    let name = ''
-    if (flattenedNode.prefix.includes(':')) {
-      var params = handler.params
-      name = params[params.length - 1]
-      if (index > 0) {
-        name = ':' + name
+  if (printHandlers.length) {
+    printHandlers.forEach((handler, index) => {
+      let suffix = `(${handler.method || '-'})`
+      if (Object.keys(handler.constraints).length > 0) {
+        suffix += ' ' + JSON.stringify(handler.constraints)
       }
-    } else if (index > 0) {
-      name = flattenedNode.prefix
-    }
 
-    if (index === 0) {
-      paramName += name + ` ${suffix}`
-      return
-    } else {
-      paramName += '\n'
-    }
+      let name = ''
+      // find locations of parameters in prefix
+      const paramIndices = flattenedNode.prefix.split('').map((ch, idx) => ch === ':' ? idx : null).filter(idx => idx !== null)
+      if (paramIndices.length) {
+        let prevLoc = 0
+        paramIndices.forEach((loc, idx) => {
+          // find parameter in prefix
+          name += flattenedNode.prefix.slice(prevLoc, loc + 1)
+          // insert parameters
+          name += handler.params[handler.params.length - paramIndices.length + idx]
+          if (idx === paramIndices.length - 1) name += flattenedNode.prefix.slice(loc + 1)
+          prevLoc = loc + 1
+        })
+      } else {
+        // there are no parameters, return full object
+        name = flattenedNode.prefix
+      }
 
-    paramName += prefix + '    ' + name + ` ${suffix}`
-  })
+      if (index === 0) {
+        paramName += `${name} ${suffix}`
+      } else {
+        paramName += `\n${prefix}${tail ? indent : branchIndent}${name} ${suffix}`
+      }
+      if (opts.includeMeta) {
+        const meta = buildMetaObject.call(this, handler, opts.includeMeta)
+        Object.keys(meta).forEach((m, hidx) => {
+          paramName += `\n${prefix || ''}${tail ? indent : branchIndent}`
+          paramName += `• (${m}) ${JSON.stringify(meta[m])}`
+        })
+      }
+    })
+  } else {
+    paramName = flattenedNode.prefix
+  }
 
-  var tree = `${prefix}${tail ? '└── ' : '├── '}${flattenedNode.prefix}${paramName}\n`
+  let tree = `${prefix}${tail ? endBranchIndent : midBranchIndent}${paramName}\n`
 
-  prefix = `${prefix}${tail ? '    ' : '│   '}`
+  prefix = `${prefix}${tail ? indent : branchIndent}`
   const labels = Object.keys(flattenedNode.children)
-  for (var i = 0; i < labels.length; i++) {
+  for (let i = 0; i < labels.length; i++) {
     const child = flattenedNode.children[labels[i]]
-    tree += prettyPrintFlattenedNode(child, prefix, i === (labels.length - 1))
+    tree += prettyPrintFlattenedNode.call(this, child, prefix, i === (labels.length - 1), opts)
   }
   return tree
 }
@@ -54,7 +255,8 @@ function flattenNode (flattened, node) {
 
   if (node.children) {
     for (const child of Object.values(node.children)) {
-      const childPrefixSegments = child.prefix.split(/(?=\/)/) // split on the slash separator but use a regex to lookahead and not actually match it, preserving it in the returned string segments
+      // split on the slash separator but use a regex to lookahead and not actually match it, preserving it in the returned string segments
+      const childPrefixSegments = child.prefix.split(pathRegExp)
       let cursor = flattened
       let parent
       for (const segment of childPrefixSegments) {
@@ -69,7 +271,6 @@ function flattenNode (flattened, node) {
           parent.children[segment] = cursor
         }
       }
-
       flattenNode(cursor, child)
     }
   }
@@ -95,4 +296,4 @@ function compressFlattenedNode (flattenedNode) {
   return flattenedNode
 }
 
-module.exports = { flattenNode, compressFlattenedNode, prettyPrintFlattenedNode }
+module.exports = { flattenNode, compressFlattenedNode, prettyPrintFlattenedNode, prettyPrintRoutesArray }

package/node_modules/find-my-way/node.js

@@ -26,7 +26,7 @@ function Node (options) {
   this.wildcardChild = null
   this.parametricBrother = null
   this.constrainer = options.constrainer
-  this.hasConstraints = false || options.hasConstraints
+  this.hasConstraints = options.hasConstraints || false
   this.constrainedHandlerStores = null
 }
 
@@ -63,41 +63,33 @@ Node.prototype.addChild = function (node) {
   )
 
   this.children[label] = node
-  this.numberOfChildren = Object.keys(this.children).length
 
-  const labels = Object.keys(this.children)
-  var parametricBrother = this.parametricBrother
-  for (var i = 0; i < labels.length; i++) {
-    const child = this.children[labels[i]]
-    if (child.label === ':') {
+  const nodeChildren = Object.values(this.children)
+  this.numberOfChildren = nodeChildren.length
+
+  this._saveParametricBrother()
+
+  return this
+}
+
+Node.prototype._saveParametricBrother = function () {
+  let parametricBrother = this.parametricBrother
+  for (const child of Object.values(this.children)) {
+    if (child.prefix === ':') {
       parametricBrother = child
       break
     }
   }
 
   // Save the parametric brother inside static children
-  const iterate = (node) => {
-    if (!node) {
-      return
-    }
-
-    if (node.kind !== this.types.STATIC) {
-      return
-    }
-
-    if (node !== this) {
-      node.parametricBrother = parametricBrother || node.parametricBrother
-    }
-
-    const labels = Object.keys(node.children)
-    for (var i = 0; i < labels.length; i++) {
-      iterate(node.children[labels[i]])
+  if (parametricBrother) {
+    for (const child of Object.values(this.children)) {
+      if (child && child.kind === this.types.STATIC) {
+        child.parametricBrother = parametricBrother
+        child._saveParametricBrother(parametricBrother)
+      }
     }
   }
-
-  iterate(this)
-
-  return this
 }
 
 Node.prototype.reset = function (prefix) {
@@ -120,6 +112,7 @@ Node.prototype.split = function (length) {
       prefix: this.prefix.slice(length),
       children: this.children,
       kind: this.kind,
+      method: this.method,
       handlers: this.handlers.slice(0),
       regex: this.regex,
       constrainer: this.constrainer,
@@ -309,7 +302,11 @@ Node.prototype._compileGetHandlerMatchingConstraints = function () {
   }
   // Return the first handler who's bit is set in the candidates https://stackoverflow.com/questions/18134985/how-to-find-index-of-first-set-bit
   lines.push(`
-  return this.handlers[Math.floor(Math.log2(candidates))]
+  const handler = this.handlers[Math.floor(Math.log2(candidates))]
+  if (handler && derivedConstraints.__hasMustMatchValues && handler === this.unconstrainedHandler) {
+    return null;
+  }
+  return handler;
   `)
 
   this._getHandlerMatchingConstraints = new Function('derivedConstraints', lines.join('\n')) // eslint-disable-line

package/node_modules/find-my-way/package.json

@@ -1,31 +1,31 @@
 {
   "_args": [
     [
-      "find-my-way@4.0.0",
+      "find-my-way@4.5.1",
       "/home/ubuntu/buildAgent/work/20f715f46c2b009e"
     ]
   ],
-  "_from": "find-my-way@4.0.0",
-  "_id": "find-my-way@4.0.0",
+  "_from": "find-my-way@4.5.1",
+  "_id": "find-my-way@4.5.1",
   "_inBundle": false,
-  "_integrity": "sha512-IrICzn/Xm5r5A3RCB8rGLNe+dvzZl+SiUugTQOUMLJciP2qiSu2hw9JtVEYV3VruAYzSWjo/MLH9CFKtVdlWhQ==",
+  "_integrity": "sha512-kE0u7sGoUFbMXcOG/xpkmz4sRLCklERnBcg7Ftuu1iAxsfEt2S46RLJ3Sq7vshsEy2wJT2hZxE58XZK27qa8kg==",
   "_location": "/find-my-way",
   "_phantomChildren": {},
   "_requested": {
     "type": "version",
     "registry": true,
-    "raw": "find-my-way@4.0.0",
+    "raw": "find-my-way@4.5.1",
     "name": "find-my-way",
     "escapedName": "find-my-way",
-    "rawSpec": "4.0.0",
+    "rawSpec": "4.5.1",
     "saveSpec": null,
-    "fetchSpec": "4.0.0"
+    "fetchSpec": "4.5.1"
   },
   "_requiredBy": [
     "/fastify"
   ],
-  "_resolved": "https://registry.npmjs.org/find-my-way/-/find-my-way-4.0.0.tgz",
-  "_spec": "4.0.0",
+  "_resolved": "https://registry.npmjs.org/find-my-way/-/find-my-way-4.5.1.tgz",
+  "_spec": "4.5.1",
   "_where": "/home/ubuntu/buildAgent/work/20f715f46c2b009e",
   "author": {
     "name": "Tomas Della Vedova - @delvedor",
@@ -47,7 +47,7 @@
     "pre-commit": "^1.2.2",
     "request": "^2.88.2",
     "standard": "^14.3.4",
-    "tap": "^14.10.8",
+    "tap": "^15.0.9",
     "tap-mocha-reporter": "^5.0.1",
     "tsd": "^0.13.1"
   },
@@ -81,5 +81,5 @@
     "directory": "test/types"
   },
   "types": "index.d.ts",
-  "version": "4.0.0"
+  "version": "4.5.1"
 }

package/node_modules/find-my-way/test/constraint.custom-versioning.test.js

@@ -43,11 +43,11 @@ test('Overriding default strategies uses the custom deriveConstraint function',
   const findMyWay = FindMyWay({ constraints: { version: customVersioning } })
 
   findMyWay.on('GET', '/', { constraints: { version: 'application/vnd.example.api+json;version=2' } }, (req, res, params) => {
-    t.strictEqual(req.headers.accept, 'application/vnd.example.api+json;version=2')
+    t.equal(req.headers.accept, 'application/vnd.example.api+json;version=2')
   })
 
   findMyWay.on('GET', '/', { constraints: { version: 'application/vnd.example.api+json;version=3' } }, (req, res, params) => {
-    t.strictEqual(req.headers.accept, 'application/vnd.example.api+json;version=3')
+    t.equal(req.headers.accept, 'application/vnd.example.api+json;version=3')
   })
 
   findMyWay.lookup({