libmodulor 0.11.1 → 0.12.0

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

@@ -16,42 +16,29 @@ import cookieParser from 'cookie-parser';
 import express, {} from 'express';
 import fileUpload from 'express-fileupload';
 import { inject, injectable } from 'inversify';
+import { stop } from '../lib/server-node/stop.js';
 import { EntrypointsBuilder } from '../lib/server/EntrypointsBuilder.js';
-import { AuthenticationCheckerMiddlewareBuilder } from './middlewares/AuthenticationCheckerMiddlewareBuilder.js';
-import { ErrorMiddlewareBuilder } from './middlewares/ErrorMiddlewareBuilder.js';
+import { ServerRequestHandler, } from '../lib/server/ServerRequestHandler.js';
+import { ServerSSLCertLoader } from '../lib/server/ServerSSLCertLoader.js';
 import { HelmetMiddlewareBuilder } from './middlewares/HelmetMiddlewareBuilder.js';
-import { PublicApiKeyCheckerMiddlewareBuilder } from './middlewares/PublicApiKeyCheckerMiddlewareBuilder.js';
-import { RequestCheckerMiddlewareBuilder } from './middlewares/RequestCheckerMiddlewareBuilder.js';
-import { RequestHandlerMiddlewareBuilder } from './middlewares/RequestHandlerMiddlewareBuilder.js';
-import { RequestLoggerMiddlewareBuilder } from './middlewares/RequestLoggerMiddlewareBuilder.js';
 let NodeExpressServerManager = class NodeExpressServerManager {
-    authenticationCheckerMB;
     entrypointsBuilder;
     environmentManager;
-    errorMB;
-    fsManager;
     helmetMB;
     logger;
-    publicApiKeyCheckerMB;
-    requestCheckerMB;
-    requestHandlerMB;
-    requestLoggerMB;
+    serverRequestHandler;
+    serverSSLCertLoader;
     settingsManager;
     ucManager;
     runtime;
     server;
-    constructor(authenticationCheckerMB, entrypointsBuilder, environmentManager, errorMB, fsManager, helmetMB, logger, publicApiKeyCheckerMB, requestCheckerMB, requestHandlerMB, requestLoggerMB, settingsManager, ucManager) {
-        this.authenticationCheckerMB = authenticationCheckerMB;
+    constructor(entrypointsBuilder, environmentManager, helmetMB, logger, serverRequestHandler, serverSSLCertLoader, settingsManager, ucManager) {
         this.entrypointsBuilder = entrypointsBuilder;
         this.environmentManager = environmentManager;
-        this.errorMB = errorMB;
-        this.fsManager = fsManager;
         this.helmetMB = helmetMB;
         this.logger = logger;
-        this.publicApiKeyCheckerMB = publicApiKeyCheckerMB;
-        this.requestCheckerMB = requestCheckerMB;
-        this.requestHandlerMB = requestHandlerMB;
-        this.requestLoggerMB = requestLoggerMB;
+        this.serverRequestHandler = serverRequestHandler;
+        this.serverSSLCertLoader = serverSSLCertLoader;
         this.settingsManager = settingsManager;
         this.ucManager = ucManager;
     }
@@ -60,8 +47,6 @@ let NodeExpressServerManager = class NodeExpressServerManager {
             logger_level: this.settingsManager.get()('logger_level'),
             server_binding_host: this.settingsManager.get()('server_binding_host'),
             server_binding_port: this.settingsManager.get()('server_binding_port'),
-            server_ssl_fullchain_path: this.settingsManager.get()('server_ssl_fullchain_path'),
-            server_ssl_key_path: this.settingsManager.get()('server_ssl_key_path'),
             server_tmp_path: this.settingsManager.get()('server_tmp_path'),
         };
     }
@@ -88,29 +73,29 @@ let NodeExpressServerManager = class NodeExpressServerManager {
         this.runtime.use(express.json());
         this.runtime.use(express.urlencoded({ extended: true }));
         this.runtime.use(cookieParser());
-        this.runtime.use(this.requestLoggerMB.exec({}));
-        this.runtime.use(this.requestCheckerMB.exec({}));
         await this.createServer();
     }
     async mount(appManifest, ucd, contract) {
-        const { sec } = ucd;
         const { envelope, method, path, pathAliases } = contract;
         const httpMethod = method.toLowerCase();
-        const handlers = [
-            this.publicApiKeyCheckerMB.exec({
-                checkType: sec?.publicApiKeyCheckType,
-            }),
-            this.authenticationCheckerMB.exec({ appManifest, ucd }),
-            this.requestHandlerMB.exec({
+        const handler = async (req, res) => {
+            const { body, status } = await this.serverRequestHandler.exec({
                 appManifest,
                 envelope,
+                req: this.toReq(req),
+                res: this.toRes(res),
                 ucd,
                 ucManager: this.ucManager,
-            }),
-        ];
-        this.runtime[httpMethod](path, handlers);
+            });
+            if (!body) {
+                res.status(status).send();
+                return;
+            }
+            res.status(status).send(body);
+        };
+        this.runtime[httpMethod](path, handler);
         for (const pathAlias of pathAliases) {
-            this.runtime[httpMethod](pathAlias, handlers);
+            this.runtime[httpMethod](pathAlias, handler);
         }
     }
     async mountStaticDir(dirPath) {
@@ -124,26 +109,10 @@ let NodeExpressServerManager = class NodeExpressServerManager {
         });
     }
     async stop() {
-        if (!this.server?.listening) {
-            return;
-        }
-        // As stated in the docs of `close`, only awaiting `.close` is not enough to make sure all the connections are closed.
-        // Hence the wrapping in a promise, where the callback is called when the 'close' event is emitted.
-        return new Promise((resolve, reject) => {
-            if (!this.server) {
-                return resolve();
-            }
-            this.server.close((err) => {
-                if (err) {
-                    return reject(err);
-                }
-                resolve();
-            });
-        });
+        await stop(this.server);
     }
     async warmUp() {
-        // Always at the "almost" last position to handle all the errors (from other middlewares and request handlers)
-        this.runtime.use(this.errorMB.exec({}));
+        // Nothing to do
     }
     async createServer() {
         const port = this.s().server_binding_port;
@@ -153,37 +122,81 @@ let NodeExpressServerManager = class NodeExpressServerManager {
             return;
         }
         this.logger.info('Creating HTTPS server', { port });
-        const fullchainPath = this.s().server_ssl_fullchain_path;
-        const keyPath = this.s().server_ssl_key_path;
-        if (!fullchainPath || !keyPath) {
-            throw new Error('You must provide server_ssl_fullchain_path and server_ssl_key_path to start on secure port 443');
-        }
-        const credentials = {
-            cert: await this.fsManager.cat(fullchainPath),
-            key: await this.fsManager.cat(keyPath),
-        };
+        const credentials = await this.serverSSLCertLoader.exec(undefined);
         this.server = https.createServer(credentials, this.runtime);
     }
