@carno.js/core 0.2.3

package/dist/domain/Metadata.js

@@ -0,0 +1,511 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Metadata = void 0;
+require("reflect-metadata");
+const constants_1 = require("../constants");
+const classOf_1 = require("../utils/classOf");
+/**
+* Metadata key
+* @private
+* @type {string}
+*/
+const DESIGN_PARAM_TYPES = "design:paramtypes";
+/**
+* Metadata key
+* @private
+* @type {string}
+*/
+const DESIGN_TYPE = "design:type";
+/**
+* Metadata key
+* @private
+* @type {string}
+*/
+const DESIGN_RETURN_TYPE = "design:returntype";
+/**
+* Properties collections
+* @private
+* @type {string}
+*/
+const PROPERTIES = new Map();
+/**
+* @stable
+*/
+class Metadata {
+    /**
+   * Gets the metadata value for the provided metadata key on the target object or its prototype chain.
+   * @param key A key used to store and retrieve metadata.
+   * @param target The target object on which the metadata is defined.
+   * @param propertyKey The property key for the target.
+   * @returns The metadata value for the metadata key if found; otherwise, `undefined`.
+   * @example
+   *
+   * ```typescript
+   * class Example {
+   *     // property declarations are not part of ES6, though they are valid in TypeScript:
+   *     // static staticProperty;
+   *     // property;
+   *
+   *     static staticMethod(p) { }
+   *     method(p) { }
+   * }
+   *
+   * // constructor
+   * result = Metadata.get("custom:annotation", Example);
+   *
+   * // property (on constructor)
+   * result = Metadata.get("custom:annotation", Example, "staticProperty");
+   *
+   * // property (on prototype)
+   * result = Metadata.get("custom:annotation", Example.prototype, "property");
+   *
+   * // method (on constructor)
+   * result = Metadata.get("custom:annotation", Example, "staticMethod");
+   *
+   * // method (on prototype)
+   * result = Metadata.get("custom:annotation", Example.prototype, "method");
+   * ```
+   *
+   */
+    static get(key, target, propertyKey) {
+        return Reflect.getMetadata(key, (0, classOf_1.classOf)(target), propertyKey);
+    }
+    /**
+   * Gets the metadata value for the provided metadata key on the target object or its prototype chain.
+   * @param key A key used to store and retrieve metadata.
+   * @param target The target object on which the metadata is defined.
+   * @param propertyKey The property key for the target.
+   * @returns The metadata value for the metadata key if found; otherwise, `undefined`.
+   * @example
+   *
+   * ```typescript
+   * class Example {
+   *     // property declarations are not part of ES6, though they are valid in TypeScript:
+   *     // static staticProperty;
+   *     // property;
+   *
+   *     static staticMethod(p) { }
+   *     method(p) { }
+   * }
+   *
+   * // constructor
+   * result = Metadata.getOwn("custom:annotation", Example);
+   *
+   * // property (on constructor)
+   * result = Metadata.getOwn("custom:annotation", Example, "staticProperty");
+   *
+   * // property (on prototype)
+   * result = Metadata.getOwn("custom:annotation", Example.prototype, "property");
+   *
+   * // method (on constructor)
+   * result = Metadata.getOwn("custom:annotation", Example, "staticMethod");
+   *
+   * // method (on prototype)
+   * result = Metadata.getOwn("custom:annotation", Example.prototype, "method");
+   * ```
+   *
+   */
+    static getOwn(key, target, propertyKey) {
+        return Reflect.getOwnMetadata(key, (0, classOf_1.classOf)(target), propertyKey);
+    }
+    /**
+   * Gets the metadata value for the provided metadata DESIGN_TYPE on the target object or its prototype chain.
+   * @param target The target object on which the metadata is defined.
+   * @param propertyKey The property key for the target.
+   * @returns The metadata value for the metadata key if found; otherwise, `undefined`.
+   * @example
+   *
+   * ```typescript
+   * class Example {
+   *     // property declarations are not part of ES6, though they are valid in TypeScript:
+   *     // static staticProperty;
+   *     // property;
+   *
+   *     static staticMethod(p) { }
+   *     method(p) { }
+   * }
+   *
+   * // on contructor
+   * result = Metadata.getType(Example);
+   *
+   * // property (on constructor)
+   * result = Metadata.getType(Example, "staticProperty");
+   *
+   * // method (on constructor)
+   * result = Metadata.getType(Example, "staticMethod");
+   * ```
+   *
+   */
+    static getType(target, propertyKey) {
+        return Reflect.getMetadata(DESIGN_TYPE, target, propertyKey);
+    }
+    /**
+   * Gets the metadata value for the provided metadata DESIGN_TYPE on the target object or its prototype chain.
+   * @param target The target object on which the metadata is defined.
+   * @param propertyKey The property key for the target.
+   * @returns The metadata value for the metadata key if found; otherwise, `undefined`.
+   * @example
+   *
+   * ```typescript
+   * class Example {
+   *     // property declarations are not part of ES6, though they are valid in TypeScript:
+   *     // static staticProperty;
+   *     // property;
+   *
+   *     static staticMethod(p) { }
+   *     method(p) { }
+   * }
+   *
+   * // on contructor
+   * result = Metadata.getOwnType(Example);
+   *
+   * // property (on constructor)
+   * result = Metadata.getOwnType(Example, "staticProperty");
+   *
+   * // method (on constructor)
+   * result = Metadata.getOwnType(Example, "staticMethod");
+   * ```
+   *
+   */
+    static getOwnType(target, propertyKey) {
+        return Reflect.getMetadata(DESIGN_TYPE, target, propertyKey);
+    }
+    /**
+   * Gets the metadata value for the provided metadata DESIGN_RETURN_TYPE on the target object or its prototype chain.
+   * @param target The target object on which the metadata is defined.
+   * @param propertyKey The property key for the target.
+   * @returns The metadata value for the metadata key if found; otherwise, `undefined`.
+   * @example
+   *
+   * ```typescript
+   * class Example {
+   *     // property declarations are not part of ES6, though they are valid in TypeScript:
+   *     // static staticProperty;
+   *     // property;
+   *
+   *     static staticMethod(p) { }
+   *     method(p) { }
+   * }
+   *
+   * // on contructor
+   * result = Metadata.getReturnType(Example);
+   *
+   * // property (on constructor)
+   * result = Metadata.getReturnType(Example, "staticProperty");
+   *
+   * // method (on constructor)
+   * result = Metadata.getReturnType(Example, "staticMethod");
+   * ```
+   *
+   */
+    static getReturnType(target, propertyKey) {
+        return Reflect.getMetadata(DESIGN_RETURN_TYPE, target, propertyKey);
+    }
+    /**
+   * Gets the metadata value for the provided metadata DESIGN_RETURN_TYPE on the target object or its prototype chain.
+   * @param target The target object on which the metadata is defined.
+   * @param propertyKey The property key for the target.
+   * @returns The metadata value for the metadata key if found; otherwise, `undefined`.
+   * @example
+   *
+   * ```typescript
+   * class Example {
+   *     // property declarations are not part of ES6, though they are valid in TypeScript:
+   *     // static staticProperty;
+   *     // property;
+   *
+   *     static staticMethod(p) { }
+   *     method(p) { }
+   * }
+   *
+   * // on contructor
+   * result = Metadata.getOwnReturnType(Example);
+   *
+   * // property (on constructor)
+   * result = Metadata.getOwnReturnType(Example, "staticProperty");
+   *
+   * // method (on constructor)
+   * result = Metadata.getOwnReturnType(Example, "staticMethod");
+   * ```
+   *
+   */
+    static getOwnReturnType(target, propertyKey) {
+        return Reflect.getOwnMetadata(DESIGN_RETURN_TYPE, target, propertyKey);
+    }
+    /**
+   * Gets a value indicating whether the target object or its prototype chain has the provided metadata key defined.
+   * @param key A key used to store and retrieve metadata.
+   * @param target The target object on which the metadata is defined.
+   * @param propertyKey The property key for the target.
+   * @returns `true` if the metadata key was defined on the target object or its prototype chain; otherwise, `false`.
+   * @example
+   *
+   * ```typescript
+   * class Example {
+   *     // property declarations are not part of ES6, though they are valid in TypeScript:
+   *     // static staticProperty;
+   *     // property;
+   *
+   *     static staticMethod(p) { }
+   *     method(p) { }
+   * }
+   *
+   * // constructor
+   * result = Metadata.has("custom:annotation", Example);
+   *
+   * // property (on constructor)
+   * result = Metadata.has("custom:annotation", Example, "staticProperty");
+   *
+   * // property (on prototype)
+   * result = Metadata.has("custom:annotation", Example.prototype, "property");
+   *
+   * // method (on constructor)
+   * result = Metadata.has("custom:annotation", Example, "staticMethod");
+   *
+   * // method (on prototype)
+   * result = Metadata.has("custom:annotation", Example.prototype, "method");
+   * ```
+   *
+   */
+    static has(key, target, propertyKey) {
+        try {
+            return Reflect.hasMetadata(key, (0, classOf_1.classOf)(target), propertyKey);
+        }
+        catch (er) { }
+        return false;
+    }
+    /**
+   * Gets a value indicating whether the target object or its prototype chain has the provided metadata key defined.
+   * @param key A key used to store and retrieve metadata.
+   * @param target The target object on which the metadata is defined.
+   * @param propertyKey The property key for the target.
+   * @returns `true` if the metadata key was defined on the target object or its prototype chain; otherwise, `false`.
+   * @example
+   *
+   * ```typescript
+   * class Example {
+   *     // property declarations are not part of ES6, though they are valid in TypeScript:
+   *     // static staticProperty;
+   *     // property;
+   *
+   *     static staticMethod(p) { }
+   *     method(p) { }
+   * }
+   *
+   * // constructor
+   * result = Metadata.has("custom:annotation", Example);
+   *
+   * // property (on constructor)
+   * result = Metadata.hasOwn("custom:annotation", Example, "staticProperty");
+   *
+   * // property (on prototype)
+   * result = Metadata.hasOwn("custom:annotation", Example.prototype, "property");
+   *
+   * // method (on constructor)
+   * result = Metadata.hasOwn("custom:annotation", Example, "staticMethod");
+   *
+   * // method (on prototype)
+   * result = Metadata.hasOwn("custom:annotation", Example.prototype, "method");
+   * ```
+   *
+   */
+    static hasOwn(key, target, propertyKey) {
+        return Reflect.hasOwnMetadata(key, (0, classOf_1.classOf)(target), propertyKey);
+    }
+    /**
+   * Deletes the metadata entry from the target object with the provided key.
+   * @param key A key used to store and retrieve metadata.
+   * @param target The target object on which the metadata is defined.
+   * @param propertyKey The property key for the target.
+   * @returns `true` if the metadata entry was found and deleted; otherwise, false.
+   * @example
+   *
+   * ```typescript
+   * class Example {
+   *     // property declarations are not part of ES6, though they are valid in TypeScript:
+   *     // static staticProperty;
+   *     // property;
+   *
+   *     static staticMethod(p) { }
+   *     method(p) { }
+   * }
+   *
+   * // constructor
+   * result = Metadata.delete("custom:annotation", Example);
+   *
+   * // property (on constructor)
+   * result = Metadata.delete("custom:annotation", Example, "staticProperty");
+   *
+   * // property (on prototype)
+   * result = Metadata.delete("custom:annotation", Example.prototype, "property");
+   *
+   * // method (on constructor)
+   * result = Metadata.delete("custom:annotation", Example, "staticMethod");
+   *
+   * // method (on prototype)
+   * result = Metadata.delete("custom:annotation", Example.prototype, "method");
+   * ```
+   *
+   */
+    static delete(key, target, propertyKey) {
+        return Reflect.deleteMetadata(key, (0, classOf_1.classOf)(target), propertyKey);
+    }
+    /**
+   * Set the metadata value for the provided metadata DESIGN_PARAM_TYPES on the target object or its prototype chain.
+   * @param target The target object on which the metadata is defined.
+   * @param propertyKey The property key for the target.
+   * @param value A value that contains attached metadata.
+   * @returns The metadata value for the metadata key if found; otherwise, `undefined`.
+   * @example
+   *
+   * ```typescript
+   * class Example {
+   *     // property declarations are not part of ES6, though they are valid in TypeScript:
+   *     // static staticProperty;
+   *     // property;
+   *
+   *     static staticMethod(p) { }
+   *     method(p) { }
+   * }
+   *
+   * // on contructor
+   * result = Metadata.setParamTypes(Example, undefined, [Object]);
+   *
+   * // property (on constructor)
+   * result = Metadata.setParamTypes(Example, "staticProperty", [Object]);
+   *
+   * // property (on prototype)
+   * result = Metadata.setParamTypes(Example.prototype, "property", [Object]);
+   *
+   * // method (on constructor)
+   * result = Metadata.setParamTypes(Example, "staticMethod", [Object]);
+   *
+   * // method (on prototype)
+   * result = Metadata.setParamTypes(Example.prototype, "method", [Object]);
+   * ```
+   *
+   */
+    static setParamTypes(target, propertyKey, value) {
+        return this.set(DESIGN_PARAM_TYPES, value, target.prototype, propertyKey);
+    }
+    /**
+   * Define a unique metadata entry on the target.
+   * @param key A key used to store and retrieve metadata.
+   * @param value A value that contains attached metadata.
+   * @param target The target object on which to define metadata.
+   * @param propertyKey The property key for the target.
+   * @example
+   *
+   * ```typescript
+   * class Example {
+   *     // property declarations are not part of ES6, though they are valid in TypeScript:
+   *     // static staticProperty;
+   *     // property;
+   *
+   *     static staticMethod(p) { }
+   *     method(p) { }
+   * }
+   *
+   * // constructor
+   * Reflect.defineMetadata("custom:annotation", options, Example);
+   *
+   * // property (on constructor)
+   * Reflect.defineMetadata("custom:annotation", Number, Example, "staticProperty");
+   *
+   * // property (on prototype)
+   * Reflect.defineMetadata("custom:annotation", Number, Example.prototype, "property");
+   *
+   * // method (on constructor)
+   * Reflect.defineMetadata("custom:annotation", Number, Example, "staticMethod");
+   *
+   * // method (on prototype)
+   * Reflect.defineMetadata("custom:annotation", Number, Example.prototype, "method");
+   *
+   * // decorator factory as metadata-producing annotation.
+   * function MyAnnotation(options): PropertyDecorator {
+   *     return (target, key) => Reflect.defineMetadata("custom:annotation", options, target, key);
+   * }
+   * ```
+   *
+   */
+    static set(key, value, target, propertyKey) {
+        const targets = PROPERTIES.has(key) ? PROPERTIES.get(key) || [] : [];
+        const classConstructor = (0, classOf_1.classOf)(target);
+        if (targets.indexOf(classConstructor) === -1) {
+            targets.push(classConstructor);
+            PROPERTIES.set(key, targets);
+        }
+        Reflect.defineMetadata(key, value, (0, classOf_1.classOf)(target), propertyKey);
+    }
+    /**
+   * Gets the metadata value for the provided metadata DESIGN_PARAM_TYPES on the target object or its prototype chain.
+   * @param targetPrototype
+   * @param propertyKey The property key for the target.
+   * @returns The metadata value for the metadata key if found; otherwise, `undefined`.
+   * @example
+   *
+   * ```typescript
+   * class Example {
+   *     // property declarations are not part of ES6, though they are valid in TypeScript:
+   *     // static staticProperty;
+   *     // property;
+   *
+   *     static staticMethod(p) { }
+   *     method(p) { }
+   * }
+   *
+   * // on contructor
+   * result = Metadata.getParamTypes(Example.prototype);
+   *
+   * // property (on constructor)
+   * result = Metadata.getParamTypes(Example.prototype, "staticProperty");
+   *
+   * // method (on constructor)
+   * result = Metadata.getParamTypes(Example.prototype, "staticMethod");
+   * ```
+   *
+   */
+    static getParamTypes(targetPrototype, propertyKey) {
+        return Reflect.getMetadata(DESIGN_PARAM_TYPES, targetPrototype, propertyKey) || [];
+    }
+    /**
+   * Gets the metadata value for the provided metadata DESIGN_PARAM_TYPES on the target object or its prototype chain.
+   * @param target The target object on which the metadata is defined.
+   * @param propertyKey The property key for the target.
+   * @returns The metadata value for the metadata key if found; otherwise, `undefined`.
+   * @example
+   *
+   * ```typescript
+   * class Example {
+   *     // property declarations are not part of ES6, though they are valid in TypeScript:
+   *     // static staticProperty;
+   *     // property;
+   *
+   *     static staticMethod(p) { }
+   *     method(p) { }
+   * }
+   *
+   * // on contructor
+   * result = Metadata.getParamTypes(Example);
+   *
+   * // property (on constructor)
+   * result = Metadata.getParamTypes(Example, "staticProperty");
+   *
+   * // method (on constructor)
+   * result = Metadata.getParamTypes(Example, "staticMethod");
+   * ```
+   *
+   */
+    static getOwnParamTypes(target, propertyKey) {
+        return Reflect.getOwnMetadata(DESIGN_PARAM_TYPES, target, propertyKey) || [];
+    }
+    static getParamDecoratorFunc(target, propertyKey) {
+        return Reflect.getMetadata(constants_1.ROUTE_PARAM, target.constructor, propertyKey);
+    }
+}
+exports.Metadata = Metadata;
+/**
+* Get all metadata for a metadataKey.
+* @param metadataKey
+*/
+Metadata.getTargetsFromPropertyKey = (metadataKey) => PROPERTIES.has(metadataKey) ? PROPERTIES.get(metadataKey) || [] : [];

