libmodulor 0.1.0 → 0.2.0

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

@@ -0,0 +1,52 @@
+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 { capitalize } from '../../../utils/index.js';
+let PrivateApiKeyAuthenticationChecker = class PrivateApiKeyAuthenticationChecker {
+    settingsManager;
+    constructor(settingsManager) {
+        this.settingsManager = settingsManager;
+    }
+    s() {
+        return {
+            server_private_api_key_entries: this.settingsManager.get()('server_private_api_key_entries'),
+        };
+    }
+    async exec({ rawValue }) {
+        const value = rawValue?.replace('Bearer ', '');
+        if (!value) {
+            return null;
+        }
+        const exists = this.s().server_private_api_key_entries.find((key) => key === value);
+        if (!exists) {
+            return null;
+        }
+        return {
+            organization: {
+                id: '',
+            },
+            role: 'admin',
+            user: {
+                firstname: capitalize('admin'),
+                id: '',
+                initials: '',
+            },
+        };
+    }
+};
+PrivateApiKeyAuthenticationChecker = __decorate([
+    injectable(),
+    __param(0, inject('SettingsManager')),
+    __metadata("design:paramtypes", [Object])
+], PrivateApiKeyAuthenticationChecker);
+export { PrivateApiKeyAuthenticationChecker };

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

@@ -0,0 +1,16 @@
+import type { Configurable, Logger, SettingsManager, Worker } from '../../../std/index.js';
+import { type UCSecPublicApiKeyCheckType } from '../../../uc/index.js';
+import type { ServerManagerSettings } from './ServerManager.js';
+interface Input {
+    checkType: UCSecPublicApiKeyCheckType | undefined;
+    value: string | string[] | undefined;
+}
+type S = Pick<ServerManagerSettings, 'server_public_api_key_entries'>;
+export declare class PublicApiKeyChecker implements Configurable<S>, Worker<Input, Promise<void>> {
+    private logger;
+    private settingsManager;
+    constructor(logger: Logger, settingsManager: SettingsManager<S>);
+    s(): S;
+    exec({ checkType, value, }: Input): Promise<void>;
+}
+export {};

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

@@ -0,0 +1,55 @@
+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 { UnauthorizedError } from '../../../error/index.js';
+import { DEFAULT_UC_SEC_PAKCT, } from '../../../uc/index.js';
+let PublicApiKeyChecker = class PublicApiKeyChecker {
+    logger;
+    settingsManager;
+    constructor(logger, settingsManager) {
+        this.logger = logger;
+        this.settingsManager = settingsManager;
+    }
+    s() {
+        return {
+            server_public_api_key_entries: this.settingsManager.get()('server_public_api_key_entries'),
+        };
+    }
+    async exec({ checkType = DEFAULT_UC_SEC_PAKCT, value, }) {
+        this.logger.trace('Checking apiKey', { checkType, value });
+        let allowed = false;
+        switch (checkType) {
+            case 'off':
+                allowed = true;
+                break;
+            case 'on':
+                if (value && !Array.isArray(value)) {
+                    const exists = this.s().server_public_api_key_entries.find((key) => key === value);
+                    allowed = exists !== undefined;
+                }
+                break;
+            default:
+                ((_) => { })(checkType);
+        }
+        if (!allowed) {
+            throw new UnauthorizedError();
+        }
+    }
+};
+PublicApiKeyChecker = __decorate([
+    injectable(),
+    __param(0, inject('Logger')),
+    __param(1, inject('SettingsManager')),
+    __metadata("design:paramtypes", [Object, Object])
+], PublicApiKeyChecker);
+export { PublicApiKeyChecker };

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

@@ -0,0 +1,18 @@
+import type { URL } from '../../../dt/index.js';
+import type { Configurable, EnvironmentManager, Logger, SettingsManager, Worker } from '../../../std/index.js';
+import type { ServerManagerSettings } from './ServerManager.js';
+interface Input {
+    secure: boolean;
+    url: URL;
+    xForwardedProtoHeader: string | undefined;
+}
+type S = Pick<ServerManagerSettings, 'server_binding_port'>;
+export declare class RequestChecker implements Configurable<S>, Worker<Input, void> {
+    private environmentManager;
+    private logger;
+    private settingsManager;
+    constructor(environmentManager: EnvironmentManager, logger: Logger, settingsManager: SettingsManager<S>);
+    s(): S;
+    exec({ secure, url, xForwardedProtoHeader }: Input): void;
+}
+export {};

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