+    toFile(f) {
+        return {
+            name: f.name,
+            path: f.tempFilePath,
+            type: f.mimetype,
+        };
+    }
+    toReq(req) {
+        return {
+            bodyFromFormData: async () => {
+                // Since express v5, if the request contains only a file, the `req.body` returns `undefined`
+                const input = req.body ?? {};
+                // files is present when using express-fileupload
+                if ('files' in req && req.files) {
+                    for (const [field, value] of Object.entries(req.files)) {
+                        input[field] = Array.isArray(value)
+                            ? value.map(this.toFile)
+                            : this.toFile(value);
+                    }
+                }
+                for (const [k, v] of Object.entries(input)) {
+                    const isMultiple = k.endsWith('[]'); // e.g. 'tags[]': 'Electronic'
+                    const key = isMultiple ? k.replaceAll('[]', '') : k;
+                    if (isMultiple) {
+                        input[key] = Array.isArray(v) ? v : [v];
+                    }
+                    else {
+                        input[key] = v;
+                    }
+                }
+                return input;
+            },
+            bodyFromJSON: async () => req.body,
+            bodyFromQueryParams: async () => req.query,
+            bodyRaw: req.body,
+            cookie: (name) => req.cookies[name],
+            header: async (name) => {
+                const h = req.headers[name.toLowerCase()];
+                if (Array.isArray(h)) {
+                    this.logger.warn(`Multiple headers found for ${name}. Returning the first one.`);
+                    return h[0];
+                }
+                return h;
+            },
+            method: req.method,
+            secure: req.secure,
+            url: req.url,
+        };
+    }
+    toRes(res) {
+        return {
+            clearCookie: async (name) => {
+                res.clearCookie(name);
+            },
+            redirect: async (location) => res.redirect(location),
+            setCookie: async ({ name, opts, val }) => {
+                res.cookie(name, val, opts);
+            },
+        };
+    }
 };
 NodeExpressServerManager = __decorate([
     injectable(),
-    __param(0, inject(AuthenticationCheckerMiddlewareBuilder)),
-    __param(1, inject(EntrypointsBuilder)),
-    __param(2, inject('EnvironmentManager')),
-    __param(3, inject(ErrorMiddlewareBuilder)),
-    __param(4, inject('FSManager')),
-    __param(5, inject(HelmetMiddlewareBuilder)),
-    __param(6, inject('Logger')),
-    __param(7, inject(PublicApiKeyCheckerMiddlewareBuilder)),
-    __param(8, inject(RequestCheckerMiddlewareBuilder)),
-    __param(9, inject(RequestHandlerMiddlewareBuilder)),
-    __param(10, inject(RequestLoggerMiddlewareBuilder)),
-    __param(11, inject('SettingsManager')),
-    __param(12, inject('UCManager')),
-    __metadata("design:paramtypes", [AuthenticationCheckerMiddlewareBuilder,
-        EntrypointsBuilder, Object, ErrorMiddlewareBuilder, Object, HelmetMiddlewareBuilder, Object, PublicApiKeyCheckerMiddlewareBuilder,
-        RequestCheckerMiddlewareBuilder,
-        RequestHandlerMiddlewareBuilder,
-        RequestLoggerMiddlewareBuilder, Object, Object])
+    __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,
+        ServerSSLCertLoader, Object, Object])
 ], NodeExpressServerManager);
 export { NodeExpressServerManager };