package/dist/domain/cors-config.d.ts

@@ -0,0 +1,12 @@
+export type CorsOrigin = string | string[] | RegExp | ((origin: string) => boolean);
+export interface CorsConfig {
+    origins: CorsOrigin;
+    methods?: string[];
+    allowedHeaders?: string[];
+    exposedHeaders?: string[];
+    credentials?: boolean;
+    maxAge?: number;
+    preflightContinue?: boolean;
+}
+export declare const DEFAULT_CORS_METHODS: string[];
+export declare const DEFAULT_CORS_ALLOWED_HEADERS: string[];

package/dist/domain/cors-config.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_CORS_ALLOWED_HEADERS = exports.DEFAULT_CORS_METHODS = void 0;
+exports.DEFAULT_CORS_METHODS = [
+    "GET",
+    "HEAD",
+    "PUT",
+    "PATCH",
+    "POST",
+    "DELETE",
+];
+exports.DEFAULT_CORS_ALLOWED_HEADERS = [
+    "Content-Type",
+    "Authorization",
+    "X-Requested-With",
+    "Accept",
+    "Origin",
+];

package/dist/domain/http-method.d.ts

@@ -0,0 +1,7 @@
+export declare enum HttpMethod {
+    GET = "get",
+    PUT = "put",
+    POST = "post",
+    DELETE = "delete",
+    PATCH = "patch"
+}

