@adonisjs/http-server 5.11.0 → 6.0.0-0

package/build/src/router/resource.js

@@ -0,0 +1,124 @@
+import string from '@poppinss/utils/string';
+import { Macroable } from '@poppinss/macroable';
+import { RuntimeException } from '@poppinss/utils';
+import { Route } from './route.js';
+export class RouteResource extends Macroable {
+    #resource;
+    #controller;
+    #shallow = false;
+    #globalMatchers;
+    #app;
+    #middlewareStore;
+    #params = {};
+    #routesBaseName;
+    routes = [];
+    constructor(app, middlewareStore, options) {
+        super();
+        this.#validateResourceName(options.resource);
+        this.#app = app;
+        this.#shallow = options.shallow;
+        this.#middlewareStore = middlewareStore;
+        this.#controller = options.controller;
+        this.#globalMatchers = options.globalMatchers;
+        this.#resource = this.#normalizeResourceName(options.resource);
+        this.#routesBaseName = this.#getRoutesBaseName();
+        this.#buildRoutes();
+    }
+    #normalizeResourceName(resource) {
+        return resource.replace(/^\//, '').replace(/\/$/, '');
+    }
+    #validateResourceName(resource) {
+        if (!resource || resource === '/') {
+            throw new RuntimeException(`Invalid resource name "${resource}"`);
+        }
+    }
+    #getRoutesBaseName() {
+        return this.#resource
+            .split('.')
+            .map((token) => string.snakeCase(token))
+            .join('.');
+    }
+    #createRoute(pattern, methods, action) {
+        const route = new Route(this.#app, this.#middlewareStore, {
+            pattern,
+            methods,
+            handler: `${this.#controller}.${action}`,
+            globalMatchers: this.#globalMatchers,
+        });
+        route.as(`${this.#routesBaseName}.${action}`);
+        this.routes.push(route);
+    }
+    #getResourceId(resource) {
+        return `${string.snakeCase(string.singular(resource))}_id`;
+    }
+    #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(names, inverse) {
+        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;
+        });
+    }
+    only(names) {
+        this.#filter(names, true).forEach((route) => route.markAsDeleted());
+        return this;
+    }
+    except(names) {
+        this.#filter(names, false).forEach((route) => route.markAsDeleted());
+        return this;
+    }
+    apiOnly() {
+        return this.except(['create', 'edit']);
+    }
+    where(key, matcher) {
+        this.routes.forEach((route) => {
+            route.where(key, matcher);
+        });
+        return this;
+    }
+    tap(actions, callback) {
+        if (typeof actions === 'function') {
+            this.routes.forEach((route) => actions(route));
+            return this;
+        }
+        this.#filter(actions, false).forEach((route) => callback(route));
+        return this;
+    }
+    params(resources) {
+        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;
+    }
+    as(name) {
+        name = string.snakeCase(name);
+        this.routes.forEach((route) => {
+            route.as(route.getName().replace(this.#routesBaseName, name), false);
+        });
+        this.#routesBaseName = name;
+        return this;
+    }
+}

package/build/src/router/route.d.ts

@@ -0,0 +1,28 @@
+import { Macroable } from '@poppinss/macroable';
+import type { Application } from '@adonisjs/application';
+import type { MiddlewareStore } from '../middleware/store.js';
+import type { LazyImport, UnWrapLazyImport } from '../types/base.js';
+import type { GetMiddlewareArgs, MiddlewareAsClass, MiddlewareFn } from '../types/middleware.js';
+import type { RouteFn, RouteJSON, RouteMatcher, RouteMatchers, StoreRouteMiddleware } from '../types/route.js';
+export declare class Route<NamedMiddleware extends Record<string, LazyImport<MiddlewareAsClass>> = any> extends Macroable {
+    #private;
+    constructor(app: Application, middlewareStore: MiddlewareStore<NamedMiddleware>, options: {
+        pattern: string;
+        methods: string[];
+        handler: RouteFn | string;
+        globalMatchers: RouteMatchers;
+    });
+    where(param: string, matcher: RouteMatcher | string | RegExp): this;
+    prefix(prefix: string): this;
+    domain(domain: string, overwrite?: boolean): this;
+    middleware<Name extends keyof NamedMiddleware>(middleware: Name, ...args: GetMiddlewareArgs<UnWrapLazyImport<NamedMiddleware[Name]>>): this;
+    middleware(middleware: MiddlewareFn): this;
+    as(name: string, prepend?: boolean): this;
+    isDeleted(): boolean;
+    markAsDeleted(): void;
+    getName(): string | undefined;
+    getPattern(): string;
+    setPattern(pattern: string): this;
+    getMiddleware(): StoreRouteMiddleware[][];
+    toJSON(): RouteJSON;
+}

package/build/src/router/route.js

@@ -0,0 +1,135 @@
+import is from '@sindresorhus/is';
+import Middleware from '@poppinss/middleware';
+import { Macroable } from '@poppinss/macroable';
+import { moduleExpression } from '@adonisjs/fold';
+import { RuntimeException } from '@poppinss/utils';
+import { execute } from './executor.js';
+import { dropSlash } from '../helpers.js';
+export class Route extends Macroable {
+    #pattern;
+    #methods;
+    #name;
+    #isDeleted = false;
+    #handler;
+    #globalMatchers;
+    #app;
+    #middlewareStore;
+    #routeDomain = 'root';
+    #matchers = {};
+    #prefixes = [];
+    #middleware = [];
+    constructor(app, middlewareStore, options) {
+        super();
+        this.#app = app;
+        this.#middlewareStore = middlewareStore;
+        this.#pattern = options.pattern;
+        this.#methods = options.methods;
+        this.#handler = this.#resolveRouteHandle(options.handler);
+        this.#globalMatchers = options.globalMatchers;
+    }
+    #resolveRouteHandle(handler) {
+        if (typeof handler === 'string') {
+            return {
+                name: handler,
+                ...moduleExpression(handler, this.#app.appRoot).toHandleMethod(),
+            };
+        }
+        return handler;
+    }
+    #getMatchers() {
+        return { ...this.#globalMatchers, ...this.#matchers };
+    }
+    #computePattern() {
+        const pattern = dropSlash(this.#pattern);
+        const prefix = this.#prefixes
+            .slice()
+            .reverse()
+            .map((one) => dropSlash(one))
+            .join('');
+        return prefix ? `${prefix}${pattern === '/' ? '' : pattern}` : pattern;
+    }
+    where(param, matcher) {
+        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;
+    }
+    prefix(prefix) {
+        this.#prefixes.push(prefix);
+        return this;
+    }
+    domain(domain, overwrite = false) {
+        if (this.#routeDomain === 'root' || overwrite) {
+            this.#routeDomain = domain;
+        }
+        return this;
+    }
+    middleware(middleware, args) {
+        if (typeof middleware === 'string') {
+            this.#middleware.push([this.#middlewareStore.get(middleware, args)]);
+            return this;
+        }
+        if (typeof middleware === 'function') {
+            this.#middleware.push([middleware]);
+        }
+        return this;
+    }
+    as(name, prepend = false) {
+        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;
+    }
+    isDeleted() {
+        return this.#isDeleted;
+    }
+    markAsDeleted() {
+        this.#isDeleted = true;
+    }
+    getName() {
+        return this.#name;
+    }
+    getPattern() {
+        return this.#pattern;
+    }
+    setPattern(pattern) {
+        this.#pattern = pattern;
+        return this;
+    }
+    getMiddleware() {
+        return this.#middleware;
+    }
+    #getMiddlewareForStore() {
+        const middleware = new Middleware();
+        this.#middlewareStore.list().forEach((one) => middleware.add(one));
+        this.#middleware.flat().forEach((one) => middleware.add(one));
+        return middleware;
+    }
+    toJSON() {
+        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,
+        };
+    }
+}

