Brunobkr/llama.cpp_AlgMor24_github

1/*!2 * router3 * Copyright(c) 2013 Roman Shtylman4 * Copyright(c) 2014-2022 Douglas Christopher Wilson5 * MIT Licensed6 */7 8'use strict'9 10/**11 * Module dependencies.12 * @private13 */14 15const isPromise = require('is-promise')16const Layer = require('./lib/layer')17const { METHODS } = require('node:http')18const parseUrl = require('parseurl')19const Route = require('./lib/route')20const debug = require('debug')('router')21const deprecate = require('depd')('router')22 23/**24 * Module variables.25 * @private26 */27 28const slice = Array.prototype.slice29const flatten = Array.prototype.flat30const methods = METHODS.map((method) => method.toLowerCase())31 32/**33 * Expose `Router`.34 */35 36module.exports = Router37 38/**39 * Expose `Route`.40 */41 42module.exports.Route = Route43 44/**45 * Initialize a new `Router` with the given `options`.46 *47 * @param {object} [options]48 * @return {Router} which is a callable function49 * @public50 */51 52function Router (options) {53  if (!(this instanceof Router)) {54    return new Router(options)55  }56 57  const opts = options || {}58 59  function router (req, res, next) {60    router.handle(req, res, next)61  }62 63  // inherit from the correct prototype64  Object.setPrototypeOf(router, this)65 66  router.caseSensitive = opts.caseSensitive67  router.mergeParams = opts.mergeParams68  router.params = {}69  router.strict = opts.strict70  router.stack = []71 72  return router73}74 75/**76 * Router prototype inherits from a Function.77 */78 79/* istanbul ignore next */80Router.prototype = function () {}81 82/**83 * Map the given param placeholder `name`(s) to the given callback.84 *85 * Parameter mapping is used to provide pre-conditions to routes86 * which use normalized placeholders. For example a _:user_id_ parameter87 * could automatically load a user's information from the database without88 * any additional code.89 *90 * The callback uses the same signature as middleware, the only difference91 * being that the value of the placeholder is passed, in this case the _id_92 * of the user. Once the `next()` function is invoked, just like middleware93 * it will continue on to execute the route, or subsequent parameter functions.94 *95 * Just like in middleware, you must either respond to the request or call next96 * to avoid stalling the request.97 *98 *  router.param('user_id', function(req, res, next, id){99 *    User.find(id, function(err, user){100 *      if (err) {101 *        return next(err)102 *      } else if (!user) {103 *        return next(new Error('failed to load user'))104 *      }105 *      req.user = user106 *      next()107 *    })108 *  })109 *110 * @param {string} name111 * @param {function} fn112 * @public113 */114 115Router.prototype.param = function param (name, fn) {116  if (!name) {117    throw new TypeError('argument name is required')118  }119 120  if (typeof name !== 'string') {121    throw new TypeError('argument name must be a string')122  }123 124  if (!fn) {125    throw new TypeError('argument fn is required')126  }127 128  if (typeof fn !== 'function') {129    throw new TypeError('argument fn must be a function')130  }131 132  let params = this.params[name]133 134  if (!params) {135    params = this.params[name] = []136  }137 138  params.push(fn)139 140  return this141}142 143/**144 * Dispatch a req, res into the router.145 *146 * @private147 */148 149Router.prototype.handle = function handle (req, res, callback) {150  if (!callback) {151    throw new TypeError('argument callback is required')152  }153 154  debug('dispatching %s %s', req.method, req.url)155 156  let idx = 0157  let methods158  const protohost = getProtohost(req.url) || ''159  let removed = ''160  const self = this161  let slashAdded = false162  let sync = 0163  const paramcalled = {}164 165  // middleware and routes166  const stack = this.stack167 168  // manage inter-router variables169  const parentParams = req.params170  const parentUrl = req.baseUrl || ''171  let done = restore(callback, req, 'baseUrl', 'next', 'params')172 173  // setup next layer174  req.next = next175 176  // for options requests, respond with a default if nothing else responds177  if (req.method === 'OPTIONS') {178    methods = []179    done = wrap(done, generateOptionsResponder(res, methods))180  }181 182  // setup basic req values183  req.baseUrl = parentUrl184  req.originalUrl = req.originalUrl || req.url185 186  next()187 188  function next (err) {189    let layerError = err === 'route'190      ? null191      : err192 193    // remove added slash194    if (slashAdded) {195      req.url = req.url.slice(1)196      slashAdded = false197    }198 199    // restore altered req.url200    if (removed.length !== 0) {201      req.baseUrl = parentUrl202      req.url = protohost + removed + req.url.slice(protohost.length)203      removed = ''204    }205 206    // signal to exit router207    if (layerError === 'router') {208      setImmediate(done, null)209      return210    }211 212    // no more matching layers213    if (idx >= stack.length) {214      setImmediate(done, layerError)215      return216    }217 218    // max sync stack219    if (++sync > 100) {220      return setImmediate(next, err)221    }222 223    // get pathname of request224    const path = getPathname(req)225 226    if (path == null) {227      return done(layerError)228    }229 230    // find next matching layer231    let layer232    let match233    let route234 235    while (match !== true && idx < stack.length) {236      layer = stack[idx++]237      match = matchLayer(layer, path)238      route = layer.route239 240      if (typeof match !== 'boolean') {241        // hold on to layerError242        layerError = layerError || match243      }244 245      if (match !== true) {246        continue247      }248 249      if (!route) {250        // process non-route handlers normally251        continue252      }253 254      if (layerError) {255        // routes do not match with a pending error256        match = false257        continue258      }259 260      const method = req.method261      const hasMethod = route._handlesMethod(method)262 263      // build up automatic options response264      if (!hasMethod && method === 'OPTIONS' && methods) {265        methods.push.apply(methods, route._methods())266      }267 268      // don't even bother matching route269      if (!hasMethod && method !== 'HEAD') {270        match = false271      }272    }273 274    // no match275    if (match !== true) {276      return done(layerError)277    }278 279    // store route for dispatch on change280    if (route) {281      req.route = route282    }283 284    // Capture one-time layer values285    req.params = self.mergeParams286      ? mergeParams(layer.params, parentParams)287      : layer.params288    const layerPath = layer.path289 290    // this should be done for the layer291    processParams(self.params, layer, paramcalled, req, res, function (err) {292      if (err) {293        next(layerError || err)294      } else if (route) {295        layer.handleRequest(req, res, next)296      } else {297        trimPrefix(layer, layerError, layerPath, path)298      }299 300      sync = 0301    })302  }303 304  function trimPrefix (layer, layerError, layerPath, path) {305    if (layerPath.length !== 0) {306      // Validate path is a prefix match307      if (layerPath !== path.substring(0, layerPath.length)) {308        next(layerError)309        return310      }311 312      // Validate path breaks on a path separator313      const c = path[layerPath.length]314      if (c && c !== '/') {315        next(layerError)316        return317      }318 319      // Trim off the part of the url that matches the route320      // middleware (.use stuff) needs to have the path stripped321      debug('trim prefix (%s) from url %s', layerPath, req.url)322      removed = layerPath323      req.url = protohost + req.url.slice(protohost.length + removed.length)324 325      // Ensure leading slash326      if (!protohost && req.url[0] !== '/') {327        req.url = '/' + req.url328        slashAdded = true329      }330 331      // Setup base URL (no trailing slash)332      req.baseUrl = parentUrl + (removed[removed.length - 1] === '/'333        ? removed.substring(0, removed.length - 1)334        : removed)335    }336 337    debug('%s %s : %s', layer.name, layerPath, req.originalUrl)338 339    if (layerError) {340      layer.handleError(layerError, req, res, next)341    } else {342      layer.handleRequest(req, res, next)343    }344  }345}346 347/**348 * Use the given middleware function, with optional path, defaulting to "/".349 *350 * Use (like `.all`) will run for any http METHOD, but it will not add351 * handlers for those methods so OPTIONS requests will not consider `.use`352 * functions even if they could respond.353 *354 * The other difference is that _route_ path is stripped and not visible355 * to the handler function. The main effect of this feature is that mounted356 * handlers can operate without any code changes regardless of the "prefix"357 * pathname.358 *359 * @public360 */361 362Router.prototype.use = function use (handler) {363  let offset = 0364  let path = '/'365 366  // default path to '/'367  // disambiguate router.use([handler])368  if (typeof handler !== 'function') {369    let arg = handler370 371    while (Array.isArray(arg) && arg.length !== 0) {372      arg = arg[0]373    }374 375    // first arg is the path376    if (typeof arg !== 'function') {377      offset = 1378      path = handler379    }380  }381 382  const callbacks = flatten.call(slice.call(arguments, offset), Infinity)383 384  if (callbacks.length === 0) {385    throw new TypeError('argument handler is required')386  }387 388  for (let i = 0; i < callbacks.length; i++) {389    const fn = callbacks[i]390 391    if (typeof fn !== 'function') {392      throw new TypeError('argument handler must be a function')393    }394 395    // add the middleware396    debug('use %o %s', path, fn.name || '<anonymous>')397 398    const layer = new Layer(path, {399      sensitive: this.caseSensitive,400      strict: false,401      end: false402    }, fn)403 404    layer.route = undefined405 406    this.stack.push(layer)407  }408 409  return this410}411 412/**413 * Create a new Route for the given path.414 *415 * Each route contains a separate middleware stack and VERB handlers.416 *417 * See the Route api documentation for details on adding handlers418 * and middleware to routes.419 *420 * @param {string} path421 * @return {Route}422 * @public423 */424 425Router.prototype.route = function route (path) {426  const route = new Route(path)427 428  const layer = new Layer(path, {429    sensitive: this.caseSensitive,430    strict: this.strict,431    end: true432  }, handle)433 434  function handle (req, res, next) {435    route.dispatch(req, res, next)436  }437 438  layer.route = route439 440  this.stack.push(layer)441  return route442}443 444// create Router#VERB functions445methods.concat('all').forEach(function (method) {446  Router.prototype[method] = function (path) {447    const route = this.route(path)448    route[method].apply(route, slice.call(arguments, 1))449    return this450  }451})452 453/**454 * Generate a callback that will make an OPTIONS response.455 *456 * @param {OutgoingMessage} res457 * @param {array} methods458 * @private459 */460 461function generateOptionsResponder (res, methods) {462  return function onDone (fn, err) {463    if (err || methods.length === 0) {464      return fn(err)465    }466 467    trySendOptionsResponse(res, methods, fn)468  }469}470 471/**472 * Get pathname of request.473 *474 * @param {IncomingMessage} req475 * @private476 */477 478function getPathname (req) {479  try {480    return parseUrl(req).pathname481  } catch (err) {482    return undefined483  }484}485 486/**487 * Get get protocol + host for a URL.488 *489 * @param {string} url490 * @private491 */492 493function getProtohost (url) {494  if (typeof url !== 'string' || url.length === 0 || url[0] === '/') {495    return undefined496  }497 498  const searchIndex = url.indexOf('?')499  const pathLength = searchIndex !== -1500    ? searchIndex501    : url.length502  const fqdnIndex = url.substring(0, pathLength).indexOf('://')503 504  return fqdnIndex !== -1505    ? url.substring(0, url.indexOf('/', 3 + fqdnIndex))506    : undefined507}508 509/**510 * Match path to a layer.511 *512 * @param {Layer} layer513 * @param {string} path514 * @private515 */516 517function matchLayer (layer, path) {518  try {519    return layer.match(path)520  } catch (err) {521    return err522  }523}524 525/**526 * Merge params with parent params527 *528 * @private529 */530 531function mergeParams (params, parent) {532  if (typeof parent !== 'object' || !parent) {533    return params534  }535 536  // make copy of parent for base537  const obj = Object.assign({}, parent)538 539  // simple non-numeric merging540  if (!(0 in params) || !(0 in parent)) {541    return Object.assign(obj, params)542  }543 544  let i = 0545  let o = 0546 547  // determine numeric gap in params548  while (i in params) {549    i++550  }551 552  // determine numeric gap in parent553  while (o in parent) {554    o++555  }556 557  // offset numeric indices in params before merge558  for (i--; i >= 0; i--) {559    params[i + o] = params[i]560 561    // create holes for the merge when necessary562    if (i < o) {563      delete params[i]564    }565  }566 567  return Object.assign(obj, params)568}569 570/**571 * Process any parameters for the layer.572 *573 * @private574 */575 576function processParams (params, layer, called, req, res, done) {577  // captured parameters from the layer, keys and values578  const keys = layer.keys579 580  // fast track581  if (!keys || keys.length === 0) {582    return done()583  }584 585  let i = 0586  let paramIndex = 0587  let key588  let paramVal589  let paramCallbacks590  let paramCalled591 592  // process params in order593  // param callbacks can be async594  function param (err) {595    if (err) {596      return done(err)597    }598 599    if (i >= keys.length) {600      return done()601    }602 603    paramIndex = 0604    key = keys[i++]605    paramVal = req.params[key]606    paramCallbacks = params[key]607    paramCalled = called[key]608 609    if (paramVal === undefined || !paramCallbacks) {610      return param()611    }612 613    // param previously called with same value or error occurred614    if (paramCalled && (paramCalled.match === paramVal ||615      (paramCalled.error && paramCalled.error !== 'route'))) {616      // restore value617      req.params[key] = paramCalled.value618 619      // next param620      return param(paramCalled.error)621    }622 623    called[key] = paramCalled = {624      error: null,625      match: paramVal,626      value: paramVal627    }628 629    paramCallback()630  }631 632  // single param callbacks633  function paramCallback (err) {634    const fn = paramCallbacks[paramIndex++]635 636    // store updated value637    paramCalled.value = req.params[key]638 639    if (err) {640      // store error641      paramCalled.error = err642      param(err)643      return644    }645 646    if (!fn) return param()647 648    try {649      const ret = fn(req, res, paramCallback, paramVal, key)650      if (isPromise(ret)) {651        if (!(ret instanceof Promise)) {652          deprecate('parameters that are Promise-like are deprecated, use a native Promise instead')653        }654 655        ret.then(null, function (error) {656          paramCallback(error || new Error('Rejected promise'))657        })658      }659    } catch (e) {660      paramCallback(e)661    }662  }663 664  param()665}666 667/**668 * Restore obj props after function669 *670 * @private671 */672 673function restore (fn, obj) {674  const props = new Array(arguments.length - 2)675  const vals = new Array(arguments.length - 2)676 677  for (let i = 0; i < props.length; i++) {678    props[i] = arguments[i + 2]679    vals[i] = obj[props[i]]680  }681 682  return function () {683    // restore vals684    for (let i = 0; i < props.length; i++) {685      obj[props[i]] = vals[i]686    }687 688    return fn.apply(this, arguments)689  }690}691 692/**693 * Send an OPTIONS response.694 *695 * @private696 */697 698function sendOptionsResponse (res, methods) {699  const options = Object.create(null)700 701  // build unique method map702  for (let i = 0; i < methods.length; i++) {703    options[methods[i]] = true704  }705 706  // construct the allow list707  const allow = Object.keys(options).sort().join(', ')708 709  // send response710  res.setHeader('Allow', allow)711  res.setHeader('Content-Length', Buffer.byteLength(allow))712  res.setHeader('Content-Type', 'text/plain')713  res.setHeader('X-Content-Type-Options', 'nosniff')714  res.end(allow)715}716 717/**718 * Try to send an OPTIONS response.719 *720 * @private721 */722 723function trySendOptionsResponse (res, methods, next) {724  try {725    sendOptionsResponse(res, methods)726  } catch (err) {727    next(err)728  }729}730 731/**732 * Wrap a function733 *734 * @private735 */736 737function wrap (old, fn) {738  return function proxy () {739    const args = new Array(arguments.length + 1)740 741    args[0] = old742    for (let i = 0, len = arguments.length; i < len; i++) {743      args[i + 1] = arguments[i]744    }745 746    fn.apply(this, args)747  }748}749