@carno.js/core 0.2.11 → 1.0.2

package/dist/domain/Metadata.js

@@ -1,511 +0,0 @@
-"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

@@ -1,12 +0,0 @@
-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

@@ -1,18 +0,0 @@
-"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/cors-headers-cache.d.ts

@@ -1,17 +0,0 @@
-import { CorsConfig } from './cors-config';
-export declare class CorsHeadersCache {
-    private readonly config;
-    private readonly cache;
-    private readonly methodsString;
-    private readonly allowedHeadersString;
-    private readonly exposedHeadersString;
-    private readonly maxAgeString;
-    private readonly hasCredentials;
-    private readonly isWildcard;
-    private readonly originAllowed;
-    constructor(config: CorsConfig);
-    get(origin: string): Record<string, string>;
-    private buildHeaders;
-    applyToResponse(response: Response, origin: string): Response;
-    isOriginAllowed(origin: string): boolean;
-}

package/dist/domain/cors-headers-cache.js

@@ -1,101 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CorsHeadersCache = void 0;
-const cors_config_1 = require("./cors-config");
-const allowAnyOrigin = () => {
-    return true;
-};
-const denyAnyOrigin = () => {
-    return false;
-};
-function buildOriginAllowed(origins) {
-    if (origins === '*') {
-        return allowAnyOrigin;
-    }
-    if (typeof origins === 'string') {
-        return createExactOriginMatcher(origins);
-    }
-    if (Array.isArray(origins)) {
-        return createSetOriginMatcher(origins);
-    }
-    if (origins instanceof RegExp) {
-        return createRegexOriginMatcher(origins);
-    }
-    if (typeof origins === 'function') {
-        return origins;
-    }
-    return denyAnyOrigin;
-}
-function createExactOriginMatcher(origin) {
-    return (value) => {
-        return value === origin;
-    };
-}
-function createSetOriginMatcher(origins) {
-    const originSet = new Set(origins);
-    return (value) => {
-        return originSet.has(value);
-    };
-}
-function createRegexOriginMatcher(origins) {
-    return (value) => {
-        return origins.test(value);
-    };
-}
-class CorsHeadersCache {
-    constructor(config) {
-        this.config = config;
-        this.cache = new Map();
-        const methods = config.methods || cors_config_1.DEFAULT_CORS_METHODS;
-        this.methodsString = methods.join(', ');
-        const allowedHeaders = config.allowedHeaders || cors_config_1.DEFAULT_CORS_ALLOWED_HEADERS;
-        this.allowedHeadersString = allowedHeaders.join(', ');
-        this.exposedHeadersString = config.exposedHeaders?.length
-            ? config.exposedHeaders.join(', ')
-            : null;
-        this.maxAgeString = config.maxAge !== undefined
-            ? config.maxAge.toString()
-            : null;
-        this.hasCredentials = !!config.credentials;
-        this.isWildcard = config.origins === '*';
-        this.originAllowed = buildOriginAllowed(config.origins);
-    }
-    get(origin) {
-        const cacheKey = this.isWildcard ? '*' : origin;
-        let cached = this.cache.get(cacheKey);
-        if (cached) {
-            return cached;
-        }
-        cached = this.buildHeaders(origin);
-        this.cache.set(cacheKey, cached);
-        return cached;
-    }
-    buildHeaders(origin) {
-        const headers = {
-            'Access-Control-Allow-Origin': this.isWildcard ? '*' : origin,
-            'Access-Control-Allow-Methods': this.methodsString,
-            'Access-Control-Allow-Headers': this.allowedHeadersString,
-        };
-        if (this.hasCredentials) {
-            headers['Access-Control-Allow-Credentials'] = 'true';
-        }
-        if (this.exposedHeadersString) {
-            headers['Access-Control-Expose-Headers'] = this.exposedHeadersString;
-        }
-        if (this.maxAgeString) {
-            headers['Access-Control-Max-Age'] = this.maxAgeString;
-        }
-        return headers;
-    }
-    applyToResponse(response, origin) {
-        const corsHeaders = this.get(origin);
-        for (const key in corsHeaders) {
-            response.headers.set(key, corsHeaders[key]);
-        }
-        return response;
-    }
-    isOriginAllowed(origin) {
-        return this.originAllowed(origin);
-    }
-}
-exports.CorsHeadersCache = CorsHeadersCache;

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

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

package/dist/domain/http-method.js

@@ -1,11 +0,0 @@
-"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

@@ -1,10 +0,0 @@
-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';