libmodulor 0.11.1 → 0.13.0

package/dist/esm/target/lib/server/ServerRequestHandler.js

@@ -0,0 +1,202 @@
+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); }
+};
+var ServerRequestHandler_1;
+import { inject, injectable } from 'inversify';
+import { UCBuilder, UCOutputReader, UCOutputSideEffectType, } from '../../../uc/index.js';
+import { AuthCookieCreator, } from './AuthCookieCreator.js';
+import { AuthenticationChecker } from './AuthenticationChecker.js';
+import { CustomerFacingErrorBuilder } from './CustomerFacingErrorBuilder.js';
+import { PublicApiKeyChecker } from './PublicApiKeyChecker.js';
+import { RequestChecker } from './RequestChecker.js';
+import { RequestLogger } from './RequestLogger.js';
+let ServerRequestHandler = class ServerRequestHandler {
+    static { ServerRequestHandler_1 = this; }
+    authCookieCreator;
+    authenticationChecker;
+    customerFacingErrorBuilder;
+    publicApiKeyChecker;
+    requestChecker;
+    requestLogger;
+    settingsManager;
+    ucBuilder;
+    static AUTHORIZATION_HEADER_NAME = 'Authorization';
+    static X_FORWARDED_PROTO_HEADER_NAME = 'X-Forwarded-Proto';
+    constructor(authCookieCreator, authenticationChecker, customerFacingErrorBuilder, publicApiKeyChecker, requestChecker, requestLogger, settingsManager, ucBuilder) {
+        this.authCookieCreator = authCookieCreator;
+        this.authenticationChecker = authenticationChecker;
+        this.customerFacingErrorBuilder = customerFacingErrorBuilder;
+        this.publicApiKeyChecker = publicApiKeyChecker;
+        this.requestChecker = requestChecker;
+        this.requestLogger = requestLogger;
+        this.settingsManager = settingsManager;
+        this.ucBuilder = ucBuilder;
+    }
+    s() {
+        return {
+            server_cookies_name_auth: this.settingsManager.get()('server_cookies_name_auth'),
+            server_public_api_key_header_name: this.settingsManager.get()('server_public_api_key_header_name'),
+        };
+    }
+    async exec({ appManifest, envelope, req, res, ucd, ucManager, }) {
+        try {
+            const { bodyRaw, cookie, header, method, secure, url } = req;
+            this.requestLogger.exec({
+                body: bodyRaw,
+                method,
+                url,
+            });
+            this.requestChecker.exec({
+                secure,
+                url,
+                xForwardedProtoHeader: await header(ServerRequestHandler_1.X_FORWARDED_PROTO_HEADER_NAME),
+            });
+            const { ext, sec } = ucd;
+            await this.publicApiKeyChecker.exec({
+                checkType: sec?.publicApiKeyCheckType,
+                value: await header(this.s().server_public_api_key_header_name),
+            });
+            const uc = this.ucBuilder.exec({
+                appManifest,
+                auth: null,
+                def: ucd,
+            });
+            const { auth } = await this.authenticationChecker.exec({
+                authCookie: await cookie(this.s().server_cookies_name_auth),
+                authorizationHeader: await header(ServerRequestHandler_1.AUTHORIZATION_HEADER_NAME),
+                uc,
+            });
+            if (auth) {
+                uc.auth = auth;
+            }
+            await this.fill(req, envelope, uc);
+            const output = await ucManager.execServer(uc);
+            const { status } = await this.applySideEffects(res, ucd, output);
+            if (status !== undefined) {
+                return {
+                    body: undefined,
+                    status,
+                };
+            }
+            if (!output) {
+                return {
+                    body: undefined,
+                    status: 204,
+                };
+            }
+            const transform = ext?.http?.transform;
+            return {
+                body: transform ? transform(output) : output,
+                status: 200,
+            };
+        }
+        catch (err) {
+            const { error } = this.customerFacingErrorBuilder.exec({
+                error: err,
+            });
+            return {
+                body: error.toObj(),
+                status: error.httpStatus,
+            };
+        }
+    }
+    async fill(req, envelope, uc) {
+        switch (envelope) {
+            case 'form-data': {
+                uc.fill((await req.bodyFromFormData()));
+                break;
+            }
+            case 'json':
+                try {
+                    uc.fill((await req.bodyFromJSON()));
+                }
+                catch (err) {
+                    // Ignore any JSON.parse error as everything is validated afterwards
+                }
+                break;
+            case 'query-params':
+                uc.fill((await req.bodyFromQueryParams()));
+                break;
+            default:
+                ((_) => { })(envelope);
+        }
+    }
+    async applySideEffects(res, ucd, output) {
+        const { io } = ucd;
+        const sideEffects = io.o?.sideEffects;
+        if (!sideEffects) {
+            return { status: undefined };
+        }
+        const ucor = new UCOutputReader(ucd, output ?? undefined);
+        let item;
+        if (ucor.canItem00()) {
+            item = ucor.item00().item;
+        }
+        for (const se of sideEffects) {
+            const { type } = se;
+            switch (type) {
+                case UCOutputSideEffectType.CLEAR_AUTH:
+                    await this.applyClearAuthSideEffect(res);
+                    break;
+                case UCOutputSideEffectType.REDIRECT:
+                    await this.applyRedirectSideEffect(res, item);
+                    return { status: 302 };
+                case UCOutputSideEffectType.SET_AUTH:
+                    await this.applySetAuthSideEffect(res, item);
+                    break;
+                default:
+                    ((_) => { })(type);
+            }
+        }
+        return { status: undefined };
+    }
+    async applyClearAuthSideEffect(res) {
+        res.clearCookie(this.s().server_cookies_name_auth);
+    }
+    async applyRedirectSideEffect(res, item) {
+        if (!item ||
+            !('redirect' in item) ||
+            typeof item['redirect'] !== 'string') {
+            return;
+        }
+        const { redirect } = item;
+        res.redirect(redirect);
+    }
+    async applySetAuthSideEffect(res, item) {
+        if (!item || !('jwt' in item) || typeof item['jwt'] !== 'string') {
+            return;
+        }
+        const { jwt } = item;
+        const output = await this.authCookieCreator.exec({
+            jwt,
+        });
+        res.setCookie(output);
+    }
+};
+ServerRequestHandler = ServerRequestHandler_1 = __decorate([
+    injectable(),
+    __param(0, inject(AuthCookieCreator)),
+    __param(1, inject(AuthenticationChecker)),
+    __param(2, inject(CustomerFacingErrorBuilder)),
+    __param(3, inject(PublicApiKeyChecker)),
+    __param(4, inject(RequestChecker)),
+    __param(5, inject(RequestLogger)),
+    __param(6, inject('SettingsManager')),
+    __param(7, inject(UCBuilder)),
+    __metadata("design:paramtypes", [AuthCookieCreator,
+        AuthenticationChecker,
+        CustomerFacingErrorBuilder,
+        PublicApiKeyChecker,
+        RequestChecker,
+        RequestLogger, Object, UCBuilder])
+], ServerRequestHandler);
+export { ServerRequestHandler };