@@ -0,0 +1,53 @@
+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 { ForbiddenError } from '../../../error/index.js';
+let RequestChecker = class RequestChecker {
+    environmentManager;
+    logger;
+    settingsManager;
+    constructor(environmentManager, logger, settingsManager) {
+        this.environmentManager = environmentManager;
+        this.logger = logger;
+        this.settingsManager = settingsManager;
+    }
+    s() {
+        return {
+            server_binding_port: this.settingsManager.get()('server_binding_port'),
+        };
+    }
+    exec({ secure, url, xForwardedProtoHeader }) {
+        const isSecure = secure;
+        const isSecureForwarded = xForwardedProtoHeader === 'https';
+        const isNotProd = !this.environmentManager.isProd();
+        const isSSLCertificateCheck = !!url.match(/^\/\.well-known\/acme-challenge\/(.*)/);
+        this.logger.trace('Request checker', {
+            isNotProd,
+            isSSLCertificateCheck,
+            isSecure,
+            isSecureForwarded,
+        });
+        const allowed = isSecure || isSecureForwarded || isNotProd || isSSLCertificateCheck;
+        if (!allowed) {
+            throw new ForbiddenError();
+        }
+    }
+};
+RequestChecker = __decorate([
+    injectable(),
+    __param(0, inject('EnvironmentManager')),
+    __param(1, inject('Logger')),
+    __param(2, inject('SettingsManager')),
+    __metadata("design:paramtypes", [Object, Object, Object])
+], RequestChecker);
+export { RequestChecker };

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

@@ -0,0 +1,9 @@
+import type { AppManifest } from '../../../app/index.js';
+import type { UCDef, UCInput, UCManager, UCOPIBase } from '../../../uc/index.js';
+import type { HTTPDataEnvelope } from '../../../utils/index.js';
+export interface RequestHandlerInputRaw<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> {
+    appManifest: AppManifest;
+    envelope: HTTPDataEnvelope;
+    ucd: UCDef<I, OPI0, OPI1>;
+    ucManager: UCManager;
+}

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

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

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

@@ -0,0 +1,14 @@
+import type { HTTPMethod, URL } from '../../../dt/index.js';
+import type { EnvironmentManager, Logger, Worker } from '../../../std/index.js';
+interface Input {
+    body: unknown;
+    method: HTTPMethod;
+    url: URL;
+}
+export declare class RequestLogger implements Worker<Input, void> {
+    private environmentManager;
+    private logger;
+    constructor(environmentManager: EnvironmentManager, logger: Logger);
+    exec({ body, method, url }: Input): void;
+}
+export {};

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

@@ -0,0 +1,36 @@
+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 RequestLogger = class RequestLogger {
+    environmentManager;
+    logger;
+    constructor(environmentManager, logger) {
+        this.environmentManager = environmentManager;
+        this.logger = logger;
+    }
+    exec({ body, method, url }) {
+        const prefix = [method, url].join(' ');
+        if (this.environmentManager.isProd()) {
+            this.logger.debug(prefix);
+            return;
+        }
+        this.logger.debug(prefix, JSON.stringify(body));
+    }
+};
+RequestLogger = __decorate([
+    injectable(),
+    __param(0, inject('EnvironmentManager')),
+    __param(1, inject('Logger')),
+    __metadata("design:paramtypes", [Object, Object])
+], RequestLogger);
+export { RequestLogger };

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

@@ -0,0 +1,24 @@
+import type { AppUCsLoaderInput } from '../../../app/index.js';
+import { ProductUCsLoader } from '../../../product/index.js';
+import type { Configurable, EmailManager, FSManager, I18nManager, JobManager, Logger, SettingsManager, Worker } from '../../../std/index.js';
+import { type UCManager } from '../../../uc/index.js';
+import { ServerInstaller } from './ServerInstaller.js';
+import type { ServerManager, ServerManagerSettings } from './ServerManager.js';
+type S = Pick<ServerManagerSettings, 'server_static_dir_path'>;
+type Input = Pick<AppUCsLoaderInput, 'appsRootPath' | 'srcImporter'>;
+export declare class ServerBooter implements Configurable<S>, Worker<Input, Promise<void>> {
+    private emailManager;
+    private fsManager;
+    private i18nManager;
+    private jobManager;
+    private logger;
+    private productUCsLoader;
+    private serverManager;
+    private serverInstaller;
+    private settingsManager;
+    private ucManager;
+    constructor(emailManager: EmailManager, fsManager: FSManager, i18nManager: I18nManager, jobManager: JobManager, logger: Logger, productUCsLoader: ProductUCsLoader, serverManager: ServerManager, serverInstaller: ServerInstaller, settingsManager: SettingsManager<S>, ucManager: UCManager);
+    s(): S;
+    exec({ appsRootPath, srcImporter }: Input): Promise<void>;
+}
+export {};

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

