@lakutata/core 1.0.60 → 3.0.0-beta.0

package/dist/cjs/lib/app/Application.js

@@ -0,0 +1,613 @@
+"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);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Application = exports.ApplicationState = void 0;
+const Module_js_1 = require("../core/Module.js");
+const Container_js_1 = require("../core/Container.js");
+const ApplicationConfigLoader_js_1 = require("./ApplicationConfigLoader.js");
+const ApplicationOptions_js_1 = require("../../options/ApplicationOptions.js");
+const Alias_js_1 = require("../core/Alias.js");
+const BasicInfo_js_1 = require("../foundation/BasicInfo.js");
+const LifecycleErrorReporter_js_1 = require("../foundation/LifecycleErrorReporter.js");
+const ConsoleLogger_js_1 = require("../../components/ConsoleLogger.js");
+const Accept_js_1 = require("../../decorators/dto/Accept.js");
+const DTO_js_1 = require("../dto/DTO.js");
+const fs_1 = require("fs");
+const node_path_1 = __importDefault(require("node:path"));
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const As_1 = require("@lakutata/utils/As");
+const EventEmitter_js_1 = require("../base/EventEmitter.js");
+const MigrationCommand_js_1 = require("./MigrationCommand.js");
+const ApplicationLaunch_js_1 = require("../base/internal/ApplicationLaunch.js");
+const EndProcess_js_1 = require("../foundation/EndProcess.js");
+/**
+ * The events of the application's lifecycle.
+ */
+var ApplicationState;
+(function (ApplicationState) {
+    ApplicationState["Launched"] = "LAUNCHED";
+    ApplicationState["Done"] = "DONE";
+    ApplicationState["UncaughtException"] = "UNCAUGHT_EXCEPTION";
+    ApplicationState["FatalException"] = "FATAL_EXCEPTION";
+})(ApplicationState || (exports.ApplicationState = ApplicationState = {}));
+/**
+ * The application: the root module, created and launched by the static fluent API. `Application.run()` gives its
+ * options (its identity and its components, providers, objects and bootstrap); the other static calls set its
+ * environment variables, path aliases and lifecycle handlers. The application launches once, in the turn of the event
+ * loop following the first calls; the calls made once its launch started only add their handlers (`env()`, `alias()`
+ * and `run()` have no effect then):
+ * 1. the environment variables are set, the aliases registered (`@runtime` being the working directory);
+ * 2. the options are read (from the getter given to `run()`, which may be async) and validated, the identity applied
+ *    (`process.title` is the application ID, the time zone and the mode set);
+ * 3. the application is created in a new root container: its objects are registered and its bootstrap runs in order;
+ * 4. the `onLaunched()` handlers and the objects' `launched()` hooks run.
+ *
+ * A failure of steps 1 to 3 is a fatal exception: the `onFatalException()` handler runs (or the error is logged), then
+ * the process exits (code 1 by default). The application ends by `app.exit()` or a shutdown signal (`shutdownSignals`
+ * option): the `onDone()` handlers run, the objects are destroyed, then the process exits.
+ *
+ * The objects of the application are reached with `@Inject`, or with `app.getObject()`.
+ * @example
+ * ```typescript
+ * import {Application, Component} from 'lakutata'
+ *
+ * class Greeter extends Component {
+ *     public greet(name: string): string {
+ *         return `Hello, ${name}`
+ *     }
+ * }
+ *
+ * Application
+ *     .env({TZ_NAME: 'Asia/Shanghai'})
+ *     .alias({'@data': './data'}, true)
+ *     .run(() => ({
+ *         id: 'greeter.app',
+ *         name: 'Greeter',
+ *         components: {
+ *             greeter: {class: Greeter}
+ *         },
+ *         bootstrap: ['greeter']
+ *     }))
+ *     .onLaunched(async (app, logger): Promise<void> => {
+ *         const greeter: Greeter = await app.getObject<Greeter>('greeter')
+ *         logger.info(greeter.greet(app.appName))
+ *     })
+ *     .onDone((app, logger, reason): void => logger.info('Exiting with the code %d', reason.code))
+ *     .onFatalException((error, logger): number => {
+ *         logger.error(error)
+ *         return 2
+ *     })
+ * ```
+ */
+class Application extends Module_js_1.Module {
+    constructor() {
+        super(...arguments);
+        /**
+         * The class reading the application options, which also applies its identity (ID, name, time zone, mode).
+         * @protected
+         */
+        this.ConfigLoader = ApplicationConfigLoader_js_1.ApplicationConfigLoader;
+        /**
+         * The application's own declarations: a copy of the preset options (see `preset()`), the options given to `run()`
+         * being merged over them.
+         * @protected
+         */
+        this.options = Application.copyPresetOptions();
+    }
+    /**
+     * The emitter of the lifecycle events, shared by the application class.
+     * @protected
+     */
+    static { this.eventEmitter = new EventEmitter_js_1.SynchronousEventEmitter(); }
+    /**
+     * The environment variables given by `env()`, set at launch.
+     * @protected
+     */
+    static { this.environmentVariableMap = new Map(); }
+    /**
+     * The path aliases given by `alias()`, registered at launch.
+     * @protected
+     */
+    static { this.aliasDeclarations = []; }
+    /**
+     * Whether the launch of the application started (the calls of the fluent API after it do not launch it again)
+     * @protected
+     */
+    static { this.launchStarted = false; }
+    /**
+     * The options preset for the applications, see `preset()`.
+     * @protected
+     */
+    static { this.presetOptions = {}; }
+    /**
+     * The logger of the applications without "log" component
+     * @private
+     */
+    static #consoleLogger;
+    /**
+     * Preset the options of the applications, before they run: the packages assembling the framework preset their
+     * components (the `lakutata` package presets its Logger as `log` and its Entrypoint as `entrypoint`). An object
+     * given to `run()` under a preset name replaces the preset one when it gives its class, or completes its options
+     * when it gives none (`log: {level: 'debug'}`); the preset bootstrap steps run first. Each call adds to the preset:
+     * its components, providers and named objects replace the preset ones of the same name, its anonymous objects and
+     * bootstrap steps are appended. Does not launch the application.
+     * @param options The objects and bootstrap steps to preset.
+     * @returns The application class, to chain the other calls.
+     * @example
+     * ```typescript
+     * import {Application, Component} from 'lakutata'
+     *
+     * class Metrics extends Component {
+     * }
+     *
+     * //Every application of this process gets the "metrics" component, started at launch
+     * Application.preset({
+     *     components: {
+     *         metrics: {class: Metrics}
+     *     },
+     *     bootstrap: ['metrics']
+     * })
+     * ```
+     */
+    static preset(options) {
+        const preset = this.presetOptions;
+        if (options.components)
+            Reflect.set(preset, 'components', { ...preset.components, ...options.components });
+        if (options.providers)
+            Reflect.set(preset, 'providers', { ...preset.providers, ...options.providers });
+        if (options.objects)
+            Reflect.set(preset, 'objects', {
+                named: { ...preset.objects?.named, ...options.objects.named },
+                anonymous: [...(preset.objects?.anonymous ?? []), ...(options.objects.anonymous ?? [])]
+            });
+        if (options.bootstrap)
+            Reflect.set(preset, 'bootstrap', [...new Set([...(preset.bootstrap ?? []), ...options.bootstrap])]);
+        return this;
+    }
+    /**
+     * The logger: the application's `log` component, or a console logger when there is no application or no `log`
+     * component.
+     * @returns The logger.
+     * @protected
+     */
+    static async getLogger() {
+        return this.appInstance ? await this.appInstance.getLogger() : await this.getConsoleLogger();
+    }
+    /**
+     * The console logger ({@link ConsoleLogger}), created once.
+     * @returns The console logger.
+     * @protected
+     */
+    static getConsoleLogger() {
+        if (!this.#consoleLogger)
+            this.#consoleLogger = new Container_js_1.Container().set(ConsoleLogger_js_1.ConsoleLogger);
+        return this.#consoleLogger;
+    }
+    /**
+     * Set environment variables, written to `process.env` at launch, before the options getter given to `run()` is
+     * called (it may read them). Each call adds to the previous ones.
+     * @param env The variables, by name; the values are strings.
+     * @returns The application class, to chain the other calls.
+     * @throws {InvalidMethodAcceptException} When a value is not a string.
+     */
+    static env(env) {
+        Object.keys(env).forEach((key) => this.environmentVariableMap.set(key, env[key]));
+        return this.launch();
+    }
+    /**
+     * Register path aliases at launch: an alias (`@data`) in a path given to `path.resolve()` of Node.js or to
+     * `app.alias.resolve()` is replaced with its path. The alias `@runtime` (the working directory) is
+     * registered by the application. An invalid alias name (`@` followed by letters and digits only) or an alias
+     * registered twice fails the launch (a fatal exception). Each call adds to the previous ones.
+     * @param alias The paths, by alias name (`{'@data': '/var/lib/app'}`).
+     * @param createIfNotExist Create the directories of the aliases which do not exist; false by default.
+     * @returns The application class, to chain the other calls.
+     * @throws {InvalidMethodAcceptException} When a path is not a string.
+     */
+    static alias(alias, createIfNotExist = false) {
+        this.aliasDeclarations.push({
+            alias: alias ? alias : {},
+            createIfNotExist: createIfNotExist
+        });
+        return this.launch();
+    }
+    /**
+     * Add a handler called once the application has launched (its bootstrap completed), or at once when it has
+     * launched already. An async handler is not awaited; its rejection is an unhandled rejection.
+     * @param handler The function called with the application and its logger.
+     * @returns The application class, to chain the other calls.
+     */
+    static onLaunched(handler) {
+        const launched = this.appInstance;
+        if (launched) {
+            //Added once the application has launched: called at once
+            void (async () => handler(launched, await launched.getLogger()))();
+            return this;
+        }
+        this.eventEmitter.once(ApplicationState.Launched, async (app) => handler(app, await app.getLogger()));
+        return this.launch();
+    }
+    /**
+     * Add a handler called when the application exits (`app.exit()`, a shutdown signal): it runs, awaited, before the
+     * entrypoints stop and the objects are destroyed, the application still working. A handler failing makes the
+     * process exit with the code 1.
+     * @param handler The function called with the application, its logger and why it exits (its exit code, the
+     * signal ending it).
+     * @returns The application class, to chain the other calls.
+     */
+    static onDone(handler) {
+        this.eventEmitter.once(ApplicationState.Done, async (app, reason) => handler(app, await app.getLogger(), reason));
+        return this.launch();
+    }
+    /**
+     * Add a handler of the process' uncaught exceptions (`process.on('uncaughtException')`), the application keeping
+     * running. Without handler, the exception is logged as a warning. Every handler added is called.
+     * @param handler The function called with the error and the logger.
+     * @returns The application class, to chain the other calls.
+     */
+    static onUncaughtException(handler) {
+        this.eventEmitter.on(ApplicationState.UncaughtException, async (error) => {
+            const logger = await this.getLogger();
+            await handler(error, logger);
+        });
+        return this.launch();
+    }
+    /**
+     * Set the handler of a fatal exception: an error stopping the launch (invalid options or aliases, an object failing
+     * to initialize, a bootstrap step failing). The process exits after it, with the code it returns (1 when it returns
+     * none). Without handler, the error is logged and the process exits with the code 1. Only the first handler added
+     * is called.
+     * @param handler The function called with the error and the logger, returning the exit code.
+     * @returns The application class, to chain the other calls.
+     */
+    static onFatalException(handler) {
+        this.eventEmitter.once(ApplicationState.FatalException, async (error) => {
+            const logger = await this.getLogger();
+            let exitCode = await handler(error, logger);
+            if (typeof exitCode !== 'number')
+                exitCode = 1;
+            return (0, EndProcess_js_1.endProcess)(exitCode);
+        });
+        return this.launch();
+    }
+    static run(inp) {
+        Reflect.set(this, 'launchOptions', inp);
+        return this.launch();
+    }
+    /**
+     * Schedule the launch for the next turn of the event loop, replacing the launch already scheduled.
+     * @returns The application class.
+     * @protected
+     */
+    static launch() {
+        //Launched once: the calls after its launch started only add their handlers
+        if (this.launchStarted)
+            return this;
+        if (this.launchTimeout)
+            clearTimeout(this.launchTimeout);
+        this.launchTimeout = setTimeout(() => {
+            this.launchStarted = true;
+            process.on('uncaughtException', (error) => void this.processUncaughtException(error));
+            this.launchApplication()
+                .then((app) => Reflect.set(this, 'appInstance', app))
+                .catch((e) => this.processFatalException(e));
+        });
+        return this;
+    }
+    /**
+     * Handle an uncaught exception: the handlers of `onUncaughtException()`, else a warning of the logger (the console
+     * when the logger cannot be got).
+     * @param error The uncaught error.
+     * @returns Resolves once handled.
+     * @protected
+     */
+    static async processUncaughtException(error) {
+        if (this.eventEmitter.listenerCount(ApplicationState.UncaughtException)) {
+            this.eventEmitter.emit(ApplicationState.UncaughtException, error);
+            return;
+        }
+        const exception = new Error('UncaughtException', { cause: error });
+        try {
+            const logger = await this.getLogger();
+            logger.warn(exception);
+        }
+        catch (e) {
+            console.error(exception, e);
+        }
+    }
+    /**
+     * Handle a fatal exception: the handler of `onFatalException()`, else an error of the logger (the console when the
+     * logger cannot be got), then the process exits (with the code 1 by default, as Node.js on an uncaught exception):
+     * the application cannot run, and the objects already created (a server listening, a connection) would keep the
+     * process alive. Ignored once the process is ending.
+     * @param error The error.
+     * @protected
+     */
+    static processFatalException(error) {
+        //The errors of the code still running once the application is destroyed (it is ending)
+        if ((0, EndProcess_js_1.isEnding)())
+            return;
+        if (!this.eventEmitter.listenerCount(ApplicationState.FatalException)) {
+            return process.nextTick(async () => {
+                const exception = new Error('FatalException', { cause: error });
+                try {
+                    const logger = await this.getLogger();
+                    logger.error(exception);
+                }
+                catch (e) {
+                    console.error(exception, e);
+                }
+                return (0, EndProcess_js_1.endProcess)(1);
+            });
+        }
+        this.eventEmitter.emit(ApplicationState.FatalException, error);
+    }
+    /**
+     * End the application gracefully on the signals: its exit (the done handlers, the requests running complete, the
+     * objects destroyed, the code 0); a second signal, or a signal received while it launches, ends the process at
+     * once with the code 128 + the signal number.
+     * @param signals The signals to listen to.
+     * @protected
+     */
+    static listenShutdownSignals(signals) {
+        let ending = false;
+        for (const signal of signals) {
+            process.on(signal, () => {
+                const code = 128 + (node_os_1.constants.signals[signal] ?? 0);
+                if (ending || !this.appInstance)
+                    return process.exit(code);
+                ending = true;
+                //The exit of the application, ended by the signal
+                this.eventEmitter.emit('exit', this.appInstance, 0, signal);
+            });
+        }
+    }
+    /**
+     * Launch the application: environment variables, aliases, options (or the database migration command given by the
+     * `MIGRATION_*` environment variables), then the application created in a new root container.
+     * @returns The application, once its bootstrap has completed.
+     * @protected
+     */
+    static async launchApplication() {
+        this.eventEmitter.once('exit', async (app, exitCode, signal) => {
+            try {
+                //The done handler, told why the application exits
+                const reason = signal ? { code: exitCode ? exitCode : 0, signal: signal } : { code: exitCode ? exitCode : 0 };
+                await this.eventEmitter.emitRequest(ApplicationState.Done, app, reason);
+                await rootContainer.destroy();
+                (0, EndProcess_js_1.endProcess)(exitCode ? exitCode : 0);
+            }
+            catch (e) {
+                (0, EndProcess_js_1.endProcess)(1);
+            }
+        });
+        this.environmentVariableMap.forEach((value, key) => process.env[key] = value);
+        //Alias registration must be done before application container create
+        const aliasManager = Alias_js_1.Alias.getAliasInstance();
+        aliasManager.set('@runtime', process.cwd());
+        this.aliasDeclarations.forEach(aliasDeclaration => {
+            const aliases = aliasDeclaration.alias;
+            const createIfNotExist = aliasDeclaration.createIfNotExist;
+            Object.keys(aliases).forEach((aliasName) => {
+                aliasManager.set(aliasName, aliases[aliasName]);
+                if (createIfNotExist) {
+                    const realPath = node_path_1.default.resolve(aliasName);
+                    if (!(0, node_fs_1.existsSync)(realPath))
+                        (0, fs_1.mkdirSync)(node_path_1.default.resolve(aliasName), { recursive: true });
+                }
+            });
+        });
+        const options = typeof this.launchOptions === 'object' ? this.launchOptions : await this.launchOptions();
+        //The commands of the migrations of the databases: the application connects its databases, does the command and exits
+        let migrationCommand;
+        try {
+            migrationCommand = (0, MigrationCommand_js_1.readMigrationCommand)(process.env);
+        }
+        catch (error) {
+            //A command of the migrations fails with the code 1, the tools running it know it
+            console.error(error.message);
+            process.exit(1);
+        }
+        if (migrationCommand) {
+            this.eventEmitter.removeAllListeners(ApplicationState.Launched);
+            this.eventEmitter.removeAllListeners(ApplicationState.Done);
+            this.eventEmitter.removeAllListeners(ApplicationState.UncaughtException);
+            this.eventEmitter.removeAllListeners(ApplicationState.FatalException);
+            //The classes of the databases (the Database classes of the orm package) are recognized by the static lazy
+            //loaders of their providers (migrationGenerator, migrationExecutor), so core never references the orm package.
+            const loaderName = migrationCommand.action === 'generate' ? 'migrationGenerator' : 'migrationExecutor';
+            const getMigrationTargets = (input) => {
+                const migrationTargets = [];
+                for (const name in input) {
+                    const objectClass = input[name]?.class;
+                    if (typeof objectClass?.[loaderName] === 'function') {
+                        if (!input[name].options)
+                            continue;
+                        //A copy (the options given are not changed), with the entities given apart to a provider
+                        const entities = Array.isArray(input[name].entities) ? input[name].entities : [];
+                        const own = input[name].options.entities;
+                        const dataSourceOptions = {
+                            ...input[name].options,
+                            ...entities.length ? { entities: [...Array.isArray(own) ? own : Object.values(own ?? {}), ...entities] } : {},
+                            dataSourceName: name
+                        };
+                        migrationTargets.push({ dataSourceName: name, dataSourceOptions: dataSourceOptions, loader: objectClass[loaderName] });
+                    }
+                }
+                return migrationTargets;
+            };
+            let migrationTargets = [
+                ...(options.components ? getMigrationTargets(options.components) : []),
+                ...(options.providers ? getMigrationTargets(options.providers) : [])
+            ];
+            const names = migrationTargets.map((target) => target.dataSourceName).join(', ');
+            if (migrationCommand.database) {
+                migrationTargets = migrationTargets.filter((target) => target.dataSourceName === migrationCommand.database);
+                if (!migrationTargets.length) {
+                    console.error(`The application has no database ${migrationCommand.database} (${names || 'no Database component or provider'})`);
+                    process.exit(1);
+                }
+            }
+            if (!migrationTargets.length) {
+                //Nothing to generate; the other commands need a database
+                if (migrationCommand.action === 'generate')
+                    process.exit(0);
+                console.error('The application has no Database component or provider');
+                process.exit(1);
+            }
+            if (migrationCommand.action === 'revert' && migrationTargets.length > 1) {
+                console.error(`The application has several databases (${names}): MIGRATION_DATABASE selects the one whose last migration is reverted`);
+                process.exit(1);
+            }
+            options.bootstrap = [];
+            if (!options.providers)
+                options.providers = {};
+            for (let index = 0; index < migrationTargets.length; index++) {
+                const migrationTarget = migrationTargets[index];
+                const migrationProviderName = `Migration${index}${Date.now()}`;
+                const common = {
+                    class: await migrationTarget.loader(),
+                    exitProcess: index === migrationTargets.length - 1,
+                    dataSourceName: migrationTarget.dataSourceName,
+                    dataSource: migrationTarget.dataSourceOptions
+                };
+                options.providers[migrationProviderName] = migrationCommand.action === 'generate'
+                    ? { ...common, path: migrationCommand.path, outputJs: false }
+                    : { ...common, action: migrationCommand.action, transaction: migrationCommand.transaction, fake: migrationCommand.fake };
+                options.bootstrap.push(migrationProviderName);
+            }
+        }
+        const rootContainer = new Container_js_1.Container();
+        return new Promise((resolve, reject) => {
+            ApplicationOptions_js_1.ApplicationOptions
+                .validateAsync(options)
+                .then((applicationOptions) => {
+                if (applicationOptions.shutdownSignals)
+                    this.listenShutdownSignals(applicationOptions.shutdownSignals);
+                applicationOptions.bootstrap?.push(async (target) => {
+                    const launchedCallbackRemover = function () {
+                        this.options.bootstrap?.pop();
+                        (0, As_1.As)(Reflect.getOwnMetadata('#bootstrap', this))?.pop();
+                    };
+                    launchedCallbackRemover.bind((0, As_1.As)(target))();
+                    //The errors of the lifecycle of the objects (cascaded destruction, launched hooks) are reported through the application logger
+                    const logger = await (0, As_1.As)(target).getLogger();
+                    (0, LifecycleErrorReporter_js_1.setLifecycleErrorReporter)((error, message) => logger.warn(error, message));
+                    (0, ApplicationLaunch_js_1.markApplicationLaunched)(target);
+                    //The application launched is the one the signals end (its launched handlers may receive them)
+                    Reflect.set(this, 'appInstance', target);
+                    this.eventEmitter.emit(ApplicationState.Launched, (0, As_1.As)(target));
+                });
+                //Resolved once the application is initialized (its objects loaded, its bootstrap run), rejected with
+                //the error of its initialization (a fatal exception)
+                rootContainer
+                    .set(Application, { options: applicationOptions })
+                    .then(resolve)
+                    .catch(reject);
+            })
+                .catch(reject);
+        });
+    }
+    /**
+     * A copy of the preset options, for an application.
+     * @returns The copy.
+     * @protected
+     */
+    static copyPresetOptions() {
+        const preset = Application.presetOptions;
+        return {
+            ...(preset.components ? { components: { ...preset.components } } : {}),
+            ...(preset.providers ? { providers: { ...preset.providers } } : {}),
+            ...(preset.objects ? { objects: { named: { ...preset.objects.named }, anonymous: [...(preset.objects.anonymous ?? [])] } } : {}),
+            bootstrap: [...(preset.bootstrap ?? [])]
+        };
+    }
+    /**
+     * The logger of the application: its `log` component, or a console logger when it has none.
+     * @returns The logger.
+     * @protected
+     */
+    async getLogger() {
+        return this.container.has('log') ? (0, As_1.As)(await this.getObject('log')) : await Application.getConsoleLogger();
+    }
+    /**
+     * The path alias manager, shared by the process: `resolve()` replaces the aliases in a path, `get()`, `set()`,
+     * `has()` and `list()` manage them.
+     */
+    get alias() {
+        return Alias_js_1.Alias.getAliasInstance();
+    }
+    /**
+     * The ID of the application (its `id` option), readable before the application is created; "Unknown" until its
+     * options are loaded.
+     */
+    static get appId() {
+        return (0, BasicInfo_js_1.getAppId)();
+    }
+    /**
+     * The name of the application (its `name` option), readable before the application is created; "Unknown" until
+     * its options are loaded.
+     */
+    static get appName() {
+        return (0, BasicInfo_js_1.getAppName)();
+    }
+    /**
+     * The ID of the application (its `id` option).
+     */
+    get appId() {
+        return (0, BasicInfo_js_1.getAppId)();
+    }
+    /**
+     * The name of the application (its `name` option).
+     */
+    get appName() {
+        return (0, BasicInfo_js_1.getAppName)();
+    }
+    /**
+     * The time zone of the application: its `timezone` option, or the system's (`auto`); the `TZ` environment
+     * variable.
+     */
+    get timezone() {
+        return (0, BasicInfo_js_1.getBasicInfo)().timezone;
+    }
+    /**
+     * The time the process has been running, in seconds (rounded down).
+     */
+    get uptime() {
+        return Math.floor(process.uptime());
+    }
+    exit(forceOrExitCode) {
+        if (typeof forceOrExitCode === 'boolean' && forceOrExitCode) {
+            return process.exit(2);
+        }
+        else {
+            Application.eventEmitter.emit('exit', this, forceOrExitCode ? forceOrExitCode : 0);
+        }
+    }
+}
+exports.Application = Application;
+__decorate([
+    (0, Accept_js_1.Accept)(DTO_js_1.DTO.Object().pattern(DTO_js_1.DTO.String(), DTO_js_1.DTO.String()).required()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Object)
+], Application, "env", null);
+__decorate([
+    (0, Accept_js_1.Accept)(DTO_js_1.DTO.Object().pattern(DTO_js_1.DTO.String(), DTO_js_1.DTO.String()).required(), DTO_js_1.DTO.Boolean().optional().default(false)),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Boolean]),
+    __metadata("design:returntype", Object)
+], Application, "alias", null);
+(0, ApplicationLaunch_js_1.declareApplicationClass)(Application);