package/build/src/router/store.d.ts

@@ -0,0 +1,12 @@
+import type { RouteJSON, MatchedRoute, StoreRoutesTree, MatchItRouteToken } from '../types/route.js';
+export declare class RoutesStore {
+    #private;
+    usingDomains: boolean;
+    tree: StoreRoutesTree;
+    add(route: RouteJSON): this;
+    match(url: string, method: string, domain?: {
+        tokens: MatchItRouteToken[];
+        hostname: string;
+    }): null | MatchedRoute;
+    matchDomain(hostname?: string | null): MatchItRouteToken[];
+}

package/build/src/router/store.js

@@ -0,0 +1,87 @@
+import matchit from '@poppinss/matchit';
+import lodash from '@poppinss/utils/lodash';
+import { RuntimeException } from '@poppinss/utils';
+export class RoutesStore {
+    usingDomains = false;
+    tree = { tokens: [], domains: {} };
+    #getDomainNode(domain) {
+        if (!this.tree.domains[domain]) {
+            this.tree.tokens.push(matchit.parse(domain));
+            this.tree.domains[domain] = {};
+        }
+        return this.tree.domains[domain];
+    }
+    #getMethodNode(domain, method) {
+        const domainNode = this.#getDomainNode(domain);
+        if (!domainNode[method]) {
+            domainNode[method] = { tokens: [], routes: {}, routeKeys: {} };
+        }
+        return domainNode[method];
+    }
+    #collectRouteParams(route, tokens) {
+        const collectedParams = 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;
+    }
+    #registerRoute(domain, method, tokens, route) {
+        const methodRoutes = this.#getMethodNode(domain, 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(route) {
+        if (route.domain !== 'root') {
+            this.usingDomains = true;
+        }
+        const tokens = matchit.parse(route.pattern, route.matchers);
+        const routeNode = lodash.merge({ meta: {} }, lodash.pick(route, ['pattern', 'handler', 'meta', 'middleware', 'name', 'execute']));
+        routeNode.meta.params = this.#collectRouteParams(routeNode, tokens);
+        route.methods.forEach((method) => {
+            this.#registerRoute(route.domain, method, tokens, routeNode);
+        });
+        return this;
+    }
+    match(url, method, domain) {
+        const domainName = domain?.tokens[0]?.old || 'root';
+        const matchedDomain = this.tree.domains[domainName];
+        if (!matchedDomain) {
+            return null;
+        }
+        const matchedMethod = this.tree.domains[domainName][method];
+        if (!matchedMethod) {
+            return null;
+        }
+        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) : {},
+        };
+    }
+    matchDomain(hostname) {
+        if (!hostname || !this.usingDomains) {
+            return [];
+        }
+        return matchit.match(hostname, this.tree.tokens);
+    }
+}

