libmodulor 0.29.0 → 0.30.0

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

@@ -30,19 +30,21 @@ let NodeExpressServerManager = class NodeExpressServerManager {
     environmentManager;
     helmetMiddlewareBuilder;
     logger;
+    mcpHTTPRequestHandlerBuilder;
     serverRequestHandler;
     serverSSLCertLoader;
     settingsManager;
     ucManager;
     runtime;
     server;
-    constructor(corsMiddlewareBuilder, customerFacingErrorBuilder, entrypointsBuilder, environmentManager, helmetMiddlewareBuilder, 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.helmetMiddlewareBuilder = helmetMiddlewareBuilder;
         this.logger = logger;
+        this.mcpHTTPRequestHandlerBuilder = mcpHTTPRequestHandlerBuilder;
         this.serverRequestHandler = serverRequestHandler;
         this.serverSSLCertLoader = serverSSLCertLoader;
         this.settingsManager = settingsManager;
@@ -79,6 +81,12 @@ 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);
@@ -119,13 +127,14 @@ NodeExpressServerManager = __decorate([
     __param(3, inject('EnvironmentManager')),
     __param(4, inject(HelmetMiddlewareBuilder)),
     __param(5, inject('Logger')),
-    __param(6, inject(ServerRequestHandler)),
-    __param(7, inject(ServerSSLCertLoader)),
-    __param(8, inject('SettingsManager')),
-    __param(9, inject('UCManager')),
+    __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, ServerRequestHandler,
+        EntrypointsBuilder, Object, HelmetMiddlewareBuilder, Object, Object, ServerRequestHandler,
         ServerSSLCertLoader, Object, Object])
 ], NodeExpressServerManager);
 export { NodeExpressServerManager };

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

@@ -1,8 +1,10 @@
-import type { Hono } from 'hono';
+import type { Hono, MiddlewareHandler } from 'hono';
 import type { AppManifest } from '../../app/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';
@@ -18,13 +20,14 @@ export declare class NodeHonoServerManager implements Configurable<S>, ServerMan
     private entrypointsBuilder;
     protected environmentManager: EnvironmentManager;
     private logger;
+    private mcpHTTPRequestHandlerBuilder;
     private serverRequestHandler;
     private serverSSLCertLoader;
     private settingsManager;
     private ucManager;
     protected runtime: Hono;
     private server;
