@adonisjs/http-server 7.0.0-0 → 7.0.0-1

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

@@ -0,0 +1,166 @@
+import type Middleware from '@poppinss/middleware';
+import type { ContainerResolver } from '@adonisjs/fold';
+import type { Constructor, LazyImport } from './base.js';
+import type { HttpContext } from '../http_context/main.js';
+import type { MiddlewareFn, ParsedGlobalMiddleware } from './middleware.js';
+import { ServerErrorHandler } from './server.js';
+/**
+ * Returns a union of methods from a controller that accepts
+ * the context as the first argument.
+ */
+export type GetControllerHandlers<Controller extends Constructor<any>> = {
+    [K in keyof InstanceType<Controller>]: InstanceType<Controller>[K] extends (ctx: HttpContext, ...args: any[]) => any ? K : never;
+}[keyof InstanceType<Controller>];
+/**
+ * Route token stored by matchit library
+ */
+export type MatchItRouteToken = RouteMatcher & {
+    old: string;
+    type: 0 | 1 | 2 | 3;
+    val: string;
+    end: string;
+};
+/**
+ * Route handler defined as a function
+ */
+export type RouteFn = (ctx: HttpContext) => any;
+/**
+ * Route handler persisted with the route store
+ */
+export type StoreRouteHandler = RouteFn | {
+    reference: string | [LazyImport<Constructor<any>> | Constructor<any>, any?];
+    handle: (resolver: ContainerResolver<any>, ...args: [ctx: HttpContext, ...injections: any[]]) => any;
+};
+/**
+ * The middleware persisted with the route store
+ */
+export type StoreRouteMiddleware = MiddlewareFn | ({
+    name?: string;
+    args?: any[];
+} & ParsedGlobalMiddleware);
+/**
+ * Route node persisted within the routes store
+ */
+export type StoreRouteNode = {
+    /**
+     * The execute function to execute the route middleware
+     * and the handler
+     */
+    execute: (route: StoreRouteNode, resolver: ContainerResolver<any>, ctx: HttpContext, errorResponder: ServerErrorHandler['handle']) => any;
+    /**
+     * A unique name for the route
+     */
+    name?: string;
+    /**
+     * Route URI pattern
+     */
+    pattern: string;
+    /**
+     * Route handler
+     */
+    handler: StoreRouteHandler;
+    /**
+     * Route middleware
+     */
+    middleware: Middleware<StoreRouteMiddleware>;
+    /**
+     * Additional metadata associated with the route
+     */
+    meta: Record<string, any>;
+};
+/**
+ * An object of routes for a given HTTP method
+ */
+export type StoreMethodNode = {
+    tokens: MatchItRouteToken[][];
+    routeKeys: {
+        [pattern: string]: string;
+    };
+    routes: {
+        [pattern: string]: StoreRouteNode;
+    };
+};
+/**
+ * Each domain node container an object of methods. Each method
+ * object has nested routes.
+ */
+export type StoreDomainNode = {
+    [method: string]: StoreMethodNode;
+};
+/**
+ * Routes tree stored within the routes store
+ */
+export type StoreRoutesTree = {
+    tokens: MatchItRouteToken[][];
+    domains: {
+        [domain: string]: StoreDomainNode;
+    };
+};
+/**
+ * Shape of the matched route for a pattern, method and domain.
+ */
+export type MatchedRoute = {
+    route: StoreRouteNode;
+    /**
+     * A unique key for the looked up route
+     */
+    routeKey: string;
+    /**
+     * Route params
+     */
+    params: Record<string, any>;
+    /**
+     * Route subdomains (if part of a subdomain)
+     */
+    subdomains: Record<string, any>;
+};
+/**
+ * Shape of a route param matcher
+ */
+export type RouteMatcher = {
+    match?: RegExp;
+    cast?: (value: string) => any;
+};
+/**
+ * A collection of route matchers
+ */
+export type RouteMatchers = {
+    [param: string]: RouteMatcher;
+};
+/**
+ * Representation of a route as JSON
+ */
+export type RouteJSON = StoreRouteNode & {
+    /**
+     * HTTP methods, the route responds to.
+     */
+    methods: string[];
+    /**
+     * The domain for which the route is registered.
+     */
+    domain: string;
+    /**
+     * Matchers for route params.
+     */
+    matchers: RouteMatchers;
+};
+/**
+ * Resource action names
+ */
+export type ResourceActionNames = 'create' | 'index' | 'store' | 'show' | 'edit' | 'update' | 'destroy';
+/**
+ * Options accepted by makeUrl method
+ */
+export type MakeUrlOptions = {
+    qs?: Record<string, any>;
+    domain?: string;
+    prefixUrl?: string;
+    disableRouteLookup?: boolean;
+};
+/**
+ * Options accepted by makeSignedUrl method
+ */
+export type MakeSignedUrlOptions = MakeUrlOptions & {
+    expiresIn?: string | number;
+    purpose?: string;
+};