package/dist/esm/target/node-express-server/middlewares/RequestHandlerMiddlewareBuilder.js

@@ -78,7 +78,8 @@ let RequestHandlerMiddlewareBuilder = class RequestHandlerMiddlewareBuilder {
     fillUCFromReq(req, envelope, uc) {
         switch (envelope) {
             case 'form-data': {
-                const input = req.body;
+                // Since express v5, if the request contains only a file, the `req.body` returns `undefined`
+                const input = req.body ?? {};
                 // files is present when using express-fileupload
                 if ('files' in req && req.files) {
                     for (const [field, value] of Object.entries(req.files)) {

package/dist/esm/testing/AppTester.js

@@ -307,13 +307,13 @@ let AppTester = class AppTester {
                 ...appI18n[l],
             };
         }
-        container.rebind('I18n').toConstantValue(productI18n);
+        (await container.rebind('I18n')).toConstantValue(productI18n);
     }
     async bindServerClientSettings(serverClientSettings) {
         const { container } = this.ctx;
         const opts = optsAllSet(this.ctx.opts);
         const existingSettings = container.get('Settings');
-        container.rebind('Settings').toConstantValue({
+        (await container.rebind('Settings')).toConstantValue({
             ...existingSettings,
             ...serverClientSettings,
             logger_level: opts.logger_level,

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

@@ -41,7 +41,7 @@ export async function newNodeAppTester(serverPortRangeStart, idx, args) {
     container
         .bind('UCDefASTParser')
         .to(TypeScriptLibUCDefASTParser);
-    const tester = container.resolve(AppTester);
+    const tester = container.get(AppTester);
     const jwtManager = container.get('JWTManager');
     const apiKey = settings.server_private_api_key_entries[0];
     const [basicAuth] = Object.entries(settings.server_basic_auth_entries);

package/dist/esm/uc/impl/SimpleUCManager.d.ts

@@ -1,4 +1,4 @@
-import { type interfaces } from 'inversify';
+import { type Provider } from 'inversify';
 import type { ClockManager, CryptoManager, Logger } from '../../std/index.js';
 import type { UC } from '../UC.js';
 import type { UCClientConfirmManager } from '../client.js';
@@ -26,7 +26,7 @@ export declare class SimpleUCManager implements UCManager {
     private ucInitProvider;
     private ucMainProvider;
     private tx?;
-    constructor(ucClientConfirmManager: UCClientConfirmManager, clockManager: ClockManager, cryptoManager: CryptoManager, logger: Logger, ucDataStore: UCDataStore, ucExecChecker: UCExecChecker, ucInputFilesProcessor: UCInputFilesProcessor, ucInputValidator: UCInputValidator, ucInitProvider: interfaces.Provider<UCInit>, ucMainProvider: interfaces.Provider<UCMain>);
+    constructor(ucClientConfirmManager: UCClientConfirmManager, clockManager: ClockManager, cryptoManager: CryptoManager, logger: Logger, ucDataStore: UCDataStore, ucExecChecker: UCExecChecker, ucInputFilesProcessor: UCInputFilesProcessor, ucInputValidator: UCInputValidator, ucInitProvider: Provider<UCInit>, ucMainProvider: Provider<UCMain>);
     commitTx(): Promise<void>;
     confirmClient<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(uc: UC<I, OPI0, OPI1>): Promise<boolean>;
     execClient<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(uc: UC<I, OPI0, OPI1>): Promise<UCOutputReader<I, OPI0, OPI1>>;

package/dist/esm/uc/utils/ucHTTPContract.js

@@ -7,7 +7,7 @@ const ACTION_HTTP_METHOD_MAPPING = {
     Update: 'PUT',
     View: 'GET',
 };
-const METHODS_WITH_NO_BODY = ['GET'];
+const METHODS_WITH_NO_BODY = ['GET', 'HEAD'];
 export function ucHTTPContract(uc, pathPrefix = '/api/v1') {
     const { ext, metadata } = uc.def;
     const { action } = metadata;

package/dist/esm/uc/workers/UCExecChecker.d.ts

@@ -1,4 +1,4 @@
-import { type interfaces } from 'inversify';
+import { type Provider } from 'inversify';
 import type { ProductManifest } from '../../product/index.js';
 import type { Configurable, SettingsManager, Worker } from '../../std/index.js';
 import type { UC } from '../UC.js';
@@ -17,7 +17,7 @@ export declare class UCExecChecker implements Configurable<S>, Worker<Input, Pro
     private productManifest;
     private settingsManager;
     private ucPolicyProvider;
-    constructor(productManifest: ProductManifest, settingsManager: SettingsManager<S>, ucPolicyProvider: interfaces.Provider<UCPolicy>);
+    constructor(productManifest: ProductManifest, settingsManager: SettingsManager<S>, ucPolicyProvider: Provider<UCPolicy>);
     s(): S;
     exec<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>({ lifecycle, uc }: Input<I, OPI0, OPI1>): Promise<Output>;
 }

package/dist/esm/uc/workers/UCInputFilesProcessor.js

@@ -61,12 +61,15 @@ let UCInputFilesProcessor = class UCInputFilesProcessor {
         const prefix = this.clockManager.nowToKey();
         const fileName = `${prefix}-${this.cryptoManager.randomUUID()}.${extension}`; // => 20230110143732-155eb8d3-9af5-430e-b856-248007859df1.jpg
         const fileNameRef = `${this.s().uc_file_ref_prefix}${fileName}`; // => $ref:20230110143732-155eb8d3-9af5-430e-b856-248007859df1.jpg
-        // When calling this client side, we still have a https://developer.mozilla.org/en-US/docs/Web/API/File
-        // Consider moving this logic to UCManager.execClient ?
-        // TODO : Improve client/server input files management
-        const path = file instanceof File ? file.name : file.path;
-        await this.fsManager.cp(path, this.fsManager.path(this.s().uc_files_directory_path, fileName)); // => /path/to/files/20230110143732-155eb8d3-9af5-430e-b856-248007859df1.jpg
-        await this.fsManager.rm(path);
+        const destPath = this.fsManager.path(this.s().uc_files_directory_path, fileName); // => /path/to/files/20230110143732-155eb8d3-9af5-430e-b856-248007859df1.jpg
+        if (file instanceof File) {
+            await this.fsManager.touch(destPath, await file.arrayBuffer());
+        }
+        else {
+            const { path } = file;
+            await this.fsManager.cp(path, destPath);
+            await this.fsManager.rm(path);
+        }
         return fileNameRef;
     }
 };

package/dist/esm/utils/http/HTTPRequestBuilder.js

@@ -11,9 +11,9 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 import { inject, injectable } from 'inversify';
-import { toFormData } from './toFormData.js';
-import { toJSON } from './toJSON.js';
-import { toQueryParams } from './toQueryParams.js';
+import { toFormData } from './form-data.js';
+import { toJSON } from './json.js';
+import { toQueryParams } from './query-params.js';
 let HTTPRequestBuilder = class HTTPRequestBuilder {
     formDataBuilder;
     constructor(formDataBuilder) {

package/dist/esm/utils/http/form-data.d.ts

@@ -0,0 +1,4 @@
+import type { FormDataBuilder } from '../../std/index.js';
+import type { HTTPReqData } from './types.js';
+export declare function fromFormData<T extends HTTPReqData>(fd: FormData): Promise<T>;
+export declare function toFormData<T extends HTTPReqData>(data: T | undefined | null, fd: FormData, formDataBuilder: FormDataBuilder): Promise<void>;

package/dist/esm/utils/http/form-data.js

@@ -0,0 +1,20 @@
+import { appendData } from './appendData.js';
+export async function fromFormData(fd) {
+    // biome-ignore lint/suspicious/noExplicitAny: can be anything
+    const data = {};
+    for (const [k, v] of fd) {
+        const isMultiple = k.endsWith('[]'); // e.g. 'tags[]': 'Electronic'
+        const key = isMultiple ? k.replaceAll('[]', '') : k;
+        const value = data[key];
+        if (value === undefined) {
+            data[key] = isMultiple ? [v] : v;
+        }
+        else if (Array.isArray(value)) {
+            value.push(v);
+        }
+    }
+    return data;
+}
+export async function toFormData(data, fd, formDataBuilder) {
+    await appendData(data, (k, v) => formDataBuilder.append(fd, k, v));
+}

package/dist/esm/utils/http/json.d.ts

@@ -0,0 +1,3 @@
+import type { JSONString } from '../../dt/index.js';
+import type { HTTPReqData } from './types.js';
+export declare function toJSON<T extends HTTPReqData>(data: T | undefined | null): JSONString;

package/dist/esm/utils/http/json.js

@@ -0,0 +1,3 @@
+export function toJSON(data) {
+    return JSON.stringify(data);
+}

package/dist/esm/utils/http/query-params.d.ts

@@ -0,0 +1,3 @@
+import type { HTTPReqData } from './types.js';
+export declare function fromQueryParams(url: URL): Promise<HTTPReqData>;
+export declare function toQueryParams<T extends HTTPReqData>(data: T | undefined | null, url: URL): Promise<void>;

package/dist/esm/utils/http/query-params.js

@@ -0,0 +1,20 @@
+import { appendData } from './appendData.js';
+export async function fromQueryParams(url) {
+    // biome-ignore lint/suspicious/noExplicitAny: can be anything
+    const data = {};
+    for (const [k, v] of url.searchParams) {
+        const isMultiple = k.endsWith('[]');
+        const key = isMultiple ? k.replaceAll('[]', '') : k;
+        const value = data[key];
+        if (value === undefined) {
+            data[key] = isMultiple ? [v] : v;
+        }
+        else if (Array.isArray(value)) {
+            value.push(v);
+        }
+    }
+    return data;
+}
+export async function toQueryParams(data, url) {
+    await appendData(data, async (k, v) => url.searchParams.append(k, v));
+}

package/dist/esm/utils/index.d.ts

@@ -2,7 +2,10 @@ export { sleep } from './async/sleep.js';
 export type { Clearable } from './concerns/Clearable.js';
 export type { Initializable } from './concerns/Initializable.js';
 export type { SrcImporter } from './esm/srcImporter.js';
+export { fromFormData, toFormData } from './http/form-data.js';
 export { HTTPRequestBuilder } from './http/HTTPRequestBuilder.js';
+export { toJSON } from './http/json.js';
+export { fromQueryParams, toQueryParams } from './http/query-params.js';
 export type { HTTPDataEnvelope, HTTPReqData } from './http/types.js';
 export { bindProvider } from './ioc/bindProvider.js';
 export { CONTAINER_OPTS } from './ioc/container.js';

package/dist/esm/utils/index.js

@@ -1,5 +1,8 @@
 export { sleep } from './async/sleep.js';
+export { fromFormData, toFormData } from './http/form-data.js';
 export { HTTPRequestBuilder } from './http/HTTPRequestBuilder.js';
+export { toJSON } from './http/json.js';
+export { fromQueryParams, toQueryParams } from './http/query-params.js';
 export { bindProvider } from './ioc/bindProvider.js';
 export { CONTAINER_OPTS } from './ioc/container.js';
 export { fmt as fmtNumber } from './numbers/fmt.js';

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

@@ -5,6 +5,6 @@ export function bindNodeCLI(container) {
     container.bind('PromptManager').to(NodePromptManager);
     // uc
     container
-        .rebind('UCClientConfirmManager')
+        .rebindSync('UCClientConfirmManager')
         .to(PromptUCClientConfirmManager);
 }

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

@@ -12,6 +12,6 @@ export function bindNodeCore(container) {
         .to(NodeEnvironmentManager);
     container.bind('FSManager').to(NodeFSManager);
     container
-        .rebind('FormDataBuilder')
+        .rebindSync('FormDataBuilder')
         .to(NodeFormDataBuilder);
 }

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

@@ -1,8 +1,8 @@
 export function bindProduct(container, productManifest, productI18n) {
     // Using rebind because these are already bound by default in {@link bindCommon}.
     // The goal is to make it easier to get started for a user.
-    container.rebind('I18n').toConstantValue(productI18n);
+    container.rebindSync('I18n').toConstantValue(productI18n);
     container
-        .rebind('ProductManifest')
+        .rebindSync('ProductManifest')
         .toConstantValue(productManifest);
 }

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

@@ -3,7 +3,7 @@ export function bindProvider(container, identifier) {
         .bind(`Provider<${identifier}>`)
         .toProvider((context) => {
         return async (clazz) => {
-            return context.container.resolve(clazz);
+            return context.get(clazz);
         };
     });
 }

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

@@ -9,6 +9,6 @@ export function bindWeb(container) {
     container.bind('FSManager').to(WebFSManager);
     // uc
     container
-        .rebind('UCClientConfirmManager')
+        .rebindSync('UCClientConfirmManager')
         .to(WebUCClientConfirmManager);
 }

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

@@ -1,2 +1,2 @@
-import type { interfaces } from 'inversify';
-export declare const CONTAINER_OPTS: interfaces.ContainerOptions;
+import type { ContainerOptions } from 'inversify';
+export declare const CONTAINER_OPTS: ContainerOptions;

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

@@ -2,8 +2,7 @@ export const CONTAINER_OPTS = {
     /**
      * Allows us to avoid binding concrete classes
      *
-     * @see https://github.com/inversify/InversifyJS/issues/1302
-     * @see https://github.com/inversify/InversifyJS/blob/master/wiki/container_api.md#autobindinjectable
+     * @see https://inversify.io/docs/fundamentals/binding/#autobinding
      */
-    autoBindInjectable: true,
+    autobind: true,
 };

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

@@ -1,2 +1,2 @@
-import type { interfaces } from 'inversify';
-export type Class<T> = interfaces.Newable<T>;
+import type { Newable } from 'inversify';
+export type Class<T> = Newable<T>;

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "libmodulor",
     "description": "A TypeScript library to create business oriented applications",
-    "version": "0.11.1",
+    "version": "0.12.0",
     "license": "LGPL-3.0",
     "author": "Chafik H'nini <chafik.hnini@gmail.com>",
     "homepage": "https://github.com/c100k/libmodulor#readme",
@@ -29,6 +29,9 @@
         "./locales/fr": {
             "import": "./dist/esm/i18n/locales/fr.js"
         },
+        "./nextjs": {
+            "import": "./dist/esm/index.nextjs.js"
+        },
         "./node-express": {
             "import": "./dist/esm/index.node-express.js"
         },
@@ -82,21 +85,22 @@
         "cookie-parser": "^1.4.7",
         "express": "^5.1.0",
         "express-fileupload": "^1.5.1",
-        "fast-check": "^4.0.1",
+        "fast-check": "^4.1.0",
         "helmet": "^8.1.0",
         "hono": "^4.7.5",
-        "inversify": "^6.2.2",
+        "inversify": "^7.5.0",
         "jose": "^6.0.10",
         "knex": "^3.1.0",
+        "next": "^15.3.0",
         "pg": "^8.14.1",
         "react": "^19.1.0",
         "react-dom": "^19.1.0",
-        "react-native": "^0.78.1",
+        "react-native": "^0.78.2",
         "reflect-metadata": "^0.2.2",
         "sqlite3": "^5.1.7",
-        "typescript": "^5.8.2",
-        "vite": "^6.2.3",
-        "vitest": "^3.0.9"
+        "typescript": "^5.8.3",
+        "vite": "^6.2.5",
+        "vitest": "^3.1.1"
     },
     "peerDependenciesMeta": {
         "@hono/node-server": {
@@ -132,6 +136,9 @@
         "knex": {
             "optional": true
         },
+        "next": {
+            "optional": true
+        },
         "jose": {
             "optional": true
         },