@lakutata/core 1.0.60 → 3.0.0-beta.0

package/dist/cjs/lib/core/Module.d.ts

@@ -0,0 +1,165 @@
+import { Component } from './Component.js';
+import { __destroy, __init, type BaseObject } from '../base/BaseObject.js';
+import { Container } from './Container.js';
+import { ModuleOptions } from '../../options/ModuleOptions.js';
+import { ModuleConfigLoader } from '../base/internal/ModuleConfigLoader.js';
+import { IBaseObjectConstructor } from '../../interfaces/IBaseObjectConstructor.js';
+import { MODULE_INITIALIZATION } from '../base/internal/ModuleInitialization.js';
+export declare const MODULE_INITIALIZED: string;
+export declare const MODULE_INITIALIZE_ERROR: string;
+/**
+ * The base class of the modules: a component owning its own objects (components, providers, named and anonymous
+ * objects) declared by its options, the way the application declares its own. Its lifetime is `@Singleton`, locked.
+ * The objects of a module resolve their dependencies from the module first, then from the application; the objects
+ * of the application do not see the module's.
+ *
+ * Declare it in the `objects.named` of the application (or of a parent module) options, its options under `options`
+ * (they are merged over its `options` initializer), and list it in `bootstrap` to start it at launch. When a module is
+ * created, its options are checked (see `checkOptions`), its objects registered, then its `bootstrap` runs in order: a
+ * name or class is got from its container (creating it), an async function is called with the module. An object
+ * outside the module getting it (`getObject`, `@Inject`) receives it once these steps are complete, and receives the
+ * error of a step that fails; the module's own objects, created by these steps, receive it at once (they can inject
+ * the module they belong to).
+ * @example
+ * ```typescript
+ * import {Application, Component, Module, type ModuleOptions} from 'lakutata'
+ *
+ * class Billing extends Component {
+ *     public charge(amount: number): void {
+ *         console.log(`Charged ${amount}`)
+ *     }
+ * }
+ *
+ * export class PaymentModule extends Module {
+ *     protected options: ModuleOptions = {
+ *         components: {
+ *             billing: {class: Billing}
+ *         },
+ *         bootstrap: ['billing']
+ *     }
+ * }
+ *
+ * Application.run({
+ *     id: 'shop.app',
+ *     name: 'Shop',
+ *     objects: {
+ *         named: {
+ *             payment: {class: PaymentModule}
+ *         }
+ *     },
+ *     bootstrap: ['payment']
+ * })
+ * ```
+ */
+export declare class Module extends Component {
+    #private;
+    [MODULE_INITIALIZATION]: () => Promise<void>;
+    /**
+     * The class reading the module options into the declarations to register and the bootstrap steps (the
+     * application's reads its identity too).
+     * @protected
+     */
+    protected readonly ConfigLoader: typeof ModuleConfigLoader;
+    /**
+     * The module's own declarations, given by the initializer of a subclass; the options configured for the module
+     * (its `options` option) are merged over them: a component, provider or named object of the same name is
+     * replaced, or completed when declared without its class, and the bootstrap steps are appended.
+     * @protected
+     */
+    protected options: ModuleOptions;
+    /**
+     * The module's container, holding the objects it declares.
+     * @protected
+     */
+    protected get container(): Container;
+    /**
+     * Called by the container only: a module is created through a container, never with `new`.
+     * @param cradleProxy The container's resolution proxy.
+     */
+    constructor(cradleProxy: Record<string | symbol, any>);
+    /**
+     * The framework's initializer: schedules the initialization (injection, configured values, `init()`, the objects
+     * registered, the bootstrap) for a later turn of the event loop and returns at once; the completion or the failure
+     * is emitted as an internal event. Override `init()` instead.
+     * @param hooks The steps the framework's subclasses run before the objects are registered.
+     * @returns Resolves at once, before the initialization.
+     * @protected
+     */
+    protected [__init](...hooks: (() => Promise<void>)[]): Promise<void>;
+    /**
+     * The framework's destroyer, see {@link Component}; override `beforeDestroy()` and `destroy()` instead.
+     * @param hooks The steps the framework's subclasses run before `destroy()`.
+     * @returns Resolves once the module and its objects are destroyed.
+     * @protected
+     */
+    protected [__destroy](...hooks: (() => Promise<void>)[]): Promise<void>;
+    /**
+     * The mode the application runs in: the `MODE` environment variable, else `NODE_ENV`, when it is `development` or
+     * `production`; `development` otherwise.
+     * @returns The mode.
+     */
+    mode(): 'development' | 'production';
+    /**
+     * Destroy the module with its objects and initialize it again (same instance): its objects are registered again
+     * and its bootstrap runs again.
+     * @returns Resolves once the module is initialized again.
+     * @throws {ObjectDestroyedException} When its parent has been destroyed.
+     * @throws {Error} The error of its teardown or of its initialization.
+     */
+    reload(): Promise<void>;
+    /**
+     * Get an object registered by its class, from the module's container or its parents, as {@link Container.get}.
+     * @param constructor The class the object was registered with (or an `@Autoload` class).
+     * @param configurableRecords The options of the object, merged over the ones it was declared with. Ignored, with a
+     * warning outside production, when the cached singleton or scoped instance already exists; a scoped object
+     * requested with options is a new instance owned by the module.
+     * @returns The object, once created and initialized.
+     * @throws {ObjectDestroyedException} When the module has been destroyed.
+     * @throws {Error} When nothing is registered under it, or the object fails to be created.
+     */
+    getObject<T extends BaseObject>(constructor: IBaseObjectConstructor<T>, configurableRecords?: Record<string, any>): Promise<T>;
+    /**
+     * Get an object registered under a name (its key in the module options), as {@link Module.getObject} by class.
+     * @param name The registration name.
+     * @param configurableRecords The options of the object, merged over the ones it was declared with. Ignored, with a
+     * warning outside production, when the cached singleton or scoped instance already exists; a scoped object
+     * requested with options is a new instance owned by the module.
+     * @returns The object, once created and initialized.
+     * @throws {ObjectDestroyedException} When the module has been destroyed.
+     * @throws {Error} When nothing is registered under it, or the object fails to be created.
+     */
+    getObject<T extends BaseObject>(name: string, configurableRecords?: Record<string, any>): Promise<T>;
+    /**
+     * Get an object registered under a symbol, as {@link Module.getObject} by class.
+     * @param name The registration symbol.
+     * @param configurableRecords The options of the object, merged over the ones it was declared with. Ignored, with a
+     * warning outside production, when the cached singleton or scoped instance already exists; a scoped object
+     * requested with options is a new instance owned by the module.
+     * @returns The object, once created and initialized.
+     * @throws {ObjectDestroyedException} When the module has been destroyed.
+     * @throws {Error} When nothing is registered under it, or the object fails to be created.
+     */
+    getObject<T extends BaseObject>(name: symbol, configurableRecords?: Record<string, any>): Promise<T>;
+    /**
+     * Get an object registered under a name or a symbol, as {@link Module.getObject} by class.
+     * @param name The registration name or symbol.
+     * @param configurableRecords The options of the object, merged over the ones it was declared with. Ignored, with a
+     * warning outside production, when the cached singleton or scoped instance already exists; a scoped object
+     * requested with options is a new instance owned by the module.
+     * @returns The object, once created and initialized.
+     * @throws {ObjectDestroyedException} When the module has been destroyed.
+     * @throws {Error} When nothing is registered under it, or the object fails to be created.
+     */
+    getObject<T extends BaseObject>(name: string | symbol, configurableRecords?: Record<string, any>): Promise<T>;
+    /**
+     * Get an object registered under a name, a symbol or by its class, as {@link Module.getObject} by class.
+     * @param nameOrConstructor The registration name, symbol or class.
+     * @param configurableRecords The options of the object, merged over the ones it was declared with. Ignored, with a
+     * warning outside production, when the cached singleton or scoped instance already exists; a scoped object
+     * requested with options is a new instance owned by the module.
+     * @returns The object, once created and initialized.
+     * @throws {ObjectDestroyedException} When the module has been destroyed.
+     * @throws {Error} When nothing is registered under it, or the object fails to be created.
+     */
+    getObject<T extends BaseObject>(nameOrConstructor: string | symbol | IBaseObjectConstructor<T>, configurableRecords?: Record<string, any>): Promise<T>;
+}

