libmodulor 0.25.0 → 0.27.0

package/dist/esm/target/node-express-server/NodeExpressServerManager.js

@@ -15,13 +15,15 @@ import https from 'node:https';
 import express, {} from 'express';
 import { inject, injectable } from 'inversify';
 import { NotCallableError } from '../../error/index.js';
+import { CustomerFacingErrorBuilder } from '../lib/server/CustomerFacingErrorBuilder.js';
 import { EntrypointsBuilder } from '../lib/server/EntrypointsBuilder.js';
 import { ServerRequestHandler } from '../lib/server/ServerRequestHandler.js';
 import { ServerSSLCertLoader } from '../lib/server/ServerSSLCertLoader.js';
-import { buildHandler, init, mountHandler, } from '../lib/server-express/funcs.js';
+import { buildHandler, init, mountHandler, postInit, } from '../lib/server-express/funcs.js';
 import { HelmetMiddlewareBuilder } from '../lib/server-express/HelmetMiddlewareBuilder.js';
 import { listen, stop } from '../lib/server-node/funcs.js';
 let NodeExpressServerManager = class NodeExpressServerManager {
+    customerFacingErrorBuilder;
     entrypointsBuilder;
     environmentManager;
     helmetMB;
@@ -32,7 +34,8 @@ let NodeExpressServerManager = class NodeExpressServerManager {
     ucManager;
     runtime;
     server;
-    constructor(entrypointsBuilder, environmentManager, helmetMB, logger, serverRequestHandler, serverSSLCertLoader, settingsManager, ucManager) {
+    constructor(customerFacingErrorBuilder, entrypointsBuilder, environmentManager, helmetMB, logger, serverRequestHandler, serverSSLCertLoader, settingsManager, ucManager) {
+        this.customerFacingErrorBuilder = customerFacingErrorBuilder;
         this.entrypointsBuilder = entrypointsBuilder;
         this.environmentManager = environmentManager;
         this.helmetMB = helmetMB;
@@ -83,7 +86,7 @@ let NodeExpressServerManager = class NodeExpressServerManager {
         await stop(this.server, this.settingsManager);
     }
     async warmUp() {
-        // Nothing to do
+        postInit(this.runtime, this.customerFacingErrorBuilder);
     }
     async createServer() {
         const port = this.s().server_binding_port;
@@ -102,15 +105,17 @@ let NodeExpressServerManager = class NodeExpressServerManager {
 };
 NodeExpressServerManager = __decorate([
     injectable(),
-    __param(0, inject(EntrypointsBuilder)),
-    __param(1, inject('EnvironmentManager')),
-    __param(2, inject(HelmetMiddlewareBuilder)),
-    __param(3, inject('Logger')),
-    __param(4, inject(ServerRequestHandler)),
-    __param(5, inject(ServerSSLCertLoader)),
-    __param(6, inject('SettingsManager')),
-    __param(7, inject('UCManager')),
-    __metadata("design:paramtypes", [EntrypointsBuilder, Object, HelmetMiddlewareBuilder, Object, ServerRequestHandler,
+    __param(0, inject(CustomerFacingErrorBuilder)),
+    __param(1, inject(EntrypointsBuilder)),
+    __param(2, inject('EnvironmentManager')),
+    __param(3, inject(HelmetMiddlewareBuilder)),
+    __param(4, inject('Logger')),
+    __param(5, inject(ServerRequestHandler)),
+    __param(6, inject(ServerSSLCertLoader)),
+    __param(7, inject('SettingsManager')),
+    __param(8, inject('UCManager')),
+    __metadata("design:paramtypes", [CustomerFacingErrorBuilder,
+        EntrypointsBuilder, Object, HelmetMiddlewareBuilder, Object, ServerRequestHandler,
         ServerSSLCertLoader, Object, Object])
 ], NodeExpressServerManager);
 export { NodeExpressServerManager };

package/dist/esm/target/node-hono-server/NodeHonoServerManager.d.ts

@@ -3,6 +3,7 @@ import type { AppManifest } from '../../app/index.js';
 import type { DirPath } from '../../dt/index.js';
 import type { Configurable, EnvironmentManager, Logger, SettingsManager } from '../../std/index.js';
 import type { UCDef, UCHTTPContract, UCInput, UCManager, UCOPIBase } from '../../uc/index.js';
+import { CustomerFacingErrorBuilder } from '../lib/server/CustomerFacingErrorBuilder.js';
 import { EntrypointsBuilder } from '../lib/server/EntrypointsBuilder.js';
 import type { ServerManager } from '../lib/server/ServerManager.js';
 import { ServerRequestHandler } from '../lib/server/ServerRequestHandler.js';
@@ -10,6 +11,7 @@ import { ServerSSLCertLoader } from '../lib/server/ServerSSLCertLoader.js';
 import type { ListenSettings, StopSettings } from '../lib/server-node/types.js';
 type S = ListenSettings & StopSettings;
 export declare class NodeHonoServerManager implements Configurable<S>, ServerManager {
+    private customerFacingErrorBuilder;
     private entrypointsBuilder;
     protected environmentManager: EnvironmentManager;
     private logger;
@@ -19,7 +21,7 @@ export declare class NodeHonoServerManager implements Configurable<S>, ServerMan
     private ucManager;
     protected runtime: Hono;
     private server;
-    constructor(entrypointsBuilder: EntrypointsBuilder, environmentManager: EnvironmentManager, logger: Logger, serverRequestHandler: ServerRequestHandler, serverSSLCertLoader: ServerSSLCertLoader, settingsManager: SettingsManager<S>, ucManager: UCManager);
+    constructor(customerFacingErrorBuilder: CustomerFacingErrorBuilder, entrypointsBuilder: EntrypointsBuilder, environmentManager: EnvironmentManager, logger: Logger, serverRequestHandler: ServerRequestHandler, serverSSLCertLoader: ServerSSLCertLoader, settingsManager: SettingsManager<S>, ucManager: UCManager);
     s(): S;
     getRuntime(): Hono;
     overrideUCManager(ucManager: UCManager): void;

package/dist/esm/target/node-hono-server/NodeHonoServerManager.js

@@ -16,12 +16,14 @@ import { createAdaptorServer } from '@hono/node-server';
 import { serveStatic } from '@hono/node-server/serve-static';
 import { inject, injectable } from 'inversify';
 import { NotCallableError } from '../../error/index.js';
+import { CustomerFacingErrorBuilder } from '../lib/server/CustomerFacingErrorBuilder.js';
 import { EntrypointsBuilder } from '../lib/server/EntrypointsBuilder.js';
 import { ServerRequestHandler } from '../lib/server/ServerRequestHandler.js';
 import { ServerSSLCertLoader } from '../lib/server/ServerSSLCertLoader.js';
 import { buildHandler, init, mountHandler } from '../lib/server-hono/funcs.js';
 import { listen, stop } from '../lib/server-node/funcs.js';
 let NodeHonoServerManager = class NodeHonoServerManager {
+    customerFacingErrorBuilder;
     entrypointsBuilder;
     environmentManager;
     logger;
@@ -31,7 +33,8 @@ let NodeHonoServerManager = class NodeHonoServerManager {
     ucManager;
     runtime;
     server;
-    constructor(entrypointsBuilder, environmentManager, logger, serverRequestHandler, serverSSLCertLoader, settingsManager, ucManager) {
+    constructor(customerFacingErrorBuilder, entrypointsBuilder, environmentManager, logger, serverRequestHandler, serverSSLCertLoader, settingsManager, ucManager) {
+        this.customerFacingErrorBuilder = customerFacingErrorBuilder;
         this.entrypointsBuilder = entrypointsBuilder;
         this.environmentManager = environmentManager;
         this.logger = logger;
@@ -57,7 +60,7 @@ let NodeHonoServerManager = class NodeHonoServerManager {
         this.ucManager = ucManager;
     }
     async init() {
-        this.runtime = init();
+        this.runtime = init(this.customerFacingErrorBuilder);
         await this.createServer();
     }
     initSync() {
@@ -106,14 +109,16 @@ let NodeHonoServerManager = class NodeHonoServerManager {
 };
 NodeHonoServerManager = __decorate([
     injectable(),
-    __param(0, inject(EntrypointsBuilder)),
-    __param(1, inject('EnvironmentManager')),
-    __param(2, inject('Logger')),
-    __param(3, inject(ServerRequestHandler)),
-    __param(4, inject(ServerSSLCertLoader)),
-    __param(5, inject('SettingsManager')),
-    __param(6, inject('UCManager')),
-    __metadata("design:paramtypes", [EntrypointsBuilder, Object, Object, ServerRequestHandler,
+    __param(0, inject(CustomerFacingErrorBuilder)),
+    __param(1, inject(EntrypointsBuilder)),
+    __param(2, inject('EnvironmentManager')),
+    __param(3, inject('Logger')),
+    __param(4, inject(ServerRequestHandler)),
+    __param(5, inject(ServerSSLCertLoader)),
+    __param(6, inject('SettingsManager')),
+    __param(7, inject('UCManager')),
+    __metadata("design:paramtypes", [CustomerFacingErrorBuilder,
+        EntrypointsBuilder, Object, Object, ServerRequestHandler,
         ServerSSLCertLoader, Object, Object])
 ], NodeHonoServerManager);
 export { NodeHonoServerManager };

package/dist/esm/target/node-stricli-cli/NodeStricliCLIManager.d.ts

@@ -1,12 +1,14 @@
 import { WordingManager } from '../../i18n/index.js';
 import { type ProductManifest, ProductUCsLoader } from '../../product/index.js';
+import type { I18nManager } from '../../std/index.js';
 import type { CLIManager, Input, Output } from '../lib/cli/CLIManager.js';
 import { CommandExecutor } from '../lib/cli/CommandExecutor.js';
 export declare class NodeStricliCLIManager implements CLIManager {
     private commandExecutor;
+    private i18nManager;
     private productManifest;
     private productUCsLoader;
     private wordingManager;
-    constructor(commandExecutor: CommandExecutor, productManifest: ProductManifest, productUCsLoader: ProductUCsLoader, wordingManager: WordingManager);
+    constructor(commandExecutor: CommandExecutor, i18nManager: I18nManager, productManifest: ProductManifest, productUCsLoader: ProductUCsLoader, wordingManager: WordingManager);
     handleCommand({ appsRootPath, srcImporter, }: Input): Promise<Output>;
 }

package/dist/esm/target/node-stricli-cli/NodeStricliCLIManager.js

@@ -18,16 +18,19 @@ import { ucifHint, ucifIsMandatory, ucifRepeatability, ucMountingPoint, } from '
 import { CommandExecutor } from '../lib/cli/CommandExecutor.js';
 let NodeStricliCLIManager = class NodeStricliCLIManager {
     commandExecutor;
+    i18nManager;
     productManifest;
     productUCsLoader;
     wordingManager;
-    constructor(commandExecutor, productManifest, productUCsLoader, wordingManager) {
+    constructor(commandExecutor, i18nManager, productManifest, productUCsLoader, wordingManager) {
         this.commandExecutor = commandExecutor;
+        this.i18nManager = i18nManager;
         this.productManifest = productManifest;
         this.productUCsLoader = productUCsLoader;
         this.wordingManager = wordingManager;
     }
     async handleCommand({ appsRootPath, srcImporter, }) {
+        await this.i18nManager.init();
         const ucs = await this.productUCsLoader.exec({
             appsRootPath,
             srcImporter,
@@ -109,10 +112,11 @@ let NodeStricliCLIManager = class NodeStricliCLIManager {
 NodeStricliCLIManager = __decorate([
     injectable(),
     __param(0, inject(CommandExecutor)),
-    __param(1, inject('ProductManifest')),
-    __param(2, inject(ProductUCsLoader)),
-    __param(3, inject(WordingManager)),
-    __metadata("design:paramtypes", [CommandExecutor, Object, ProductUCsLoader,
+    __param(1, inject('I18nManager')),
+    __param(2, inject('ProductManifest')),
+    __param(3, inject(ProductUCsLoader)),
+    __param(4, inject(WordingManager)),
+    __metadata("design:paramtypes", [CommandExecutor, Object, Object, ProductUCsLoader,
         WordingManager])
 ], NodeStricliCLIManager);
 export { NodeStricliCLIManager };

package/dist/esm/testing/impl/NodeAppTesterConfigurator.d.ts

@@ -0,0 +1,15 @@
+import type { AppTesterConfigurator, AppTesterConfiguratorAuthSettersConfig, AppTesterConfiguratorInputFillers, AppTesterConfiguratorSideEffects, AppTesterConfiguratorSpecificAssertions } from '../AppTesterConfigurator.js';
+import type { AppTesterCtx } from '../ctx.js';
+import type { AppTesterFlow } from '../flow.js';
+export declare class NodeAppTesterConfigurator implements AppTesterConfigurator {
+    authSettersConfig(): Promise<AppTesterConfiguratorAuthSettersConfig | undefined>;
+    bindImplementations(ctx: AppTesterCtx): Promise<void>;
+    clearExecution(ctx: AppTesterCtx): Promise<void>;
+    flows(): Promise<AppTesterFlow[]>;
+    inputFillers(): Promise<AppTesterConfiguratorInputFillers | undefined>;
+    opts(): Promise<AppTesterCtx['opts']>;
+    seed(_ctx: AppTesterCtx): Promise<void>;
+    sideEffects(_ctx: AppTesterCtx): Promise<AppTesterConfiguratorSideEffects | undefined>;
+    specificAssertions(): Promise<AppTesterConfiguratorSpecificAssertions | undefined>;
+    updateSettings<S>(ctx: AppTesterCtx, settings: S): Promise<void>;
+}

package/dist/esm/testing/impl/NodeAppTesterConfigurator.js

@@ -0,0 +1,68 @@
+import { PRODUCT_NAME_PLACEHOLDER } from '../../convention.js';
+import { FakeClockManager } from '../../std/impl/FakeClockManager.js';
+import { FakeFSManager } from '../../std/impl/FakeFSManager.js';
+import { FakeHTTPAPICallExecutor } from '../../std/impl/FakeHTTPAPICallExecutor.js';
+import { NodeDeterministicCryptoManager } from '../../std/impl/NodeDeterministicCryptoManager.js';
+import { SimpleFormDataBuilder } from '../../std/impl/SimpleFormDataBuilder.js';
+import { bindCommon } from '../../utils/ioc/bindCommon.js';
+import { bindNodeCore } from '../../utils/ioc/bindNodeCore.js';
+import { bindServer } from '../../utils/ioc/bindServer.js';
+export class NodeAppTesterConfigurator {
+    async authSettersConfig() {
+        return undefined;
+    }
+    async bindImplementations(ctx) {
+        const { container } = ctx;
+        bindCommon(container);
+        bindNodeCore(container);
+        bindServer(container);
+        (await container.rebind('ProductManifest')).toConstantValue({
+            appReg: [{ name: ctx.appManifest.name }],
+            name: PRODUCT_NAME_PLACEHOLDER,
+        });
+        (await container.rebind('ClockManager')).to(FakeClockManager);
+        (await container.rebind('CryptoManager'))
+            .to(NodeDeterministicCryptoManager)
+            .inSingletonScope();
+        (await container.rebind('FSManager'))
+            .to(FakeFSManager)
+            .inSingletonScope();
+        (await container.rebind('FormDataBuilder')).to(SimpleFormDataBuilder);
+        (await container.rebind('HTTPAPICallExecutor'))
+            .to(FakeHTTPAPICallExecutor)
+            .inSingletonScope();
+    }
+    async clearExecution(ctx) {
+        const { container } = ctx;
+        await container.get('CryptoManager').clear();
+        await container.get('EmailManager').clear();
+        await container.get('JobManager').clear();
+        await container.get('UCDataStore').clear();
+    }
+    async flows() {
+        return [];
+    }
+    async inputFillers() {
+        return undefined;
+    }
+    async opts() {
+        return undefined;
+    }
+    async seed(_ctx) {
+        // Nothing to do
+    }
+    async sideEffects(_ctx) {
+        return undefined;
+    }
+    async specificAssertions() {
+        return undefined;
+    }
+    async updateSettings(ctx, settings) {
+        const { container } = ctx;
+        const current = container.get('Settings');
+        (await container.rebind('Settings')).toConstantValue({
+            ...current,
+            ...settings,
+        });
+    }
+}

package/dist/esm/testing/impl/VitestAppTestSuiteEmitter.d.ts

@@ -4,4 +4,6 @@ export declare class VitestAppTestSuiteEmitter implements AppTestSuiteEmitter {
     private fsManager;
     constructor(fsManager: FSManager);
     exec({ appPath, depsMapping, idx, monkeyTestingTimeoutInMs, serverPortRangeStart, }: Input): Promise<Output>;
+    private createConfiguratorIfNotExists;
+    private mapDeps;
 }

package/dist/esm/testing/impl/VitestAppTestSuiteEmitter.js

@@ -11,7 +11,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 import { inject, injectable } from 'inversify';
-import { APP_I18N_NAME, APP_INDEX_NAME, APP_MANIFEST_NAME, APP_TEST_DIR_NAME, APP_TEST_MAIN_FILE_NAME, } from '../../convention.js';
+import { APP_I18N_NAME, APP_INDEX_NAME, APP_MANIFEST_NAME, APP_TEST_CONFIGURATOR_FILE_NAME, APP_TEST_CONFIGURATOR_NAME, APP_TEST_DIR_NAME, APP_TEST_MAIN_FILE_NAME, } from '../../convention.js';
 let VitestAppTestSuiteEmitter = class VitestAppTestSuiteEmitter {
     fsManager;
     constructor(fsManager) {
@@ -21,16 +21,29 @@ let VitestAppTestSuiteEmitter = class VitestAppTestSuiteEmitter {
         const testPath = this.fsManager.path(appPath, APP_TEST_DIR_NAME);
         // Since we're using 'recursive: true', there will be no error if the directory already exists
         await this.fsManager.mkdir(testPath, { recursive: true });
-        const outPath = this.fsManager.path(testPath, APP_TEST_MAIN_FILE_NAME);
-        let tpl = template(serverPortRangeStart, idx, monkeyTestingTimeoutInMs);
-        depsMapping?.forEach((to, from) => {
-            tpl = tpl.replaceAll(`from '${from}'`, `from '${to}'`);
-        });
-        await this.fsManager.touch(outPath, tpl);
+        await this.createConfiguratorIfNotExists(testPath, depsMapping);
+        const testFilePath = this.fsManager.path(testPath, APP_TEST_MAIN_FILE_NAME);
+        const tpl = this.mapDeps(depsMapping, template(serverPortRangeStart, idx, monkeyTestingTimeoutInMs));
+        await this.fsManager.touch(testFilePath, tpl);
         return {
-            outPath,
+            outPath: testFilePath,
         };
     }
+    async createConfiguratorIfNotExists(testPath, depsMapping) {
+        const filePath = this.fsManager.path(testPath, APP_TEST_CONFIGURATOR_FILE_NAME);
+        if (await this.fsManager.exists(filePath)) {
+            return;
+        }
+        const tpl = this.mapDeps(depsMapping, CONFIGURATOR_TS);
+        await this.fsManager.touch(filePath, tpl);
+    }
+    mapDeps(depsMapping, tpl) {
+        let res = tpl;
+        depsMapping?.forEach((to, from) => {
+            res = res.replaceAll(`from '${from}'`, `from '${to}'`);
+        });
+        return res;
+    }
 };
 VitestAppTestSuiteEmitter = __decorate([
     injectable(),
@@ -38,6 +51,10 @@ VitestAppTestSuiteEmitter = __decorate([
     __metadata("design:paramtypes", [Object])
 ], VitestAppTestSuiteEmitter);
 export { VitestAppTestSuiteEmitter };
+const CONFIGURATOR_TS = `import { NodeAppTesterConfigurator } from 'libmodulor/node-test';
+
+export class ${APP_TEST_CONFIGURATOR_NAME} extends NodeAppTesterConfigurator {}
+`;
 // For now, we can have it here. When it becomes harder to maintain, we can introduce some kind of template engine.
 // Be aware that this will introduce complexities on building the lib.
 // We'll need to include these templates in the build and make them accessible via package.json "exports" or any other mechanism.
@@ -72,10 +89,10 @@ import {
 import { newNodeAppTester } from 'libmodulor/node-test';
 import { afterAll, afterEach, beforeAll, describe, expect, test } from 'vitest';
 
-import { Configurator } from './Configurator.js';
+import { ${APP_TEST_CONFIGURATOR_NAME} } from './${APP_TEST_CONFIGURATOR_NAME}.js';
 
 const appPath = join(import.meta.dirname, '..');
-const configurator = new Configurator();
+const configurator = new ${APP_TEST_CONFIGURATOR_NAME}();
 const runner = await newNodeAppTester(${serverPortRangeStart}, ${idx}, {
     appPath,
     configurator,

package/dist/esm/testing/impl/newNodeAppTester.js

@@ -5,7 +5,7 @@ import { TARGET_DEFAULT_SERVER_MANAGER_SETTINGS } from '../../target/lib/server/
 import { NodeExpressServerManager } from '../../target/node-express-server/NodeExpressServerManager.js';
 import { FAKE_USER_ADMIN, FAKE_USER_REGULAR } from '../../uc/index.js';
 import { CONTAINER_OPTS } from '../../utils/index.js';
-import { bindCommon } from '../../utils/ioc/bindCommon.js';
+import { bindCommon, updateSettings } from '../../utils/ioc/bindCommon.js';
 import { bindNodeCore } from '../../utils/ioc/bindNodeCore.js';
 import { bindServer } from '../../utils/ioc/bindServer.js';
 import { AppTester } from '../AppTester.js';
@@ -18,8 +18,6 @@ export async function newNodeAppTester(serverPortRangeStart, idx, args) {
     const settings = {
         ...STD_DEFAULT_JWT_MANAGER_SETTINGS,
         ...TARGET_DEFAULT_SERVER_MANAGER_SETTINGS,
-        jwt_manager_audience: 'libmodulor-test',
-        jwt_manager_issuer: 'libmodulor-test',
         jwt_manager_secret: new TPassword().example(),
         logger_level,
         server_basic_auth_entries: {
@@ -31,7 +29,8 @@ export async function newNodeAppTester(serverPortRangeStart, idx, args) {
         server_stop_mode: 'aggressive',
     };
     const container = new Container(CONTAINER_OPTS);
-    bindCommon(container, () => settings);
+    bindCommon(container);
+    updateSettings(container, settings);
     bindNodeCore(container);
     bindServer(container);
     container.bind('AppDocsEmitter').to(SimpleAppDocsEmitter);

package/dist/esm/testing/opts.d.ts

@@ -43,7 +43,7 @@ export type AppTesterOpts = Partial<Pick<LoggerSettings, 'logger_level'>> & {
                  */
                 aliasPrefix?: AppTesterOptsAliasPrefix;
                 /**
-                 * @defaultValue ['fik-sdk', 'inversify']
+                 * @defaultValue ['libmodulor', 'inversify']
                  */
                 allowed?: AppTesterOptsImportsList;
             };

package/dist/esm/utils/ioc/bindCommon.d.ts

@@ -1,6 +1,6 @@
 import type { Container } from 'inversify';
-import { type LoggerSettings, type Settings } from '../../std/index.js';
+import { type LoggerSettings } from '../../std/index.js';
 import { type UCSettings } from '../../uc/index.js';
-export type CommonSettings = LoggerSettings & UCSettings;
-export type SettingsFunc<S extends Settings> = (commonSettings: CommonSettings) => S & Partial<CommonSettings>;
-export declare function bindCommon<S extends Settings = object>(container: Container, settingsFunc?: SettingsFunc<S>): void;
+export type S = LoggerSettings & UCSettings;
+export declare function bindCommon(container: Container): void;
+export declare function updateSettings<SOverride>(container: Container, settings: Partial<S & SOverride>): void;

package/dist/esm/utils/ioc/bindCommon.js

@@ -17,22 +17,17 @@ import { SimpleUCManager } from '../../uc/impl/SimpleUCManager.js';
 import { StaticUCClientConfirmManager } from '../../uc/impl/StaticUCClientConfirmManager.js';
 import { UC_DEFAULT_SETTINGS, } from '../../uc/index.js';
 import { bindProvider } from './bindProvider.js';
-export function bindCommon(container, settingsFunc) {
-    const commonSettings = {
+export function bindCommon(container) {
+    // settings
+    container.bind('Settings').toConstantValue({
         ...STD_DEFAULT_LOGGER_SETTINGS,
         ...UC_DEFAULT_SETTINGS,
-    };
-    const settings = {
-        ...commonSettings,
-        ...settingsFunc?.(commonSettings),
-    };
+    });
     // product
-    if (!container.isBound('ProductManifest')) {
-        container.bind('ProductManifest').toConstantValue({
-            appReg: [{ name: APP_NAME_PLACEHOLDER }],
-            name: PRODUCT_NAME_PLACEHOLDER,
-        });
-    }
+    container.bind('ProductManifest').toConstantValue({
+        appReg: [{ name: APP_NAME_PLACEHOLDER }],
+        name: PRODUCT_NAME_PLACEHOLDER,
+    });
     // std
     container.bind('ClockManager').to(StdDateClockManager);
     container
@@ -51,10 +46,10 @@ export function bindCommon(container, settingsFunc) {
         .inSingletonScope();
     container.bind('I18n').toConstantValue({ en: {} });
     container.bind('Logger').to(ConsoleLogger);
-    container.bind('Settings').toConstantValue(settings);
     container
         .bind('SettingsManager')
-        .to(StaticSettingsManager);
+        .to(StaticSettingsManager)
+        .inSingletonScope();
     container
         .bind('ServerClientManager')
         .to(SettingsServerClientManager);
@@ -73,3 +68,10 @@ export function bindCommon(container, settingsFunc) {
     container.bind('UCManager').to(SimpleUCManager).inRequestScope();
     container.bind('UCTransporter').to(HTTPUCTransporter);
 }
+export function updateSettings(container, settings) {
+    const current = container.get('Settings');
+    container.rebindSync('Settings').toConstantValue({
+        ...current,
+        ...settings,
+    });
+}

package/dist/esm/utils/ioc/bindNodeCore.js

@@ -1,3 +1,4 @@
+import { EnvSettingsManager } from '../../std/impl/EnvSettingsManager.js';
 import { NodeBufferManager } from '../../std/impl/NodeBufferManager.js';
 import { NodeCryptoManager } from '../../std/impl/NodeCryptoManager.js';
 import { NodeEnvironmentManager } from '../../std/impl/NodeEnvironmentManager.js';
@@ -14,4 +15,8 @@ export function bindNodeCore(container) {
     container
         .rebindSync('FormDataBuilder')
         .to(NodeFormDataBuilder);
+    container
+        .rebindSync('SettingsManager')
+        .to(EnvSettingsManager)
+        .inSingletonScope();
 }

package/dist/esm/utils/ioc/bindServer.js

@@ -3,7 +3,13 @@ import { FakeJobManager } from '../../std/impl/FakeJobManager.js';
 import { JoseJWTManager } from '../../std/impl/JoseJWTManager.js';
 export function bindServer(container) {
     // std
-    container.bind('EmailManager').to(FakeEmailManager);
+    container
+        .bind('EmailManager')
+        .to(FakeEmailManager)
+        .inSingletonScope();
     container.bind('JWTManager').to(JoseJWTManager);
-    container.bind('JobManager').to(FakeJobManager);
+    container
+        .bind('JobManager')
+        .to(FakeJobManager)
+        .inSingletonScope();
 }

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "libmodulor",
     "description": "A TypeScript library to create platform-agnostic applications",
-    "version": "0.25.0",
+    "version": "0.27.0",
     "license": "LGPL-3.0",
     "author": "Chafik H'nini <chafik.hnini@gmail.com>",
     "homepage": "https://libmodulor.c100k.eu",
@@ -90,42 +90,43 @@
             "import": "./dist/esm/index.webpack.js"
         }
     },
-    "bin": "./dist/esm/products/Helper/index.js",
+    "bin": "./dist/esm/products/Helper/targets/node-core-cli/index.js",
     "scripts": {
         "lint": "biome check --write .",
-        "lint:ci": "biome check"
+        "lint:ci": "biome check",
+        "test": "tsc && vitest run"
     },
     "devDependencies": {
-        "@biomejs/biome": "^2.3.10",
+        "@biomejs/biome": "^2.3.14",
         "@react-native-community/slider": "^4.5.7",
-        "@types/react": "^19.2.7",
+        "@types/react": "^19.2.11",
         "@types/react-dom": "^19.2.3",
         "babel-plugin-parameter-decorator": "^1.0.16",
         "babel-plugin-transform-typescript-metadata": "^0.3.2",
-        "expo": "^54.0.29",
+        "expo": "55.0.0-preview.9",
         "expo-document-picker": "~14.0.8",
         "expo-image-picker": "^17.0.10",
-        "wrangler": "^4.55.0"
+        "wrangler": "^4.62.0"
     },
     "peerDependencies": {
-        "@hono/node-server": "^1.19.7",
-        "@modelcontextprotocol/sdk": "^1.25.1",
-        "@stricli/core": "^1.2.4",
+        "@hono/node-server": "^1.19.9",
+        "@modelcontextprotocol/sdk": "^1.25.3",
+        "@stricli/core": "^1.2.5",
         "buffer": "^6.0.3",
         "cookie-parser": "^1.4.7",
         "express": "^5.2.1",
         "express-fileupload": "^1.5.2",
-        "fast-check": "^4.4.0",
+        "fast-check": "^4.5.3",
         "helmet": "^8.1.0",
-        "hono": "^4.11.1",
-        "inversify": "^7.10.7",
+        "hono": "^4.11.7",
+        "inversify": "^7.11.0",
         "jose": "^6.1.3",
         "knex": "^3.1.0",
-        "next": "^15.5.9",
-        "pg": "^8.16.3",
-        "react": "^19.2.3",
-        "react-dom": "^19.2.3",
-        "react-native": "^0.81.5",
+        "next": "^15.5.12",
+        "pg": "^8.18.0",
+        "react": "^19.2.4",
+        "react-dom": "^19.2.4",
+        "react-native": "^0.83.1",
         "reflect-metadata": "^0.2.2",
         "sqlite3": "^5.1.7",
         "typescript": "^5.9.3",

package/pnpm-workspace.yaml

@@ -1,8 +0,0 @@
-minimumReleaseAge: 2880
-onlyBuiltDependencies:
-  - '@biomejs/biome'
-  - '@tailwindcss/oxide'
-  - esbuild
-  - sharp
-  - sqlite3
-  - workerd

package/tsconfig.build.examples.json

@@ -1,8 +0,0 @@
-{
-    "compilerOptions": {
-        "noEmit": false,
-        "outDir": "dist-examples"
-    },
-    "extends": "./tsconfig.json",
-    "include": ["examples"]
-}

package/tsconfig.json

@@ -1,36 +0,0 @@
-{
-    "compilerOptions": {
-        "allowJs": true,
-        "allowSyntheticDefaultImports": true,
-        "allowUnreachableCode": false,
-        "allowUnusedLabels": false,
-        "declaration": true,
-        "emitDecoratorMetadata": true,
-        "exactOptionalPropertyTypes": true,
-        "experimentalDecorators": true,
-        "jsx": "react-jsx",
-        "lib": ["dom", "dom.iterable", "esnext"],
-        "module": "NodeNext",
-        "moduleResolution": "NodeNext",
-        "noEmit": true,
-        "noFallthroughCasesInSwitch": true,
-        "noImplicitOverride": true,
-        "noImplicitReturns": true,
-        "noPropertyAccessFromIndexSignature": true,
-        "noUncheckedIndexedAccess": true,
-        "noUnusedLocals": true,
-        "noUnusedParameters": true,
-        "skipLibCheck": true,
-        "sourceMap": true,
-        "strict": true,
-        "target": "ESNext",
-        "verbatimModuleSyntax": true
-    },
-    "exclude": [
-        "dist",
-        "dist-examples",
-        "examples/**/dist",
-        "examples/**/node_modules",
-        "node_modules"
-    ]
-}

package/vitest.config.ts

@@ -1,16 +0,0 @@
-import { loadEnv } from 'vite';
-import { defineConfig } from 'vitest/config';
-
-export default defineConfig(({ mode }) => ({
-    test: {
-        coverage: {
-            exclude: ['src/apps/**/test', 'src/**/*.test.ts'],
-            include: ['src'],
-            reporter: ['html', 'lcov', 'text'],
-            reportOnFailure: false,
-        },
-        env: loadEnv(mode, process.cwd(), ''),
-        exclude: ['**/node_modules/**', '**/dist/**', '**/dist-examples/**'],
-        reporters: ['verbose'],
-    },
-}));