package/dist/cjs/lib/app/ApplicationConfigLoader.d.ts

@@ -0,0 +1,17 @@
+import { ModuleConfigLoader } from '../base/internal/ModuleConfigLoader.js';
+import { LoadObjectOptions } from '../../options/LoadObjectOptions.js';
+import { BaseObject } from '../base/BaseObject.js';
+import { ApplicationOptions } from '../../options/ApplicationOptions.js';
+import { Application } from './Application.js';
+/**
+ * Application configurations loader
+ */
+export declare class ApplicationConfigLoader extends ModuleConfigLoader {
+    /**
+     * Constructor
+     * @param app
+     * @param applicationOptions
+     * @param presetLoadOptions
+     */
+    constructor(app: Application, applicationOptions: ApplicationOptions, presetLoadOptions?: (LoadObjectOptions | typeof BaseObject | string)[]);
+}

package/dist/cjs/lib/app/ApplicationConfigLoader.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApplicationConfigLoader = void 0;
+const ModuleConfigLoader_js_1 = require("../base/internal/ModuleConfigLoader.js");
+const ApplicationOptions_js_1 = require("../../options/ApplicationOptions.js");
+const BasicInfo_js_1 = require("../foundation/BasicInfo.js");
+/**
+ * Application configurations loader
+ */
+class ApplicationConfigLoader extends ModuleConfigLoader_js_1.ModuleConfigLoader {
+    /**
+     * Constructor
+     * @param app
+     * @param applicationOptions
+     * @param presetLoadOptions
+     */
+    constructor(app, applicationOptions, presetLoadOptions = []) {
+        if (ApplicationOptions_js_1.ApplicationOptions.isValid(applicationOptions)) {
+            process.title = (0, BasicInfo_js_1.setBasicInfo)({
+                appId: applicationOptions.id,
+                appName: applicationOptions.name,
+                timezone: applicationOptions.timezone ? applicationOptions.timezone : 'auto',
+                //MODE, NODE_ENV, the options, development
+                mode: (0, BasicInfo_js_1.resolveMode)(applicationOptions.mode)
+            }).appId;
+        }
+        super(app, applicationOptions, presetLoadOptions);
+    }
+}
+exports.ApplicationConfigLoader = ApplicationConfigLoader;