libmodulor 0.29.0 → 0.31.0

package/dist/esm/target/lib/mcp-server/http/hono/MCPHTTPHonoProtocolRequestHandlerBuilder.js

@@ -0,0 +1,100 @@
+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 { WebStandardStreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js';
+import { inject, injectable } from 'inversify';
+import { WordingManager } from '../../../../../i18n/index.js';
+import { ucMountingPoint, } from '../../../../../uc/index.js';
+import { toReq, toRes } from '../../../server-hono/funcs.js';
+import { init, toolConfig } from '../../funcs.js';
+import { MCPServerRequestChecker } from '../../MCPServerRequestChecker.js';
+import { MCPServerRequestHandler } from '../../MCPServerRequestHandler.js';
+import { ucStreamExecOpts } from '../funcs.js';
+let MCPHTTPHonoProtocolRequestHandlerBuilder = class MCPHTTPHonoProtocolRequestHandlerBuilder {
+    logger;
+    productManifest;
+    serverRequestChecker;
+    serverRequestHandler;
+    wordingManager;
+    constructor(logger, productManifest, serverRequestChecker, serverRequestHandler, wordingManager) {
+        this.logger = logger;
+        this.productManifest = productManifest;
+        this.serverRequestChecker = serverRequestChecker;
+        this.serverRequestHandler = serverRequestHandler;
+        this.wordingManager = wordingManager;
+    }
+    exec({ ucs, ucManager, }) {
+        return async (c) => {
+            const { status } = await this.serverRequestChecker.exec({
+                req: toReq(c),
+            });
+            if (status) {
+                c.status(status);
+                return c.json({});
+            }
+            const server = init(this.productManifest);
+            const transport = new WebStandardStreamableHTTPServerTransport();
+            // In Streamable HTTP, there is usually one request => one transport => one server.
+            // So there shouldn't be multiple 'stream' use cases invoked at the same time.
+            // But maintaining a Map allows us to handle this case if it occurs.
+            // This way, we have all the streams available to close them when the transport is closed.
+            const execOptss = new Map();
+            for (const uc of ucs) {
+                const { def: { ext }, } = uc;
+                const mountingPoint = ext?.cmd?.mountAt ?? ucMountingPoint(uc);
+                const wording = this.wordingManager.uc(uc.def);
+                const config = toolConfig(uc, 'server', wording);
+                const transportType = ext?.http?.transportType ?? 'standard';
+                server.registerTool(mountingPoint, config, (input, extra) => {
+                    const execOpts = ucStreamExecOpts(this.logger, transportType, extra);
+                    if (execOpts) {
+                        execOptss.set(mountingPoint, execOpts);
+                    }
+                    return this.serverRequestHandler.exec({
+                        appManifest: uc.appManifest,
+                        envelope: 'json',
+                        execOpts,
+                        req: {
+                            ...toReq(c),
+                            bodyFromJSON: async () => input,
+                        },
+                        res: toRes(c),
+                        ucd: uc.def,
+                        ucManager,
+                    });
+                });
+            }
+            transport.onclose = async () => {
+                this.logger.trace('Transport closed => closing streams');
+                await Promise.all(execOptss.values().map((eo) => eo.stream?.onClose()));
+            };
+            c.req.raw.signal.addEventListener('abort', async () => {
+                this.logger.trace('Connection closed => closing transport');
+                await transport.close();
+            });
+            await server.connect(transport);
+            return transport.handleRequest(c.req.raw);
+        };
+    }
+};
+MCPHTTPHonoProtocolRequestHandlerBuilder = __decorate([
+    injectable(),
+    __param(0, inject('Logger')),
+    __param(1, inject('ProductManifest')),
+    __param(2, inject(MCPServerRequestChecker)),
+    __param(3, inject(MCPServerRequestHandler)),
+    __param(4, inject(WordingManager)),
+    __metadata("design:paramtypes", [Object, Object, MCPServerRequestChecker,
+        MCPServerRequestHandler,
+        WordingManager])
+], MCPHTTPHonoProtocolRequestHandlerBuilder);
+export { MCPHTTPHonoProtocolRequestHandlerBuilder };

package/dist/esm/target/lib/mcp-server/http/hono/types.d.ts

@@ -0,0 +1,3 @@
+import type { MiddlewareHandler } from 'hono';
+import type { MCPHTTPRequestHandlerBuilder } from '../MCPHTTPRequestHandlerBuilder.js';
+export type MCPHTTPHonoRequestHandlerBuilder = MCPHTTPRequestHandlerBuilder<MiddlewareHandler>;

package/dist/esm/target/lib/mcp-server/http/hono/types.js

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

package/dist/esm/target/lib/mcp-server/stdio/MCPStdioRequestHandler.d.ts

@@ -0,0 +1,31 @@
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import type { AppManifest } from '../../../../app/index.js';
+import type { JWTManager, Worker } from '../../../../std/index.js';
+import { UCBuilder, type UCDef, type UCInput, type UCManager, type UCOPIBase } from '../../../../uc/index.js';
+import type { AuthDataStore } from '../../client/AuthDataStore.js';
+import type { StdioToolInput } from './input.js';
+interface Input<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> {
+    appManifest: AppManifest;
+    toolInput: StdioToolInput<I>;
+    ucd: UCDef<I, OPI0, OPI1>;
+    /**
+     * It is not injected in the handler constructor because it must be the same as the one used in ServerManager.
+     *
+     * And in some cases, this latter is specific to a context : for instance in automated tests.
+     */
+    ucManager: UCManager;
+}
+type Output = CallToolResult;
+export declare class MCPStdioRequestHandler implements Worker<Input, Promise<Output>> {
+    private authDataStore;
+    private jwtManager;
+    private ucBuilder;
+    constructor(authDataStore: AuthDataStore, jwtManager: JWTManager, ucBuilder: UCBuilder);
+    exec<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>({ appManifest, toolInput, ucd, ucManager, }: Input<I, OPI0, OPI1>): Promise<Output>;
+    private auth;
+    private applySideEffects;
+    private applyClearAuthSideEffect;
+    private applyRedirectSideEffect;
+    private applySetAuthSideEffect;
+}
+export {};

package/dist/esm/target/lib/mcp-server/stdio/MCPStdioRequestHandler.js

@@ -0,0 +1,108 @@
+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, UCOutputSideEffectType, } from '../../../../uc/index.js';
+import { resAborted, resError, resObj } from '../funcs.js';
+let MCPStdioRequestHandler = class MCPStdioRequestHandler {
+    authDataStore;
+    jwtManager;
+    ucBuilder;
+    constructor(authDataStore, jwtManager, ucBuilder) {
+        this.authDataStore = authDataStore;
+        this.jwtManager = jwtManager;
+        this.ucBuilder = ucBuilder;
+    }
+    async exec({ appManifest, toolInput, ucd, ucManager, }) {
+        try {
+            const auth = await this.auth();
+            const uc = this.ucBuilder.exec({
+                appManifest,
+                auth,
+                def: ucd,
+            });
+            if (toolInput) {
+                const { _reserved, ...rest } = toolInput;
+                uc.fill(rest);
+                if (_reserved?.confirmed === undefined) {
+                    await ucManager.confirmClient(uc);
+                    // ... throws an error
+                }
+                else if (_reserved.confirmed === false) {
+                    return resAborted();
+                }
+            }
+            const ucor = await ucManager.execClient(uc);
+            await this.applySideEffects(ucor);
+            return resObj(ucor.output());
+        }
+        catch (err) {
+            return resError(err);
+        }
+    }
+    async auth() {
+        // TODO : Memoize the auth instead of decoding each time
+        const jwt = await this.authDataStore.get();
+        if (!jwt) {
+            return null;
+        }
+        return this.jwtManager.decodeUnsafe(jwt);
+    }
+    async applySideEffects(ucor) {
+        const { io } = ucor.ucd();
+        const sideEffects = io.o?.sideEffects;
+        if (!sideEffects) {
+            return;
+        }
+        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();
+                    return;
+                case UCOutputSideEffectType.REDIRECT:
+                    await this.applyRedirectSideEffect(item);
+                    return;
+                case UCOutputSideEffectType.SET_AUTH:
+                    await this.applySetAuthSideEffect(item);
+                    return;
+                default:
+                    (type);
+            }
+        }
+    }
+    async applyClearAuthSideEffect() {
+        await this.authDataStore.set(null);
+    }
+    async applyRedirectSideEffect(_item) {
+        // Nothing to do
+    }
+    async applySetAuthSideEffect(item) {
+        if (!item || !('jwt' in item) || typeof item.jwt !== 'string') {
+            return;
+        }
+        const { jwt } = item;
+        await this.authDataStore.set(jwt);
+    }
+};
+MCPStdioRequestHandler = __decorate([
+    injectable(),
+    __param(0, inject('AuthDataStore')),
+    __param(1, inject('JWTManager')),
+    __param(2, inject(UCBuilder)),
+    __metadata("design:paramtypes", [Object, Object, UCBuilder])
+], MCPStdioRequestHandler);
+export { MCPStdioRequestHandler };

package/dist/esm/target/lib/mcp-server/stdio/MCPStdioUCClientConfirmManager.d.ts

@@ -0,0 +1,7 @@
+import { WordingManager } from '../../../../i18n/index.js';
+import type { UCClientConfirmManager, UCDef, UCInput, UCOPIBase } from '../../../../uc/index.js';
+export declare class MCPStdioUCClientConfirmManager implements UCClientConfirmManager {
+    private wordingManager;
+    constructor(wordingManager: WordingManager);
+    exec<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(ucd: UCDef<I, OPI0, OPI1>): Promise<boolean>;
+}

package/dist/esm/target/lib/mcp-server/stdio/MCPStdioUCClientConfirmManager.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';
+import { WordingManager } from '../../../../i18n/index.js';
+import { UC_CONFIRM_HINT } from './consts.js';
+let MCPStdioUCClientConfirmManager = class MCPStdioUCClientConfirmManager {
+    wordingManager;
+    constructor(wordingManager) {
+        this.wordingManager = wordingManager;
+    }
+    async exec(ucd) {
+        const { message, title } = this.wordingManager.ucClientConfirm(ucd);
+        let m = title;
+        if (message) {
+            m = `\n${message}`;
+        }
+        m = `\n${UC_CONFIRM_HINT}`;
+        throw new Error(m);
+    }
+};
+MCPStdioUCClientConfirmManager = __decorate([
+    injectable(),
+    __param(0, inject(WordingManager)),
+    __metadata("design:paramtypes", [WordingManager])
+], MCPStdioUCClientConfirmManager);
+export { MCPStdioUCClientConfirmManager };