package/dist/cjs/lib/core/Module.js

@@ -0,0 +1,268 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Module = exports.MODULE_INITIALIZE_ERROR = exports.MODULE_INITIALIZED = void 0;
+const Component_js_1 = require("./Component.js");
+const Lifetime_js_1 = require("../../decorators/di/Lifetime.js");
+const BaseObject_js_1 = require("../base/BaseObject.js");
+const ObjectContainer_js_1 = require("../base/internal/ObjectContainer.js");
+const ModuleOptions_js_1 = require("../../options/ModuleOptions.js");
+const ModuleConfigLoader_js_1 = require("../base/internal/ModuleConfigLoader.js");
+const types_1 = require("node:util/types");
+const Configurable_js_1 = require("../../decorators/di/Configurable.js");
+const As_1 = require("@lakutata/utils/As");
+const ObjectType_js_1 = require("../base/internal/ObjectType.js");
+const NonceString_1 = require("@lakutata/utils/NonceString");
+const ObjectOptionsCheck_js_1 = require("../base/internal/ObjectOptionsCheck.js");
+const BasicInfo_js_1 = require("../foundation/BasicInfo.js");
+const ModuleInitialization_js_1 = require("../base/internal/ModuleInitialization.js");
+exports.MODULE_INITIALIZED = `_$.MODULE.INITIALIZED_${(0, NonceString_1.nonceString)()}`;
+exports.MODULE_INITIALIZE_ERROR = `_$.MODULE.INITIALIZE_ERROR_${(0, NonceString_1.nonceString)()}`;
+/**
+ * The base class of the modules: a component owning its own objects (components, providers, named and anonymous
+ * objects) declared by its options, the way the application declares its own. Its lifetime is `@Singleton`, locked.
+ * The objects of a module resolve their dependencies from the module first, then from the application; the objects
+ * of the application do not see the module's.
+ *
+ * Declare it in the `objects.named` of the application (or of a parent module) options, its options under `options`
+ * (they are merged over its `options` initializer), and list it in `bootstrap` to start it at launch. When a module is
+ * created, its options are checked (see `checkOptions`), its objects registered, then its `bootstrap` runs in order: a
+ * name or class is got from its container (creating it), an async function is called with the module. An object
+ * outside the module getting it (`getObject`, `@Inject`) receives it once these steps are complete, and receives the
+ * error of a step that fails; the module's own objects, created by these steps, receive it at once (they can inject
+ * the module they belong to).
+ * @example
+ * ```typescript
+ * import {Application, Component, Module, type ModuleOptions} from 'lakutata'
+ *
+ * class Billing extends Component {
+ *     public charge(amount: number): void {
+ *         console.log(`Charged ${amount}`)
+ *     }
+ * }
+ *
+ * export class PaymentModule extends Module {
+ *     protected options: ModuleOptions = {
+ *         components: {
+ *             billing: {class: Billing}
+ *         },
+ *         bootstrap: ['billing']
+ *     }
+ * }
+ *
+ * Application.run({
+ *     id: 'shop.app',
+ *     name: 'Shop',
+ *     objects: {
+ *         named: {
+ *             payment: {class: PaymentModule}
+ *         }
+ *     },
+ *     bootstrap: ['payment']
+ * })
+ * ```
+ */
+let Module = class Module extends Component_js_1.Component {
+    /**
+     * The module's container, holding the objects it declares.
+     * @protected
+     */
+    get container() {
+        return (0, ObjectContainer_js_1.getObjectContainer)(this);
+    }
+    /**
+     * Objects to be loaded
+     * @private
+     */
+    #objects;
+    /**
+     * Bootstrap
+     * @private
+     */
+    #bootstrap;
+    /**
+     * Whether the options of the objects are checked before they are loaded
+     * @private
+     */
+    #checkOptions;
+    /**
+     * Called by the container only: a module is created through a container, never with `new`.
+     * @param cradleProxy The container's resolution proxy.
+     */
+    constructor(cradleProxy) {
+        super(cradleProxy);
+        /**
+         * The class reading the module options into the declarations to register and the bootstrap steps (the
+         * application's reads its identity too).
+         * @protected
+         */
+        this.ConfigLoader = ModuleConfigLoader_js_1.ModuleConfigLoader;
+        /**
+         * The module's own declarations, given by the initializer of a subclass; the options configured for the module
+         * (its `options` option) are merged over them: a component, provider or named object of the same name is
+         * replaced, or completed when declared without its class, and the bootstrap steps are appended.
+         * @protected
+         */
+        this.options = {
+        /**
+         * write options here
+         */
+        };
+        /**
+         * Objects to be loaded
+         * @private
+         */
+        this.#objects = [];
+        /**
+         * Bootstrap
+         * @private
+         */
+        this.#bootstrap = [];
+        /**
+         * Whether the options of the objects are checked before they are loaded
+         * @private
+         */
+        this.#checkOptions = true;
+    }
+    /**
+     * The framework's initializer: schedules the initialization (injection, configured values, `init()`, the objects
+     * registered, the bootstrap) for a later turn of the event loop and returns at once; the completion or the failure
+     * is emitted as an internal event. Override `init()` instead.
+     * @param hooks The steps the framework's subclasses run before the objects are registered.
+     * @returns Resolves at once, before the initialization.
+     * @protected
+     */
+    async [BaseObject_js_1.__init](...hooks) {
+        //Use setImmediate here for init module instance first, then sub objects can use @Inject decorator get current module
+        //The initialization reports its errors (MODULE_INITIALIZE_ERROR)
+        //The initialization in progress, waited for by the objects resolving the module from outside it
+        const initialization = {};
+        initialization.promise = new Promise((resolve, reject) => {
+            initialization.resolve = resolve;
+            initialization.reject = reject;
+        });
+        //Its failure is reported by the event, the waiters receive it
+        initialization.promise.catch(() => undefined);
+        this.#initialization = initialization;
+        setImmediate(() => void (async () => {
+            try {
+                await super[BaseObject_js_1.__init](...hooks, async () => {
+                    //Load objects stage
+                    if (this.#checkOptions)
+                        (0, ObjectOptionsCheck_js_1.checkObjectOptions)(this.#objects);
+                    await this.container.load(this.#objects);
+                }, async () => {
+                    Reflect.defineMetadata('#bootstrap', this.#bootstrap, this);
+                    //Bootstrap stage
+                    for (const bootstrapOption of this.#bootstrap) {
+                        if ((0, types_1.isAsyncFunction)(bootstrapOption)) {
+                            await (0, As_1.As)(bootstrapOption)(this);
+                        }
+                        else {
+                            await this.getObject((0, As_1.As)(bootstrapOption));
+                        }
+                    }
+                    Reflect.deleteMetadata('#bootstrap', this);
+                });
+                this.emit(exports.MODULE_INITIALIZED);
+                initialization.resolve();
+            }
+            catch (e) {
+                this.emit(exports.MODULE_INITIALIZE_ERROR, e);
+                initialization.reject(e);
+            }
+        })());
+    }
+    /**
+     * The initialization of the module in progress or done (none before it starts), see {@link MODULE_INITIALIZATION}
+     * @internal
+     */
+    #initialization;
+    /**
+     * Wait for the initialization of the module: its objects loaded and its bootstrap run
+     * @returns Resolves once it is initialized (at once when its initialization did not start), rejects with the error
+     * of its initialization
+     * @internal
+     */
+    async [ModuleInitialization_js_1.MODULE_INITIALIZATION]() {
+        await this.#initialization?.promise;
+    }
+    /**
+     * The framework's destroyer, see {@link Component}; override `beforeDestroy()` and `destroy()` instead.
+     * @param hooks The steps the framework's subclasses run before `destroy()`.
+     * @returns Resolves once the module and its objects are destroyed.
+     * @protected
+     */
+    async [BaseObject_js_1.__destroy](...hooks) {
+        //Destroyed before its initialization ran (it never runs then): its waiters are released
+        this.#initialization?.resolve();
+        return await super[BaseObject_js_1.__destroy](...hooks);
+    }
+    /**
+     * The mode the application runs in: the `MODE` environment variable, else `NODE_ENV`, when it is `development` or
+     * `production`; `development` otherwise.
+     * @returns The mode.
+     */
+    mode() {
+        return (0, BasicInfo_js_1.currentMode)();
+    }
+    /**
+     * Destroy the module with its objects and initialize it again (same instance): its objects are registered again
+     * and its bootstrap runs again.
+     * @returns Resolves once the module is initialized again.
+     * @throws {ObjectDestroyedException} When its parent has been destroyed.
+     * @throws {Error} The error of its teardown or of its initialization.
+     */
+    async reload() {
+        await this[BaseObject_js_1.__destroy]();
+        this[BaseObject_js_1.__revive]();
+        //Listen after the teardown, which removes all event listeners of the module
+        await new Promise((resolve, reject) => {
+            const onInitialized = () => {
+                this.off(exports.MODULE_INITIALIZE_ERROR, onInitializeError);
+                resolve();
+            };
+            const onInitializeError = (error) => {
+                this.off(exports.MODULE_INITIALIZED, onInitialized);
+                reject(error);
+            };
+            this.once(exports.MODULE_INITIALIZED, onInitialized);
+            this.once(exports.MODULE_INITIALIZE_ERROR, onInitializeError);
+            this[BaseObject_js_1.__init]().catch(reject);
+        });
+    }
+    async getObject(inp, configurableRecords = {}) {
+        return await super.getObject(inp, configurableRecords);
+    }
+    static {
+        __decorate([
+            (0, Configurable_js_1.Configurable)(ModuleOptions_js_1.ModuleOptions.optional().default({}).options({ stripUnknown: false }), function (options) {
+                //The options of the module (its initializer) with the options configured over them: without configuration, the
+                //value is the initializer, which is not merged twice
+                const configured = this.getConfigurableRecords().options !== undefined ? options : {};
+                const { bootstrap, loadOptions } = new this.ConfigLoader(this, this.options);
+                bootstrap.forEach(value => this.#bootstrap.push(value));
+                const result = new this.ConfigLoader(this, configured, loadOptions);
+                result.bootstrap.forEach(value => this.#bootstrap.push(value));
+                this.#objects = result.loadOptions;
+                this.#checkOptions = (configured.checkOptions ?? this.options.checkOptions) !== false;
+                return options;
+            }),
+            __metadata("design:type", ModuleOptions_js_1.ModuleOptions)
+        ], Module.prototype, "options", void 0);
+    }
+};
+exports.Module = Module;
+exports.Module = Module = __decorate([
+    (0, Lifetime_js_1.Singleton)(true),
+    (0, ObjectType_js_1.DefineObjectType)(ObjectType_js_1.ObjectType.Module),
+    __metadata("design:paramtypes", [Object])
+], Module);

package/dist/cjs/lib/core/Provider.d.ts

@@ -0,0 +1,52 @@
+import { BaseObject } from '../base/BaseObject.js';
+/**
+ * The base class of the providers: the functional units living in a scope, such as a request (a repository, a
+ * password hasher, a client configured per request). Its lifetime is `@Scoped` by default: one instance per scope (the
+ * root container being a scope too). A provider may be declared `@Transient`, or `@Singleton` (one instance shared by
+ * the scopes, as in 2.x: a client of a remote service); a long-lived object owning resources (connections,
+ * subscriptions, servers) and emitting events is rather a {@link Component}. A singleton provider injecting a scoped
+ * object keeps the instance of the scope which created it.
+ *
+ * Declare it in the `providers` of the application or module options, under a name, with its options; get it with
+ * `@Inject` or `getObject()`. It is created on first request, with the async construction of {@link BaseObject}.
+ * @example
+ * ```typescript
+ * import {Application, DTO, Provider} from 'lakutata'
+ * import {Configurable} from 'lakutata/decorator/di'
+ *
+ * export class PriceCalculator extends Provider {
+ *     //The tax rate, 0.2 unless configured or set by the TAX_RATE environment variable
+ *     @Configurable(DTO.Number().min(0).max(1))
+ *     protected readonly taxRate: number = Number(this.getEnv('TAX_RATE', '0.2'))
+ *
+ *     public withTax(price: number): number {
+ *         return price * (1 + this.taxRate)
+ *     }
+ * }
+ *
+ * Application.run({
+ *     id: 'shop.app',
+ *     name: 'Shop',
+ *     providers: {
+ *         prices: {class: PriceCalculator, taxRate: 0.1}
+ *     }
+ * })
+ * ```
+ */
+export declare class Provider extends BaseObject {
+    /**
+     * Read an environment variable (including the ones set by `Application.env()`).
+     * @param name The variable name.
+     * @returns The value, or undefined when the variable is not set.
+     * @protected
+     */
+    protected getEnv(name: string): string | undefined;
+    /**
+     * Read an environment variable (including the ones set by `Application.env()`), with a default value.
+     * @param name The variable name.
+     * @param defaultValue The value returned when the variable is not set.
+     * @returns The value, or the default value.
+     * @protected
+     */
+    protected getEnv(name: string, defaultValue: string): string;
+}

package/dist/cjs/lib/core/Provider.js

@@ -0,0 +1,57 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Provider = void 0;
+const BaseObject_js_1 = require("../base/BaseObject.js");
+const Lifetime_js_1 = require("../../decorators/di/Lifetime.js");
+const ObjectType_js_1 = require("../base/internal/ObjectType.js");
+/**
+ * The base class of the providers: the functional units living in a scope, such as a request (a repository, a
+ * password hasher, a client configured per request). Its lifetime is `@Scoped` by default: one instance per scope (the
+ * root container being a scope too). A provider may be declared `@Transient`, or `@Singleton` (one instance shared by
+ * the scopes, as in 2.x: a client of a remote service); a long-lived object owning resources (connections,
+ * subscriptions, servers) and emitting events is rather a {@link Component}. A singleton provider injecting a scoped
+ * object keeps the instance of the scope which created it.
+ *
+ * Declare it in the `providers` of the application or module options, under a name, with its options; get it with
+ * `@Inject` or `getObject()`. It is created on first request, with the async construction of {@link BaseObject}.
+ * @example
+ * ```typescript
+ * import {Application, DTO, Provider} from 'lakutata'
+ * import {Configurable} from 'lakutata/decorator/di'
+ *
+ * export class PriceCalculator extends Provider {
+ *     //The tax rate, 0.2 unless configured or set by the TAX_RATE environment variable
+ *     @Configurable(DTO.Number().min(0).max(1))
+ *     protected readonly taxRate: number = Number(this.getEnv('TAX_RATE', '0.2'))
+ *
+ *     public withTax(price: number): number {
+ *         return price * (1 + this.taxRate)
+ *     }
+ * }
+ *
+ * Application.run({
+ *     id: 'shop.app',
+ *     name: 'Shop',
+ *     providers: {
+ *         prices: {class: PriceCalculator, taxRate: 0.1}
+ *     }
+ * })
+ * ```
+ */
+let Provider = class Provider extends BaseObject_js_1.BaseObject {
+    getEnv(name, defaultValue) {
+        const value = process.env[name];
+        return (value === undefined && defaultValue !== undefined) ? defaultValue : value;
+    }
+};
+exports.Provider = Provider;
+exports.Provider = Provider = __decorate([
+    (0, Lifetime_js_1.Scoped)(),
+    (0, ObjectType_js_1.DefineObjectType)(ObjectType_js_1.ObjectType.Provider)
+], Provider);

package/dist/cjs/lib/dto/CachedSchema.d.ts

@@ -0,0 +1,7 @@
+/**
+ * A schema built for a class, with the revision of the metadata of the classes it was built from
+ */
+export type CachedSchema<T> = {
+    revision: number;
+    value: T;
+};

package/dist/cjs/lib/dto/CachedSchema.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });