libmodulor 0.1.0 → 0.3.0

package/dist/esm/target/node-core-cli/NodeCoreCLIManager.js

@@ -0,0 +1,93 @@
+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 { parseArgs } from 'node:util';
+import { inject, injectable } from 'inversify';
+import { TBoolean } from '../../dt/index.js';
+import { WordingManager } from '../../i18n/index.js';
+import { ProductUCsLoader } from '../../product/index.js';
+import { ucMountingPoint, ucifRepeatability, } from '../../uc/index.js';
+import { CommandExecutor } from '../lib/cli/CommandExecutor.js';
+import { print } from '../lib/cli/renderer.js';
+import { showHelp } from './commands.js';
+let NodeCoreCLIManager = class NodeCoreCLIManager {
+    commandExecutor;
+    productUCsLoader;
+    wordingManager;
+    constructor(commandExecutor, productUCsLoader, wordingManager) {
+        this.commandExecutor = commandExecutor;
+        this.productUCsLoader = productUCsLoader;
+        this.wordingManager = wordingManager;
+    }
+    async handleCommand({ appsRootPath, srcImporter, }) {
+        const command = process.argv[2] ?? '';
+        const ucs = await this.productUCsLoader.exec({
+            appsRootPath,
+            srcImporter,
+        });
+        const commands = new Map(ucs.map((uc) => [
+            uc.def.ext?.cmd?.mountAt ?? ucMountingPoint(uc),
+            uc,
+        ]));
+        if (!command || !command.trim() || command === '--help') {
+            showHelp(ucs, this.wordingManager);
+        }
+        else if (command === '--version') {
+            print(await this.commandExecutor.version());
+        }
+        else {
+            const uc = commands.get(command);
+            if (!uc) {
+                showHelp(ucs, this.wordingManager);
+                return;
+            }
+            const args = parseArgs(this.parseArgsConfig(uc));
+            uc.fill(args.values);
+            await this.commandExecutor.exec({ uc });
+        }
+    }
+    parseArgsConfig(uc) {
+        const config = {
+            allowPositionals: true,
+            strict: true,
+        };
+        if (uc.inputFields.length === 0) {
+            return config;
+        }
+        config.options = {};
+        for (const f of this.commandExecutor.fieldsForFlags(uc)) {
+            const { def } = f;
+            let defaultValue = def.type.getDefaultValue();
+            if (typeof defaultValue === 'number') {
+                defaultValue = defaultValue.toString();
+            }
+            const [isRepeatable, _max] = ucifRepeatability(def);
+            const type = def.type instanceof TBoolean ? 'boolean' : 'string';
+            config.options[f.key] = {
+                default: defaultValue,
+                multiple: isRepeatable,
+                type,
+            };
+        }
+        return config;
+    }
+};
+NodeCoreCLIManager = __decorate([
+    injectable(),
+    __param(0, inject(CommandExecutor)),
+    __param(1, inject(ProductUCsLoader)),
+    __param(2, inject(WordingManager)),
+    __metadata("design:paramtypes", [CommandExecutor,
+        ProductUCsLoader,
+        WordingManager])
+], NodeCoreCLIManager);
+export { NodeCoreCLIManager };

package/dist/esm/target/node-core-cli/commands.d.ts

@@ -0,0 +1,3 @@
+import type { WordingManager } from '../../i18n/index.js';
+import { type UC } from '../../uc/index.js';
+export declare function showHelp(ucs: UC[], wordingManager: WordingManager): void;

package/dist/esm/target/node-core-cli/commands.js