package/dist/esm/target/lib/server/ServerSSLCertLoader.d.ts

@@ -0,0 +1,18 @@
+import type { Configurable, FSManager, SettingsManager, Worker } from '../../../std/index.js';
+import type { ServerManagerSettings } from './ServerManager.js';
+type Input = undefined;
+type Cert = string;
+type Key = string;
+interface Output {
+    cert: Cert;
+    key: Key;
+}
+type S = Pick<ServerManagerSettings, 'server_ssl_fullchain_path' | 'server_ssl_key_path'>;
+export declare class ServerSSLCertLoader implements Configurable<S>, Worker<Input, Promise<Output>> {
+    private fsManager;
+    private settingsManager;
+    constructor(fsManager: FSManager, settingsManager: SettingsManager<S>);
+    s(): S;
+    exec(_input: Input): Promise<Output>;
+}
+export {};

package/dist/esm/target/lib/server/ServerSSLCertLoader.js

@@ -0,0 +1,45 @@
+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 { inject, injectable } from 'inversify';
+let ServerSSLCertLoader = class ServerSSLCertLoader {
+    fsManager;
+    settingsManager;
+    constructor(fsManager, settingsManager) {
+        this.fsManager = fsManager;
+        this.settingsManager = settingsManager;
+    }
+    s() {
+        return {
+            server_ssl_fullchain_path: this.settingsManager.get()('server_ssl_fullchain_path'),
+            server_ssl_key_path: this.settingsManager.get()('server_ssl_key_path'),
+        };
+    }
+    async exec(_input) {
+        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');
+        }
+        return {
+            cert: await this.fsManager.cat(fullchainPath),
+            key: await this.fsManager.cat(keyPath),
+        };
+    }
+};
+ServerSSLCertLoader = __decorate([
+    injectable(),
+    __param(0, inject('FSManager')),
+    __param(1, inject('SettingsManager')),
+    __metadata("design:paramtypes", [Object, Object])
+], ServerSSLCertLoader);
+export { ServerSSLCertLoader };

