libmodulor 0.28.0 → 0.29.0

package/dist/esm/std/impl/SimpleMapI18nManager.d.ts

@@ -1,4 +1,4 @@
-import type { I18n, I18nLanguageCode, I18nTranslationKey } from '../../i18n/index.js';
+import { type I18n, type I18nLanguageCode, type I18nTranslationKey } from '../../i18n/index.js';
 import type { I18nManager, I18nManagerTOpts } from '../I18nManager.js';
 import type { Logger } from '../Logger.js';
 export declare class SimpleMapI18nManager implements I18nManager {

package/dist/esm/std/impl/SimpleMapI18nManager.js

@@ -12,6 +12,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 var SimpleMapI18nManager_1;
 import { inject, injectable } from 'inversify';
+import { I18N_DEFAULT_LANG, } from '../../i18n/index.js';
 let SimpleMapI18nManager = class SimpleMapI18nManager {
     static { SimpleMapI18nManager_1 = this; }
     i18n;
@@ -28,8 +29,9 @@ let SimpleMapI18nManager = class SimpleMapI18nManager {
             throw new Error('I18n must define at least one lang');
         }
         this.entries = new Map();
-        // biome-ignore lint/style/noNonNullAssertion: we want it
-        this.currentLang = this.langs[0];
+        this.currentLang =
+            // biome-ignore lint/style/noNonNullAssertion: we want it
+            this.langs.find((l) => l === I18N_DEFAULT_LANG) ?? this.langs[0];
     }
     async add(key, value) {
         this.current().set(key, value);

package/dist/esm/target/edge-worker-hono-server/SyncEdgeWorkerHonoServerManager.d.ts

@@ -1,23 +1,26 @@
 import type { Hono } from 'hono';
 import type { AppManifest } from '../../app/index.js';
-import type { DirPath } from '../../dt/index.js';
+import type { DirPath, URLPath } from '../../dt/index.js';
 import type { Configurable, SettingsManager } from '../../std/index.js';
 import type { UCDataStore, UCDef, UCHTTPContract, UCInput, UCManager, UCOPIBase } from '../../uc/index.js';
+import type { OpenAPISpec } from '../lib/openapi/types.js';
 import { CustomerFacingErrorBuilder } from '../lib/server/CustomerFacingErrorBuilder.js';
 import type { ServerManager } from '../lib/server/ServerManager.js';
 import { ServerRequestHandler } from '../lib/server/ServerRequestHandler.js';
+import { CORSMiddlewareBuilder } from '../lib/server-hono/CORSMiddlewareBuilder.js';
 export interface SyncEdgeWorkerHonoServerManagerSettings {
     sewhsm_bindings_uc_data_store: string | null;
 }
 type S = SyncEdgeWorkerHonoServerManagerSettings;
 export declare class SyncEdgeWorkerHonoServerManager implements Configurable<S>, ServerManager {
+    private corsMiddlewareBuilder;
     private customerFacingErrorBuilder;
     private serverRequestHandler;
     private settingsManager;
     private ucDataStore;
     private ucManager;
     protected runtime: Hono;
-    constructor(customerFacingErrorBuilder: CustomerFacingErrorBuilder, serverRequestHandler: ServerRequestHandler, settingsManager: SettingsManager<S>, ucDataStore: UCDataStore, ucManager: UCManager);
+    constructor(corsMiddlewareBuilder: CORSMiddlewareBuilder, customerFacingErrorBuilder: CustomerFacingErrorBuilder, serverRequestHandler: ServerRequestHandler, settingsManager: SettingsManager<S>, ucDataStore: UCDataStore, ucManager: UCManager);
     s(): SyncEdgeWorkerHonoServerManagerSettings;
     getRuntime(): Hono;
     overrideUCManager(ucManager: UCManager): void;
@@ -25,6 +28,7 @@ export declare class SyncEdgeWorkerHonoServerManager implements Configurable<S>,
     initSync(): 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>;
     mountSync<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(appManifest: AppManifest, ucd: UCDef<I, OPI0, OPI1>, contract: UCHTTPContract): void;
+    mountOpenAPISpec(_spec: OpenAPISpec, _at: URLPath): Promise<void>;
     mountStaticDir(_dirPath: DirPath): Promise<void>;
     start(): Promise<void>;
     stop(): Promise<void>;

package/dist/esm/target/edge-worker-hono-server/SyncEdgeWorkerHonoServerManager.js

@@ -11,18 +11,21 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 import { inject, injectable } from 'inversify';
-import { NotAvailableError, NotCallableError } from '../../error/index.js';
+import { NotAvailableError, NotCallableError, NotImplementedError, } from '../../error/index.js';
 import { CustomerFacingErrorBuilder } from '../lib/server/CustomerFacingErrorBuilder.js';
 import { ServerRequestHandler } from '../lib/server/ServerRequestHandler.js';
+import { CORSMiddlewareBuilder } from '../lib/server-hono/CORSMiddlewareBuilder.js';
 import { buildHandler, init, mountHandler } from '../lib/server-hono/funcs.js';
 let SyncEdgeWorkerHonoServerManager = class SyncEdgeWorkerHonoServerManager {
+    corsMiddlewareBuilder;
     customerFacingErrorBuilder;
     serverRequestHandler;
     settingsManager;
     ucDataStore;
     ucManager;
     runtime;
-    constructor(customerFacingErrorBuilder, serverRequestHandler, settingsManager, ucDataStore, ucManager) {
+    constructor(corsMiddlewareBuilder, customerFacingErrorBuilder, serverRequestHandler, settingsManager, ucDataStore, ucManager) {
+        this.corsMiddlewareBuilder = corsMiddlewareBuilder;
         this.customerFacingErrorBuilder = customerFacingErrorBuilder;
         this.serverRequestHandler = serverRequestHandler;
         this.settingsManager = settingsManager;
@@ -44,7 +47,7 @@ let SyncEdgeWorkerHonoServerManager = class SyncEdgeWorkerHonoServerManager {
         throw new NotCallableError('init', 'initSync', 'sync-only');
     }
     initSync() {
-        this.runtime = init(this.customerFacingErrorBuilder);
+        this.runtime = init(this.corsMiddlewareBuilder, this.customerFacingErrorBuilder);
     }
     async mount(_appManifest, _ucd, _contract) {
         throw new NotCallableError('mount', 'mountSync', 'sync-only');
@@ -52,6 +55,9 @@ let SyncEdgeWorkerHonoServerManager = class SyncEdgeWorkerHonoServerManager {
     mountSync(appManifest, ucd, contract) {
         mountHandler(contract, this.runtime, buildHandler(appManifest, ucd, contract, this.serverRequestHandler, this.ucManager, (c) => this.beforeExec(c)));
     }
+    async mountOpenAPISpec(_spec, _at) {
+        throw new NotImplementedError('mountOpenAPISpec');
+    }
     async mountStaticDir(_dirPath) {
         throw new NotAvailableError('mountStaticDir');
     }
@@ -81,12 +87,14 @@ let SyncEdgeWorkerHonoServerManager = class SyncEdgeWorkerHonoServerManager {
 };
 SyncEdgeWorkerHonoServerManager = __decorate([
     injectable(),
-    __param(0, inject(CustomerFacingErrorBuilder)),
-    __param(1, inject(ServerRequestHandler)),
-    __param(2, inject('SettingsManager')),
-    __param(3, inject('UCDataStore')),
-    __param(4, inject('UCManager')),
-    __metadata("design:paramtypes", [CustomerFacingErrorBuilder,
+    __param(0, inject(CORSMiddlewareBuilder)),
+    __param(1, inject(CustomerFacingErrorBuilder)),
+    __param(2, inject(ServerRequestHandler)),
+    __param(3, inject('SettingsManager')),
+    __param(4, inject('UCDataStore')),
+    __param(5, inject('UCManager')),
+    __metadata("design:paramtypes", [CORSMiddlewareBuilder,
+        CustomerFacingErrorBuilder,
         ServerRequestHandler, Object, Object, Object])
 ], SyncEdgeWorkerHonoServerManager);
 export { SyncEdgeWorkerHonoServerManager };

package/dist/esm/target/index.d.ts

@@ -1 +1,2 @@
 export { TARGETS, type TargetName } from './lib/manifest.js';
+export type { OpenAPISpec } from './lib/openapi/types.js';

package/dist/esm/target/lib/openapi/OpenAPISpecBuilder.d.ts

@@ -0,0 +1,25 @@
+import { WordingManager } from '../../../i18n/index.js';
+import type { ProductManifest, ProductUCsLoaderOutput } from '../../../product/index.js';
+import type { Configurable, I18nManager, SettingsManager, Worker } from '../../../std/index.js';
+import type { ServerManagerSettings } from '../server/ServerManager.js';
+import type { OpenAPISpec } from './types.js';
+type Input = {
+    ucs: ProductUCsLoaderOutput;
+};
+interface Output {
+    spec: OpenAPISpec;
+}
+type S = Pick<ServerManagerSettings, 'server_cookies_name_auth' | 'server_public_api_key_header_name' | 'server_public_url'>;
+export declare class OpenAPISpecBuilder implements Configurable<S>, Worker<Input, Promise<Output>> {
+    private i18nManager;
+    private productManifest;
+    private settingsManager;
+    private wordingManager;
+    constructor(i18nManager: I18nManager, productManifest: ProductManifest, settingsManager: SettingsManager<S>, wordingManager: WordingManager);
+    s(): S;
+    exec({ ucs }: Input): Promise<Output>;
+    private initErrors;
+    private initOutput;
+    private initPath;
+}
+export {};

package/dist/esm/target/lib/openapi/OpenAPISpecBuilder.js

@@ -0,0 +1,131 @@
+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 { WordingManager } from '../../../i18n/index.js';
+import { formatFQUCInputName, formatFQUCName, ucHTTPContract, } from '../../../uc/index.js';
+import { DEFAULT_VERSION } from '../shared.js';
+import { openAPIErrorSchema, openAPIErrors, openAPIInputSchema, openAPIParameters, openAPIRequestBody, openAPISecurity, openAPISecuritySchemes, openAPISuccess, } from './funcs.js';
+let OpenAPISpecBuilder = class OpenAPISpecBuilder {
+    i18nManager;
+    productManifest;
+    settingsManager;
+    wordingManager;
+    constructor(i18nManager, productManifest, settingsManager, wordingManager) {
+        this.i18nManager = i18nManager;
+        this.productManifest = productManifest;
+        this.settingsManager = settingsManager;
+        this.wordingManager = wordingManager;
+    }
+    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'),
+            server_public_url: this.settingsManager.get()('server_public_url'),
+        };
+    }
+    async exec({ ucs }) {
+        const output = this.initOutput();
+        const errors = this.initErrors();
+        const { desc, slogan } = this.wordingManager.p();
+        if (desc) {
+            output.spec.info.description = desc;
+        }
+        if (slogan) {
+            output.spec.info.summary = slogan;
+        }
+        for (const uc of ucs) {
+            const { method, path, pathAliases, envelope } = ucHTTPContract(uc);
+            const httpMethod = method.toLowerCase();
+            const fqUCName = formatFQUCName(uc.appManifest.name, uc.def.metadata.name);
+            const fqUCInputName = formatFQUCInputName(fqUCName);
+            output.spec.components.schemas[fqUCInputName] =
+                openAPIInputSchema(uc);
+            for (const p of [path, ...pathAliases]) {
+                output.spec.paths[p] = {
+                    ...output.spec.paths[p],
+                    [httpMethod]: this.initPath(errors, uc, envelope, fqUCInputName),
+                };
+            }
+        }
+        return output;
+    }
+    initErrors() {
+        const errors = openAPIErrors();
+        for (const error of Object.values(errors)) {
+            error.description = this.i18nManager.t(error.description);
+        }
+        return errors;
+    }
+    initOutput() {
+        return {
+            spec: {
+                components: {
+                    schemas: {
+                        Error: openAPIErrorSchema(),
+                    },
+                    securitySchemes: openAPISecuritySchemes(this.s().server_cookies_name_auth, this.s().server_public_api_key_header_name),
+                },
+                info: {
+                    title: this.productManifest.name,
+                    version: this.productManifest.version ?? DEFAULT_VERSION,
+                },
+                openapi: '3.1.0',
+                paths: {},
+                servers: [
+                    {
+                        url: this.s().server_public_url,
+                    },
+                ],
+            },
+        };
+    }
+    initPath(errors, 
+    // biome-ignore lint/suspicious/noExplicitAny: can be anything
+    uc, envelope, fqUCInputName) {
+        const { desc, label } = this.wordingManager.uc(uc.def);
+        const path = {
+            responses: {
+                ...openAPISuccess(uc),
+                ...errors,
+                // TODO : Infer errors that can be sent within ServerMain
+            },
+            security: openAPISecurity(uc.def.sec),
+            summary: label,
+            tags: [uc.appManifest.name],
+        };
+        if (desc) {
+            path.description = desc;
+        }
+        switch (envelope) {
+            case 'form-data':
+            case 'json':
+                path.requestBody = openAPIRequestBody(uc, envelope, fqUCInputName);
+                break;
+            case 'query-params':
+                path.parameters = openAPIParameters(uc, envelope);
+                break;
+            default:
+                envelope;
+        }
+        return path;
+    }
+};
+OpenAPISpecBuilder = __decorate([
+    injectable(),
+    __param(0, inject('I18nManager')),
+    __param(1, inject('ProductManifest')),
+    __param(2, inject('SettingsManager')),
+    __param(3, inject(WordingManager)),
+    __metadata("design:paramtypes", [Object, Object, Object, WordingManager])
+], OpenAPISpecBuilder);
+export { OpenAPISpecBuilder };

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

@@ -0,0 +1,2 @@
+import type { OpenAPIDescription } from './types.js';
+export declare const SUCCESS_DESCRIPTION: OpenAPIDescription;

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

@@ -0,0 +1 @@
+export const SUCCESS_DESCRIPTION = '🕺🏽';

package/dist/esm/target/lib/openapi/funcs.d.ts

@@ -0,0 +1,16 @@
+import { type ServerError } from '../../../error/index.js';
+import { type FQUCInputName, type UC, type UCInput, type UCInputUnwrapped, type UCOPIBase, type UCOutput, type UCOutputPart, type UCOutputReaderPart, type UCSec } from '../../../uc/index.js';
+import { type HTTPDataEnvelope } from '../../../utils/index.js';
+import { type AuthCookieName, type PublicApiKeyHeaderName } from '../shared.js';
+import type { OpenAPIParameter, OpenAPIRequestBody, OpenAPIResponses, OpenAPISchema, OpenAPISecurity, OpenAPISecuritySchemes } from './types.js';
+export declare function openAPIErrorSchema(): OpenAPISchema<ServerError>;
+export declare function openAPIErrors(): OpenAPIResponses;
+export declare function openAPIInputSchema<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(uc: UC<I, OPI0, OPI1>): OpenAPISchema<UCInputUnwrapped<I>>;
+export declare function openAPIOPISchema<OPI extends UCOPIBase>(part: UCOutputReaderPart<NonNullable<OPI>>): OpenAPISchema<OPI>;
+export declare function openAPIOutputPartSchema<OPI extends UCOPIBase>(part: UCOutputReaderPart<NonNullable<OPI>>): OpenAPISchema<UCOutputPart<OPI>>;
+export declare function openAPIOutputSchema<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(uc: UC<I, OPI0, OPI1>): OpenAPISchema<UCOutput<OPI0, OPI1>>;
+export declare function openAPIParameters<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(uc: UC<I, OPI0, OPI1>, envelope: Extract<HTTPDataEnvelope, 'query-params'>): OpenAPIParameter[];
+export declare function openAPIRequestBody<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(uc: UC<I, OPI0, OPI1>, envelope: Extract<HTTPDataEnvelope, 'form-data' | 'json'>, fqUCInputName: FQUCInputName): OpenAPIRequestBody;
+export declare function openAPISecuritySchemes(authCookieName: AuthCookieName, publicApiKeyHeaderName: PublicApiKeyHeaderName): OpenAPISecuritySchemes;
+export declare function openAPISecurity(sec: UCSec | undefined): OpenAPISecurity;
+export declare function openAPISuccess<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(uc: UC<I, OPI0, OPI1>): OpenAPIResponses;

package/dist/esm/target/lib/openapi/funcs.js

@@ -0,0 +1,249 @@
+import { ERROR_HTTP_STATUS_MAP, IllegalArgumentError, } from '../../../error/index.js';
+import { DEFAULT_UC_SEC_AT, DEFAULT_UC_SEC_PAKCT, UCOutputReader, ucofExamples, } from '../../../uc/index.js';
+import { isBlank } from '../../../utils/index.js';
+import { AUTHORIZATION_HEADER_NAME, } from '../shared.js';
+import { SUCCESS_DESCRIPTION } from './consts.js';
+import { openAPIInputDef } from './input.js';
+export function openAPIErrorSchema() {
+    return {
+        additionalProperties: false,
+        properties: {
+            message: {
+                examples: [new IllegalArgumentError().message],
+                type: 'string',
+            },
+        },
+        type: 'object',
+    };
+}
+export function openAPIErrors() {
+    return ERROR_HTTP_STATUS_MAP.entries().reduce((acc, cur) => {
+        const [status, clazz] = cur;
+        const message = new clazz().message;
+        acc[status] = {
+            content: {
+                'application/json': {
+                    schema: {
+                        additionalProperties: false,
+                        properties: {
+                            message: {
+                                examples: [message],
+                                type: 'string',
+                            },
+                        },
+                        type: 'object',
+                    },
+                },
+            },
+            description: message,
+        };
+        return acc;
+    }, {});
+}
+export function openAPIInputSchema(uc) {
+    const res = {
+        additionalProperties: false,
+        properties: {},
+        type: 'object',
+    };
+    for (const f of uc.inputFields) {
+        const { key } = f;
+        const { internal, spec } = openAPIInputDef(f);
+        if (!spec) {
+            continue;
+        }
+        const k = key;
+        res.properties[k] = spec;
+        if (!internal?.required) {
+            continue;
+        }
+        if (!res.required) {
+            res.required = [];
+        }
+        res.required.push(k);
+    }
+    return res;
+}
+export function openAPIOPISchema(part) {
+    const res = {
+        additionalProperties: false,
+        properties: {},
+        type: 'object',
+    };
+    for (const f of part.fields) {
+        const { def, key } = f;
+        const { type } = def;
+        const k = key;
+        res.properties[k] = type.jsonSchemaType();
+        const examples = ucofExamples(def);
+        if (examples) {
+            res.properties[k].examples = examples;
+        }
+    }
+    return res;
+}
+export function openAPIOutputPartSchema(part) {
+    return {
+        additionalProperties: false,
+        properties: {
+            items: {
+                items: openAPIOPISchema(part),
+                type: 'array',
+            },
+            pagination: {
+                properties: {
+                    id: { format: 'uuid', type: 'string' },
+                    limit: { type: 'integer' },
+                    offset: { type: 'integer' },
+                    q: { type: 'string' },
+                },
+                type: 'object',
+            },
+            total: { examples: [1], type: 'integer' },
+        },
+        required: ['items', 'total'],
+        type: 'object',
+    };
+}
+export function openAPIOutputSchema(uc) {
+    const res = {
+        additionalProperties: false,
+        properties: {},
+        type: 'object',
+    };
+    if (!uc.hasOutputParts()) {
+        return res;
+    }
+    const ucor = new UCOutputReader(uc.def, undefined);
+    const [part0, part1] = ucor.parts();
+    res.properties.parts = {
+        properties: {
+            _0: openAPIOutputPartSchema(part0),
+        },
+        type: 'object',
+    };
+    if (part1) {
+        res.properties.parts.properties = {
+            _1: openAPIOutputPartSchema(part1),
+        };
+    }
+    return res;
+}
+export function openAPIParameters(uc, envelope) {
+    const res = [];
+    switch (envelope) {
+        case 'query-params':
+            {
+                for (const f of uc.inputFields) {
+                    const { key } = f;
+                    const { internal, spec } = openAPIInputDef(f);
+                    if (!spec) {
+                        continue;
+                    }
+                    res.push({
+                        in: 'query',
+                        name: key,
+                        required: internal?.required ?? false,
+                        schema: spec,
+                    });
+                }
+            }
+            break;
+        default:
+            envelope;
+    }
+    return res;
+}
+export function openAPIRequestBody(uc, envelope, fqUCInputName) {
+    const innerContent = {
+        schema: {
+            $ref: `#/components/schemas/${fqUCInputName}`,
+        },
+    };
+    switch (envelope) {
+        case 'form-data': {
+            const repeatableFields = uc.inputFieldsRepeatable();
+            const content = {
+                'multipart/form-data': innerContent,
+            };
+            if (!isBlank(repeatableFields)) {
+                content['multipart/form-data'].encoding = {};
+            }
+            for (const f of repeatableFields) {
+                // This is to prevent SwaggerUI from sending the values comma separated
+                // biome-ignore lint/style/noNonNullAssertion: we want it
+                content['multipart/form-data'].encoding[f.key] = {
+                    explode: true,
+                    style: 'form',
+                };
+            }
+            return {
+                content,
+                required: true,
+            };
+        }
+        case 'json':
+            return {
+                content: {
+                    'application/json': innerContent,
+                },
+                required: true,
+            };
+        default:
+            envelope;
+            throw new Error();
+    }
+}
+export function openAPISecuritySchemes(authCookieName, publicApiKeyHeaderName) {
+    return {
+        apiKey: {
+            bearerFormat: 'Bearer',
+            in: 'header',
+            name: AUTHORIZATION_HEADER_NAME,
+            type: 'apiKey',
+        },
+        basic: {
+            scheme: 'basic',
+            type: 'http',
+        },
+        jwt: {
+            in: 'cookie',
+            name: authCookieName,
+            type: 'apiKey',
+        },
+        publicApiKey: {
+            in: 'header',
+            name: publicApiKeyHeaderName,
+            type: 'apiKey',
+        },
+    };
+}
+export function openAPISecurity(sec) {
+    const item = {};
+    const res = [item];
+    const publicApiCheckType = sec?.publicApiKeyCheckType ?? DEFAULT_UC_SEC_PAKCT;
+    switch (publicApiCheckType) {
+        case 'off':
+            break;
+        case 'on':
+            item.publicApiKey = [];
+            break;
+        default:
+            publicApiCheckType;
+    }
+    const authType = sec?.authType ?? DEFAULT_UC_SEC_AT;
+    item[authType] = [];
+    return res;
+}
+export function openAPISuccess(uc) {
+    return {
+        '200': {
+            content: {
+                'application/json': {
+                    schema: openAPIOutputSchema(uc),
+                },
+            },
+            description: SUCCESS_DESCRIPTION,
+        },
+    };
+}

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

@@ -0,0 +1,16 @@
+import type { DataType } from '../../../dt/index.js';
+import { type UCInputField } from '../../../uc/index.js';
+import type { OpenAPIProperty } from './types.js';
+export interface OpenAPIInputDef<T extends DataType> {
+    /**
+     * Internal types that are not part of the spec
+     */
+    internal?: {
+        required?: boolean;
+    };
+    /**
+     * Fields that are part of the spec
+     */
+    spec?: OpenAPIProperty<T>;
+}
+export declare function openAPIInputDef<T extends DataType>(field: UCInputField<T>): OpenAPIInputDef<T>;

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

@@ -0,0 +1,33 @@
+import { ucifExamples, ucifIsMandatory, ucifRepeatability, } from '../../../uc/index.js';
+export function openAPIInputDef(field) {
+    const def = {
+        internal: {},
+        spec: { type: 'string' },
+    };
+    if (!def.internal || !def.spec) {
+        // Just a guard to safely type the rest of the function without using !
+        return def;
+    }
+    const { def: fDef } = field;
+    const { type: fType } = fDef;
+    def.internal.required = ucifIsMandatory(fDef);
+    def.spec = fType.jsonSchemaType();
+    const examples = ucifExamples(fDef);
+    if (examples) {
+        def.spec.examples = examples;
+    }
+    const options = fType.getOptions();
+    if (options) {
+        def.spec.enum = options.map((o) => o.value);
+    }
+    const [isRepeatable] = ucifRepeatability(fDef);
+    if (isRepeatable) {
+        def.spec = {
+            items: def.spec,
+            maxItems: fDef.cardinality?.max,
+            minItems: fDef.cardinality?.min,
+            type: 'array',
+        };
+    }
+    return def;
+}