@@ -0,0 +1,55 @@
+import { ucMountingPoint, ucifIsMandatory } from '../../uc/index.js';
+import { fmtBold, fmtCommand, fmtPadEndFor, fmtSection, } from '../../utils/index.js';
+import { print } from '../lib/cli/renderer.js';
+const FLAG_PREFIX = '--';
+const CORE_FLAGS = [
+    ['help', 'View the available commands and flags'],
+    ['version', 'View the version'],
+];
+const COMMAND_FLAG_INDENT = '    ';
+const MANDATORY_LABEL = '(mandatory)';
+const DEFAULT_LABEL = (defaultValue) => `(default: ${defaultValue})`;
+const COMMANDS_TITLE = 'Commands';
+const FLAGS_TITLE = 'Flags';
+export function showHelp(ucs, wordingManager) {
+    const coreFlags = CORE_FLAGS.map(([f]) => `${FLAG_PREFIX}${f}`);
+    const mountingPoints = ucs.map((uc) => ucMountingPoint(uc));
+    const ucFieldsNames = ucs.flatMap((uc) => uc.inputFields.map((f) => `${FLAG_PREFIX}${f.key}`));
+    const words = [...coreFlags, ...mountingPoints, ...ucFieldsNames];
+    const padEnd = fmtPadEndFor(words);
+    const { desc } = wordingManager.p();
+    if (desc) {
+        print(fmtBold(desc));
+    }
+    print(fmtSection(COMMANDS_TITLE));
+    let i = 0;
+    for (const uc of ucs) {
+        const mountingPoint = uc.def.ext?.cmd?.mountAt ?? ucMountingPoint(uc);
+        print(fmtCommand(mountingPoint, wordingManager.uc(uc.def).desc ?? undefined, padEnd));
+        print('');
+        const fields = uc.inputFieldsInsensitive();
+        for (const f of fields) {
+            const mandatoryLabel = ucifIsMandatory(f.def)
+                ? fmtBold(MANDATORY_LABEL)
+                : '';
+            const defaultValue = f.def.type.getDefaultValue();
+            const defaultValueLabel = defaultValue !== undefined
+                ? fmtBold(DEFAULT_LABEL(defaultValue))
+                : '';
+            const field = `${COMMAND_FLAG_INDENT}${FLAG_PREFIX}${f.key}`;
+            const { desc, label } = wordingManager.ucif(f);
+            const details = [mandatoryLabel, defaultValueLabel, desc ?? label]
+                .filter((s) => !!s)
+                .join(' ');
+            print(fmtCommand(field, details.trim(), padEnd));
+        }
+        if (i < ucs.length - 1) {
+            print('');
+        }
+        i++;
+    }
+    print(fmtSection(FLAGS_TITLE));
+    for (const [f, desc] of CORE_FLAGS) {
+        print(fmtCommand(`${FLAG_PREFIX}${f}`, desc, padEnd));
+    }
+}

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

@@ -0,0 +1,44 @@
+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 { 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 { 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'>;
+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 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);
+    s(): S;
+    getRuntime(): Express;
+    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;
+}
+export {};

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

@@ -0,0 +1,184 @@
+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 cookieParser from 'cookie-parser';
+import express, {} from 'express';
+import fileUpload from 'express-fileupload';
+import { inject, injectable } from 'inversify';
+import { EntrypointsBuilder } from '../lib/server/EntrypointsBuilder.js';
+import { AuthenticationCheckerMiddlewareBuilder } from './middlewares/AuthenticationCheckerMiddlewareBuilder.js';
+import { ErrorMiddlewareBuilder } from './middlewares/ErrorMiddlewareBuilder.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;
+    settingsManager;
+    ucManager;
+    runtime;
+    server;
+    constructor(authenticationCheckerMB, entrypointsBuilder, environmentManager, errorMB, fsManager, helmetMB, logger, publicApiKeyCheckerMB, requestCheckerMB, requestHandlerMB, requestLoggerMB, settingsManager, ucManager) {
+        this.authenticationCheckerMB = authenticationCheckerMB;
+        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.settingsManager = settingsManager;
+        this.ucManager = ucManager;
+    }
+    s() {
+        return {
+            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'),
+        };
+    }
+    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 = express();
+        this.runtime.use(this.helmetMB.exec({}));
+        this.runtime.use(fileUpload({
+            createParentPath: true,
+            debug: this.s().logger_level === 'trace',
+            tempFileDir: this.s().server_tmp_path,
+            useTempFiles: true,
+        }));
+        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({
+                appManifest,
+                envelope,
+                ucd,
+                ucManager: this.ucManager,
+            }),
+        ];
+        this.runtime[httpMethod](path, handlers);
+        for (const pathAlias of pathAliases) {
+            this.runtime[httpMethod](pathAlias, handlers);
+        }
+    }
+    async mountStaticDir(dirPath) {
+        this.runtime.use(express.static(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() {
+        if (!this.server?.listening) {
+            return;
+        }
+        return new Promise((resolve, reject) => {
+            if (!this.server) {
+                return resolve();
+            }
+            this.server.close((err) => {
+                if (err) {
+                    return reject(err);
+                }
+                resolve();
+            });
+        });
+    }
+    async warmUp() {
+        this.runtime.use(this.errorMB.exec({}));
+    }
+    async createServer() {
+        const port = this.s().server_binding_port;
+        if (port !== 443) {
+            this.logger.info('Creating HTTP server', { port });
+            this.server = http.createServer(this.runtime);
+            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),
+        };
+        this.server = https.createServer(credentials, this.runtime);
+    }
+};
+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])
+], NodeExpressServerManager);
+export { NodeExpressServerManager };

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