package/dist/esm/target/lib/mcp-server/stdio/consts.d.ts

@@ -0,0 +1,2 @@
+export declare const ERR_LOGGER_LEVEL = "Set the logging_level to \"error\" as MCP does not want the server to log to stdout (see https://modelcontextprotocol.io/docs/tools/debugging#implementing-logging)";
+export declare const UC_CONFIRM_HINT: string;

package/dist/esm/target/lib/mcp-server/stdio/consts.js

@@ -0,0 +1,3 @@
+import { RESERVED_CONFIRMED_KEY, RESERVED_KEY } from './input.js';
+export const ERR_LOGGER_LEVEL = 'Set the logging_level to "error" as MCP does not want the server to log to stdout (see https://modelcontextprotocol.io/docs/tools/debugging#implementing-logging)';
+export const UC_CONFIRM_HINT = `(Hint: ask the user to confirm. If they do, set the property "${RESERVED_CONFIRMED_KEY}" in "${RESERVED_KEY}" to true in the input. Otherwise, set it to false)`;

package/dist/esm/target/lib/mcp-server/stdio/funcs.d.ts

@@ -0,0 +1,2 @@
+import type { LoggerLevel } from '../../../../std/index.js';
+export declare function assertLoggerLevel(loggerLevel: LoggerLevel): void;

package/dist/esm/target/lib/mcp-server/stdio/funcs.js

@@ -0,0 +1,10 @@
+import { ERR_LOGGER_LEVEL } from './consts.js';
+export function assertLoggerLevel(loggerLevel) {
+    if (loggerLevel === 'error') {
+        return;
+    }
+    // Depending on the `Logger` implementation, this.logger.error() might not write to stderr (e.g. can write to a file).
+    // That's why we explicitly write to stdout by calling console.error().
+    // biome-ignore lint/suspicious/noConsole: we want it
+    console.error(new Error(ERR_LOGGER_LEVEL));
+}

package/dist/esm/target/lib/mcp-server/stdio/input.d.ts

@@ -0,0 +1,10 @@
+import type { JSONSchemaObject } from '../../../../dt/index.js';
+import type { UCInput } from '../../../../uc/index.js';
+export type StdioToolInput<I extends UCInput | undefined = undefined> = I & {
+    _reserved?: {
+        confirmed?: boolean;
+    };
+};
+export declare const RESERVED_KEY: "_reserved";
+export declare const RESERVED_CONFIRMED_KEY: "confirmed";
+export declare function stdioToolInputSchema(): JSONSchemaObject<StdioToolInput>['properties'];

package/dist/esm/target/lib/mcp-server/stdio/input.js

