@deepkit/http 1.0.1-alpha.16 → 1.0.1-alpha.160

package/index.ts

@@ -1,10 +1,14 @@
-export * from './src/decorator';
-export * from './src/http';
-export * from './src/model';
-export * from './src/logger';
-export * from './src/router';
-export * from './src/static-serving';
-export * from './src/kernel';
-export * from './src/module';
-export * from './src/module.config';
-export * from './src/controllers';
+export * from './src/decorator.js';
+export * from './src/http.js';
+export * from './src/http-app.js';
+export * from './src/model.js';
+export * from './src/logger.js';
+export * from './src/router.js';
+export * from './src/static-serving.js';
+export * from './src/kernel.js';
+export * from './src/module.js';
+export * from './src/module.config.js';
+export * from './src/controllers.js';
+export * from './src/middleware.js';
+export * from './src/filter.js';
+export * from './src/utils.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deepkit/http",
-  "version": "1.0.1-alpha.16",
+  "version": "1.0.1-alpha.160",
   "description": "Deepkit HTTP server and router.",
   "type": "commonjs",
   "main": "./dist/cjs/index.js",
@@ -8,6 +8,7 @@
   "types": "./dist/cjs/index.d.ts",
   "exports": {
     ".": {
+      "types": "./dist/cjs/index.d.ts",
       "require": "./dist/cjs/index.js",
       "default": "./dist/esm/index.js"
     }
@@ -30,34 +31,44 @@
     "@deepkit/stopwatch": "^1.0.1-alpha.13",
     "@deepkit/template": "^1.0.1-alpha.13",
     "@deepkit/type": "^1.0.1-alpha.13",
-    "@deepkit/workflow": "^1.0.1-alpha.13",
-    "reflect-metadata": "^0.1.13"
+    "@deepkit/workflow": "^1.0.1-alpha.13"
   },
   "dependencies": {
-    "formidable": "^1.2.2",
-    "send": "^0.17.1"
+    "formidable": "^3.5.2",
+    "qs": "^6.14.0",
+    "send": "^1.1.0"
   },
   "devDependencies": {
-    "@deepkit/app": "^1.0.1-alpha.16",
-    "@deepkit/core": "^1.0.1-alpha.16",
-    "@deepkit/event": "^1.0.1-alpha.16",
-    "@deepkit/injector": "^1.0.1-alpha.16",
-    "@deepkit/logger": "^1.0.1-alpha.16",
-    "@deepkit/stopwatch": "^1.0.1-alpha.16",
-    "@deepkit/template": "^1.0.1-alpha.16",
-    "@deepkit/type": "^1.0.1-alpha.16",
-    "@deepkit/workflow": "^1.0.1-alpha.16",
-    "@types/node": "14.14.28",
-    "@types/send": "^0.14.6",
-    "reflect-metadata": "^0.1.13"
+    "@deepkit/app": "^1.0.1-alpha.160",
+    "@deepkit/core": "^1.0.1-alpha.158",
+    "@deepkit/event": "^1.0.1-alpha.160",
+    "@deepkit/injector": "^1.0.1-alpha.160",
+    "@deepkit/logger": "^1.0.1-alpha.160",
+    "@deepkit/stopwatch": "^1.0.1-alpha.160",
+    "@deepkit/template": "^1.0.1-alpha.160",
+    "@deepkit/type": "^1.0.1-alpha.160",
+    "@deepkit/workflow": "^1.0.1-alpha.160",
+    "@types/formidable": "^3.4.5",
+    "@types/node": "^22.13.1",
+    "@types/send": "^0.14.6"
   },
   "jest": {
+    "testEnvironment": "node",
     "transform": {
-      "^.+\\.(ts|tsx)$": "ts-jest"
+      "^.+\\.(ts|tsx)$": [
+        "ts-jest",
+        {
+          "tsconfig": "<rootDir>/tsconfig.spec.json"
+        }
+      ]
     },
+    "moduleNameMapper": {
+      "(.+)\\.js": "$1"
+    },
+    "resolver": "../../jest-resolver.js",
     "testMatch": [
       "**/tests/**/*.spec.ts"
     ]
   },
-  "gitHead": "0f3c1766cbd9d1ac489d8f396a52f21f1a3da6ff"
+  "gitHead": "52a703a1f6747c59e77cbf44d80d3bc5b1424ee6"
 }

package/src/controllers.ts

@@ -1,10 +1,11 @@
 import { ClassType } from '@deepkit/core';