@@ -0,0 +1,21 @@
+import type { CookieOptions } from 'express';
+import type { JWT } from '../../../dt/index.js';
+import type { JWTManager, SettingsManager, Worker } from '../../../std/index.js';
+import type { ServerManagerSettings } from '../../lib/server/ServerManager.js';
+interface Input {
+    jwt: JWT;
+}
+interface Output {
+    name: string;
+    opts: CookieOptions;
+    val: JWT;
+}
+type S = Pick<ServerManagerSettings, 'server_cookies_http_only' | 'server_cookies_name_auth' | 'server_cookies_same_site' | 'server_cookies_secure'>;
+export declare class AuthCookieCreator implements Worker<Input, Promise<Output>> {
+    private jwtManager;
+    private settingsManager;
+    constructor(jwtManager: JWTManager, settingsManager: SettingsManager<S>);
+    s(): S;
+    exec({ jwt }: Input): Promise<Output>;
+}
+export {};

package/dist/esm/target/node-express-server/lib/AuthCookieCreator.js

@@ -0,0 +1,50 @@
+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 AuthCookieCreator = class AuthCookieCreator {
+    jwtManager;
+    settingsManager;
+    constructor(jwtManager, settingsManager) {
+        this.jwtManager = jwtManager;
+        this.settingsManager = settingsManager;
+    }
+    s() {
+        return {
+            server_cookies_http_only: this.settingsManager.get()('server_cookies_http_only'),
+            server_cookies_name_auth: this.settingsManager.get()('server_cookies_name_auth'),
+            server_cookies_same_site: this.settingsManager.get()('server_cookies_same_site'),
+            server_cookies_secure: this.settingsManager.get()('server_cookies_secure'),
+        };
+    }
+    async exec({ jwt }) {
+        const { exp } = await this.jwtManager.decode(jwt);
+        return {
+            name: this.s().server_cookies_name_auth,
+            opts: {
+                expires: exp ? new Date(exp * 1000) : undefined,
+                httpOnly: this.s().server_cookies_http_only,
+                sameSite: this.s().server_cookies_same_site,
+                secure: this.s().server_cookies_secure,
+                signed: false,
+            },
+            val: jwt,
+        };
+    }
+};
+AuthCookieCreator = __decorate([
+    injectable(),
+    __param(0, inject('JWTManager')),
+    __param(1, inject('SettingsManager')),
+    __metadata("design:paramtypes", [Object, Object])
+], AuthCookieCreator);
+export { AuthCookieCreator };

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

@@ -0,0 +1,21 @@
+import type { Request, RequestHandler } from 'express';
+import type { Configurable, SettingsManager, Worker } from '../../../std/index.js';
+import { type UCAuth, UCBuilder, type UCInput, type UCOPIBase } from '../../../uc/index.js';
+import { AuthenticationChecker, type AuthenticationCheckerInputRaw } from '../../lib/server/AuthenticationChecker.js';
+import type { ServerManagerSettings } from '../../lib/server/ServerManager.js';
+type Input<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> = AuthenticationCheckerInputRaw<I, OPI0, OPI1>;
+type Output = RequestHandler;
+interface ReqAuthenticated extends Request {
+    auth: UCAuth;
+}
+export declare function isReqAuthenticated(req: Request): req is ReqAuthenticated;
+type S = Pick<ServerManagerSettings, 'server_cookies_name_auth'>;
+export declare class AuthenticationCheckerMiddlewareBuilder<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> implements Configurable<S>, Worker<Input<I, OPI0, OPI1>, Output> {
+    private authenticationChecker;
+    private settingsManager;
+    private ucBuilder;
+    constructor(authenticationChecker: AuthenticationChecker, settingsManager: SettingsManager<S>, ucBuilder: UCBuilder);
+    s(): S;
+    exec({ appManifest, ucd }: Input<I, OPI0, OPI1>): Output;
+}
+export {};

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