package/dist/domain/http-method.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpMethod = void 0;
+var HttpMethod;
+(function (HttpMethod) {
+    HttpMethod["GET"] = "get";
+    HttpMethod["PUT"] = "put";
+    HttpMethod["POST"] = "post";
+    HttpMethod["DELETE"] = "delete";
+    HttpMethod["PATCH"] = "patch";
+})(HttpMethod || (exports.HttpMethod = HttpMethod = {}));

package/dist/domain/index.d.ts

@@ -0,0 +1,10 @@
+export * from './provider-scope';
+export * from './provider-type';
+export * from './Context';
+export * from './LocalsContainer';
+export * from './Metadata';
+export * from './provider';
+export * from './CarnoMiddleware';
+export * from './CarnoClosure';
+export * from './http-method';
+export * from './cors-config';

package/dist/domain/index.js

@@ -0,0 +1,26 @@
+"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("./provider-scope"), exports);
+__exportStar(require("./provider-type"), exports);
+__exportStar(require("./Context"), exports);
+__exportStar(require("./LocalsContainer"), exports);
+__exportStar(require("./Metadata"), exports);
+__exportStar(require("./provider"), exports);
+__exportStar(require("./CarnoMiddleware"), exports);
+__exportStar(require("./CarnoClosure"), exports);
+__exportStar(require("./http-method"), exports);
+__exportStar(require("./cors-config"), exports);