package/dist/esm/target/lib/server-node/stop.d.ts

@@ -0,0 +1,2 @@
+import type { Server } from './types.js';
+export declare function stop(server: Server): Promise<void>;

package/dist/esm/target/lib/server-node/stop.js

@@ -0,0 +1,18 @@
+export async function stop(server) {
+    if (!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 (!server) {
+            return resolve();
+        }
+        server.close((err) => {
+            if (err) {
+                return reject(err);
+            }
+            resolve();
+        });
+    });
+}

package/dist/esm/target/lib/server-node/types.d.ts

@@ -0,0 +1,3 @@
+import type http from 'node:http';
+import type https from 'node:https';
+export type Server = http.Server | https.Server;

package/dist/esm/target/lib/server-node/types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/target/nextjs-server/NextJSAPIRouteHandler.d.ts

@@ -0,0 +1,23 @@
+import { type NextRequest, NextResponse } from 'next/server.js';
+import type { AppManifest } from '../../app/index.js';
+import type { Worker } from '../../std/index.js';
+import { UCBuilder, type UCDef, type UCInput, type UCManager, type UCOPIBase } from '../../uc/index.js';
+import { ServerRequestHandler } from '../lib/server/ServerRequestHandler.js';
+interface Input<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> {
+    appManifest: AppManifest;
+    req: NextRequest;
+    ucd: UCDef<I, OPI0, OPI1>;
+}
+interface Output {
+    res: NextResponse;
+}
+export declare class NextJSAPIRouteHandler implements Worker<Input, Promise<Output>> {
+    private serverRequestHandler;
+    private ucBuilder;
+    private ucManager;
+    constructor(serverRequestHandler: ServerRequestHandler, ucBuilder: UCBuilder, ucManager: UCManager);
+    exec<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>({ appManifest, req, ucd }: Input<I, OPI0, OPI1>): Promise<Output>;
+    private toReq;
+    private toRes;
+}
+export {};

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

@@ -0,0 +1,82 @@
+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 { inject, injectable } from 'inversify';
+import { cookies, headers } from 'next/headers.js';
+import { redirect } from 'next/navigation.js';
+import { NextResponse } from 'next/server.js';
+import { UCBuilder, ucHTTPContract, } from '../../uc/index.js';
+import { fromFormData, fromQueryParams } from '../../utils/index.js';
+import { ServerRequestHandler, } from '../lib/server/ServerRequestHandler.js';
+let NextJSAPIRouteHandler = class NextJSAPIRouteHandler {
+    serverRequestHandler;
+    ucBuilder;
+    ucManager;
+    constructor(serverRequestHandler, ucBuilder, ucManager) {
+        this.serverRequestHandler = serverRequestHandler;
+        this.ucBuilder = ucBuilder;
+        this.ucManager = ucManager;
+    }
+    async exec({ appManifest, req, ucd }) {
+        const uc = this.ucBuilder.exec({ appManifest, auth: null, def: ucd });
+        const { envelope } = ucHTTPContract(uc);
+        const { body, status } = await this.serverRequestHandler.exec({
+            appManifest,
+            envelope,
+            req: this.toReq(req),
+            res: this.toRes(),
+            ucd,
+            ucManager: this.ucManager,
+        });
+        if (!body) {
+            return {
+                res: new NextResponse(null, { status }),
+            };
+        }
+        return {
+            res: NextResponse.json(body, { status }),
+        };
+    }
+    toReq(req) {
+        return {
+            bodyFromFormData: async () => fromFormData((await req.formData())),
+            bodyFromJSON: () => req.json(),
+            bodyFromQueryParams: async () => fromQueryParams(req.nextUrl),
+            bodyRaw: req.body,
+            cookie: async (name) => (await cookies()).get(name)?.value,
+            header: async (name) => (await headers()).get(name) ?? undefined,
+            method: req.method,
+            secure: req.url.startsWith('https://'),
+            url: req.url,
+        };
+    }
+    toRes() {
+        return {
+            clearCookie: async (name) => {
+                (await cookies()).delete(name);
+            },
+            redirect: (location) => redirect(location),
+            setCookie: async ({ name, opts, val }) => {
+                (await cookies()).set(name, val, opts);
+            },
+        };
+    }
+};
+NextJSAPIRouteHandler = __decorate([
+    injectable(),
+    __param(0, inject(ServerRequestHandler)),
+    __param(1, inject(UCBuilder)),
+    __param(2, inject('UCManager')),
+    __metadata("design:paramtypes", [ServerRequestHandler,
+        UCBuilder, Object])
+], NextJSAPIRouteHandler);
+export { NextJSAPIRouteHandler };