package/build/src/server/factories/final_handler.d.ts

@@ -0,0 +1,4 @@
+import type { ContainerResolver } from '@adonisjs/fold';
+import type { Router } from '../../router/main.js';
+import type { HttpContext } from '../../http_context/main.js';
+export declare function finalHandler(router: Router, resolver: ContainerResolver, ctx: HttpContext): () => any;

package/build/src/server/factories/final_handler.js

@@ -0,0 +1,17 @@
+import { RouteNotFoundException } from '../../exceptions/route_not_found.js';
+export function finalHandler(router, resolver, ctx) {
+    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);
+        }
+        throw new RouteNotFoundException(`Cannot ${method}:${url}`);
+    };
+}

package/build/src/server/factories/middleware_handler.d.ts

@@ -0,0 +1,5 @@
+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';
+export declare function middlewareHandler(resolver: ContainerResolver, ctx: HttpContext): (fn: ParsedGlobalMiddleware, next: NextFn) => any;

package/build/src/server/factories/middleware_handler.js

@@ -0,0 +1,5 @@
+export function middlewareHandler(resolver, ctx) {
+    return function (fn, next) {
+        return fn.handle(resolver, ctx, next);
+    };
+}

package/build/src/server/factories/use_return_value.d.ts

@@ -0,0 +1,2 @@
+import type { HttpContext } from '../../http_context/main.js';
+export declare function useReturnValue(ctx: HttpContext): (value: any) => void;

package/build/src/server/factories/use_return_value.js

@@ -0,0 +1,9 @@
+export function useReturnValue(ctx) {
+    return function (value) {
+        if (value !== undefined &&
+            !ctx.response.hasLazyBody &&
+            value !== ctx.response) {
+            ctx.response.send(value);
+        }
+    };
+}

package/build/src/server/factories/write_response.d.ts

@@ -0,0 +1,2 @@
+import type { HttpContext } from '../../http_context/main.js';
+export declare function writeResponse(ctx: HttpContext): () => void;

package/build/src/server/factories/write_response.js

