@lakutata/core 1.0.59 → 3.0.0-beta.0

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

@@ -0,0 +1,265 @@
+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);
+};
+import { Component } from './Component.js';
+import { Singleton } from '../../decorators/di/Lifetime.js';
+import { __destroy, __init, __revive } from '../base/BaseObject.js';
+import { getObjectContainer } from '../base/internal/ObjectContainer.js';
+import { ModuleOptions } from '../../options/ModuleOptions.js';
+import { ModuleConfigLoader } from '../base/internal/ModuleConfigLoader.js';
+import { isAsyncFunction } from 'node:util/types';
+import { Configurable } from '../../decorators/di/Configurable.js';
+import { As } from '@lakutata/utils/As';
+import { DefineObjectType, ObjectType } from '../base/internal/ObjectType.js';
+import { nonceString } from '@lakutata/utils/NonceString';
+import { checkObjectOptions } from '../base/internal/ObjectOptionsCheck.js';
+import { currentMode } from '../foundation/BasicInfo.js';
+import { MODULE_INITIALIZATION } from '../base/internal/ModuleInitialization.js';
+export const MODULE_INITIALIZED = `_$.MODULE.INITIALIZED_${nonceString()}`;
+export const MODULE_INITIALIZE_ERROR = `_$.MODULE.INITIALIZE_ERROR_${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 {
+    /**
+     * The module's container, holding the objects it declares.
+     * @protected
+     */
+    get container() {
+        return 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;
+        /**
+         * 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 [__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[__init](...hooks, async () => {
+                    //Load objects stage
+                    if (this.#checkOptions)
+                        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 (isAsyncFunction(bootstrapOption)) {
+                            await As(bootstrapOption)(this);
+                        }
+                        else {
+                            await this.getObject(As(bootstrapOption));
+                        }
+                    }
+                    Reflect.deleteMetadata('#bootstrap', this);
+                });
+                this.emit(MODULE_INITIALIZED);
+                initialization.resolve();
+            }
+            catch (e) {
+                this.emit(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 [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 [__destroy](...hooks) {
+        //Destroyed before its initialization ran (it never runs then): its waiters are released
+        this.#initialization?.resolve();
+        return await super[__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 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[__destroy]();
+        this[__revive]();
+        //Listen after the teardown, which removes all event listeners of the module
+        await new Promise((resolve, reject) => {
+            const onInitialized = () => {
+                this.off(MODULE_INITIALIZE_ERROR, onInitializeError);
+                resolve();
+            };
+            const onInitializeError = (error) => {
+                this.off(MODULE_INITIALIZED, onInitialized);
+                reject(error);
+            };
+            this.once(MODULE_INITIALIZED, onInitialized);
+            this.once(MODULE_INITIALIZE_ERROR, onInitializeError);
+            this[__init]().catch(reject);
+        });
+    }
+    async getObject(inp, configurableRecords = {}) {
+        return await super.getObject(inp, configurableRecords);
+    }
+    static {
+        __decorate([
+            Configurable(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)
+        ], Module.prototype, "options", void 0);
+    }
+};
+Module = __decorate([
+    Singleton(true),
+    DefineObjectType(ObjectType.Module),
+    __metadata("design:paramtypes", [Object])
+], Module);
+export { Module };

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

@@ -0,0 +1,54 @@
+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;
+};
+import { BaseObject } from '../base/BaseObject.js';
+import { Scoped } from '../../decorators/di/Lifetime.js';
+import { DefineObjectType, ObjectType } from '../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 {
+    getEnv(name, defaultValue) {
+        const value = process.env[name];
+        return (value === undefined && defaultValue !== undefined) ? defaultValue : value;
+    }
+};
+Provider = __decorate([
+    Scoped(),
+    DefineObjectType(ObjectType.Provider)
+], Provider);
+export { Provider };

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

@@ -0,0 +1 @@
+export {};