libmodulor 0.12.0 → 0.13.0

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # CHANGELOG
 
+## v0.13.0 (2025-04-25)
+
+**Added**
+
+- Introduce `target/node-hono-server` allowing you to expose a server using [Hono](https://hono.dev) in addition to the existing implementations based on [express](https://expressjs.com) and [next.js](https://nextjs.org)
+
+**Misc**
+
+- Upgrade `examples/supertrader` to rn `react-native@0.79.x` and `expo@53.x`
+
 ## v0.12.0 (2025-04-13)
 
 **BREAKING**

package/README.md

@@ -17,4 +17,4 @@ If you think you can help in any way, feel free to contact me (cf. `author` in `
 
 ## ⚖️ License
 
-[LGPL-3.0](https://github.com/c100k/libmodulor/blob/v0.12.0/LICENSE)
+[LGPL-3.0](https://github.com/c100k/libmodulor/blob/v0.13.0/LICENSE)

package/dist/esm/apps/Helper/src/lib/project.js

@@ -36,23 +36,23 @@ export const PACKAGE_JSON = (name) => `{
         "test": "tsc && vitest run --passWithNoTests"
     },
     "dependencies": {
-        "inversify": "^7.5.0",
+        "inversify": "^7.5.1",
         "libmodulor": "latest",
         "reflect-metadata": "^0.2.2"
     },
     "devDependencies": {
         "@biomejs/biome": "^1.9.4",
-        "@types/node": "^22.14.0",
+        "@types/node": "^22.14.1",
         "@vitest/coverage-v8": "^3.1.1",
         "buffer": "^6.0.3",
         "cookie-parser": "^1.4.7",
         "express": "^5.1.0",
         "express-fileupload": "^1.5.1",
-        "fast-check": "^4.1.0",
+        "fast-check": "^4.1.1",
         "helmet": "^8.1.0",
         "jose": "^6.0.10",
         "typescript": "^5.8.3",
-        "vite": "^6.2.5",
+        "vite": "^6.3.2",
         "vitest": "^3.1.1"
     }
 }

package/dist/esm/index.node-hono.d.ts

@@ -0,0 +1,2 @@
+export { NodeHonoServerManager } from './target/node-hono-server/NodeHonoServerManager.js';
+export { bindServer } from './utils/ioc/bindServer.js';

package/dist/esm/index.node-hono.js

@@ -0,0 +1,2 @@
+export { NodeHonoServerManager } from './target/node-hono-server/NodeHonoServerManager.js';
+export { bindServer } from './utils/ioc/bindServer.js';

package/dist/esm/target/nextjs-server/NextJSAPIRouteHandler.js

@@ -48,7 +48,7 @@ let NextJSAPIRouteHandler = class NextJSAPIRouteHandler {
     }
     toReq(req) {
         return {
-            bodyFromFormData: async () => fromFormData(await req.formData()),
+            bodyFromFormData: async () => fromFormData((await req.formData())),
             bodyFromJSON: () => req.json(),
             bodyFromQueryParams: async () => fromQueryParams(req.nextUrl),
             bodyRaw: req.body,

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

@@ -0,0 +1,35 @@
+import { Hono } from 'hono';
+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 { EntrypointsBuilder } from '../lib/server/EntrypointsBuilder.js';
+import type { ServerManager, ServerManagerSettings } from '../lib/server/ServerManager.js';
+import { ServerRequestHandler } from '../lib/server/ServerRequestHandler.js';
+import { ServerSSLCertLoader } from '../lib/server/ServerSSLCertLoader.js';
+type S = Pick<ServerManagerSettings, 'server_binding_host' | 'server_binding_port'>;
+export declare class NodeHonoServerManager implements Configurable<S>, ServerManager {
+    private entrypointsBuilder;
+    protected environmentManager: EnvironmentManager;
+    private logger;
+    private serverRequestHandler;
+    private serverSSLCertLoader;
+    private settingsManager;
+    private ucManager;
+    protected runtime: Hono;
+    private server;
+    constructor(entrypointsBuilder: EntrypointsBuilder, environmentManager: EnvironmentManager, logger: Logger, serverRequestHandler: ServerRequestHandler, serverSSLCertLoader: ServerSSLCertLoader, settingsManager: SettingsManager<S>, ucManager: UCManager);
+    s(): S;
+    getRuntime(): Hono;
+    overrideUCManager(ucManager: UCManager): void;
+    init(): Promise<void>;
+    mount<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(appManifest: AppManifest, ucd: UCDef<I, OPI0, OPI1>, contract: UCHTTPContract): Promise<void>;
+    mountStaticDir(dirPath: DirPath): Promise<void>;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    warmUp(): Promise<void>;
+    private createServer;
+    private toReq;
+    private toRes;
+}
+export {};

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

@@ -0,0 +1,169 @@
+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 __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import http from 'node:http';
+import https from 'node:https';
+import { createAdaptorServer, } from '@hono/node-server';
+import { serveStatic } from '@hono/node-server/serve-static';
+import { Hono } from 'hono';
+import { deleteCookie, getCookie, setCookie } from 'hono/cookie';
+import { logger } from 'hono/logger';
+import { secureHeaders } from 'hono/secure-headers';
+import { inject, injectable } from 'inversify';
+import { fromFormData } from '../../utils/index.js';
+import { stop } from '../lib/server-node/stop.js';
+import { EntrypointsBuilder } from '../lib/server/EntrypointsBuilder.js';
+import { ServerRequestHandler, } from '../lib/server/ServerRequestHandler.js';
+import { ServerSSLCertLoader } from '../lib/server/ServerSSLCertLoader.js';
+let NodeHonoServerManager = class NodeHonoServerManager {
+    entrypointsBuilder;
+    environmentManager;
+    logger;
+    serverRequestHandler;
+    serverSSLCertLoader;
+    settingsManager;
+    ucManager;
+    runtime;
+    server;
+    constructor(entrypointsBuilder, environmentManager, logger, serverRequestHandler, serverSSLCertLoader, settingsManager, ucManager) {
+        this.entrypointsBuilder = entrypointsBuilder;
+        this.environmentManager = environmentManager;
+        this.logger = logger;
+        this.serverRequestHandler = serverRequestHandler;
+        this.serverSSLCertLoader = serverSSLCertLoader;
+        this.settingsManager = settingsManager;
+        this.ucManager = ucManager;
+    }
+    s() {
+        return {
+            server_binding_host: this.settingsManager.get()('server_binding_host'),
+            server_binding_port: this.settingsManager.get()('server_binding_port'),
+        };
+    }
+    getRuntime() {
+        if (this.environmentManager.isProd()) {
+            throw new Error('Do not use getRuntime() in production !');
+        }
+        return this.runtime;
+    }
+    overrideUCManager(ucManager) {
+        this.ucManager = ucManager;
+    }
+    async init() {
+        this.runtime = new Hono();
+        this.runtime.use(secureHeaders());
+        this.runtime.use(logger());
+        this.runtime.notFound((c) => {
+            return c.json({}, 404);
+        });
+        await this.createServer();
+    }
+    async mount(appManifest, ucd, contract) {
+        const { envelope, method, path, pathAliases } = contract;
+        const httpMethod = method.toLowerCase();
+        if (httpMethod === 'connect' ||
+            httpMethod === 'head' ||
+            httpMethod === 'trace') {
+            throw new Error(`Unsupported HTTP method : ${httpMethod}`);
+        }
+        const handler = async (c) => {
+            const { body, status } = await this.serverRequestHandler.exec({
+                appManifest,
+                envelope,
+                req: this.toReq(c),
+                res: this.toRes(c),
+                ucd,
+                ucManager: this.ucManager,
+            });
+            if (!body) {
+                return c.newResponse(null, status);
+            }
+            return c.json(body, status);
+        };
+        this.runtime[httpMethod](path, handler);
+        for (const pathAlias of pathAliases) {
+            this.runtime[httpMethod](pathAlias, handler);
+        }
+    }
+    async mountStaticDir(dirPath) {
+        this.runtime.use(serveStatic({ root: dirPath }));
+    }
+    async start() {
+        const host = this.s().server_binding_host;
+        const port = this.s().server_binding_port;
+        this.server.listen(port, host, () => {
+            this.logger.info(`Listening on ${this.entrypointsBuilder.exec().http}`);
+        });
+    }
+    async stop() {
+        await stop(this.server);
+    }
+    async warmUp() {
+        // Nothing to do
+    }
+    async createServer() {
+        const host = this.s().server_binding_host;
+        const port = this.s().server_binding_port;
+        const opts = {
+            fetch: this.runtime.fetch,
+            hostname: host,
+            port,
+        };
+        if (port !== 443) {
+            this.logger.info('Creating HTTP server', { port });
+            opts.createServer = http.createServer;
+            this.server = createAdaptorServer(opts);
+            return;
+        }
+        this.logger.info('Creating HTTPS server', { port });
+        opts.createServer = https.createServer;
+        opts.serverOptions = await this.serverSSLCertLoader.exec(undefined);
+        this.server = createAdaptorServer(opts);
+    }
+    toReq(c) {
+        return {
+            bodyFromFormData: async () => fromFormData(await c.req.formData()),
+            bodyFromJSON: () => c.req.json(),
+            bodyFromQueryParams: async () => c.req.queries(),
+            bodyRaw: c.req.raw,
+            cookie: async (name) => getCookie(c, name),
+            header: async (name) => c.req.header(name),
+            method: c.req.method,
+            secure: c.req.url.startsWith('https://'),
+            url: c.req.url,
+        };
+    }
+    toRes(c) {
+        return {
+            clearCookie: async (name) => {
+                deleteCookie(c, name);
+            },
+            redirect: async (location) => {
+                c.redirect(location);
+            },
+            setCookie: async ({ name, opts, val }) => setCookie(c, name, val, opts),
+        };
+    }
+};
+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,
+        ServerSSLCertLoader, Object, Object])
+], NodeHonoServerManager);
+export { NodeHonoServerManager };