@@ -0,0 +1,12 @@
+export function writeResponse(ctx) {
+    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/build/src/server/main.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import type Encryption from '@adonisjs/encryption';
+import type { Application } from '@adonisjs/application';
+import type { Server as HttpsServer } from 'node:https';
+import type { ServerResponse, IncomingMessage, Server as HttpServer } from 'node:http';
+import type { LazyImport } from '../types/base.js';
+import type { MiddlewareAsClass } from '../types/middleware.js';
+import type { ErrorHandlerAsAClass, ServerConfig } from '../types/server.js';
+import { Router } from '../router/main.js';
+export declare class Server<NamedMiddleware extends Record<string, LazyImport<MiddlewareAsClass>> = any> {
+    #private;
+    get usingAsyncLocalStorage(): boolean;
+    constructor(app: Application, encryption: Encryption, config: ServerConfig);
+    use(serverMiddleware: LazyImport<MiddlewareAsClass>[], routerMiddleware: LazyImport<MiddlewareAsClass>[], namedMiddleware: NamedMiddleware): this;
+    errorHandler(handler: LazyImport<ErrorHandlerAsAClass>): this;
+    boot(): Promise<void>;
+    setNodeServer(server: HttpServer | HttpsServer): void;
+    close(): Promise<void>;
+    getNodeServer(): HttpServer<typeof IncomingMessage, typeof ServerResponse> | HttpsServer<typeof IncomingMessage, typeof ServerResponse> | undefined;
+    getRouter(): Router<any> | undefined;
+    handle(req: IncomingMessage, res: ServerResponse): Promise<any>;
+}

package/build/src/server/main.js

@@ -0,0 +1,124 @@
+import Middleware from '@poppinss/middleware';
+import { RuntimeException } from '@poppinss/utils';
+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 { MiddlewareStore } from '../middleware/store.js';
+import { finalHandler } from './factories/final_handler.js';
+import { writeResponse } from './factories/write_response.js';
+import { useReturnValue } from './factories/use_return_value.js';
+import { asyncLocalStorage } from '../http_context/local_storage.js';
+import { middlewareHandler } from './factories/middleware_handler.js';
+export class Server {
+    #errorHandler;
+    #resolvedErrorHandler = {
+        handle(error, ctx) {
+            ctx.response.status(error.status || 500).send(error.message || 'Internal server error');
+        },
+    };
+    #app;
+    #encryption;
+    #config;
+    #qsParser;
+    #serverMiddlewareStack;
+    #router;
+    #underlyingHttpServer;
+    get usingAsyncLocalStorage() {
+        return asyncLocalStorage.isEnabled;
+    }
+    constructor(app, encryption, config) {
+        this.#app = app;
+        this.#encryption = encryption;
+        this.#config = config;
+        this.#qsParser = new Qs(this.#config.qs);
+        this.#createAsyncLocalStore();
+        debug('server config: %O', this.#config);
+    }
+    #createAsyncLocalStore() {
+        if (this.#config.useAsyncLocalStorage) {
+            debug('creating http context async local storage');
+            asyncLocalStorage.create();
+        }
+        else {
+            asyncLocalStorage.destroy();
+        }
+    }
+    #createRouter(middlewareStore) {
+        this.#router = new Router(this.#app, this.#encryption, middlewareStore, this.#qsParser);
+    }
+    #createServerMiddlewareStack(middlewareStore) {
+        this.#serverMiddlewareStack = new Middleware();
+        middlewareStore.list().forEach((middleware) => this.#serverMiddlewareStack.add(middleware));
+        this.#serverMiddlewareStack.freeze();
+    }
+    #createContext(req, res) {
+        const request = new Request(req, res, this.#encryption, this.#config, this.#qsParser);
+        const response = new Response(req, res, this.#encryption, this.#config, this.#router, this.#qsParser);
+        return new HttpContext(request, response, this.#app.logger.child({}));
+    }
+    use(serverMiddleware, routerMiddleware, namedMiddleware) {
+        this.#createRouter(new MiddlewareStore(routerMiddleware, namedMiddleware));
+        this.#createServerMiddlewareStack(new MiddlewareStore(serverMiddleware));
+        return this;
+    }
+    errorHandler(handler) {
+        this.#errorHandler = handler;
+        return this;
+    }
+    async boot() {
+        debug('booting HTTP server');
+        if (!this.#router) {
+            throw new RuntimeException('Cannot boot HTTP server. Register middleware using "server.use" first');
+        }
+        this.#router.commit();
+        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);
+        }
+    }
+    #handleRequest(ctx, resolver) {
+        return this.#serverMiddlewareStack.runner()
+            .finalHandler(finalHandler(this.#router, resolver, ctx))
+            .run(middlewareHandler(resolver, ctx))
+            .then(useReturnValue(ctx))
+            .catch((error) => this.#resolvedErrorHandler.handle(error, ctx))
+            .finally(writeResponse(ctx));
+    }
+    setNodeServer(server) {
+        this.#underlyingHttpServer = server;
+    }
+    close() {
+        return new Promise((resolve, reject) => {
+            if (!this.#underlyingHttpServer || !this.#underlyingHttpServer.listening) {
+                resolve();
+                return;
+            }
+            this.#underlyingHttpServer.close((error) => {
+                if (error) {
+                    return reject(error);
+                }
+                resolve();
+            });
+        });
+    }
+    getNodeServer() {
+        return this.#underlyingHttpServer;
+    }
+    getRouter() {
+        return this.#router;
+    }
+    handle(req, res) {
+        const ctx = this.#createContext(req, res);
+        const resolver = this.#app.container.createResolver();
+        if (this.usingAsyncLocalStorage) {
+            return asyncLocalStorage.storage.run(ctx, () => this.#handleRequest(ctx, resolver));
+        }
+        return this.#handleRequest(ctx, resolver);
+    }
+}