package/build/src/types/route.js

@@ -0,0 +1,9 @@
+/*
+ * @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 {};

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

@@ -0,0 +1,72 @@
+import type { ErrorHandler, FinalHandler } from '@poppinss/middleware/types';
+import type { Constructor } from './base.js';
+import type { QSParserConfig } from './qs.js';
+import type { RequestConfig } from './request.js';
+import type { ResponseConfig } from './response.js';
+import type { HttpContext } from '../http_context/main.js';
+/**
+ * Normalized HTTP error used by the exception
+ * handler.
+ */
+export type HttpError = {
+    message: string;
+    status: number;
+    code?: string;
+    stack?: string;
+    cause?: any;
+    messages?: any;
+    errors?: any;
+    handle?: (...args: any[]) => any;
+    report?: (...args: any[]) => any;
+};
+/**
+ * The pipeline for executing middleware during tests
+ */
+export interface TestingMiddlewarePipeline {
+    finalHandler(handler: FinalHandler): this;
+    errorHandler(handler: ErrorHandler): this;
+    run(ctx: HttpContext): Promise<any>;
+}
+/**
+ * The expression to define a status page range
+ */
+export type StatusPageRange = `${number}..${number}` | `${number}` | number;
+/**
+ * The callback function to render status page for a given
+ * error.
+ */
+export type StatusPageRenderer = (error: HttpError, ctx: HttpContext) => any | Promise<any>;
+/**
+ * Data type for the "http:request_finished" event
+ */
+export type HttpRequestFinishedPayload = {
+    ctx: HttpContext;
+    duration: [number, number];
+};
+/**
+ * Error handler to handle HTTP errors
+ */
+export type ServerErrorHandler = {
+    report: (error: any, ctx: HttpContext) => any;
+    handle: (error: any, ctx: HttpContext) => any;
+};
+/**
+ * Error handler represented as a class
+ */
+export type ErrorHandlerAsAClass = Constructor<ServerErrorHandler>;
+/**
+ * Config accepted by the HTTP server
+ */
+export type ServerConfig = RequestConfig & ResponseConfig & {
+    /**
+     * Whether or not to create an async local storage store for
+     * the HTTP context.
+     *
+     * Defaults to false
+     */
+    useAsyncLocalStorage: boolean;
+    /**
+     * Config for query string parser
+     */
+    qs: QSParserConfig;
+};

package/build/src/types/server.js

@@ -0,0 +1,9 @@
+/*
+ * @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 {};

package/package.json

@@ -1,11 +1,14 @@
 {
   "name": "@adonisjs/http-server",
-  "version": "7.0.0-0",
+  "version": "7.0.0-1",
   "description": "AdonisJS HTTP server with support packed with Routing and Cookies",
   "main": "build/index.js",
   "type": "module",
   "files": [
-    "build"
+    "build/factories",
+    "build/src",
+    "build/index.d.ts",
+    "build/index.js"
   ],
   "exports": {
     ".": "./build/index.js",
@@ -20,7 +23,7 @@
     "test": "cross-env NODE_DEBUG=adonisjs:http c8 npm run quick:test",
     "clean": "del-cli build",
     "typecheck": "tsc --noEmit",
-    "compile": "npm run lint && npm run clean && tsup-node",
+    "compile": "npm run lint && npm run clean && tsc",
     "build": "npm run compile",
     "prebenchmark": "npm run build",
     "benchmark": "node benchmarks/index.js",