-    constructor(corsMiddlewareBuilder: CORSMiddlewareBuilder, 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;
@@ -32,6 +35,7 @@ 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>;

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

@@ -29,18 +29,20 @@ let NodeHonoServerManager = class NodeHonoServerManager {
     entrypointsBuilder;
     environmentManager;
     logger;
+    mcpHTTPRequestHandlerBuilder;
     serverRequestHandler;
     serverSSLCertLoader;
     settingsManager;
     ucManager;
     runtime;
     server;
-    constructor(corsMiddlewareBuilder, 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;
@@ -75,6 +77,12 @@ 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);
@@ -122,13 +130,14 @@ NodeHonoServerManager = __decorate([
     __param(2, inject(EntrypointsBuilder)),
     __param(3, inject('EnvironmentManager')),
     __param(4, inject('Logger')),
-    __param(5, inject(ServerRequestHandler)),
-    __param(6, inject(ServerSSLCertLoader)),
-    __param(7, inject('SettingsManager')),
-    __param(8, inject('UCManager')),
+    __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, ServerRequestHandler,
+        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,48 +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, 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/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;

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

@@ -1,4 +1,5 @@
-import type { DataType, UUID } from '../dt/index.js';
+import { type DataType, type UUID } from '../dt/index.js';
+import type { UCOutputPartDefFields } from './output-part.js';
 import type { Value } from './value.js';
 /**
  * Base interface all the use case OPI interfaces must extend
@@ -6,6 +7,7 @@ import type { Value } from './value.js';
 export interface UCOPIBase {
     id: UUID;
 }
+export declare const UCOPIBaseDefFields: UCOutputPartDefFields<UCOPIBase>;
 /**
  * A value returned as part of an OPI
  *

package/dist/esm/uc/opi.js

@@ -1 +1,4 @@
-export {};
+import { TUUID } from '../dt/index.js';
+export const UCOPIBaseDefFields = {
+    id: { type: new TUUID() },
+};

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

@@ -1,10 +1,20 @@
-import type { DataType, TBase } from '../dt/index.js';
+import type { DataType, TBase, UIntQuantity } from '../dt/index.js';
 import type { StringKeys } from '../utils/index.js';
+import { type UCFieldDefCardinality } from './cardinality.js';
 import type { UCOPIBase } from './opi.js';
 /**
  * Definition of a use case output field
  */
 export interface UCOutputFieldDef<OPI extends UCOPIBase, T extends DataType> {
+    /**
+     * A field can have 0, 1 or n values. This field defines the rules.
+     *
+     * @defaultValue { max: 1, min: 1 } => it has a single value
+     *
+     * @example { max: 5, min: 0 } => it has at most 5 values or none
+     * @example { min: 0 } => it is nullable
+     */
+    cardinality?: UCFieldDefCardinality;
     /**
      * Indicates another field of the output this field can potentially link to (in the `<a></a>` way).
      */
@@ -16,3 +26,5 @@ export interface UCOutputFieldDef<OPI extends UCOPIBase, T extends DataType> {
     type: TBase<T>;
 }
 export declare function ucofExamples<OPI extends UCOPIBase, T extends DataType>(def: UCOutputFieldDef<OPI, T>): T[] | undefined;
+export declare function ucofIsMandatory<OPI extends UCOPIBase, T extends DataType>(def: UCOutputFieldDef<OPI, T>): boolean;
+export declare function ucofRepeatability<OPI extends UCOPIBase, T extends DataType>(def: UCOutputFieldDef<OPI, T>): [boolean, UIntQuantity];

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

@@ -1,13 +1,11 @@
+import { ucfIsMandatory, ucfRepeatability, } from './cardinality.js';
+import { ucfExamples } from './examples.js';
 export function ucofExamples(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 ucofIsMandatory(def) {
+    return ucfIsMandatory(def.cardinality);
+}
+export function ucofRepeatability(def) {
+    return ucfRepeatability(def.cardinality);
 }

package/dist/esm/utils/bundling/funcs.js

@@ -15,6 +15,6 @@ export function assertTransformedCorrectly(transformed, fileName) {
     if (match !== null) {
         // biome-ignore lint/suspicious/noConsole: we want it
         console.warn(transformed);
-        throw new Error(`[WARNING] The following file might not have been transformed correctly : ${fileName} (see transformed above)`);
+        throw new Error(`The following file might not have been transformed correctly : ${fileName} (see transformed above)`);
     }
 }

package/dist/esm/utils/bundling/vite/plugin.d.ts

@@ -1,6 +1,6 @@
 export declare const Plugin: {
     name: string;
-    transform: (this: import("rollup").TransformPluginContext, code: string, id: string) => {
+    transform: (this: import("rolldown").TransformPluginContext, code: string, id: string) => {
         code: string;
     };
 };

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

@@ -17,6 +17,7 @@ export { CONTAINER_OPTS } from './ioc/container.js';
 export type { Class } from './ioc/types.js';
 export { fmt as fmtNumber } from './numbers/fmt.js';
 export { baseFromSquareUnit, type CoreUnit, isSquareUnit, type SquareableUnit, type SquareUnit, type Unit, } from './numbers/units.js';
+export { defaultStreamOnClose } from './streams/funcs.js';
 export type { StreamConfig, StreamOnClose, StreamOnData, StreamOnDone, } from './streams/types.js';
 export { capitalize, isCapitalized } from './strings/capitalize.js';
 export { humanize } from './strings/humanize.js';

package/dist/esm/utils/index.js

@@ -11,6 +11,7 @@ export { bindFactory } from './ioc/bindFactory.js';
 export { CONTAINER_OPTS } from './ioc/container.js';
 export { fmt as fmtNumber } from './numbers/fmt.js';
 export { baseFromSquareUnit, isSquareUnit, } from './numbers/units.js';
+export { defaultStreamOnClose } from './streams/funcs.js';
 export { capitalize, isCapitalized } from './strings/capitalize.js';
 export { humanize } from './strings/humanize.js';
 export { truncate } from './strings/truncate.js';

package/dist/esm/utils/streams/funcs.d.ts

@@ -0,0 +1,2 @@
+import type { StreamOnClose } from './types.js';
+export declare function defaultStreamOnClose(streamedOnce: boolean): StreamOnClose;

package/dist/esm/utils/streams/funcs.js

@@ -0,0 +1,10 @@
+const ERR_MISSING_STREAM_ON_CLOSE = 'execOpts.stream.onClose needs to be set in the ServerMain to avoid memory leaks';
+export function defaultStreamOnClose(streamedOnce) {
+    return async () => {
+        if (!streamedOnce) {
+            // No need to close or register anything if it hasn't streamed anything yet
+            return;
+        }
+        throw new Error(ERR_MISSING_STREAM_ON_CLOSE);
+    };
+}