libmodulor 0.11.1 → 0.13.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/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/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';