@@ -0,0 +1,66 @@
+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 { UCBuilder, } from '../../../uc/index.js';
+import { AuthenticationChecker, } from '../../lib/server/AuthenticationChecker.js';
+export function isReqAuthenticated(req) {
+    return !!req.auth;
+}
+let AuthenticationCheckerMiddlewareBuilder = class AuthenticationCheckerMiddlewareBuilder {
+    authenticationChecker;
+    settingsManager;
+    ucBuilder;
+    constructor(authenticationChecker, settingsManager, ucBuilder) {
+        this.authenticationChecker = authenticationChecker;
+        this.settingsManager = settingsManager;
+        this.ucBuilder = ucBuilder;
+    }
+    s() {
+        return {
+            server_cookies_name_auth: this.settingsManager.get()('server_cookies_name_auth'),
+        };
+    }
+    exec({ appManifest, ucd }) {
+        return async (req, _res, nextFn) => {
+            const authCookie = req.cookies[this.s().server_cookies_name_auth];
+            const authorizationHeader = req.headers.authorization;
+            const uc = this.ucBuilder.exec({
+                appManifest,
+                auth: null,
+                def: ucd,
+            });
+            try {
+                const { auth } = await this.authenticationChecker.exec({
+                    authCookie,
+                    authorizationHeader,
+                    uc,
+                });
+                if (auth) {
+                    req.auth = auth;
+                }
+                nextFn();
+            }
+            catch (err) {
+                nextFn(err);
+            }
+        };
+    }
+};
+AuthenticationCheckerMiddlewareBuilder = __decorate([
+    injectable(),
+    __param(0, inject(AuthenticationChecker)),
+    __param(1, inject('SettingsManager')),
+    __param(2, inject(UCBuilder)),
+    __metadata("design:paramtypes", [AuthenticationChecker, Object, UCBuilder])
+], AuthenticationCheckerMiddlewareBuilder);
+export { AuthenticationCheckerMiddlewareBuilder };

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

@@ -0,0 +1,12 @@
+import type { ErrorRequestHandler } from 'express';
+import type { Worker } from '../../../std/index.js';
+import { CustomerFacingErrorBuilder } from '../../lib/server/CustomerFacingErrorBuilder.js';
+interface Input {
+}
+type Output = ErrorRequestHandler;
+export declare class ErrorMiddlewareBuilder implements Worker<Input, Output> {
+    private customerFacingErrorBuilder;
+    constructor(customerFacingErrorBuilder: CustomerFacingErrorBuilder);
+    exec(_input: Input): Output;
+}
+export {};

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

@@ -0,0 +1,35 @@
+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 { CustomerFacingErrorBuilder } from '../../lib/server/CustomerFacingErrorBuilder.js';
+let ErrorMiddlewareBuilder = class ErrorMiddlewareBuilder {
+    customerFacingErrorBuilder;
+    constructor(customerFacingErrorBuilder) {
+        this.customerFacingErrorBuilder = customerFacingErrorBuilder;
+    }
+    exec(_input) {
+        return (error, _req, res, nextFn) => {
+            const { error: customError } = this.customerFacingErrorBuilder.exec({
+                error,
+            });
+            res.status(customError.httpStatus).send(customError.toObj());
+            nextFn();
+        };
+    }
+};
+ErrorMiddlewareBuilder = __decorate([
+    injectable(),
+    __param(0, inject(CustomerFacingErrorBuilder)),
+    __metadata("design:paramtypes", [CustomerFacingErrorBuilder])
+], ErrorMiddlewareBuilder);
+export { ErrorMiddlewareBuilder };

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

@@ -0,0 +1,12 @@
+import type { RequestHandler } from 'express';
+import type { Worker } from '../../../std/index.js';
+import { CSPDirectivesBuilder } from '../../lib/server/CSPDirectivesBuilder.js';
+interface Input {
+}
+type Output = RequestHandler;
+export declare class HelmetMiddlewareBuilder implements Worker<Input, Output> {
+    private cspDirectivesBuilder;
+    constructor(cspDirectivesBuilder: CSPDirectivesBuilder);
+    exec(_input: Input): Output;
+}
+export {};

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

@@ -0,0 +1,39 @@
+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 helmet from 'helmet';
+import { inject, injectable } from 'inversify';
+import { CSPDirectivesBuilder, } from '../../lib/server/CSPDirectivesBuilder.js';
+let HelmetMiddlewareBuilder = class HelmetMiddlewareBuilder {
+    cspDirectivesBuilder;
+    constructor(cspDirectivesBuilder) {
+        this.cspDirectivesBuilder = cspDirectivesBuilder;
+    }
+    exec(_input) {
+        const defaultDirectives = helmet.contentSecurityPolicy.getDefaultDirectives();
+        const { directives } = this.cspDirectivesBuilder.exec({
+            defaultDirectives,
+        });
+        return helmet({
+            contentSecurityPolicy: {
+                directives,
+                useDefaults: false,
+            },
+        });
+    }
+};
+HelmetMiddlewareBuilder = __decorate([
+    injectable(),
+    __param(0, inject(CSPDirectivesBuilder)),
+    __metadata("design:paramtypes", [CSPDirectivesBuilder])
+], HelmetMiddlewareBuilder);
+export { HelmetMiddlewareBuilder };