@deepkit/http 1.0.1-alpha.100

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 Marc J. Schmidt <marc@marcjschmidt.de>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,13 @@
+# skeleton package
+
+This package can be copied when a new package should be created.
+
+### Steps after copying:
+
+- Adjust "name", "description", and "private" in `package.json`.
+- Adjust README.md
+- Put this package into root `/package.json` "jest.references".
+- Put this package into root `/tsconfig.json` "references".
+- Put this package into root `/tsconfig.esm.json` "references".
+- Add dependencies to `package.json` and run `node sync-tsconfig-deps.js` to adjust tsconfig automatically.
+- Add to .github/workflows/main.yml tsc build step if necessary.

package/dist/cjs/index.d.ts

@@ -0,0 +1,14 @@
+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/dist/cjs/index.js

@@ -0,0 +1,31 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./src/decorator.js"), exports);
+__exportStar(require("./src/http.js"), exports);
+__exportStar(require("./src/http-app.js"), exports);
+__exportStar(require("./src/model.js"), exports);
+__exportStar(require("./src/logger.js"), exports);
+__exportStar(require("./src/router.js"), exports);
+__exportStar(require("./src/static-serving.js"), exports);
+__exportStar(require("./src/kernel.js"), exports);
+__exportStar(require("./src/module.js"), exports);
+__exportStar(require("./src/module.config.js"), exports);
+__exportStar(require("./src/controllers.js"), exports);
+__exportStar(require("./src/middleware.js"), exports);
+__exportStar(require("./src/filter.js"), exports);
+__exportStar(require("./src/utils.js"), exports);
+//# sourceMappingURL=index.js.map

package/dist/cjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,qDAAmC;AACnC,gDAA8B;AAC9B,oDAAkC;AAClC,iDAA+B;AAC/B,kDAAgC;AAChC,kDAAgC;AAChC,0DAAwC;AACxC,kDAAgC;AAChC,kDAAgC;AAChC,yDAAuC;AACvC,uDAAqC;AACrC,sDAAoC;AACpC,kDAAgC;AAChC,iDAA+B"}

package/dist/cjs/src/controllers.d.ts

@@ -0,0 +1,13 @@
+import { ClassType } from '@deepkit/core';
+import { InjectorModule } from '@deepkit/injector';
+export declare class HttpControllers {
+    readonly controllers: {
+        controller: ClassType;
+        module: InjectorModule<any>;
+    }[];
+    constructor(controllers?: {
+        controller: ClassType;
+        module: InjectorModule<any>;
+    }[]);
+    add(controller: ClassType, module: InjectorModule<any>): void;
+}

package/dist/cjs/src/controllers.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpControllers = void 0;
+/*@ts-ignore*/
+const { __ΩClassType } = require('@deepkit/core');
+const injector_1 = require("@deepkit/injector");
+class HttpControllers {
+    constructor(controllers = []) {
+        this.controllers = controllers;
+    }
+    add(controller, module) {
+        this.controllers.push({ controller, module });
+    }
+}
+exports.HttpControllers = HttpControllers;
+HttpControllers.__type = [() => __ΩClassType, 'controller', () => injector_1.InjectorModule, 'module', 'controllers', () => [], 'constructor', () => __ΩClassType, () => injector_1.InjectorModule, 'add', 'PPn!4"P"7#4$MF2%:9>&"0\'Pn(2"P"7)2$"0*5'];
+//# sourceMappingURL=controllers.js.map

package/dist/cjs/src/controllers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"controllers.js","sourceRoot":"","sources":["../../../src/controllers.ts"],"names":[],"mappings":";;;;iCAA0B,eAAe;AACzC,gDAAmD;AAEnD,MAAa,eAAe;IACxB,YAA4B,cAAsE,EAAE;QAAxE,gBAAW,GAAX,WAAW,CAA6D;IACpG,CAAC;IAEM,GAAG,CAAC,UAAqB,EAAE,MAA2B;QACzD,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,EAAC,UAAU,EAAE,MAAM,EAAC,CAAC,CAAC;IAChD,CAAC;;AANL,0CAOC"}

package/dist/cjs/src/decorator.d.ts

