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

package/src/router/parser.ts

@@ -1,20 +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 { MatchItRouteToken, RouteMatchers } from '../types/route.js'
-
-/**
- * Parses the route pattern
- */
-export function parseRoutePattern(pattern: string, matchers?: RouteMatchers): MatchItRouteToken[] {
-  const tokens = matchit.parse(pattern, matchers)
-  return tokens
-}

package/src/router/resource.ts

@@ -1,277 +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 string from '@poppinss/utils/string'
-import Macroable from '@poppinss/macroable'
-import { RuntimeException } from '@poppinss/utils'
-import type { Application } from '@adonisjs/application'
-
-import { Route } from './route.js'
-import type { Constructor, LazyImport } from '../types/base.js'
-import type { ParsedGlobalMiddleware } from '../types/middleware.js'
-import type { ResourceActionNames, RouteMatcher, RouteMatchers } from '../types/route.js'
-
-/**
- * Route resource exposes the API to register multiple routes for a resource.
- */
-export class RouteResource extends Macroable {
-  /**
-   * Resource identifier. Nested resources are separated
-   * with a dot notation
-   */
-  #resource: string
-
-  /**
-   * The controller to handle resource routing requests
-   */
-  #controller: string | LazyImport<Constructor<any>> | Constructor<any>
-
-  /**
-   * Is it a shallow resource? Shallow resources URLs do not have parent
-   * resource name and id once they can be identified with the id.
-   */
-  #shallow: boolean = false
-
-  /**
-   * Matchers inherited from the router
-   */
-  #globalMatchers: RouteMatchers
-
-  /**
-   * Reference to the AdonisJS application
-   */
-  #app: Application<any>
-
-  /**
-   * Middleware registered on the router
-   */
-  #routerMiddleware: ParsedGlobalMiddleware[]
-
-  /**
-   * Parameter names for the resources. Defaults to `id` for
-   * a singular resource and `resource_id` for nested
-   * resources.
-   */
-  #params: Record<string, string> = {}
-
-  /**
-   * Base name for the routes. We suffix action names
-   * on top of the base name
-   */
-  #routesBaseName: string
-
-  /**
-   * A collection of routes instances that belongs to this resource
-   */
-  routes: Route[] = []
-
-  constructor(
-    app: Application<any>,
-    routerMiddleware: ParsedGlobalMiddleware[],
-    options: {
-      resource: string
-      controller: string | LazyImport<Constructor<any>> | Constructor<any>
-      globalMatchers: RouteMatchers
-      shallow: boolean
-    }
-  ) {
-    super()
-    this.#validateResourceName(options.resource)
-
-    this.#app = app
-    this.#shallow = options.shallow
-    this.#routerMiddleware = routerMiddleware
-    this.#controller = options.controller
-    this.#globalMatchers = options.globalMatchers
-    this.#resource = this.#normalizeResourceName(options.resource)
-    this.#routesBaseName = this.#getRoutesBaseName()
-    this.#buildRoutes()
-  }
-
-  /**
-   * Normalizes the resource name to dropping leading and trailing
-   * slashes.
-   */
-  #normalizeResourceName(resource: string) {
-    return resource.replace(/^\//, '').replace(/\/$/, '')
-  }
-
-  /**
-   * Ensure resource name is not an empty string
-   */
-  #validateResourceName(resource: string) {
-    if (!resource || resource === '/') {
-      throw new RuntimeException(`Invalid resource name "${resource}"`)
-    }
-  }
-
-  /**
-   * Converting segments of a resource to snake case to
-   * make the route name.
-   */
-  #getRoutesBaseName() {
-    return this.#resource
-      .split('.')
-      .map((token) => string.snakeCase(token))
-      .join('.')
-  }
-
-  /**
-   * Create a new route for the given pattern, methods and controller action
-   */
-  #createRoute(pattern: string, methods: string[], action: ResourceActionNames) {
-    const route = new Route(this.#app, this.#routerMiddleware, {
-      pattern,
-      methods,
-      handler:
-        typeof this.#controller === 'string'
-          ? `${this.#controller}.${action}`
-          : [this.#controller, action],
-      globalMatchers: this.#globalMatchers,
-    })
-
-    route.as(`${this.#routesBaseName}.${action}`)
-    this.routes.push(route)
-  }
-
-  /**
-   * Returns the `resource_id` name for a given resource. The
-   * resource name is converted to singular form and
-   * transformed to snake case.
-   *
-   * photos becomes photo_id
-   * users becomes user_id
-   */
-  #getResourceId(resource: string) {
-    return `${string.snakeCase(string.singular(resource))}_id`
-  }
-
-  /**
-   * Build routes for the given resource
-   */
-  #buildRoutes() {
-    const resources = this.#resource.split('.')
-
-    const mainResource = resources.pop()!
-    this.#params[mainResource] = ':id'
-
-    const baseURI = `${resources
-      .map((resource) => {
-        const paramName = `:${this.#getResourceId(resource)}`
-        this.#params[resource] = paramName
-
-        return `${resource}/${paramName}`
-      })
-      .join('/')}/${mainResource}`
-
-    this.#createRoute(baseURI, ['GET', 'HEAD'], 'index')
-    this.#createRoute(`${baseURI}/create`, ['GET', 'HEAD'], 'create')
-    this.#createRoute(baseURI, ['POST'], 'store')
-    this.#createRoute(`${this.#shallow ? mainResource : baseURI}/:id`, ['GET', 'HEAD'], 'show')
-    this.#createRoute(`${this.#shallow ? mainResource : baseURI}/:id/edit`, ['GET', 'HEAD'], 'edit')
-    this.#createRoute(`${this.#shallow ? mainResource : baseURI}/:id`, ['PUT', 'PATCH'], 'update')
-    this.#createRoute(`${this.#shallow ? mainResource : baseURI}/:id`, ['DELETE'], 'destroy')
-  }
-
-  /**
-   * Filter the routes based on their partial names
-   */
-  #filter(names: ResourceActionNames | ResourceActionNames[], inverse: boolean) {
-    const actions = Array.isArray(names) ? names : [names]
-    return this.routes.filter((route) => {
-      const match = actions.find((name) => route.getName()!.endsWith(name))
-      return inverse ? !match : match
-    })
-  }
-
-  /**
-   * Register only given routes and remove others
-   */
-  only(names: ResourceActionNames[]): this {
-    this.#filter(names, true).forEach((route) => route.markAsDeleted())
-    return this
-  }
-
-  /**
-   * Register all routes, except the one's defined
-   */
-  except(names: ResourceActionNames[]): this {
-    this.#filter(names, false).forEach((route) => route.markAsDeleted())
-    return this
-  }
-
-  /**
-   * Register api only routes. The `create` and `edit` routes, which
-   * are meant to show forms will not be registered
-   */
-  apiOnly(): this {
-    return this.except(['create', 'edit'])
-  }
-
-  /**
-   * Define matcher for params inside the resource
-   */
-  where(key: string, matcher: RouteMatcher | string | RegExp): this {
-    this.routes.forEach((route) => {
-      route.where(key, matcher)
-    })
-
-    return this
-  }
-
-  /**
-   * Tap into multiple routes to configure them by their name
-   */
-  tap(callback: (route: Route) => void): this
-  tap(actions: ResourceActionNames | ResourceActionNames[], callback: (route: Route) => void): this
-  tap(
-    actions: ((route: Route) => void) | ResourceActionNames | ResourceActionNames[],
-    callback?: (route: Route) => void
-  ): this {
-    if (typeof actions === 'function') {
-      this.routes.forEach((route) => actions(route))
-      return this
-    }
-
-    this.#filter(actions, false).forEach((route) => callback!(route))
-    return this
-  }
-
-  /**
-   * Set the param name for a given resource
-   */
-  params(resources: { [resource: string]: string }): this {
-    Object.keys(resources).forEach((resource) => {
-      const param = resources[resource]
-      const existingParam = this.#params[resource]
-      this.#params[resource] = `:${param}`
-
-      this.routes.forEach((route) => {
-        route.setPattern(
-          route.getPattern().replace(`${resource}/${existingParam}`, `${resource}/:${param}`)
-        )
-      })
-    })
-
-    return this
-  }
-
-  /**
-   * Prepend name to all the routes
-   */
-  as(name: string, normalizeName: boolean = true): this {
-    name = normalizeName ? string.snakeCase(name) : name
-    this.routes.forEach((route) => {
-      route.as(route.getName()!.replace(this.#routesBaseName, name), false)
-    })
-
-    this.#routesBaseName = name
-    return this
-  }
-}

package/src/router/route.ts

@@ -1,363 +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 is from '@sindresorhus/is'
-import Macroable from '@poppinss/macroable'
-import Middleware from '@poppinss/middleware'
-import { RuntimeException } from '@poppinss/utils'
-import type { Application } from '@adonisjs/application'
-import { moduleCaller, moduleExpression, moduleImporter } from '@adonisjs/fold'
-
-import { execute } from './executor.js'
-import { dropSlash } from '../helpers.js'
-import type { Constructor, LazyImport, OneOrMore } from '../types/base.js'
-
-import type {
-  MiddlewareFn,
-  ParsedNamedMiddleware,
-  ParsedGlobalMiddleware,
-} from '../types/middleware.js'
-
-import type {
-  GetControllerHandlers,
-  RouteFn,
-  RouteJSON,
-  RouteMatcher,
-  RouteMatchers,
-  StoreRouteHandler,
-  StoreRouteMiddleware,
-} from '../types/route.js'
-
-/**
- * The route class exposes the APIs for constructing a route using the
- * fluent API.
- */
-export class Route<Controller extends Constructor<any> = any> extends Macroable {
-  /**
-   * Route pattern
-   */
-  #pattern: string
-
-  /**
-   * HTTP Methods for the route
-   */
-  #methods: string[]
-
-  /**
-   * A unique name for the route
-   */
-  #name?: string
-
-  /**
-   * A boolean to prevent route from getting registered within
-   * the store.
-   *
-   * This flag must be set before "Router.commit" method
-   */
-  #isDeleted: boolean = false
-
-  /**
-   * Route handler
-   */
-  #handler: StoreRouteHandler
-
-  /**
-   * Matchers inherited from the router
-   */
-  #globalMatchers: RouteMatchers
-
-  /**
-   * Reference to the AdonisJS application
-   */
-  #app: Application<any>
-
-  /**
-   * Middleware registered on the router
-   */
-  #routerMiddleware: ParsedGlobalMiddleware[]
-
-  /**
-   * By default the route is part of the `root` domain. Root domain is used
-   * when no domain is defined
-   */
-  #routeDomain: string = 'root'
-
-  /**
-   * An object of matchers to be forwarded to the store. The matchers
-   * list is populated by calling `where` method
-   */
-  #matchers: RouteMatchers = {}
-
-  /**
-   * Custom prefixes defined on the route or the route parent
-   * groups
-   */
-  #prefixes: string[] = []
-
-  /**
-   * Middleware defined directly on the route or the route parent
-   * routes. We mantain an array for each layer of the stack
-   */
-  #middleware: StoreRouteMiddleware[][] = []
-
-  constructor(
-    app: Application<any>,
-    routerMiddleware: ParsedGlobalMiddleware[],
-    options: {
-      pattern: string
-      methods: string[]
-      handler:
-        | RouteFn
-        | string
-        | [LazyImport<Controller> | Controller, GetControllerHandlers<Controller>?]
-      globalMatchers: RouteMatchers
-    }
-  ) {
-    super()
-    this.#app = app
-    this.#routerMiddleware = routerMiddleware
-    this.#pattern = options.pattern
-    this.#methods = options.methods
-    this.#handler = this.#resolveRouteHandle(options.handler)
-    this.#globalMatchers = options.globalMatchers
-  }
-
-  /**
-   * Resolves the route handler string expression to a
-   * handler method object
-   */
-  #resolveRouteHandle(
-    handler:
-      | RouteFn
-      | string
-      | [LazyImport<Controller> | Controller, GetControllerHandlers<Controller>?]
-  ) {
-    if (typeof handler === 'string') {
-      return {
-        reference: handler,
-        ...moduleExpression(handler, this.#app.appRoot).toHandleMethod(),
-      }
-    }
-
-    /**
-     * Using a lazily imported controller
-     */
-    if (Array.isArray(handler)) {
-      /**
-       * The first item of the tuple is a class constructor
-       */
-      if (is.class_(handler[0])) {
-        return {
-          reference: handler,
-          ...moduleCaller(handler[0], (handler[1] || 'handle') as string).toHandleMethod(),
-        }
-      }
-
-      /**
-       * The first item of the tuple is a function that lazily
-       * loads the controller
-       */
-      return {
-        reference: handler,
-        ...moduleImporter(handler[0], (handler[1] || 'handle') as string).toHandleMethod(),
-      }
-    }
-
-    return handler
-  }
-
-  /**
-   * Returns an object of param matchers by merging global and local
-   * matchers. The local copy is given preference over the global
-   * one's
-   */
-  #getMatchers() {
-    return { ...this.#globalMatchers, ...this.#matchers }
-  }
-
-  /**
-   * Returns a normalized pattern string by prefixing the `prefix` (if defined).
-   */
-  #computePattern(): string {
-    const pattern = dropSlash(this.#pattern)
-    const prefix = this.#prefixes
-      .slice()
-      .reverse()
-      .map((one) => dropSlash(one))
-      .join('')
-
-    return prefix ? `${prefix}${pattern === '/' ? '' : pattern}` : pattern
-  }
-
-  /**
-   * Define matcher for a given param. If a matcher exists, then we do not
-   * override that, since the routes inside a group will set matchers
-   * before the group, so they should have priority over the group
-   * matchers.
-   *
-   * ```ts
-   * Route.group(() => {
-   *   Route.get('/:id', 'handler').where('id', /^[0-9]$/)
-   * }).where('id', /[^a-z$]/)
-   * ```
-   *
-   * The `/^[0-9]$/` will win over the matcher defined by the group
-   */
-  where(param: string, matcher: RouteMatcher | string | RegExp): this {
-    if (this.#matchers[param]) {
-      return this
-    }
-
-    if (typeof matcher === 'string') {
-      this.#matchers[param] = { match: new RegExp(matcher) }
-    } else if (is.regExp(matcher)) {
-      this.#matchers[param] = { match: matcher }
-    } else {
-      this.#matchers[param] = matcher
-    }
-
-    return this
-  }
-
-  /**
-   * Define prefix for the route. Calling this method multiple times
-   * applies multiple prefixes in the reverse order.
-   */
-  prefix(prefix: string): this {
-    this.#prefixes.push(prefix)
-    return this
-  }
-
-  /**
-   * Define a custom domain for the route. We do not overwrite the domain
-   * unless `overwrite` flag is set to true.
-   */
-  domain(domain: string, overwrite: boolean = false): this {
-    if (this.#routeDomain === 'root' || overwrite) {
-      this.#routeDomain = domain
-    }
-    return this
-  }
-
-  /**
-   * Define one or more middleware to be executed before the route
-   * handler.
-   *
-   * Named middleware can be referenced using the name registered with
-   * the router middleware store.
-   */
-  use(middleware: OneOrMore<MiddlewareFn | ParsedNamedMiddleware>): this {
-    this.#middleware.push(Array.isArray(middleware) ? middleware : [middleware])
-    return this
-  }
-
-  /**
-   * @alias use
-   */
-  middleware(middleware: OneOrMore<MiddlewareFn | ParsedNamedMiddleware>): this {
-    return this.use(middleware)
-  }
-
-  /**
-   * Give a unique name to the route. Assinging a new unique removes the
-   * existing name of the route.
-   *
-   * Setting prepends to true prefixes the name to the existing name.
-   */
-  as(name: string, prepend = false): this {
-    if (prepend) {
-      if (!this.#name) {
-        throw new RuntimeException(
-          `Routes inside a group must have names before calling "router.group.as"`
-        )
-      }
-
-      this.#name = `${name}.${this.#name}`
-      return this
-    }
-
-    this.#name = name
-    return this
-  }
-
-  /**
-   * Check if the route was marked to be deleted
-   */
-  isDeleted(): boolean {
-    return this.#isDeleted
-  }
-
-  /**
-   * Mark route as deleted. Deleted routes are not registered
-   * with the route store
-   */
-  markAsDeleted() {
-    this.#isDeleted = true
-  }
-
-  /**
-   * Get the route name
-   */
-  getName(): string | undefined {
-    return this.#name
-  }
-
-  /**
-   * Get the route pattern
-   */
-  getPattern(): string {
-    return this.#pattern
-  }
-
-  /**
-   * Set the route pattern
-   */
-  setPattern(pattern: string): this {
-    this.#pattern = pattern
-    return this
-  }
-
-  /**
-   * Returns the stack of middleware registered on the route.
-   * The value is shared by reference.
-   */
-  getMiddleware() {
-    return this.#middleware
-  }
-
-  /**
-   * Returns the middleware instance for persistence inside the
-   * store
-   */
-  #getMiddlewareForStore() {
-    const middleware = new Middleware<StoreRouteMiddleware>()
-
-    this.#routerMiddleware.forEach((one) => middleware.add(one))
-    this.#middleware.flat().forEach((one) => middleware.add(one))
-
-    return middleware
-  }
-
-  /**
-   * Returns JSON representation of the route
-   */
-  toJSON(): RouteJSON {
-    return {
-      domain: this.#routeDomain,
-      pattern: this.#computePattern(),
-      matchers: this.#getMatchers(),
-      meta: {},
-      name: this.#name,
-      handler: this.#handler,
-      methods: this.#methods,
-      middleware: this.#getMiddlewareForStore(),
-      execute: execute,
-    }
-  }
-}