@@ -0,0 +1,111 @@
+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 { ProductUCsLoader } from '../../../product/index.js';
+import { UCExecMode, ucHTTPContract, } from '../../../uc/index.js';
+import { ServerInstaller } from './ServerInstaller.js';
+let ServerBooter = class ServerBooter {
+    emailManager;
+    fsManager;
+    i18nManager;
+    jobManager;
+    logger;
+    productUCsLoader;
+    serverManager;
+    serverInstaller;
+    settingsManager;
+    ucManager;
+    constructor(emailManager, fsManager, i18nManager, jobManager, logger, productUCsLoader, serverManager, serverInstaller, settingsManager, ucManager) {
+        this.emailManager = emailManager;
+        this.fsManager = fsManager;
+        this.i18nManager = i18nManager;
+        this.jobManager = jobManager;
+        this.logger = logger;
+        this.productUCsLoader = productUCsLoader;
+        this.serverManager = serverManager;
+        this.serverInstaller = serverInstaller;
+        this.settingsManager = settingsManager;
+        this.ucManager = ucManager;
+    }
+    s() {
+        return {
+            server_static_dir_path: this.settingsManager.get()('server_static_dir_path'),
+        };
+    }
+    async exec({ appsRootPath, srcImporter }) {
+        this.logger.info('Initializing i18n manager');
+        await this.i18nManager.init();
+        this.logger.info('Installing');
+        await this.serverInstaller.exec();
+        this.logger.info('Initializing job manager');
+        await this.jobManager.init();
+        this.logger.info('Verifying email manager');
+        await this.emailManager.verify();
+        this.logger.info('Starting');
+        try {
+            await this.serverManager.init();
+            const ucs = await this.productUCsLoader.exec({
+                appsRootPath,
+                srcImporter,
+            });
+            for await (const uc of ucs) {
+                const { lifecycle: { server }, sec, } = uc.def;
+                const contract = ucHTTPContract(uc);
+                const { mountingPoint } = contract;
+                if (typeof server !== 'object' ||
+                    server.execMode === UCExecMode.AUTO) {
+                    this.logger.debug(`Not mounting ${mountingPoint}`, {
+                        reason: typeof server !== 'object'
+                            ? 'no ucd.lifecycle.server'
+                            : 'execMode is AUTO',
+                    });
+                    continue;
+                }
+                this.logger.info(`Mounting ${mountingPoint}`, {
+                    contract,
+                    sec,
+                });
+                await this.ucManager.initServer(uc);
+                await this.serverManager.mount(uc.appManifest, uc.def, contract);
+            }
+            const staticDirPath = this.s().server_static_dir_path;
+            if (staticDirPath) {
+                if (!(await this.fsManager.exists(staticDirPath))) {
+                    throw new Error(`Static dir '${staticDirPath}' does not exist`);
+                }
+                this.logger.info('Mounting static dir', { staticDirPath });
+                await this.serverManager.mountStaticDir(staticDirPath);
+            }
+            await this.serverManager.warmUp();
+            await this.serverManager.start();
+        }
+        catch (err) {
+            this.logger.error(err);
+        }
+    }
+};
+ServerBooter = __decorate([
+    injectable(),
+    __param(0, inject('EmailManager')),
+    __param(1, inject('FSManager')),
+    __param(2, inject('I18nManager')),
+    __param(3, inject('JobManager')),
+    __param(4, inject('Logger')),
+    __param(5, inject(ProductUCsLoader)),
+    __param(6, inject('ServerManager')),
+    __param(7, inject(ServerInstaller)),
+    __param(8, inject('SettingsManager')),
+    __param(9, inject('UCManager')),
+    __metadata("design:paramtypes", [Object, Object, Object, Object, Object, ProductUCsLoader, Object, ServerInstaller, Object, Object])
+], ServerBooter);
+export { ServerBooter };

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