package/dist/domain/provider-scope.d.ts

@@ -0,0 +1,5 @@
+export declare enum ProviderScope {
+    REQUEST = "request",
+    INSTANCE = "instance",
+    SINGLETON = "singleton"
+}

package/dist/domain/provider-scope.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProviderScope = void 0;
+var ProviderScope;
+(function (ProviderScope) {
+    ProviderScope["REQUEST"] = "request";
+    ProviderScope["INSTANCE"] = "instance";
+    ProviderScope["SINGLETON"] = "singleton";
+})(ProviderScope || (exports.ProviderScope = ProviderScope = {}));

package/dist/domain/provider-type.d.ts

@@ -0,0 +1,6 @@
+export declare enum ProviderType {
+    ROUTES = "routes",
+    SERVICE = "service",
+    PROVIDER = "provider",
+    CONTROLLER = "controller"
+}

package/dist/domain/provider-type.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProviderType = void 0;
+var ProviderType;
+(function (ProviderType) {
+    ProviderType["ROUTES"] = "routes";
+    ProviderType["SERVICE"] = "service";
+    ProviderType["PROVIDER"] = "provider";
+    ProviderType["CONTROLLER"] = "controller";
+})(ProviderType || (exports.ProviderType = ProviderType = {}));

package/dist/domain/provider.d.ts