package/dist/esm/target/nextjs-server/NextJSServerManager.d.ts

@@ -0,0 +1,13 @@
+import type { AppManifest } from '../../app/index.js';
+import type { DirPath } from '../../dt/index.js';
+import type { UCDef, UCHTTPContract, UCInput, UCManager, UCOPIBase } from '../../uc/index.js';
+import type { ServerManager } from '../lib/server/ServerManager.js';
+export declare class NextJSServerManager implements ServerManager {
+    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>;
+}

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

@@ -0,0 +1,34 @@
+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;
+};
+import { injectable } from 'inversify';
+let NextJSServerManager = class NextJSServerManager {
+    overrideUCManager(_ucManager) {
+        // Nothing to do
+    }
+    async init() {
+        // Nothing to do
+    }
+    async mount(_appManifest, _ucd, _contract) {
+        // Nothing to do
+    }
+    async mountStaticDir(_dirPath) {
+        // Nothing to do
+    }
+    async start() {
+        // Nothing to do
+    }
+    async stop() {
+        // Nothing to do
+    }
+    async warmUp() {
+        // Nothing to do
+    }
+};
+NextJSServerManager = __decorate([
+    injectable()
+], NextJSServerManager);
+export { NextJSServerManager };

package/dist/esm/target/node-express-server/NodeExpressServerManager.d.ts

@@ -1,35 +1,26 @@
 import { type Express } from 'express';
 import type { AppManifest } from '../../app/index.js';
 import type { DirPath } from '../../dt/index.js';
-import type { Configurable, EnvironmentManager, FSManager, Logger, LoggerSettings, SettingsManager } from '../../std/index.js';
+import type { Configurable, EnvironmentManager, Logger, LoggerSettings, 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 { 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';
-type S = Pick<LoggerSettings, 'logger_level'> & Pick<ServerManagerSettings, 'server_binding_host' | 'server_binding_port' | 'server_ssl_fullchain_path' | 'server_ssl_key_path' | 'server_tmp_path'>;
+type S = Pick<LoggerSettings, 'logger_level'> & Pick<ServerManagerSettings, 'server_binding_host' | 'server_binding_port' | 'server_tmp_path'>;
 export declare class NodeExpressServerManager implements Configurable<S>, ServerManager {
-    private authenticationCheckerMB;
     private entrypointsBuilder;
     protected environmentManager: EnvironmentManager;
-    private errorMB;
-    private fsManager;
     private helmetMB;
     protected logger: Logger;
-    private publicApiKeyCheckerMB;
-    private requestCheckerMB;
-    private requestHandlerMB;
-    private requestLoggerMB;
+    private serverRequestHandler;
+    private serverSSLCertLoader;
     private settingsManager;
     private ucManager;
     protected runtime: Express;
     private server;
-    constructor(authenticationCheckerMB: AuthenticationCheckerMiddlewareBuilder<any, any, any>, entrypointsBuilder: EntrypointsBuilder, environmentManager: EnvironmentManager, errorMB: ErrorMiddlewareBuilder, fsManager: FSManager, helmetMB: HelmetMiddlewareBuilder, logger: Logger, publicApiKeyCheckerMB: PublicApiKeyCheckerMiddlewareBuilder, requestCheckerMB: RequestCheckerMiddlewareBuilder, requestHandlerMB: RequestHandlerMiddlewareBuilder<any, any, any>, requestLoggerMB: RequestLoggerMiddlewareBuilder, settingsManager: SettingsManager<S>, ucManager: UCManager);
+    constructor(entrypointsBuilder: EntrypointsBuilder, environmentManager: EnvironmentManager, helmetMB: HelmetMiddlewareBuilder, logger: Logger, serverRequestHandler: ServerRequestHandler, serverSSLCertLoader: ServerSSLCertLoader, settingsManager: SettingsManager<S>, ucManager: UCManager);
     s(): S;
     getRuntime(): Express;
     overrideUCManager(ucManager: UCManager): void;
@@ -40,5 +31,8 @@ export declare class NodeExpressServerManager implements Configurable<S>, Server
     stop(): Promise<void>;
     warmUp(): Promise<void>;
     private createServer;
+    private toFile;
+    private toReq;
+    private toRes;
 }
 export {};