@@ -0,0 +1,15 @@
+export const RESERVED_KEY = '_reserved';
+export const RESERVED_CONFIRMED_KEY = 'confirmed';
+export function stdioToolInputSchema() {
+    return {
+        [RESERVED_KEY]: {
+            additionalProperties: false,
+            properties: {
+                [RESERVED_CONFIRMED_KEY]: {
+                    type: 'boolean',
+                },
+            },
+            type: 'object',
+        },
+    };
+}

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

@@ -0,0 +1,2 @@
+import type { RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
+export type RegisterToolConfig = Pick<RegisteredTool, 'description' | 'inputSchema' | 'outputSchema' | 'title' | 'annotations' | '_meta'>;

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

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

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

@@ -13,8 +13,10 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 import { inject, injectable } from 'inversify';
 import { WordingManager } from '../../../i18n/index.js';
 import { formatFQUCInputName, formatFQUCName, ucHTTPContract, } from '../../../uc/index.js';
+import { serverErrorJsonSchema } from '../json-schema/error.js';
+import { ucInputJsonSchema } from '../json-schema/input.js';
 import { DEFAULT_VERSION } from '../shared.js';
-import { openAPIErrorSchema, openAPIErrors, openAPIInputSchema, openAPIParameters, openAPIRequestBody, openAPISecurity, openAPISecuritySchemes, openAPISuccess, } from './funcs.js';
+import { openAPIErrors, openAPIParameters, openAPIRequestBody, openAPISecurity, openAPISecuritySchemes, openAPISuccess, } from './funcs.js';
 let OpenAPISpecBuilder = class OpenAPISpecBuilder {
     i18nManager;
     productManifest;
@@ -49,7 +51,7 @@ let OpenAPISpecBuilder = class OpenAPISpecBuilder {
             const fqUCName = formatFQUCName(uc.appManifest.name, uc.def.metadata.name);
             const fqUCInputName = formatFQUCInputName(fqUCName);
             output.spec.components.schemas[fqUCInputName] =
-                openAPIInputSchema(uc);
+                ucInputJsonSchema(uc);
             for (const p of [path, ...pathAliases]) {
                 output.spec.paths[p] = {
                     ...output.spec.paths[p],
@@ -71,7 +73,7 @@ let OpenAPISpecBuilder = class OpenAPISpecBuilder {
             spec: {
                 components: {
                     schemas: {
-                        Error: openAPIErrorSchema(),
+                        Error: serverErrorJsonSchema(),
                     },
                     securitySchemes: openAPISecuritySchemes(this.s().server_cookies_name_auth, this.s().server_public_api_key_header_name),
                 },
@@ -93,9 +95,11 @@ let OpenAPISpecBuilder = class OpenAPISpecBuilder {
     // biome-ignore lint/suspicious/noExplicitAny: can be anything
     uc, envelope, fqUCInputName) {
         const { desc, label } = this.wordingManager.uc(uc.def);
+        const res_200 = this.i18nManager.t('res_200');
+        const res_204 = this.i18nManager.t('res_204');
         const path = {
             responses: {
-                ...openAPISuccess(uc),
+                ...openAPISuccess(uc, { 200: res_200, 204: res_204 }),
                 ...errors,
                 // TODO : Infer errors that can be sent within ServerMain
             },

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

@@ -1,16 +1,11 @@
-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 { HTTPStatusNumber } from '../../../dt/index.js';
+import { type FQUCInputName, type UC, type UCInput, type UCOPIBase, 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>;
+import type { OpenAPIParameter, OpenAPIRequestBody, OpenAPIResponses, OpenAPISecurity, OpenAPISecuritySchemes } from './types.js';
 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;
+export declare function openAPISuccess<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(uc: UC<I, OPI0, OPI1>, descriptions: Record<Extract<HTTPStatusNumber, 200 | 204>, string>): OpenAPIResponses;

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

@@ -1,21 +1,10 @@
-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 { ERROR_HTTP_STATUS_MAP } from '../../../error/index.js';
+import { DEFAULT_UC_SEC_AT, DEFAULT_UC_SEC_PAKCT, } from '../../../uc/index.js';
 import { isBlank } from '../../../utils/index.js';
+import { serverErrorJsonSchema } from '../json-schema/error.js';
+import { ucifJsonSchemaDef } from '../json-schema/input.js';
+import { ucOutputJsonSchema } from '../json-schema/output.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;
@@ -23,16 +12,7 @@ export function openAPIErrors() {
         acc[status] = {
             content: {
                 'application/json': {
-                    schema: {
-                        additionalProperties: false,
-                        properties: {
-                            message: {
-                                examples: [message],
-                                type: 'string',
-                            },
-                        },
-                        type: 'object',
-                    },
+                    schema: serverErrorJsonSchema(message),
                 },
             },
             description: message,
@@ -40,95 +20,6 @@ export function openAPIErrors() {
         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) {
@@ -136,7 +27,7 @@ export function openAPIParameters(uc, envelope) {
             {
                 for (const f of uc.inputFields) {
                     const { key } = f;
-                    const { internal, spec } = openAPIInputDef(f);
+                    const { internal, spec } = ucifJsonSchemaDef(f);
                     if (!spec) {
                         continue;
                     }
@@ -235,15 +126,23 @@ export function openAPISecurity(sec) {
     item[authType] = [];
     return res;
 }
-export function openAPISuccess(uc) {
+export function openAPISuccess(uc, descriptions) {
+    const schema = ucOutputJsonSchema(uc);
+    if (!schema) {
+        return {
+            '204': {
+                description: descriptions[204],
+            },
+        };
+    }
     return {
         '200': {
             content: {
                 'application/json': {
-                    schema: openAPIOutputSchema(uc),
+                    schema,
                 },
             },
-            description: SUCCESS_DESCRIPTION,
+            description: descriptions[200],
         },
     };
 }

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

@@ -1,23 +1,12 @@
-import type { DataType, FreeTextLong, FreeTextShort, HTTPMethod, HTTPStatusNumber, JSONSchemaType, SemVerVersion, URL } from '../../../dt/index.js';
+import type { FreeTextLong, FreeTextShort, HTTPMethod, HTTPStatusNumber, JSONSchemaObject, JSONSchemaProperty, SemVerVersion, URL } from '../../../dt/index.js';
 import type { ProductName } from '../../../product/index.js';
 import type { FQUCInputName, FQUCOPI0Name, FQUCOPI1Name, UCFieldKey } from '../../../uc/index.js';
-import type { StringKeys } from '../../../utils/index.js';
 import type { AUTHORIZATION_HEADER_NAME, AuthCookieName, PublicApiKeyHeaderName } from '../shared.js';
 export type OpenAPIPathName = string;
 export type OpenAPIDescription = FreeTextLong;
 export type OpenAPISchemaName = FQUCInputName | FQUCOPI0Name | FQUCOPI1Name | `Error`;
 export type OpenAPISchemaRef = `#/components/schemas/${OpenAPISchemaName}`;
 export type OpenAPISummary = FreeTextShort;
-export type OpenAPIProperty<T extends DataType> = JSONSchemaType & {
-    enum?: T[];
-    examples?: T[];
-};
-export interface OpenAPISchema<T extends object> {
-    additionalProperties: false;
-    properties: Record<StringKeys<T>, OpenAPIProperty<any>>;
-    required?: StringKeys<T>[];
-    type: 'object';
-}
 export type OpenAPISecurityItem = Partial<Record<keyof OpenAPISecuritySchemes, []>>;
 export type OpenAPISecurity = OpenAPISecurityItem[];
 export interface OpenAPISecurityScheme {
@@ -47,14 +36,14 @@ export interface OpenAPISecuritySchemes {
 }
 export interface OpenAPIComponents {
     securitySchemes: OpenAPISecuritySchemes;
-    schemas: Record<OpenAPISchemaName, OpenAPISchema<any>>;
+    schemas: Record<OpenAPISchemaName, JSONSchemaObject<any>>;
 }
 export interface OpenAPIParameter {
     description?: OpenAPIDescription;
     in: 'path' | 'query';
     name: UCFieldKey;
     required: boolean;
-    schema: OpenAPIProperty<any>;
+    schema: JSONSchemaProperty<any>;
 }
 export interface OpenAPIPath {
     description?: OpenAPIDescription;
@@ -68,7 +57,7 @@ export interface OpenAPIPath {
 export interface OpenAPIInnerContent {
     schema: {
         $ref: OpenAPISchemaRef;
-    } | OpenAPISchema<any>;
+    } | JSONSchemaObject<any>;
 }
 export type OpenAPIContent = {
     'application/json': OpenAPIInnerContent;
@@ -87,7 +76,7 @@ export interface OpenAPIRequestBody {
 }
 export type OpenAPIPaths = Record<OpenAPIPathName, Partial<Record<Lowercase<HTTPMethod>, OpenAPIPath>>>;
 export interface OpenAPIResponse {
-    content: OpenAPIContent;
+    content?: OpenAPIContent;
     description: OpenAPIDescription;
 }
 export type OpenAPIResponses = Partial<Record<HTTPStatusNumber, OpenAPIResponse>>;