+import { InjectorModule } from '@deepkit/injector';
 
 export class HttpControllers {
-    constructor(public readonly controllers: ClassType[]) {
+    constructor(public readonly controllers: {controller: ClassType, module: InjectorModule<any>}[] = []) {
     }
 
-    public add(controller: ClassType) {
-        this.controllers.push(controller);
+    public add(controller: ClassType, module: InjectorModule<any>) {
+        this.controllers.push({controller, module});
     }
 }

package/src/decorator.ts

@@ -8,21 +8,48 @@
  * You should have received a copy of the MIT License along with this program.
  */
 
-import { ClassType } from '@deepkit/core';
-import { ClassDecoratorResult, createClassDecoratorContext, createPropertyDecoratorContext, getClassSchema, mergeDecorator, PropertyDecoratorResult } from '@deepkit/type';
-import { join } from 'path';
-
-export interface ControllerOptions {
-    name: string;
+import { ClassType, isClass, urlJoin } from '@deepkit/core';
+import {
+    ClassDecoratorResult,
+    createClassDecoratorContext,
+    createPropertyDecoratorContext,
+    DecoratorAndFetchSignature,
+    DualDecorator,
+    ExtractApiDataType,
+    ExtractClass,
+    isDecoratorContext,
+    mergeDecorator,
+    PropertyDecoratorFn,
+    ReceiveType,
+    resolveReceiveType,
+    SerializationOptions,
+    Serializer,
+    Type,
+    UnionToIntersection
+} from '@deepkit/type';
+import { RouteParameterResolver } from './router.js';
+import { httpMiddleware, HttpMiddleware, HttpMiddlewareConfig, HttpMiddlewareFn } from './middleware.js';
+
+type HttpActionMiddleware = (() => HttpMiddlewareConfig) | ClassType<HttpMiddleware> | HttpMiddlewareFn;
+
+function isMiddlewareClassTypeOrFn(v: HttpActionMiddleware): v is ClassType<HttpMiddleware> | HttpMiddlewareFn {
+    return isClass(v) || !isDecoratorContext(httpMiddleware, v);
 }
 
-class HttpController {
+export class HttpController {
     baseUrl: string = '';
-    protected actions = new Set<HttpAction>();
+    actions = new Set<HttpAction>();
     groups: string[] = [];
 
+    middlewares: (() => HttpMiddlewareConfig)[] = [];
+
+    resolverForToken: Map<any, ClassType> = new Map();
+    resolverForParameterName: Map<string, ClassType> = new Map();
+
+    private actionsProcessed = new Set<HttpAction>();
+
     getUrl(action: HttpAction): string {
-        return join('/', this.baseUrl, action.path);
+        return urlJoin('/', this.baseUrl, action.path);
     }
 
     addAction(action: HttpAction) {
@@ -30,15 +57,25 @@ class HttpController {
     }
 
     getActions(): Set<HttpAction> {
-        for (const a of this.actions) {
-            for (const g of this.groups) {
-                if (!a.groups.includes(g)) a.groups.push(g);
+        for (const action of this.actions) {
+            if (!this.actionsProcessed.has(action)) {
+                action.groups = [
+                    ...this.groups,
+                    ...action.groups.filter((g) => !this.groups.includes(g)),
+                ];
+                this.actionsProcessed.add(action);
             }
         }
 
         return this.actions;
     }
 
+    removeAction(methodName: string): void {
+        const action = this.getAction(methodName);
+        this.actions.delete(action);
+        this.actionsProcessed.delete(action);
+    }
+
     getAction(methodName: string): HttpAction {
         for (const a of this.getActions()) {
             if (a.methodName === methodName) return a;
@@ -49,7 +86,7 @@ class HttpController {
 
 export class HttpActionParameter {
     name: string = '';
-    type?: 'body' | 'query';
+    type?: 'body' | 'query' | 'queries';
 
     /**
      * undefined = propertyName, '' === root, else given path
@@ -63,47 +100,120 @@ export class HttpAction {
     description: string = '';
     category: string = '';
     path: string = '';
-    httpMethod: string = 'GET';
+    httpMethods: string[] = [];
     methodName: string = '';
     groups: string[] = [];
+    serializer?: Serializer;
+    middlewares: (() => HttpMiddlewareConfig)[] = [];
+    serializationOptions?: SerializationOptions;
 
-    parameterRegularExpressions: { [name: string]: any } = {};
-
-    /**
-     * This is only filled when the user used @http.body() for example on an method argument.
-     */
-    parameters: { [name: string]: HttpActionParameter } = {};
+    resolverForToken: Map<any, ClassType> = new Map();
+    resolverForParameterName: Map<string, ClassType> = new Map();
 
     /**
      * An arbitrary data container the user can use to store app specific settings/values.
      */
     data = new Map<any, any>();
 
-    throws: { errorType: ClassType, message?: string }[] = [];
+    responses: { statusCode: number, description: string, type?: Type }[] = [];
 }
 
-export class HttpDecorator {
+export class HttpControllerDecorator {
     t = new HttpController;
 
     controller(baseUrl: string = '') {
         this.t.baseUrl = baseUrl;
     }
 
-    groupAll(...group: string[]) {
+    group(...group: string[]) {
         this.t.groups.push(...group);
     }
 
+    middleware(...middlewares: HttpActionMiddleware[]) {
+        this.t.middlewares.push(...middlewares.map(v => isMiddlewareClassTypeOrFn(v) ? httpMiddleware.for(v) : v));
+    }
+
+    /**
+     * Adds a parameter resolver for parameters based on the class type. Use .resolveParameterByName() for name-based resolving.
+     *
+     * ```typescript
+     *
+     * class UserResolver {
+     *     resolve(context: RouteParameterResolverContext): any | Promise<any> {
+     *         return new User();
+     *     }
+     * }
+     *
+     * @http.resolveParameter(User, UserResolver)
+     * class MyController {
+     *
+     *     @http.GET()
+     *     myAction(user: User) {
+     *     }
+     * }
+     *
+     * new App({providers: [UserResolver]}).run();
+     * ```
+     */
+    resolveParameter(classType: ClassType | string | any, resolver: ClassType<RouteParameterResolver>) {
+        this.t.resolverForToken.set(classType, resolver);
+    }
+
+    /**
+     * Adds a parameter resolver for parameters based on its name. Use .resolveParameter() for class-based resolving.
+     *
+     * ```typescript
+     *
+     * class UserResolver {
+     *     resolve(context: RouteParameterResolverContext): any | Promise<any> {
+     *         return new User();
+     *     }
+     * }
+     *
+     * @http.resolveParameterByName('user', UserResolver)
+     * class MyController {
+     *
+     *     @http.GET()
+     *     myAction(user: User) {
+     *     }
+     * }
+     *
+     * new App({providers: [UserResolver]}).run();
+     * ```
+     */
+    resolveParameterByName(name: string, resolver: ClassType<RouteParameterResolver>) {
+        this.t.resolverForParameterName.set(name, resolver);
+    }
+
     setAction(action: HttpAction) {
         this.t.addAction(action);
     }
 }
 
-export const httpClass: ClassDecoratorResult<typeof HttpDecorator> = createClassDecoratorContext(HttpDecorator);
+export const httpClass: ClassDecoratorResult<typeof HttpControllerDecorator> = createClassDecoratorContext(HttpControllerDecorator);
+
+export function getActions(target: ClassType): HttpAction[] {
+    const parent = Object.getPrototypeOf(target);
+    const results: HttpAction[] = parent ? getActions(parent) : [];
+
+    const config = httpClass._fetch(target);
+    if (config) {
+        for (const action of config.getActions()) {
+            const existing = results.findIndex(v => v.methodName === action.methodName);
+            if (existing !== -1) results.splice(existing, 1);
+            results.push(action);
+        }
+    }
+
+    return results;
+}
 
 export class HttpActionDecorator {
     t = new HttpAction;
 
-    onDecorator(target: ClassType, property: string) {
+    onDecorator(target: ClassType, property: string | undefined, parameterIndexOrDescriptor?: any) {
+        if (!property) return;
+        if (target === Object) return;
         this.t.methodName = property;
         httpClass.setAction(this.t)(target);
     }
@@ -112,14 +222,22 @@ export class HttpActionDecorator {
         this.t.name = name;
     }
 
-    setParameter(name: string, parameter: HttpActionParameter) {
-        this.t.parameters[name] = parameter;
-    }
-
     description(description: string) {
         this.t.description = description;
     }
 
+    serialization(options: SerializationOptions) {
+        this.t.serializationOptions = options;
+    }
+
+    serializer(serializer: Serializer) {
+        this.t.serializer = serializer;
+    }
+
+    middleware(...middlewares: HttpActionMiddleware[]) {
+        this.t.middlewares.push(...middlewares.map(v => isMiddlewareClassTypeOrFn(v) ? httpMiddleware.for(v) : v));
+    }
+
     /**
      * Allows to change the HttpAction object and composite multiple properties into one function.
      *
@@ -154,7 +272,7 @@ export class HttpActionDecorator {
      *    assets() {}
      * }
      * ```
-    */
+     */
     data(name: string, value: any) {
         this.t.data.set(name, value);
     }
@@ -168,124 +286,144 @@ export class HttpActionDecorator {
     }
 
     GET(path: string = '') {
-        this.t.httpMethod = 'GET';
-        this.t.path = path;
+        this.t.httpMethods.push('GET');
+        if (path) this.t.path = path;
+    }
+
+    HEAD(path: string = '') {
+        this.t.httpMethods.push('HEAD');
+        if (path) this.t.path = path;
     }
 
     POST(path: string = '') {
-        this.t.httpMethod = 'POST';
-        this.t.path = path;
+        this.t.httpMethods.push('POST');
+        if (path) this.t.path = path;
     }
 
     PUT(path: string = '') {
-        this.t.httpMethod = 'PUT';
-        this.t.path = path;
+        this.t.httpMethods.push('PUT');
+        if (path) this.t.path = path;
     }
 
     DELETE(path: string = '') {
-        this.t.httpMethod = 'DELETE';
-        this.t.path = path;
+        this.t.httpMethods.push('DELETE');
+        if (path) this.t.path = path;
     }
 
-    ANY(path: string = '') {
-        this.t.httpMethod = 'ANY';
-        this.t.path = path;
+    OPTIONS(path: string = '') {
+        this.t.httpMethods.push('OPTIONS');
+        if (path) this.t.path = path;
     }
 
-    throws(errorType: ClassType, message?: string) {
-        this.t.throws.push({ errorType, message });
+    TRACE(path: string = '') {
+        this.t.httpMethods.push('TRACE');
+        if (path) this.t.path = path;
     }
 
-    regexp(parameterName: string, regex: any) {
-        this.t.parameterRegularExpressions[parameterName] = regex;
+    PATCH(path: string = '') {
+        this.t.httpMethods.push('PATCH');
+        if (path) this.t.path = path;
     }
-}
 
-class HttpActionParameterDecorator {
-    t = new HttpActionParameter();
-
-    onDecorator(target: ClassType, propertyName?: string, parameterIndex?: number) {
-        if (!propertyName) throw new Error('@http action parameter decorator can only be used on method arguments.');
-        if (parameterIndex === undefined) throw new Error('@http action parameter decorator can only be used on method arguments.');
-        const schema = getClassSchema(target);
-        const property = schema.getMethodProperties(propertyName)[parameterIndex];
-        this.t.name = property.name;
-        if (this.t.typePath === undefined) {
-            this.t.typePath = property.name;
-        }
-        httpAction.setParameter(property.name, this.t)(target.prototype, propertyName);
+    ANY(path: string = '') {
+        this.t.httpMethods = [];
+        if (path) this.t.path = path;
     }
 
     /**
-     * Marks the argument as body parameter. Data from the client sent in the body
-     * will be tried to parsed (JSON/form data) and deserialized to the defined type.
-     * Make sure the class type as a schema assigned.
+     * Adds additional information about what HTTP status codes are available in this route.
+     * You can add additionally a description and a response body type.
+     *
+     * The type is used for serialization for responses with the given statusCode.
+     *
+     * This information is available in Deepkit API console.
      *
-     * @example
      * ```typescript
-     * class MyActionBody {
-     *     @t name!: string;
+     *
+     * http.GET().response<boolean>(200, 'All ok')
+     *
+     * interface User {
+     *     username: string;
      * }
+     * http.GET().response<User>(200, 'User object')
      *
-     * class Controller {
-     *     @http.GET()
-     *     myAction(@http.body() body: MyActionBody) {
-     *         console.log('body', body.name);
-     *     }
+     * interface HttpErrorMessage {
+     *     error: string;
      * }
+     * http.GET().response<HttpErrorMessage>(500, 'Error')
      * ```
      */
-    body() {
-        this.t.type = 'body';
-        this.t.typePath = ''; //root
-    }
-
-    query(path?: string) {
-        this.t.typePath = path; //undefined === propertyName
-        this.t.type = 'query';
+    response<T>(statusCode: number, description: string = '', type?: ReceiveType<T>) {
+        this.t.responses.push({ statusCode, description, type: type ? resolveReceiveType(type) : undefined });
     }
 
-    get optional() {
-        this.t.optional = true;
-        return;
+    /**
+     * Adds a parameter resolver for parameters based on the class type. Use .resolveParameterByName() for name-based resolving.
+     *
+     * ```typescript
+     *
+     * class UserResolver {
+     *     resolve(context: RouteParameterResolverContext): any | Promise<any> {
+     *         return new User();
+     *     }
+     * }
+     *
+     * class MyController {
+     *     @http.GET()
+     *     @http.resolveParameter(User, UserResolver)
+     *     myAction(user: User) {
+     *     }
+     * }
+     *
+     * new App({providers: [UserResolver]}).run();
+     * ```
+     */
+    resolveParameter(classType: ClassType | string | any, resolver: ClassType<RouteParameterResolver>) {
+        this.t.resolverForToken.set(classType, resolver);
     }
 
     /**
-     * Marks the argument as query parameter. Data from the query string is parsed
-     * and deserialized to the defined type.
-     * Define a `path` if you want to parse a subset of the query string only.
-     *
-     * Note: Make sure the defined parameter type has optional properties,
-     * otherwise it's always required to pass a query string.
+     * Adds a parameter resolver for parameters based on its name. Use .resolveParameter() for class-based resolving.
      *
-     * @example
      * ```typescript
-     * class MyActionQueries {
-     *     @t.optional name?: string;
+     *
+     * class UserResolver {
+     *     resolve(context: RouteParameterResolverContext): any | Promise<any> {
+     *         return new User();
+     *     }
      * }
      *
-     * class Controller {
-     *     @http.GET('my-action')
-     *     myAction(@http.queries() query: MyActionQueries) {
-     *         console.log('query', query.name);
+     * class MyController {
+     *     @http.GET()
+     *     @http.resolveParameterByName('user', UserResolver)
+     *     myAction(user: User) {
      *     }
      * }
      *
-     * // Open via, e.g.
-     * // -> /my-action?name=Peter
+     * new App({providers: [UserResolver]}).run();
      * ```
-     *
      */
-    queries(path: string = '') {
-        this.t.typePath = path; //'' === root
-        this.t.type = 'query';
+    resolveParameterByName(name: string, resolver: ClassType<RouteParameterResolver>) {
+        this.t.resolverForParameterName.set(name, resolver);
     }
 }
 
-createPropertyDecoratorContext(HttpActionDecorator);
+//this workaround is necessary since generic functions (necessary for response<T>) are lost during a mapped type and changed ReturnType
+type HttpActionFluidDecorator<T, D extends Function> = {
+    [name in keyof T]: name extends 'response' ? <T2>(statusCode: number, description?: string, type?: ReceiveType<T2>) => D & HttpActionFluidDecorator<T, D>
+        : T[name] extends (...args: infer K) => any ? (...args: K) => D & HttpActionFluidDecorator<T, D>
+            : D & HttpActionFluidDecorator<T, D> & { _data: ExtractApiDataType<T> };
+};
+type HttpActionPropertyDecoratorResult =
+    HttpActionFluidDecorator<ExtractClass<typeof HttpActionDecorator>, PropertyDecoratorFn>
+    & DecoratorAndFetchSignature<typeof HttpActionDecorator, PropertyDecoratorFn>;
+
+export const httpAction: HttpActionPropertyDecoratorResult = createPropertyDecoratorContext(HttpActionDecorator);
 
-export const httpAction: PropertyDecoratorResult<typeof HttpActionDecorator> = createPropertyDecoratorContext(HttpActionDecorator);
+//this workaround is necessary since generic functions are lost during a mapped type and changed ReturnType
+type HttpMerge<U> = { [K in keyof U]: K extends 'response' ? <T2>(statusCode: number, description?: string, type?: ReceiveType<T2>) => PropertyDecoratorFn & U : U[K] extends ((...a: infer A) => infer R) ? R extends DualDecorator ? (...a: A) => PropertyDecoratorFn & R & U : (...a: A) => R : never };
+type MergedHttp<T extends any[]> = HttpMerge<Omit<UnionToIntersection<T[number]>, '_fetch' | 't'>>
 
-export const httpActionParameter: PropertyDecoratorResult<typeof HttpActionParameterDecorator> = createPropertyDecoratorContext(HttpActionParameterDecorator);
+export type HttpDecorator = PropertyDecoratorFn & HttpActionFluidDecorator<HttpActionDecorator, PropertyDecoratorFn>;
 
-export const http = mergeDecorator(httpClass, httpAction, httpActionParameter);
+export const http: MergedHttp<[typeof httpClass, typeof httpAction]> = mergeDecorator(httpClass, httpAction) as any as MergedHttp<[typeof httpClass, typeof httpAction]>;