@adonisjs/http-server 6.8.2-6 → 6.8.2-8

package/src/router/store.ts

@@ -1,239 +0,0 @@
-/*
- * @adonisjs/http-server
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-
-// @ts-expect-error
-import matchit from '@poppinss/matchit'
-import lodash from '@poppinss/utils/lodash'
-import { RuntimeException } from '@poppinss/utils'
-import type {
-  RouteJSON,
-  MatchedRoute,
-  StoreRouteNode,
-  StoreDomainNode,
-  StoreMethodNode,
-  StoreRoutesTree,
-  MatchItRouteToken,
-} from '../types/route.js'
-import { parseRoutePattern } from './parser.js'
-
-/**
- * Store class is used to store a list of routes, along side with their tokens
- * to match the URLs.
- *
- * ```ts
- * const store = new Store()
- *
- * store.add({
- *  pattern: 'posts/:id',
- *  handler: function onRoute () {},
- *  middleware: [],
- *  matchers: {
- *    id: '^[0-9]$+'
- *  },
- *  meta: {},
- *  methods: ['GET']
- * })
- *
- * store.match('posts/1', 'GET')
- * ```
- */
-export class RoutesStore {
-  /**
-   * A flag to know if routes for explicit domains
-   * have been registered
-   */
-  usingDomains: boolean = false
-
-  /**
-   * Tree of registered routes and their matchit tokens
-   */
-  tree: StoreRoutesTree = { tokens: [], domains: {} }
-
-  /**
-   * Returns the domain node for a given domain.
-   */
-  #getDomainNode(domain: string): StoreDomainNode {
-    if (!this.tree.domains[domain]) {
-      this.tree.tokens.push(parseRoutePattern(domain))
-      this.tree.domains[domain] = {}
-    }
-
-    return this.tree.domains[domain]
-  }
-
-  /**
-   * Returns the method node for a given domain and method.
-   */
-  #getMethodNode(domain: string, method: string): StoreMethodNode {
-    const domainNode = this.#getDomainNode(domain)
-    if (!domainNode[method]) {
-      domainNode[method] = { tokens: [], routes: {}, routeKeys: {} }
-    }
-
-    return domainNode[method]
-  }
-
-  /**
-   * Collects route params
-   */
-  #collectRouteParams(route: StoreRouteNode, tokens: MatchItRouteToken[]) {
-    const collectedParams: Set<string> = new Set()
-
-    for (let token of tokens) {
-      if ([1, 3].includes(token.type)) {
-        if (collectedParams.has(token.val)) {
-          throw new RuntimeException(`Duplicate param "${token.val}" found in "${route.pattern}"`)
-        } else {
-          collectedParams.add(token.val)
-        }
-      }
-    }
-
-    const params = [...collectedParams]
-    collectedParams.clear()
-
-    return params
-  }
-
-  /**
-   * Register route for a given domain and method
-   */
-  #registerRoute(
-    domain: string,
-    method: string,
-    tokens: MatchItRouteToken[],
-    route: StoreRouteNode
-  ) {
-    const methodRoutes = this.#getMethodNode(domain, method)
-
-    /*
-     * Check for duplicate route for the same domain and method
-     */
-    if (methodRoutes.routes[route.pattern]) {
-      throw new RuntimeException(
-        `Duplicate route found. "${method}: ${route.pattern}" route already exists`
-      )
-    }
-
-    methodRoutes.tokens.push(tokens)
-    methodRoutes.routes[route.pattern] = route
-    methodRoutes.routeKeys[route.pattern] =
-      domain !== 'root' ? `${domain}-${method}-${route.pattern}` : `${method}-${route.pattern}`
-  }
-
-  /**
-   * Add a route to the store
-   *
-   * ```ts
-   * store.add({
-   *   pattern: 'post/:id',
-   *   methods: ['GET'],
-   *   matchers: {},
-   *   meta: {},
-   *   handler: function handler () {
-   *   }
-   * })
-   * ```
-   */
-  add(route: RouteJSON): this {
-    /**
-     * Set flag when a custom domain is used
-     */
-    if (route.domain !== 'root') {
-      this.usingDomains = true
-    }
-
-    /**
-     * Generate tokens for the route
-     */
-    const tokens = parseRoutePattern(route.pattern, route.matchers)
-
-    /**
-     * Create route node object for persistence
-     */
-    const routeNode: StoreRouteNode = lodash.merge(
-      { meta: {} },
-      lodash.pick(route, ['pattern', 'handler', 'meta', 'middleware', 'name', 'execute'])
-    )
-
-    /**
-     * Set route params
-     */
-    routeNode.meta.params = this.#collectRouteParams(routeNode, tokens)
-
-    /**
-     * Register route for every method
-     */
-    route.methods.forEach((method) => {
-      this.#registerRoute(route.domain, method, tokens, routeNode)
-    })
-
-    return this
-  }
-
-  /**
-   * Matches the url, method and optionally domain to pull the matching
-   * route. `null` is returned when unable to match the URL against
-   * registered routes.
-   *
-   * The domain parameter has to be a registered pattern and not the fully
-   * qualified runtime domain. You must call `matchDomain` first to fetch
-   * the pattern for qualified domain
-   */
-  match(
-    url: string,
-    method: string,
-    domain?: { tokens: MatchItRouteToken[]; hostname: string }
-  ): null | MatchedRoute {
-    const domainName = domain?.tokens[0]?.old || 'root'
-
-    const matchedDomain = this.tree.domains[domainName]
-    if (!matchedDomain) {
-      return null
-    }
-
-    /*
-     * Next get the method node for the given method inside the domain. If
-     * method node is missing, means no routes ever got registered for that
-     * method
-     */
-    const matchedMethod = this.tree.domains[domainName][method]
-    if (!matchedMethod) {
-      return null
-    }
-
-    /*
-     * Next, match route for the given url inside the tokens list for the
-     * matchedMethod
-     */
-    const matchedRoute = matchit.match(url, matchedMethod.tokens)
-    if (!matchedRoute.length) {
-      return null
-    }
-
-    const route = matchedMethod.routes[matchedRoute[0].old]
-    return {
-      route: route,
-      routeKey: matchedMethod.routeKeys[route.pattern],
-      params: matchit.exec(url, matchedRoute),
-      subdomains: domain?.hostname ? matchit.exec(domain.hostname, domain.tokens) : {},
-    }
-  }
-
-  /**
-   * Match hostname against registered domains.
-   */
-  matchDomain(hostname?: string | null): MatchItRouteToken[] {
-    if (!hostname || !this.usingDomains) {
-      return []
-    }
-
-    return matchit.match(hostname, this.tree.tokens)
-  }
-}