package/build/src/types/base.d.ts

@@ -0,0 +1,5 @@
+export type Constructor<T> = new (...args: any[]) => T;
+export type LazyImport<DefaultExport> = () => Promise<{
+    default: DefaultExport;
+}>;
+export type UnWrapLazyImport<Fn extends LazyImport<any>> = Awaited<ReturnType<Fn>>['default'];

package/build/src/types/base.js

@@ -0,0 +1 @@
+export {};

package/build/src/types/middleware.d.ts

@@ -0,0 +1,14 @@
+import type { ContainerResolver } from '@adonisjs/fold';
+import type { NextFn } from '@poppinss/middleware/types';
+import type { Constructor } from './base.js';
+import type { HttpContext } from '../http_context/main.js';
+export type MiddlewareAsClass = Constructor<{
+    handle: (ctx: HttpContext, next: NextFn, args?: any) => any;
+}>;
+type HasUndefined<T> = T extends NonNullable<T> ? true : false;
+export type GetMiddlewareArgs<Middleware extends MiddlewareAsClass> = HasUndefined<Parameters<InstanceType<Middleware>['handle']>[2]> extends true ? [Parameters<InstanceType<Middleware>['handle']>[2]] : [Parameters<InstanceType<Middleware>['handle']>[2]?];
+export type MiddlewareFn = (ctx: HttpContext, next: NextFn) => any;
+export type ParsedGlobalMiddleware = {
+    handle: (resolver: ContainerResolver, ...args: [ctx: HttpContext, next: NextFn, params?: any]) => any;
+};
+export {};

package/build/src/types/middleware.js

@@ -0,0 +1 @@
+export {};

package/build/src/types/qs.d.ts

@@ -0,0 +1,15 @@
+export type QSParserConfig = {
+    parse: {
+        depth: number;
+        parameterLimit: number;
+        allowSparse: boolean;
+        arrayLimit: number;
+        comma: boolean;
+    };
+    stringify: {
+        encode: boolean;
+        encodeValuesOnly: boolean;
+        arrayFormat: 'indices' | 'brackets' | 'repeat' | 'comma';
+        skipNulls: boolean;
+    };
+};

package/build/src/types/qs.js

@@ -0,0 +1 @@
+export {};

package/build/src/types/request.d.ts

@@ -0,0 +1,7 @@
+export type RequestConfig = {
+    subdomainOffset: number;
+    generateRequestId: boolean;
+    allowMethodSpoofing: boolean;
+    getIp?: (request: any) => string;
+    trustProxy: (address: string, distance: number) => boolean;
+};

package/build/src/types/request.js

@@ -0,0 +1 @@
+export {};