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

package/src/router/brisk.ts

@@ -1,113 +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 Macroable from '@poppinss/macroable'
-import type { Application } from '@adonisjs/application'
-
-import { Route } from './route.js'
-import type { ParsedGlobalMiddleware } from '../types/middleware.js'
-import type { MakeUrlOptions, RouteFn, RouteMatchers } from '../types/route.js'
-
-/**
- * Brisk routes exposes the API to configure the route handler by chaining
- * one of the pre-defined methods.
- *
- * For example: Instead of defining the redirect logic as a callback, one can
- * chain the `.redirect` method.
- *
- * Brisk routes are always registered under the `GET` HTTP method.
- */
-export class BriskRoute extends Macroable {
-  /**
-   * Route pattern
-   */
-  #pattern: string
-
-  /**
-   * Matchers inherited from the router
-   */
-  #globalMatchers: RouteMatchers
-
-  /**
-   * Reference to the AdonisJS application
-   */
-  #app: Application<any>
-
-  /**
-   * Middleware registered on the router
-   */
-  #routerMiddleware: ParsedGlobalMiddleware[]
-
-  /**
-   * Reference to route instance. Set after `setHandler` is called
-   */
-  route: null | Route = null
-
-  constructor(
-    app: Application<any>,
-    routerMiddleware: ParsedGlobalMiddleware[],
-    options: {
-      pattern: string
-      globalMatchers: RouteMatchers
-    }
-  ) {
-    super()
-    this.#app = app
-    this.#routerMiddleware = routerMiddleware
-    this.#pattern = options.pattern
-    this.#globalMatchers = options.globalMatchers
-  }
-
-  /**
-   * Set handler for the brisk route
-   */
-  setHandler(handler: RouteFn): Route {
-    this.route = new Route(this.#app, this.#routerMiddleware, {
-      pattern: this.#pattern,
-      globalMatchers: this.#globalMatchers,
-      methods: ['GET', 'HEAD'],
-      handler: handler,
-    })
-
-    return this.route
-  }
-
-  /**
-   * Redirects to a given route. Params from the original request will
-   * be used when no custom params are defined.
-   */
-  redirect(
-    identifier: string,
-    params?: any[] | Record<string, any>,
-    options?: MakeUrlOptions & { status: number }
-  ): Route {
-    return this.setHandler(async function redirectsToRoute(ctx) {
-      const redirector = ctx.response.redirect()
-      if (options?.status) {
-        redirector.status(options.status)
-      }
-
-      return redirector.toRoute(identifier, params || ctx.params, options)
-    })
-  }
-
-  /**
-   * Redirect request to a fixed URL
-   */
-  redirectToPath(url: string, options?: { status: number }): Route {
-    return this.setHandler(async function redirectsToPath(ctx) {
-      const redirector = ctx.response.redirect()
-      if (options?.status) {
-        redirector.status(options.status)
-      }
-
-      return redirector.toPath(url)
-    })
-  }
-}

package/src/router/executor.ts

@@ -1,36 +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 type { StoreRouteNode } from '../types/route.js'
-import type { HttpContext } from '../http_context/main.js'
-import { useReturnValue } from './factories/use_return_value.js'
-
-/**
- * Executor to execute the route middleware pipeline the route
- * handler
- */
-export function execute(route: StoreRouteNode, resolver: ContainerResolver<any>, ctx: HttpContext) {
-  return route.middleware
-    .runner()
-    .finalHandler(async () => {
-      if (typeof route.handler === 'function') {
-        return Promise.resolve(route.handler(ctx)).then(useReturnValue(ctx))
-      }
-
-      return route.handler.handle(resolver, ctx).then(useReturnValue(ctx))
-    })
-    .run(async (middleware, next) => {
-      if (typeof middleware === 'function') {
-        return middleware(ctx, next)
-      }
-
-      return middleware.handle(resolver, ctx, next, middleware.args)
-    })
-}

package/src/router/factories/use_return_value.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'
-
-/**
- * A factory function that uses the return value of the request
- * pipeline as the response
- */
-export function useReturnValue(ctx: HttpContext) {
-  return function (value: any) {
-    if (
-      value !== undefined && // Return value is explicitly defined
-      !ctx.response.hasLazyBody && // Lazy body is not set
-      value !== ctx.response // Return value is not the instance of response object
-    ) {
-      ctx.response.send(value)
-    }
-  }
-}

package/src/router/group.ts