@@ -0,0 +1,241 @@
+import { ClassType } from '@deepkit/core';
+import { ClassDecoratorResult, DecoratorAndFetchSignature, DualDecorator, ExtractApiDataType, ExtractClass, PropertyDecoratorFn, ReceiveType, SerializationOptions, Serializer, Type, UnionToIntersection } from '@deepkit/type';
+import { RouteParameterResolver } from './router.js';
+import { HttpMiddleware, HttpMiddlewareConfig, HttpMiddlewareFn } from './middleware.js';
+declare type HttpActionMiddleware = (() => HttpMiddlewareConfig) | ClassType<HttpMiddleware> | HttpMiddlewareFn;
+export declare class HttpController {
+    baseUrl: string;
+    actions: Set<HttpAction>;
+    groups: string[];
+    middlewares: (() => HttpMiddlewareConfig)[];
+    resolverForToken: Map<any, ClassType>;
+    resolverForParameterName: Map<string, ClassType>;
+    private actionsProcessed;
+    getUrl(action: HttpAction): string;
+    addAction(action: HttpAction): void;
+    getActions(): Set<HttpAction>;
+    removeAction(methodName: string): void;
+    getAction(methodName: string): HttpAction;
+}
+export declare class HttpActionParameter {
+    name: string;
+    type?: 'body' | 'query' | 'queries';
+    /**
+     * undefined = propertyName, '' === root, else given path
+     */
+    typePath?: string;
+    optional: boolean;
+}
+export declare class HttpAction {
+    name: string;
+    description: string;
+    category: string;
+    path: string;
+    httpMethods: string[];
+    methodName: string;
+    groups: string[];
+    serializer?: Serializer;
+    middlewares: (() => HttpMiddlewareConfig)[];
+    serializationOptions?: SerializationOptions;
+    resolverForToken: Map<any, ClassType>;
+    resolverForParameterName: Map<string, ClassType>;
+    /**
+     * An arbitrary data container the user can use to store app specific settings/values.
+     */
+    data: Map<any, any>;
+    responses: {
+        statusCode: number;
+        description: string;
+        type?: Type;
+    }[];
+}
+export declare class HttpControllerDecorator {
+    t: HttpController;
+    controller(baseUrl?: string): void;
+    group(...group: string[]): void;
+    middleware(...middlewares: HttpActionMiddleware[]): void;
+    /**
+     * 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>): void;
+    /**
+     * 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>): void;
+    setAction(action: HttpAction): void;
+}
+export declare const httpClass: ClassDecoratorResult<typeof HttpControllerDecorator>;
+export declare class HttpActionDecorator {
+    t: HttpAction;
+    onDecorator(target: ClassType, property: string | undefined, parameterIndexOrDescriptor?: any): void;
+    name(name: string): void;
+    description(description: string): void;
+    serialization(options: SerializationOptions): void;
+    serializer(serializer: Serializer): void;
+    middleware(...middlewares: HttpActionMiddleware[]): void;
+    /**
+     * Allows to change the HttpAction object and composite multiple properties into one function.
+     *
+     * @example
+     * ```typescript
+     * const authGroup = Symbol('authGroup');
+     *
+     * function authGroup(group: 'admin' | 'user') {
+     *    return (action: HttpAction) => {
+     *        action.data.set(authGroup, group);
+     *    };
+     * }
+     *
+     * class My Controller {
+     *    @http.GET('/assets').use(authGroup('admin'))
+     *    assets() {}
+     * }
+     * ```
+     */
+    use(use: (action: HttpAction) => void): void;
+    /**
+     * Arbitrary value container that can be read in RouterParameterResolver and all
+     * HTTP workflow events (like authentication).
+     *
+     * @example
+     * ```typescript
+     * class My Controller {
+     *    @http.GET('/assets').data('authGroup', 'admin')
+     *    assets() {}
+     * }
+     * ```
+     */
+    data(name: string, value: any): void;
+    category(category: string): void;
+    group(...group: string[]): void;
+    GET(path?: string): void;
+    HEAD(path?: string): void;
+    POST(path?: string): void;
+    PUT(path?: string): void;
+    DELETE(path?: string): void;
+    OPTIONS(path?: string): void;
+    TRACE(path?: string): void;
+    PATCH(path?: string): void;
+    ANY(path?: string): void;
+    /**
+     * 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.
+     *
+     * ```typescript
+     *
+     * http.GET().response<boolean>(200, 'All ok')
+     *
+     * interface User {
+     *     username: string;
+     * }
+     * http.GET().response<User>(200, 'User object')
+     *
+     * interface HttpErrorMessage {
+     *     error: string;
+     * }
+     * http.GET().response<HttpErrorMessage>(500, 'Error')
+     * ```
+     */
+    response<T>(statusCode: number, description?: string, type?: ReceiveType<T>): void;
+    /**
+     * 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>): void;
+    /**
+     * 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();
+     *     }
+     * }
+     *
+     * class MyController {
+     *     @http.GET()
+     *     @http.resolveParameterByName('user', UserResolver)
+     *     myAction(user: User) {
+     *     }
+     * }
+     *
+     * new App({providers: [UserResolver]}).run();
+     * ```
+     */
+    resolveParameterByName(name: string, resolver: ClassType<RouteParameterResolver>): void;
+}
+declare 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>;
+    };
+};
+declare type HttpActionPropertyDecoratorResult = HttpActionFluidDecorator<ExtractClass<typeof HttpActionDecorator>, PropertyDecoratorFn> & DecoratorAndFetchSignature<typeof HttpActionDecorator, PropertyDecoratorFn>;
+export declare const httpAction: HttpActionPropertyDecoratorResult;
+declare 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;
+};
+declare type MergedHttp<T extends any[]> = HttpMerge<Omit<UnionToIntersection<T[number]>, '_fetch' | 't'>>;
+export declare type HttpDecorator = PropertyDecoratorFn & HttpActionFluidDecorator<HttpActionDecorator, PropertyDecoratorFn>;
+export declare const http: MergedHttp<[typeof httpClass, typeof httpAction]>;
+export {};
+export declare type __ΩHttpDecorator = any[];