package/src/server/factories/final_handler.ts

@@ -1,38 +0,0 @@
-/*
- * @adonisjs/http-server
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-
-import type { ContainerResolver } from '@adonisjs/fold'
-
-import * as errors from '../../exceptions.js'
-import type { Router } from '../../router/main.js'
-import type { HttpContext } from '../../http_context/main.js'
-
-/**
- * The final handler is executed after the server middleware stack.
- * It looks for a matching route and executes the route middleware
- * stack.
- */
-export function finalHandler(router: Router, resolver: ContainerResolver<any>, ctx: HttpContext) {
-  return function () {
-    const url = ctx.request.url()
-    const method = ctx.request.method()
-    const hostname = router.usingDomains ? ctx.request.hostname() : undefined
-    const route = router.match(url, method, hostname)
-
-    if (route) {
-      ctx.params = route.params
-      ctx.subdomains = route.subdomains
-      ctx.route = route.route
-      ctx.routeKey = route.routeKey
-      return route.route.execute(route.route, resolver, ctx)
-    }
-
-    return Promise.reject(new errors.E_ROUTE_NOT_FOUND([method, url]))
-  }
-}

package/src/server/factories/middleware_handler.ts

@@ -1,23 +0,0 @@
-/*
- * @adonisjs/http-server
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-
-import type { NextFn } from '@poppinss/middleware/types'
-import type { ContainerResolver } from '@adonisjs/fold'
-
-import type { HttpContext } from '../../http_context/main.js'
-import { ParsedGlobalMiddleware } from '../../types/middleware.js'
-
-/**
- * The middleware handler invokes the middleware functions.
- */
-export function middlewareHandler(resolver: ContainerResolver<any>, ctx: HttpContext) {
-  return function (fn: ParsedGlobalMiddleware, next: NextFn) {
-    return fn.handle(resolver, ctx, next)
-  }
-}

