libmodulor 0.28.0 → 0.30.0

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

@@ -19,27 +19,32 @@ import { CustomerFacingErrorBuilder } from '../lib/server/CustomerFacingErrorBui
 import { EntrypointsBuilder } from '../lib/server/EntrypointsBuilder.js';
 import { ServerRequestHandler } from '../lib/server/ServerRequestHandler.js';
 import { ServerSSLCertLoader } from '../lib/server/ServerSSLCertLoader.js';
+import { CORSMiddlewareBuilder } from '../lib/server-express/CORSMiddlewareBuilder.js';
 import { buildHandler, init, mountHandler, postInit, } from '../lib/server-express/funcs.js';
 import { HelmetMiddlewareBuilder } from '../lib/server-express/HelmetMiddlewareBuilder.js';
 import { listen, stop } from '../lib/server-node/funcs.js';
 let NodeExpressServerManager = class NodeExpressServerManager {
+    corsMiddlewareBuilder;
     customerFacingErrorBuilder;
     entrypointsBuilder;
     environmentManager;
-    helmetMB;
+    helmetMiddlewareBuilder;
     logger;
+    mcpHTTPRequestHandlerBuilder;
     serverRequestHandler;
     serverSSLCertLoader;
     settingsManager;
     ucManager;
     runtime;
     server;
-    constructor(customerFacingErrorBuilder, entrypointsBuilder, environmentManager, helmetMB, logger, serverRequestHandler, serverSSLCertLoader, settingsManager, ucManager) {
+    constructor(corsMiddlewareBuilder, customerFacingErrorBuilder, entrypointsBuilder, environmentManager, helmetMiddlewareBuilder, logger, mcpHTTPRequestHandlerBuilder, serverRequestHandler, serverSSLCertLoader, settingsManager, ucManager) {
+        this.corsMiddlewareBuilder = corsMiddlewareBuilder;
         this.customerFacingErrorBuilder = customerFacingErrorBuilder;
         this.entrypointsBuilder = entrypointsBuilder;
         this.environmentManager = environmentManager;
-        this.helmetMB = helmetMB;
+        this.helmetMiddlewareBuilder = helmetMiddlewareBuilder;
         this.logger = logger;
+        this.mcpHTTPRequestHandlerBuilder = mcpHTTPRequestHandlerBuilder;
         this.serverRequestHandler = serverRequestHandler;
         this.serverSSLCertLoader = serverSSLCertLoader;
         this.settingsManager = settingsManager;
@@ -64,7 +69,7 @@ let NodeExpressServerManager = class NodeExpressServerManager {
         this.ucManager = ucManager;
     }
     async init() {
-        this.runtime = init(this.helmetMB, this.s().logger_level, this.s().server_tmp_path);
+        this.runtime = init(this.corsMiddlewareBuilder, this.helmetMiddlewareBuilder, this.s().logger_level, this.s().server_tmp_path);
         await this.createServer();
     }
     initSync() {
@@ -76,6 +81,17 @@ let NodeExpressServerManager = class NodeExpressServerManager {
     mountSync(appManifest, ucd, contract) {
         this.mountCommon(appManifest, ucd, contract);
     }
+    async mountMCP(ucs, at) {
+        this.runtime.post(at, this.mcpHTTPRequestHandlerBuilder.exec({
+            ucManager: this.ucManager,
+            ucs,
+        }));
+    }
+    async mountOpenAPISpec(spec, at) {
+        this.runtime.get(at, (_req, res) => {
+            res.send(spec);
+        });
+    }
     async mountStaticDir(dirPath) {
         this.runtime.use(express.static(dirPath));
     }
@@ -105,17 +121,20 @@ let NodeExpressServerManager = class NodeExpressServerManager {
 };
 NodeExpressServerManager = __decorate([
     injectable(),
-    __param(0, inject(CustomerFacingErrorBuilder)),
-    __param(1, inject(EntrypointsBuilder)),
-    __param(2, inject('EnvironmentManager')),
-    __param(3, inject(HelmetMiddlewareBuilder)),
-    __param(4, inject('Logger')),
-    __param(5, inject(ServerRequestHandler)),
-    __param(6, inject(ServerSSLCertLoader)),
-    __param(7, inject('SettingsManager')),
-    __param(8, inject('UCManager')),
-    __metadata("design:paramtypes", [CustomerFacingErrorBuilder,
-        EntrypointsBuilder, Object, HelmetMiddlewareBuilder, Object, ServerRequestHandler,
+    __param(0, inject(CORSMiddlewareBuilder)),
+    __param(1, inject(CustomerFacingErrorBuilder)),
+    __param(2, inject(EntrypointsBuilder)),
+    __param(3, inject('EnvironmentManager')),
+    __param(4, inject(HelmetMiddlewareBuilder)),
+    __param(5, inject('Logger')),
+    __param(6, inject('MCPHTTPRequestHandlerBuilder')),
+    __param(7, inject(ServerRequestHandler)),
+    __param(8, inject(ServerSSLCertLoader)),
+    __param(9, inject('SettingsManager')),
+    __param(10, inject('UCManager')),
+    __metadata("design:paramtypes", [CORSMiddlewareBuilder,
+        CustomerFacingErrorBuilder,
+        EntrypointsBuilder, Object, HelmetMiddlewareBuilder, Object, Object, ServerRequestHandler,
         ServerSSLCertLoader, Object, Object])
 ], NodeExpressServerManager);
 export { NodeExpressServerManager };

package/dist/esm/target/node-hono-server/NodeHonoServerManager.d.ts

@@ -1,27 +1,33 @@
-import type { Hono } from 'hono';
+import type { Hono, MiddlewareHandler } 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 { ProductUCsLoaderOutput } from '../../product/index.js';
 import type { Configurable, EnvironmentManager, Logger, SettingsManager } from '../../std/index.js';
 import type { UCDef, UCHTTPContract, UCInput, UCManager, UCOPIBase } from '../../uc/index.js';
+import type { MCPHTTPRequestHandlerBuilder } from '../lib/mcp-server/http/MCPHTTPRequestHandlerBuilder.js';
+import type { OpenAPISpec } from '../lib/openapi/types.js';
 import { CustomerFacingErrorBuilder } from '../lib/server/CustomerFacingErrorBuilder.js';
 import { EntrypointsBuilder } from '../lib/server/EntrypointsBuilder.js';
 import type { ServerManager } from '../lib/server/ServerManager.js';
 import { ServerRequestHandler } from '../lib/server/ServerRequestHandler.js';
 import { ServerSSLCertLoader } from '../lib/server/ServerSSLCertLoader.js';
+import { CORSMiddlewareBuilder } from '../lib/server-hono/CORSMiddlewareBuilder.js';
 import type { ListenSettings, StopSettings } from '../lib/server-node/types.js';
 type S = ListenSettings & StopSettings;
 export declare class NodeHonoServerManager implements Configurable<S>, ServerManager {
+    private corsMiddlewareBuilder;
     private customerFacingErrorBuilder;
     private entrypointsBuilder;
     protected environmentManager: EnvironmentManager;
     private logger;
+    private mcpHTTPRequestHandlerBuilder;
     private serverRequestHandler;
     private serverSSLCertLoader;
     private settingsManager;
     private ucManager;
     protected runtime: Hono;
     private server;
-    constructor(customerFacingErrorBuilder: CustomerFacingErrorBuilder, entrypointsBuilder: EntrypointsBuilder, environmentManager: EnvironmentManager, logger: Logger, serverRequestHandler: ServerRequestHandler, serverSSLCertLoader: ServerSSLCertLoader, settingsManager: SettingsManager<S>, ucManager: UCManager);
+    constructor(corsMiddlewareBuilder: CORSMiddlewareBuilder, customerFacingErrorBuilder: CustomerFacingErrorBuilder, entrypointsBuilder: EntrypointsBuilder, environmentManager: EnvironmentManager, logger: Logger, mcpHTTPRequestHandlerBuilder: MCPHTTPRequestHandlerBuilder<MiddlewareHandler>, serverRequestHandler: ServerRequestHandler, serverSSLCertLoader: ServerSSLCertLoader, settingsManager: SettingsManager<S>, ucManager: UCManager);
     s(): S;
     getRuntime(): Hono;
     overrideUCManager(ucManager: UCManager): void;
@@ -29,6 +35,8 @@ export declare class NodeHonoServerManager implements Configurable<S>, ServerMan
     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;
+    mountMCP(ucs: ProductUCsLoaderOutput, at: URLPath): Promise<void>;
+    mountOpenAPISpec(spec: OpenAPISpec, at: URLPath): Promise<void>;
     mountStaticDir(dirPath: DirPath): Promise<void>;
     start(): Promise<void>;
     stop(): Promise<void>;

package/dist/esm/target/node-hono-server/NodeHonoServerManager.js

@@ -20,24 +20,29 @@ import { CustomerFacingErrorBuilder } from '../lib/server/CustomerFacingErrorBui
 import { EntrypointsBuilder } from '../lib/server/EntrypointsBuilder.js';
 import { ServerRequestHandler } from '../lib/server/ServerRequestHandler.js';
 import { ServerSSLCertLoader } from '../lib/server/ServerSSLCertLoader.js';
+import { CORSMiddlewareBuilder } from '../lib/server-hono/CORSMiddlewareBuilder.js';
 import { buildHandler, init, mountHandler } from '../lib/server-hono/funcs.js';
 import { listen, stop } from '../lib/server-node/funcs.js';
 let NodeHonoServerManager = class NodeHonoServerManager {
+    corsMiddlewareBuilder;
     customerFacingErrorBuilder;
     entrypointsBuilder;
     environmentManager;
     logger;
+    mcpHTTPRequestHandlerBuilder;
     serverRequestHandler;
     serverSSLCertLoader;
     settingsManager;
     ucManager;
     runtime;
     server;
-    constructor(customerFacingErrorBuilder, entrypointsBuilder, environmentManager, logger, serverRequestHandler, serverSSLCertLoader, settingsManager, ucManager) {
+    constructor(corsMiddlewareBuilder, customerFacingErrorBuilder, entrypointsBuilder, environmentManager, logger, mcpHTTPRequestHandlerBuilder, serverRequestHandler, serverSSLCertLoader, settingsManager, ucManager) {
+        this.corsMiddlewareBuilder = corsMiddlewareBuilder;
         this.customerFacingErrorBuilder = customerFacingErrorBuilder;
         this.entrypointsBuilder = entrypointsBuilder;
         this.environmentManager = environmentManager;
         this.logger = logger;
+        this.mcpHTTPRequestHandlerBuilder = mcpHTTPRequestHandlerBuilder;
         this.serverRequestHandler = serverRequestHandler;
         this.serverSSLCertLoader = serverSSLCertLoader;
         this.settingsManager = settingsManager;
@@ -60,7 +65,7 @@ let NodeHonoServerManager = class NodeHonoServerManager {
         this.ucManager = ucManager;
     }
     async init() {
-        this.runtime = init(this.customerFacingErrorBuilder);
+        this.runtime = init(this.corsMiddlewareBuilder, this.customerFacingErrorBuilder);
         await this.createServer();
     }
     initSync() {
@@ -72,6 +77,17 @@ let NodeHonoServerManager = class NodeHonoServerManager {
     mountSync(appManifest, ucd, contract) {
         this.mountCommon(appManifest, ucd, contract);
     }
+    async mountMCP(ucs, at) {
+        this.runtime.post(at, this.mcpHTTPRequestHandlerBuilder.exec({
+            ucManager: this.ucManager,
+            ucs,
+        }));
+    }
+    async mountOpenAPISpec(spec, at) {
+        this.runtime.get(at, (c) => {
+            return c.json(spec);
+        });
+    }
     async mountStaticDir(dirPath) {
         this.runtime.use(serveStatic({ root: dirPath }));
     }
@@ -109,16 +125,19 @@ let NodeHonoServerManager = class NodeHonoServerManager {
 };
 NodeHonoServerManager = __decorate([
     injectable(),
-    __param(0, inject(CustomerFacingErrorBuilder)),
-    __param(1, inject(EntrypointsBuilder)),
-    __param(2, inject('EnvironmentManager')),
-    __param(3, inject('Logger')),
-    __param(4, inject(ServerRequestHandler)),
-    __param(5, inject(ServerSSLCertLoader)),
-    __param(6, inject('SettingsManager')),
-    __param(7, inject('UCManager')),
-    __metadata("design:paramtypes", [CustomerFacingErrorBuilder,
-        EntrypointsBuilder, Object, Object, ServerRequestHandler,
+    __param(0, inject(CORSMiddlewareBuilder)),
+    __param(1, inject(CustomerFacingErrorBuilder)),
+    __param(2, inject(EntrypointsBuilder)),
+    __param(3, inject('EnvironmentManager')),
+    __param(4, inject('Logger')),
+    __param(5, inject('MCPHTTPRequestHandlerBuilder')),
+    __param(6, inject(ServerRequestHandler)),
+    __param(7, inject(ServerSSLCertLoader)),
+    __param(8, inject('SettingsManager')),
+    __param(9, inject('UCManager')),
+    __metadata("design:paramtypes", [CORSMiddlewareBuilder,
+        CustomerFacingErrorBuilder,
+        EntrypointsBuilder, Object, Object, Object, ServerRequestHandler,
         ServerSSLCertLoader, Object, Object])
 ], NodeHonoServerManager);
 export { NodeHonoServerManager };

package/dist/esm/target/{node-mcp-server/NodeLocalStdioMCPServerManager.d.ts → node-mcp-server-stdio/NodeMCPStdioServerManager.d.ts}

@@ -1,46 +1,37 @@
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { AppManifest } from '../../app/index.js';
-import type { DirPath } from '../../dt/index.js';
+import type { DirPath, URLPath } from '../../dt/index.js';
 import { WordingManager } from '../../i18n/index.js';
-import type { ProductManifest } from '../../product/index.js';
+import type { ProductManifest, ProductUCsLoaderOutput } from '../../product/index.js';
 import type { Configurable, LoggerSettings, SettingsManager } from '../../std/index.js';
 import { UCBuilder, type UCDef, type UCHTTPContract, type UCInput, type UCManager, type UCOPIBase } from '../../uc/index.js';
+import { MCPStdioRequestHandler } from '../lib/mcp-server/stdio/MCPStdioRequestHandler.js';
+import type { OpenAPISpec } from '../lib/openapi/types.js';
 import type { ServerManager } from '../lib/server/ServerManager.js';
 type S = Pick<LoggerSettings, 'logger_level'>;
-/**
- * A simple MCP Server implementation
- *
- * Although it implements {@link ServerManager}, this implementation is not necessarily a "server".
- * Indeed, it uses a local `Transport` so it must be considered the same as a {@link NodeCoreCLIManager}.
- * Therefore, it calls `execClient` and not `execServer`.
- * This way, Claude AI, or any other client is just a wrapper on top of it.
- *
- * @alpha This implementation still has lots of TODOs and has not been tested in real conditions. It needs to be stabilized before usage.
- */
-export declare class NodeLocalStdioMCPServerManager implements Configurable<S>, ServerManager {
+export declare class NodeMCPStdioServerManager implements Configurable<S>, ServerManager {
+    private requestHandler;
     private productManifest;
     private settingsManager;
     private ucBuilder;
     private ucManager;
     private wordingManager;
-    protected runtime: Server;
+    protected runtime: McpServer;
     private transport;
-    private appManifests;
-    private tools;
-    constructor(productManifest: ProductManifest, settingsManager: SettingsManager<S>, ucBuilder: UCBuilder, ucManager: UCManager, wordingManager: WordingManager);
+    constructor(requestHandler: MCPStdioRequestHandler, productManifest: ProductManifest, settingsManager: SettingsManager<S>, ucBuilder: UCBuilder, ucManager: UCManager, wordingManager: WordingManager);
     s(): S;
     overrideUCManager(ucManager: UCManager): void;
     init(): Promise<void>;
     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;
+    mountMCP(_ucs: ProductUCsLoaderOutput, _at: URLPath): Promise<void>;
+    mountOpenAPISpec(_spec: OpenAPISpec, _at: URLPath): Promise<void>;
     mountStaticDir(_dirPath: DirPath): Promise<void>;
     start(): Promise<void>;
     stop(): Promise<void>;
     warmUp(): Promise<void>;
-    private buildInputSchema;
-    private execRequest;
     private initCommon;
-    mountCommon<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;
+    private mountCommon;
 }
 export {};

package/dist/esm/target/node-mcp-server-stdio/NodeMCPStdioServerManager.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 { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { inject, injectable } from 'inversify';
+import { WordingManager } from '../../i18n/index.js';
+import { UCBuilder, } from '../../uc/index.js';
+import { init, toolConfig } from '../lib/mcp-server/funcs.js';
+import { assertLoggerLevel } from '../lib/mcp-server/stdio/funcs.js';
+import { MCPStdioRequestHandler } from '../lib/mcp-server/stdio/MCPStdioRequestHandler.js';
+let NodeMCPStdioServerManager = class NodeMCPStdioServerManager {
+    requestHandler;
+    productManifest;
+    settingsManager;
+    ucBuilder;
+    ucManager;
+    wordingManager;
+    runtime;
+    transport;
+    constructor(requestHandler, productManifest, settingsManager, ucBuilder, ucManager, wordingManager) {
+        this.requestHandler = requestHandler;
+        this.productManifest = productManifest;
+        this.settingsManager = settingsManager;
+        this.ucBuilder = ucBuilder;
+        this.ucManager = ucManager;
+        this.wordingManager = wordingManager;
+    }
+    s() {
+        return {
+            logger_level: this.settingsManager.get()('logger_level'),
+        };
+    }
+    overrideUCManager(ucManager) {
+        this.ucManager = ucManager;
+    }
+    async init() {
+        this.initCommon();
+    }
+    initSync() {
+        this.initCommon();
+    }
+    async mount(appManifest, ucd, contract) {
+        this.mountCommon(appManifest, ucd, contract);
+    }
+    mountSync(appManifest, ucd, contract) {
+        this.mountCommon(appManifest, ucd, contract);
+    }
+    async mountMCP(_ucs, _at) {
+        // Nothing to do
+    }
+    async mountOpenAPISpec(_spec, _at) {
+        // Nothing to do
+    }
+    async mountStaticDir(_dirPath) {
+        // Nothing to do
+    }
+    async start() {
+        await this.runtime.connect(this.transport);
+    }
+    async stop() {
+        await this.runtime.close();
+        await this.transport.close();
+    }
+    async warmUp() {
+        // Nothing to do
+    }
+    initCommon() {
+        this.runtime = init(this.productManifest);
+        assertLoggerLevel(this.s().logger_level);
+        this.transport = new StdioServerTransport();
+    }
+    mountCommon(appManifest, ucd, contract) {
+        const uc = this.ucBuilder.exec({
+            appManifest,
+            auth: null,
+            def: ucd,
+        });
+        const mountingPoint = uc.def.ext?.cmd?.mountAt ?? contract.mountingPoint;
+        const wording = this.wordingManager.uc(uc.def);
+        const config = toolConfig(uc, 'client', wording);
+        this.runtime.registerTool(mountingPoint, config, (toolInput) => this.requestHandler.exec({
+            appManifest,
+            toolInput,
+            ucd,
+            ucManager: this.ucManager,
+        }));
+    }
+};
+NodeMCPStdioServerManager = __decorate([
+    injectable(),
+    __param(0, inject(MCPStdioRequestHandler)),
+    __param(1, inject('ProductManifest')),
+    __param(2, inject('SettingsManager')),
+    __param(3, inject(UCBuilder)),
+    __param(4, inject('UCManager')),
+    __param(5, inject(WordingManager)),
+    __metadata("design:paramtypes", [MCPStdioRequestHandler, Object, Object, UCBuilder, Object, WordingManager])
+], NodeMCPStdioServerManager);
+export { NodeMCPStdioServerManager };

package/dist/esm/testing/impl/newNodeAppTester.js

@@ -1,6 +1,7 @@
 import { Container } from 'inversify';
 import { TApiKey, TPassword, TUsername, } from '../../dt/index.js';
 import { STD_DEFAULT_JWT_MANAGER_SETTINGS, } from '../../std/index.js';
+import { MCPHTTPExpressFakeRequestHandlerBuilder } from '../../target/lib/mcp-server/http/express/MCPHTTPExpressFakeRequestHandlerBuilder.js';
 import { TARGET_DEFAULT_SERVER_MANAGER_SETTINGS } from '../../target/lib/server/consts.js';
 import { NodeExpressServerManager } from '../../target/node-express-server/NodeExpressServerManager.js';
 import { FAKE_USER_ADMIN, FAKE_USER_REGULAR } from '../../uc/index.js';
@@ -38,6 +39,10 @@ export async function newNodeAppTester(serverPortRangeStart, idx, args) {
         .bind('ServerManager')
         .to(NodeExpressServerManager)
         .inSingletonScope();
+    container
+        .bind('MCPHTTPRequestHandlerBuilder')
+        .to(MCPHTTPExpressFakeRequestHandlerBuilder)
+        .inSingletonScope();
     container
         .bind('UCDefASTParser')
         .to(TypeScriptLibUCDefASTParser);

package/dist/esm/uc/UC.d.ts

@@ -21,6 +21,7 @@ export declare class UC<I extends UCInput | undefined = undefined, OPI0 extends
     clear(): void;
     clearSensitiveInputFields(): void;
     fill(input: UCInputPartial<I>): this;
+    hasInput(): boolean;
     hasInputField(key: UCFieldKey): boolean;
     hasMediaInInput(): boolean;
     hasOutputParts(): boolean;
@@ -29,6 +30,7 @@ export declare class UC<I extends UCInput | undefined = undefined, OPI0 extends
     inputFieldsOrdered(): UCInputField<any>[];
     inputFieldsInsensitive(): UCInputField<any>[];
     inputFieldsSensitive(): UCInputField<any>[];
+    inputFieldsRepeatable(): UCInputField<any>[];
     needsInputFilling(): boolean;
     needsOutputDisplay(): boolean;
     operatesOnAggregate(): boolean;

package/dist/esm/uc/UC.js

@@ -1,6 +1,6 @@
 import { TFile, Validation } from '../dt/index.js';
 import { isBlank } from '../utils/index.js';
-import { ucifIsMandatory, ucifIsSensitive, ucifMustBeFilledManually, } from './input-field.js';
+import { ucifIsMandatory, ucifIsSensitive, ucifMustBeFilledManually, ucifRepeatability, } from './input-field.js';
 import { AggregateInputDef } from './io/input/AggregateInput.js';
 import { ListInputDef } from './io/input/ListInput.js';
 import { UCInputField } from './UCInputField.js';
@@ -44,6 +44,9 @@ export class UC {
         }
         return this;
     }
+    hasInput() {
+        return this.inputFields.length > 0;
+    }
     hasInputField(key) {
         return this.inputFields.find((f) => f.key === key) !== undefined;
     }
@@ -104,6 +107,18 @@ export class UC {
     inputFieldsSensitive() {
         return this.inputFields.filter((f) => ucifIsSensitive(f.def));
     }
+    // biome-ignore lint/suspicious/noExplicitAny: can be anything
+    inputFieldsRepeatable() {
+        const res = [];
+        for (const f of this.inputFields) {
+            const [isRepeatable] = ucifRepeatability(f.def);
+            if (!isRepeatable) {
+                continue;
+            }
+            res.push(f);
+        }
+        return res;
+    }
     needsInputFilling() {
         const fields = this.inputFields;
         if (fields.length === 0) {

package/dist/esm/uc/cardinality.d.ts

@@ -0,0 +1,7 @@
+import type { UIntQuantity } from '../dt/index.js';
+export interface UCFieldDefCardinality {
+    max?: UIntQuantity;
+    min?: UIntQuantity;
+}
+export declare function ucfIsMandatory(cardinality?: UCFieldDefCardinality): boolean;
+export declare function ucfRepeatability(cardinality?: UCFieldDefCardinality): [boolean, UIntQuantity];

package/dist/esm/uc/cardinality.js

@@ -0,0 +1,14 @@
+export function ucfIsMandatory(cardinality) {
+    const min = cardinality?.min;
+    if (min === undefined) {
+        return true;
+    }
+    return min > 0;
+}
+export function ucfRepeatability(cardinality) {
+    const max = cardinality?.max;
+    if (max === undefined) {
+        return [false, 0];
+    }
+    return [max > 1, max];
+}

package/dist/esm/uc/examples.d.ts

@@ -0,0 +1,2 @@
+import type { DataType, TBase } from '../dt/index.js';
+export declare function ucfExamples<T extends DataType>(type: TBase<T>): T[] | undefined;

package/dist/esm/uc/examples.js

@@ -0,0 +1,12 @@
+export function ucfExamples(type) {
+    const examples = type.getExamples();
+    // Leaving the value `undefined` means you want the default value
+    if (examples === undefined) {
+        return [type.example()];
+    }
+    // Setting the examples to `[]` means you don't want them
+    if (examples.length === 0) {
+        return undefined;
+    }
+    return examples;
+}

package/dist/esm/uc/helpers/UCOutputReader.d.ts

@@ -1,8 +1,8 @@
-import { type DataType } from '../../dt/index.js';
+import type { DataType } from '../../dt/index.js';
 import type { StringKeys } from '../../utils/index.js';
 import type { UCDef } from '../def.js';
 import type { UCInput } from '../input.js';
-import type { UCOPIBase } from '../opi.js';
+import { type UCOPIBase } from '../opi.js';
 import type { UCOutput, UCOutputPartIdx, UCOutputPartKey } from '../output.js';
 import type { UCOutputPart, UCOutputPartDef } from '../output-part.js';
 import type { UC } from '../UC.js';

package/dist/esm/uc/helpers/UCOutputReader.js

@@ -1,4 +1,4 @@
-import { TUUID } from '../../dt/index.js';
+import { UCOPIBaseDefFields } from '../opi.js';
 import { UCOutputField } from '../UCOutputField.js';
 const ERR_NO_FIELD = (key) => `No field ${key} is defined for this use case`;
 const ERR_NO_IO_OUTPUT = 'No output is defined for this use case';
@@ -65,7 +65,7 @@ export class UCOutputReader {
             return undefined;
         }
         const { fields, layout, order, related } = partDef;
-        const allFields = { id: { type: new TUUID() }, ...fields };
+        const allFields = { ...UCOPIBaseDefFields, ...fields };
         const allFieldsKeys = order ?? Object.keys(allFields);
         let items = [];
         let total = 0;

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

@@ -1,9 +1,11 @@
 export * from './auth/consts.js';
 export * from './auth.js';
+export * from './cardinality.js';
 export * from './client.js';
 export * from './data.js';
 export * from './data-store.js';
 export * from './def.js';
+export * from './examples.js';
 export * from './exec.js';
 export * from './ext.js';
 export * from './file.js';

package/dist/esm/uc/index.js

@@ -1,9 +1,11 @@
 export * from './auth/consts.js';
 export * from './auth.js';
+export * from './cardinality.js';
 export * from './client.js';
 export * from './data.js';
 export * from './data-store.js';
 export * from './def.js';
+export * from './examples.js';
 export * from './exec.js';
 export * from './ext.js';
 export * from './file.js';

package/dist/esm/uc/input-field.d.ts

@@ -1,5 +1,6 @@
 import type { DataType, TBase, UIntQuantity } from '../dt/index.js';
 import type { EnumOf } from '../utils/index.js';
+import { type UCFieldDefCardinality } from './cardinality.js';
 import type { UCFieldKey } from './def.js';
 import type { Value } from './value.js';
 export declare const UCInputFieldFillingMode: {
@@ -13,23 +14,19 @@ export declare const UCInputFieldFillingMode: {
     readonly MANUAL: "MANUAL";
 };
 export type UCInputFieldFillingMode = EnumOf<typeof UCInputFieldFillingMode>;
-export interface UCInputFieldDefCardinality {
-    max?: UIntQuantity;
-    min?: UIntQuantity;
-}
 /**
  * Definition of a use case input field
  */
 export interface UCInputFieldDef<T extends DataType> {
     /**
-     * A field can have 0, 1 or n values. This field defines the rules.
+     * A field can have 0, 1 or n values.
      *
      * @defaultValue { max: 1, min: 1 } => the user must absolutely provide one value only
      *
      * @example { max: 5, min: 0 } => the user must provide at most 5 values or none
      * @example { min: 0 } => the user must provide 0 values or none
      */
-    cardinality?: UCInputFieldDefCardinality;
+    cardinality?: UCFieldDefCardinality;
     /**
      * @defaultValue {@link UCInputFieldFillingMode.MANUAL}
      */

package/dist/esm/uc/input-field.js

@@ -1,3 +1,5 @@
+import { ucfIsMandatory, ucfRepeatability, } from './cardinality.js';
+import { ucfExamples } from './examples.js';
 export const UCInputFieldFillingMode = {
     /**
      * Set programmatically on behalf of the user (e.g. a foreign key id for a given object)
@@ -9,17 +11,7 @@ export const UCInputFieldFillingMode = {
     MANUAL: 'MANUAL',
 };
 export function ucifExamples(def) {
-    const { type } = def;
-    const examples = type.getExamples();
-    // Leaving the value `undefined` means you want the default value
-    if (examples === undefined) {
-        return [type.example()];
-    }
-    // Setting the examples to `[]` means you don't want them
-    if (examples.length === 0) {
-        return undefined;
-    }
-    return examples;
+    return ucfExamples(def.type);
 }
 export function ucifHint(def) {
     if (ucifIsSensitive(def)) {
@@ -52,18 +44,10 @@ export function ucifId(key, prefix = 'inputfield', separator = '-') {
     return `${prefix}${separator}${key}`;
 }
 export function ucifIsMandatory(def) {
-    const min = def.cardinality?.min;
-    if (min === undefined) {
-        return true;
-    }
-    return min > 0;
+    return ucfIsMandatory(def.cardinality);
 }
 export function ucifRepeatability(def) {
-    const max = def.cardinality?.max;
-    if (max === undefined) {
-        return [false, 0];
-    }
-    return [max > 1, max];
+    return ucfRepeatability(def.cardinality);
 }
 export function ucifIsSensitive(def) {
     const { sensitive, type } = def;