@@ -1,243 +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 Macroable from '@poppinss/macroable'
-import type { RouteMatcher, StoreRouteMiddleware } from '../types/route.js'
-import type { MiddlewareFn, ParsedNamedMiddleware } from '../types/middleware.js'
-
-import { Route } from './route.js'
-import { BriskRoute } from './brisk.js'
-import { RouteResource } from './resource.js'
-import { OneOrMore } from '../types/base.js'
-
-/**
- * Group class exposes the API to take action on a group of routes.
- * The group routes must be pre-defined using the constructor.
- */
-export class RouteGroup extends Macroable {
-  /**
-   * Array of middleware registered on the group.
-   */
-  #middleware: StoreRouteMiddleware[] = []
-
-  constructor(public routes: (Route | RouteGroup | RouteResource | BriskRoute)[]) {
-    super()
-  }
-
-  /**
-   * Shares midldeware stack with the routes. The method is invoked recursively
-   * to only register middleware with the route class and not with the
-   * resource or the child group
-   */
-  #shareMiddlewareStackWithRoutes(route: RouteGroup | Route | RouteResource | BriskRoute) {
-    if (route instanceof RouteGroup) {
-      route.routes.forEach((child) => this.#shareMiddlewareStackWithRoutes(child))
-      return
-    }
-
-    if (route instanceof RouteResource) {
-      route.routes.forEach((child) => child.getMiddleware().unshift(this.#middleware))
-      return
-    }
-
-    if (route instanceof BriskRoute) {
-      route.route!.getMiddleware().unshift(this.#middleware)
-      return
-    }
-
-    route.getMiddleware().unshift(this.#middleware)
-  }
-
-  /**
-   * Updates the route name. The method is invoked recursively to only update
-   * the name with the route class and not with the resource or the child
-   * group.
-   */
-  #updateRouteName(route: RouteGroup | Route | RouteResource | BriskRoute, name: string) {
-    if (route instanceof RouteGroup) {
-      route.routes.forEach((child) => this.#updateRouteName(child, name))
-      return
-    }
-
-    if (route instanceof RouteResource) {
-      route.routes.forEach((child) => child.as(name, true))
-      return
-    }
-
-    if (route instanceof BriskRoute) {
-      route.route!.as(name, true)
-      return
-    }
-
-    route.as(name, true)
-  }
-
-  /**
-   * Sets prefix on the route. The method is invoked recursively to only set
-   * the prefix with the route class and not with the resource or the
-   * child group.
-   */
-  #setRoutePrefix(route: RouteGroup | Route | RouteResource | BriskRoute, prefix: string) {
-    if (route instanceof RouteGroup) {
-      route.routes.forEach((child) => this.#setRoutePrefix(child, prefix))
-      return
-    }
-
-    if (route instanceof RouteResource) {
-      route.routes.forEach((child) => child.prefix(prefix))
-      return
-    }
-
-    if (route instanceof BriskRoute) {
-      route.route!.prefix(prefix)
-      return
-    }
-
-    route.prefix(prefix)
-  }
-
-  /**
-   * Updates domain on the route. The method is invoked recursively to only update
-   * the domain with the route class and not with the resource or the child
-   * group.
-   */
-  #updateRouteDomain(route: RouteGroup | Route | RouteResource | BriskRoute, domain: string) {
-    if (route instanceof RouteGroup) {
-      route.routes.forEach((child) => this.#updateRouteDomain(child, domain))
-      return
-    }
-
-    if (route instanceof RouteResource) {
-      route.routes.forEach((child) => child.domain(domain))
-      return
-    }
-
-    if (route instanceof BriskRoute) {
-      route.route!.domain(domain, false)
-      return
-    }
-
-    route.domain(domain, false)
-  }
-
-  /**
-   * Updates matchers on the route. The method is invoked recursively to only update
-   * the matchers with the route class and not with the resource or the child
-   * group.
-   */
-  #updateRouteMatchers(
-    route: RouteGroup | Route | RouteResource | BriskRoute,
-    param: string,
-    matcher: RouteMatcher | string | RegExp
-  ) {
-    if (route instanceof RouteGroup) {
-      route.routes.forEach((child) => this.#updateRouteMatchers(child, param, matcher))
-      return
-    }
-
-    if (route instanceof RouteResource) {
-      route.routes.forEach((child) => child.where(param, matcher))
-      return
-    }
-
-    if (route instanceof BriskRoute) {
-      route.route!.where(param, matcher)
-      return
-    }
-
-    route.where(param, matcher)
-  }
-
-  /**
-   * Define route param matcher
-   *
-   * ```ts
-   * Route.group(() => {
-   * }).where('id', /^[0-9]+/)
-   * ```
-   */
-  where(param: string, matcher: RouteMatcher | string | RegExp): this {
-    this.routes.forEach((route) => this.#updateRouteMatchers(route, param, matcher))
-    return this
-  }
-
-  /**
-   * Define prefix all the routes in the group.
-   *
-   * ```ts
-   * Route.group(() => {
-   * }).prefix('v1')
-   * ```
-   */
-  prefix(prefix: string): this {
-    this.routes.forEach((route) => this.#setRoutePrefix(route, prefix))
-    return this
-  }
-
-  /**
-   * Define domain for all the routes.
-   *
-   * ```ts
-   * Route.group(() => {
-   * }).domain(':name.adonisjs.com')
-   * ```
-   */
-  domain(domain: string): this {
-    this.routes.forEach((route) => this.#updateRouteDomain(route, domain))
-    return this
-  }
-
-  /**
-   * Prepend name to the routes name.
-   *
-   * ```ts
-   * Route.group(() => {
-   * }).as('version1')
-   * ```
-   */
-  as(name: string): this {
-    this.routes.forEach((route) => this.#updateRouteName(route, name))
-    return this
-  }
-  /**
-   * Prepend an array of middleware to all routes middleware.
-   *
-   * ```ts
-   * Route.group(() => {
-   * }).use(middleware.auth())
-   * ```
-   */
-  use(middleware: OneOrMore<MiddlewareFn | ParsedNamedMiddleware>): this {
-    /**
-     * Register middleware with children. We share the group middleware
-     * array by reference, therefore have to register it only for the
-     * first time.
-     */
-    if (!this.#middleware.length) {
-      this.routes.forEach((route) => this.#shareMiddlewareStackWithRoutes(route))
-    }
-
-    if (Array.isArray(middleware)) {
-      for (let one of middleware) {
-        this.#middleware.push(one)
-      }
-    } else {
-      this.#middleware.push(middleware)
-    }
-
-    return this
-  }
-
-  /**
-   * @alias use
-   */
-  middleware(middleware: OneOrMore<MiddlewareFn | ParsedNamedMiddleware>): this {
-    return this.use(middleware)
-  }
-}

package/src/router/lookup_store/main.ts

@@ -1,102 +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 { Encryption } from '@adonisjs/encryption'
-
-import type { Qs } from '../../qs.js'
-import { UrlBuilder } from './url_builder.js'
-import { RouteFinder } from './route_finder.js'
-import type { RouteJSON } from '../../types/route.js'
-
-/**
- * Lookup store exposes the API to lookup routes and
- * make URLs for registered routes.
- */
-export class LookupStore {
-  /**
-   * List of routes grouped by domain
-   */
-  #routes: { [domain: string]: RouteJSON[] } = {}
-
-  /**
-   * Encryption for making URLs
-   */
-  #encryption: Encryption
-
-  /**
-   * Query string parser for making URLs
-   */
-  #qsParser: Qs
-
-  constructor(encryption: Encryption, qsParser: Qs) {
-    this.#encryption = encryption
-    this.#qsParser = qsParser
-  }
-
-  /**
-   * Register route JSON payload
-   */
-  register(route: RouteJSON) {
-    this.#routes[route.domain] = this.#routes[route.domain] || []
-    this.#routes[route.domain].push(route)
-  }
-
-  /**
-   * Returns an instance of the URL builder for making
-   * route URIs
-   */
-  builder() {
-    return this.builderForDomain('root')
-  }
-
-  /**
-   * Returns an instance of the URL builder for a specific
-   * domain.
-   */
-  builderForDomain(domain: string) {
-    const routes = this.#routes[domain]
-    return new UrlBuilder(this.#encryption, new RouteFinder(routes || []), this.#qsParser)
-  }
-
-  /**
-   * Finds a route by its identifier. The identifier can be the
-   * route name, controller.method name or the route pattern
-   * itself.
-   */
-  find(routeIdentifier: string, domain?: string): RouteJSON | null {
-    const routes = this.#routes[domain || 'root'] || []
-    return new RouteFinder(routes).find(routeIdentifier)
-  }
-
-  /**
-   * Finds a route by its identifier. The identifier can be the
-   * route name, controller.method name or the route pattern
-   * itself.
-   *
-   * An error is raised when unable to find the route.
-   */
-  findOrFail(routeIdentifier: string, domain?: string): RouteJSON {
-    const routes = this.#routes[domain || 'root'] || []
-    return new RouteFinder(routes).findOrFail(routeIdentifier)
-  }
-
-  /**
-   * Check if a route exists. The identifier can be the
-   * route name, controller.method name or the route pattern
-   * itself.
-   */
-  has(routeIdentifier: string, domain?: string): boolean {
-    const routes = this.#routes[domain || 'root'] || []
-    return new RouteFinder(routes).has(routeIdentifier)
-  }
-
-  toJSON() {
-    return this.#routes
-  }
-}

package/src/router/lookup_store/route_finder.ts

@@ -1,60 +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 * as errors from '../../exceptions.js'
-import type { RouteJSON } from '../../types/route.js'
-
-/**
- * Route finder is used to find a route by its name, route pattern
- * or the controller.method name.
- */
-export class RouteFinder {
-  #routes: RouteJSON[]
-  constructor(routes: RouteJSON[]) {
-    this.#routes = routes
-  }
-
-  /**
-   * Find a route by indentifier
-   */
-  find(routeIdentifier: string): RouteJSON | null {
-    return (
-      this.#routes.find(({ name, pattern, handler }) => {
-        if (name === routeIdentifier || pattern === routeIdentifier) {
-          return true
-        }
-
-        if (typeof handler === 'function') {
-          return false
-        }
-
-        return handler.reference === routeIdentifier
-      }) || null
-    )
-  }
-
-  /**
-   * Find a route by indentifier or fail
-   */
-  findOrFail(routeIdentifier: string): RouteJSON {
-    const route = this.find(routeIdentifier)
-    if (!route) {
-      throw new errors.E_CANNOT_LOOKUP_ROUTE([routeIdentifier])
-    }
-
-    return route
-  }
-
-  /**
-   * Find if a route exists
-   */
-  has(routeIdentifier: string): boolean {
-    return !!this.find(routeIdentifier)
-  }
-}