@@ -0,0 +1,10 @@
+import { UCDataStoreExternalResourceManager } from '../../../std/impl/UCDataStoreExternalResourceManager.js';
+import { ExternalResourceInstaller, type Logger, type Worker } from '../../../std/index.js';
+export declare class ServerInstaller implements Worker<void, Promise<void>> {
+    private externalResourceInstaller;
+    private logger;
+    private ucDataStoreERM;
+    constructor(externalResourceInstaller: ExternalResourceInstaller, logger: Logger, ucDataStoreERM: UCDataStoreExternalResourceManager);
+    exec(): Promise<void>;
+    private onFeedback;
+}

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

@@ -0,0 +1,44 @@
+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 { UCDataStoreExternalResourceManager } from '../../../std/impl/UCDataStoreExternalResourceManager.js';
+import { ExternalResourceInstaller, } from '../../../std/index.js';
+let ServerInstaller = class ServerInstaller {
+    externalResourceInstaller;
+    logger;
+    ucDataStoreERM;
+    constructor(externalResourceInstaller, logger, ucDataStoreERM) {
+        this.externalResourceInstaller = externalResourceInstaller;
+        this.logger = logger;
+        this.ucDataStoreERM = ucDataStoreERM;
+    }
+    async exec() {
+        await this.externalResourceInstaller.exec({
+            autoGenerate: true,
+            force: false,
+            manager: this.ucDataStoreERM,
+            onFeedback: (feedback) => this.onFeedback(feedback),
+        });
+    }
+    async onFeedback(feedback) {
+        this.logger.info(feedback.message);
+    }
+};
+ServerInstaller = __decorate([
+    injectable(),
+    __param(0, inject(ExternalResourceInstaller)),
+    __param(1, inject('Logger')),
+    __param(2, inject(UCDataStoreExternalResourceManager)),
+    __metadata("design:paramtypes", [ExternalResourceInstaller, Object, UCDataStoreExternalResourceManager])
+], ServerInstaller);
+export { ServerInstaller };

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