package/src/server/factories/write_response.ts

@@ -1,26 +0,0 @@
-/*
- * @adonisjs/http-server
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-
-import type { HttpContext } from '../../http_context/main.js'
-
-/**
- * Writes the response to the socket. The "finish" method can
- * raise error when unable to serialize the response.
- */
-export function writeResponse(ctx: HttpContext) {
-  return function () {
-    try {
-      ctx.response.finish()
-    } catch (error) {
-      ctx.logger.fatal({ err: error }, 'Response serialization failed')
-      ctx.response.internalServerError(error.message)
-      ctx.response.finish()
-    }
-  }
-}

package/src/server/main.ts

@@ -1,356 +0,0 @@
-/*
- * @adonisjs/http-server
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-
-import onFinished from 'on-finished'
-import { Emitter } from '@adonisjs/events'
-import Middleware from '@poppinss/middleware'
-import type { Logger } from '@adonisjs/logger'
-import type { Encryption } from '@adonisjs/encryption'
-import type { Server as HttpsServer } from 'node:https'
-import type { Application } from '@adonisjs/application'
-import { ContainerResolver, moduleCaller, moduleImporter } from '@adonisjs/fold'
-import type { ServerResponse, IncomingMessage, Server as HttpServer } from 'node:http'
-
-import type { LazyImport } from '../types/base.js'
-import type { MiddlewareAsClass, ParsedGlobalMiddleware } from '../types/middleware.js'
-import type {
-  ServerConfig,
-  ServerErrorHandler,
-  ErrorHandlerAsAClass,
-  TestingMiddlewarePipeline,
-} from '../types/server.js'
-
-import { Qs } from '../qs.js'
-import debug from '../debug.js'
-import { Request } from '../request.js'
-import { Response } from '../response.js'
-import { Router } from '../router/main.js'
-import { HttpContext } from '../http_context/main.js'
-import { finalHandler } from './factories/final_handler.js'
-import { writeResponse } from './factories/write_response.js'
-import { asyncLocalStorage } from '../http_context/local_storage.js'
-import { middlewareHandler } from './factories/middleware_handler.js'
-
-/**
- * The HTTP server implementation to handle incoming requests and respond using the
- * registered routes.
- */
-export class Server {
-  /**
-   * The default error handler to use
-   */
-  #defaultErrorHandler: ServerErrorHandler = {
-    report() {},
-    handle(error, ctx) {
-      ctx.response.status(error.status || 500).send(error.message || 'Internal server error')
-    },
-  }
-
-  /**
-   * Logger instance, a child logger is added
-   * to the context to have request specific
-   * logging capabilities.
-   */
-  #logger: Logger
-
-  /**
-   * Registered error handler (if any)
-   */
-  #errorHandler?: LazyImport<ErrorHandlerAsAClass>
-
-  /**
-   * Resolved error handler is an instance of the lazily imported error
-   * handler class.
-   */
-  #resolvedErrorHandler: ServerErrorHandler = this.#defaultErrorHandler
-
-  /**
-   * Emitter is required to notify when a request finishes
-   */
-  #emitter: Emitter<any>
-
-  /**
-   * The application instance to be shared with the router
-   */
-  #app: Application<any>
-
-  /**
-   * The encryption instance to be shared with the router
-   */
-  #encryption: Encryption
-
-  /**
-   * Server config
-   */
-  #config: ServerConfig
-
-  /**
-   * Query string parser used by the server
-   */
-  #qsParser: Qs
-
-  /**
-   * Server middleware stack runs on every incoming HTTP request
-   */
-  #serverMiddlewareStack?: Middleware<ParsedGlobalMiddleware>
-
-  /**
-   * Reference to the router used by the server
-   */
-  #router: Router
-
-  /**
-   * Reference to the underlying Node HTTP server in use
-   */
-  #nodeHttpServer?: HttpServer | HttpsServer
-
-  /**
-   * Middleware store to be shared with the routes
-   */
-  #middleware: ParsedGlobalMiddleware[] = []
-
-  /**
-   * Know if async local storage is enabled or not.
-   */
-  get usingAsyncLocalStorage() {
-    return asyncLocalStorage.isEnabled
-  }
-
-  constructor(
-    app: Application<any>,
-    encryption: Encryption,
-    emitter: Emitter<any>,
-    logger: Logger,
-    config: ServerConfig
-  ) {
-    this.#app = app
-    this.#emitter = emitter
-    this.#config = config
-    this.#logger = logger
-    this.#encryption = encryption
-    this.#qsParser = new Qs(this.#config.qs)
-    this.#router = new Router(this.#app, this.#encryption, this.#qsParser)
-    this.#createAsyncLocalStore()
-
-    debug('server config: %O', this.#config)
-  }
-
-  /**
-   * Create async local storage store when enabled
-   */
-  #createAsyncLocalStore() {
-    if (this.#config.useAsyncLocalStorage) {
-      debug('creating ALS store for HTTP context')
-      asyncLocalStorage.create()
-    } else {
-      asyncLocalStorage.destroy()
-    }
-  }
-
-  /**
-   * Creates an instance of the server middleware stack
-   */
-  #createServerMiddlewareStack() {
-    this.#serverMiddlewareStack = new Middleware()
-    this.#middleware.forEach((middleware) => this.#serverMiddlewareStack!.add(middleware))
-    this.#serverMiddlewareStack.freeze()
-    this.#middleware = []
-  }
-
-  /**
-   * Handles the HTTP request
-   */
-  #handleRequest(ctx: HttpContext, resolver: ContainerResolver<any>) {
-    return this.#serverMiddlewareStack!.runner()
-      .errorHandler((error) => {
-        this.#resolvedErrorHandler.report(error, ctx)
-        return this.#resolvedErrorHandler.handle(error, ctx)
-      })
-      .finalHandler(finalHandler(this.#router!, resolver, ctx))
-      .run(middlewareHandler(resolver, ctx))
-      .catch((error) => {
-        ctx.logger.fatal({ err: error }, 'Exception raised by error handler')
-        return this.#defaultErrorHandler.handle(error, ctx)
-      })
-      .finally(writeResponse(ctx))
-  }
-
-  /**
-   * Creates a pipeline of middleware.
-   */
-  pipeline(middleware: MiddlewareAsClass[]): TestingMiddlewarePipeline {
-    const middlewareStack = new Middleware<ParsedGlobalMiddleware>()
-    middleware.forEach((one) => {
-      middlewareStack.add(moduleCaller(one, 'handle').toHandleMethod())
-    })
-
-    middlewareStack.freeze()
-    const stackRunner = middlewareStack.runner()
-
-    return {
-      finalHandler(handler) {
-        stackRunner.finalHandler(handler)
-        return this
-      },
-      errorHandler(handler) {
-        stackRunner.errorHandler(handler)
-        return this
-      },
-      run(ctx) {
-        return stackRunner.run((handler, next) => {
-          return handler.handle(ctx.containerResolver, ctx, next)
-        })
-      },
-    }
-  }
-
-  /**
-   * Define an array of middleware to use on all the incoming HTTP request.
-   * Calling this method multiple times pushes to the existing list
-   * of middleware
-   */
-  use(middleware: LazyImport<MiddlewareAsClass>[]): this {
-    middleware.forEach((one) =>
-      this.#middleware.push(moduleImporter(one, 'handle').toHandleMethod())
-    )
-
-    return this
-  }
-
-  /**
-   * Register a custom error handler for HTTP requests.
-   * All errors will be reported to this method
-   */
-  errorHandler(handler: LazyImport<ErrorHandlerAsAClass>): this {
-    this.#errorHandler = handler
-    return this
-  }
-
-  /**
-   * Boot the server. Calling this method performs the following actions.
-   *
-   * - Register routes with the store.
-   * - Resolve and construct the error handler.
-   */
-  async boot() {
-    debug('booting HTTP server')
-
-    /**
-     * Creates the middleware stack for the server
-     */
-    this.#createServerMiddlewareStack()
-
-    /**
-     * Commit routes
-     */
-    this.#router.commit()
-
-    /**
-     * Register custom error handler
-     */
-    if (this.#errorHandler) {
-      if (debug.enabled) {
-        debug('using custom error handler "%s"', this.#errorHandler)
-      }
-
-      const moduleExports = await this.#errorHandler()
-      this.#resolvedErrorHandler = await this.#app.container.make(moduleExports.default)
-    }
-  }
-
-  /**
-   * Set the HTTP server instance used to listen for requests.
-   */
-  setNodeServer(server: HttpServer | HttpsServer) {
-    this.#nodeHttpServer = server
-  }
-
-  /**
-   * Returns reference to the underlying HTTP server
-   * in use
-   */
-  getNodeServer() {
-    return this.#nodeHttpServer
-  }
-
-  /**
-   * Returns reference to the router instance used
-   * by the server.
-   */
-  getRouter(): Router {
-    return this.#router
-  }
-
-  /**
-   * Creates an instance of the [[Request]] class
-   */
-  createRequest(req: IncomingMessage, res: ServerResponse) {
-    return new Request(req, res, this.#encryption, this.#config, this.#qsParser)
-  }
-
-  /**
-   * Creates an instance of the [[Response]] class
-   */
-  createResponse(req: IncomingMessage, res: ServerResponse) {
-    return new Response(req, res, this.#encryption, this.#config, this.#router, this.#qsParser)
-  }
-
-  /**
-   * Creates an instance of the [[HttpContext]] class
-   */
-  createHttpContext(request: Request, response: Response, resolver: ContainerResolver<any>) {
-    return new HttpContext(
-      request,
-      response,
-      this.#logger.child({ request_id: request.id() }),
-      resolver
-    )
-  }
-
-  /**
-   * Handle request
-   */
-  handle(req: IncomingMessage, res: ServerResponse) {
-    /**
-     * Setup for the "http:request_finished" event
-     */
-    const hasRequestListener = this.#emitter.hasListeners('http:request_finished')
-    const startTime = hasRequestListener ? process.hrtime() : null
-
-    /**
-     * Creating essential instances
-     */
-    const resolver = this.#app.container.createResolver()
-    const ctx = this.createHttpContext(
-      this.createRequest(req, res),
-      this.createResponse(req, res),
-      resolver
-    )
-
-    /**
-     * Emit event when listening for the request_finished event
-     */
-    if (startTime) {
-      onFinished(res, () => {
-        this.#emitter.emit('http:request_finished', {
-          ctx: ctx,
-          duration: process.hrtime(startTime),
-        })
-      })
-    }
-
-    /**
-     * Handle request
-     */
-    if (this.usingAsyncLocalStorage) {
-      return asyncLocalStorage.storage!.run(ctx, () => this.#handleRequest(ctx, resolver))
-    }
-    return this.#handleRequest(ctx, resolver)
-  }
-}

package/src/types/base.ts

@@ -1,30 +0,0 @@
-/*
- * @adonisjs/http-server
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-
-export type { NextFn } from '@poppinss/middleware/types'
-
-/**
- * Accept one or more of the mentioned type
- */
-export type OneOrMore<T> = T | T[]
-
-/**
- * Class constructor type
- */
-export type Constructor<T> = new (...args: any[]) => T
-
-/**
- * A function that lazily imports a middleware
- */
-export type LazyImport<DefaultExport> = () => Promise<{ default: DefaultExport }>
-
-/**
- * Unwraps default export from a lazy import function
- */
-export type UnWrapLazyImport<Fn extends LazyImport<any>> = Awaited<ReturnType<Fn>>['default']