package/package.json

@@ -1,10 +1,10 @@
 {
     "name": "libmodulor",
     "description": "A TypeScript library to create business oriented applications",
-    "version": "0.12.0",
+    "version": "0.13.0",
     "license": "LGPL-3.0",
     "author": "Chafik H'nini <chafik.hnini@gmail.com>",
-    "homepage": "https://github.com/c100k/libmodulor#readme",
+    "homepage": "https://libmodulor.c100k.eu",
     "bugs": "https://github.com/c100k/libmodulor/issues",
     "keywords": [
         "library",
@@ -35,6 +35,9 @@
         "./node-express": {
             "import": "./dist/esm/index.node-express.js"
         },
+        "./node-hono": {
+            "import": "./dist/esm/index.node-hono.js"
+        },
         "./node-mcp": {
             "import": "./dist/esm/index.node-mcp.js"
         },
@@ -78,28 +81,28 @@
         "@biomejs/biome": "^1.9.4"
     },
     "peerDependencies": {
-        "@hono/node-server": "^1.14.0",
-        "@modelcontextprotocol/sdk": "^1.8.0",
+        "@hono/node-server": "^1.14.1",
+        "@modelcontextprotocol/sdk": "^1.10.1",
         "@stricli/core": "^1.1.2",
         "buffer": "^6.0.3",
         "cookie-parser": "^1.4.7",
         "express": "^5.1.0",
         "express-fileupload": "^1.5.1",
-        "fast-check": "^4.1.0",
+        "fast-check": "^4.1.1",
         "helmet": "^8.1.0",
-        "hono": "^4.7.5",
-        "inversify": "^7.5.0",
+        "hono": "^4.7.7",
+        "inversify": "^7.5.1",
         "jose": "^6.0.10",
         "knex": "^3.1.0",
-        "next": "^15.3.0",
+        "next": "^15.3.1",
         "pg": "^8.14.1",
         "react": "^19.1.0",
         "react-dom": "^19.1.0",
-        "react-native": "^0.78.2",
+        "react-native": "^0.79.1",
         "reflect-metadata": "^0.2.2",
         "sqlite3": "^5.1.7",
         "typescript": "^5.8.3",
-        "vite": "^6.2.5",
+        "vite": "^6.3.2",
         "vitest": "^3.1.1"
     },
     "peerDependenciesMeta": {