@@ -0,0 +1,39 @@
+import type { AppManifest } from '../../../app/index.js';
+import type { ApiKey, DirPath, FilePath, HostPort, Password, URL, Username } from '../../../dt/index.js';
+import type { Settings } from '../../../std/index.js';
+import type { UCDef, UCHTTPContract, UCInput, UCManager, UCOPIBase } from '../../../uc/index.js';
+import type { Initializable } from '../../../utils/index.js';
+import type { AuthCookieName, PublicApiKeyHeaderName } from '../shared.js';
+export type ServerManagerCSPDefType = 'defaultSrc' | 'imgSrc' | 'scriptSrc';
+export type ServerManagerCSPDefValue = URL[];
+export type ServerManagerCSPDef = Record<ServerManagerCSPDefType, ServerManagerCSPDefValue>;
+export interface ServerManagerAuthSettings {
+    server_basic_auth_entries: Record<Username, Password>;
+    server_private_api_key_entries: ApiKey[];
+    server_public_api_key_entries: ApiKey[];
+}
+export interface ServerManagerSettings extends ServerManagerAuthSettings, Settings {
+    server_binding_host: 'localhost' | '0.0.0.0';
+    server_binding_port: HostPort;
+    server_cookies_http_only: boolean;
+    server_cookies_name_auth: AuthCookieName;
+    server_cookies_same_site: 'strict';
+    server_cookies_secure: boolean;
+    server_csp_default_src: ServerManagerCSPDefValue;
+    server_csp_img_src: ServerManagerCSPDefValue;
+    server_csp_script_src: ServerManagerCSPDefValue;
+    server_public_api_key_header_name: PublicApiKeyHeaderName;
+    server_public_url: URL;
+    server_ssl_fullchain_path: FilePath | null;
+    server_ssl_key_path: FilePath | null;
+    server_static_dir_path: DirPath | null;
+    server_tmp_path: FilePath;
+}
+export interface ServerManager extends Initializable {
+    overrideUCManager(ucManager: UCManager): 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/lib/server/ServerManager.js

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

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

@@ -0,0 +1,2 @@
+import type { ServerManagerSettings } from './ServerManager.js';
+export declare const TARGET_DEFAULT_SERVER_MANAGER_SETTINGS: ServerManagerSettings;

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

@@ -0,0 +1,20 @@
+export const TARGET_DEFAULT_SERVER_MANAGER_SETTINGS = {
+    server_basic_auth_entries: {},
+    server_binding_host: 'localhost',
+    server_binding_port: 7443,
+    server_cookies_http_only: true,
+    server_cookies_name_auth: 'auth',
+    server_cookies_same_site: 'strict',
+    server_cookies_secure: true,
+    server_csp_default_src: [],
+    server_csp_img_src: [],
+    server_csp_script_src: [],
+    server_private_api_key_entries: [],
+    server_public_api_key_entries: ['PublicApiKeyToBeChangedWhenDeploying'],
+    server_public_api_key_header_name: 'X-API-Key',
+    server_public_url: 'http://localhost:7443',
+    server_ssl_fullchain_path: null,
+    server_ssl_key_path: null,
+    server_static_dir_path: null,
+    server_tmp_path: 'tmp',
+};

package/dist/esm/target/lib/shared.d.ts

@@ -0,0 +1,2 @@
+export type AuthCookieName = 'auth';
+export type PublicApiKeyHeaderName = 'X-API-Key' | (string & {});

package/dist/esm/target/lib/shared.js

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

package/dist/esm/target/lib/web/input.d.ts

@@ -0,0 +1,24 @@
+import { type DataType, type ErrorMessage, type HTMLInputType } from '../../../dt/index.js';
+import { type UCExecState, type UCInputField } from '../../../uc/index.js';
+export interface HTMLInputDef {
+    internal?: {
+        multiline?: boolean | undefined;
+    };
+    spec?: {
+        'aria-errormessage'?: string | undefined;
+        'aria-invalid'?: boolean | undefined;
+        disabled?: boolean | undefined;
+        id?: string | undefined;
+        max?: number | undefined;
+        maxLength?: number | undefined;
+        min?: number | undefined;
+        minLength?: number | undefined;
+        name?: string | undefined;
+        pattern?: string | undefined;
+        placeholder?: string | undefined;
+        required?: boolean | false;
+        step?: number | undefined;
+        type?: HTMLInputType | undefined;
+    };
+}
+export declare function htmlInputDef<T extends DataType>(field: UCInputField<T>, execState: UCExecState, errMsg: ErrorMessage | null): HTMLInputDef;

package/dist/esm/target/lib/web/input.js

@@ -0,0 +1,41 @@
+import { TNumber, TString, } from '../../../dt/index.js';
+import { ucIsDisabled, ucifHint, ucifId, ucifIsMandatory, } from '../../../uc/index.js';
+export function htmlInputDef(field, execState, errMsg) {
+    const def = {
+        internal: {},
+        spec: {},
+    };
+    if (!def.internal || !def.spec) {
+        return def;
+    }
+    const { key, def: fDef } = field;
+    const { type: fType } = fDef;
+    def.spec.disabled = ucIsDisabled(execState);
+    def.spec.id = ucifId(key);
+    def.spec.name = key;
+    if (fType instanceof TString) {
+        const constraints = fType.getConstraints();
+        if (constraints) {
+            def.spec.maxLength = constraints.maxLength;
+            def.spec.minLength = constraints.minLength;
+            def.spec.pattern = constraints.format?.regexp?.source;
+        }
+        def.internal.multiline = fType.isPotentiallyLong();
+    }
+    else if (fType instanceof TNumber) {
+        def.spec.max = fType.max();
+        def.spec.min = fType.min();
+        def.spec.step = fType.getStep();
+    }
+    def.spec.placeholder = ucifHint(fDef);
+    def.spec.required = ucifIsMandatory(fDef);
+    def.spec.type = fType.htmlInputType();
+    if (fType.isSensitive()) {
+        def.spec.type = 'password';
+    }
+    if (errMsg !== null) {
+        def.spec['aria-errormessage'] = errMsg;
+        def.spec['aria-invalid'] = true;
+    }
+    return def;
+}

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

@@ -0,0 +1,12 @@
+import { WordingManager } from '../../i18n/index.js';
+import { ProductUCsLoader } from '../../product/index.js';
+import type { CLIManager, Input, Output } from '../lib/cli/CLIManager.js';
+import { CommandExecutor } from '../lib/cli/CommandExecutor.js';
+export declare class NodeCoreCLIManager implements CLIManager {
+    private commandExecutor;
+    private productUCsLoader;
+    private wordingManager;
+    constructor(commandExecutor: CommandExecutor, productUCsLoader: ProductUCsLoader, wordingManager: WordingManager);
+    handleCommand({ appsRootPath, srcImporter, }: Input): Promise<Output>;
+    private parseArgsConfig;
+}