@@ -0,0 +1,37 @@
+import { ProviderType } from "./provider-type";
+import { ProviderScope } from "./provider-scope";
+import { TokenProvider, Type } from "../commons/registries/ProviderControl";
+export type ProviderHookCallback<T = any> = (instance: T, ...args: any[]) => Promise<void> | void;
+export declare class Provider {
+    /**
+     * Token group provider to retrieve all provider from the same type
+     */
+    type: TokenProvider | ProviderType;
+    deps: TokenProvider[];
+    instance: any;
+    private _provide;
+    private _useClass;
+    private _useValue?;
+    hooks?: Record<string, ProviderHookCallback>;
+    path?: string;
+    /**
+     * Scope used by the injector to build the provider.
+     */
+    scope?: ProviderScope;
+    children?: any[];
+    parent?: Function;
+    constructor(token: TokenProvider, options?: Partial<Provider>);
+    get token(): any;
+    get useClass(): Type;
+    /**
+     * Create a new store if the given value is a class. Otherwise the value is ignored.
+     * @param value
+     */
+    set useClass(value: Type);
+    get useValue(): () => any;
+    set useValue(value: () => any);
+    get provide(): TokenProvider;
+    set provide(value: TokenProvider);
+    clone(): Provider;
+    isChild(): boolean;
+}