libmodulor 0.23.0 → 0.24.0

package/dist/esm/target/lib/server-express/funcs.js

@@ -38,7 +38,7 @@ export function buildHandler(appManifest, ucd, contract, serverRequestHandler, u
                 break;
             }
             default:
-                ((_) => { })(transportType);
+                transportType;
         }
         const { body, status } = await serverRequestHandler.exec({
             appManifest,
@@ -67,7 +67,7 @@ export function buildHandler(appManifest, ucd, contract, serverRequestHandler, u
                 return;
             }
             default:
-                ((_) => { })(transportType);
+                transportType;
         }
     };
     return handler;

package/dist/esm/target/lib/server-hono/funcs.js

@@ -51,7 +51,7 @@ export function buildHandler(appManifest, ucd, contract, serverRequestHandler, u
                 break;
             }
             default:
-                ((_) => { })(transportType);
+                transportType;
         }
         const { body, status } = await serverRequestHandler.exec({
             appManifest,
@@ -80,7 +80,7 @@ export function buildHandler(appManifest, ucd, contract, serverRequestHandler, u
                 });
             }
             default:
-                ((_) => { })(transportType);
+                transportType;
         }
         return c.json(body, status);
     };

package/dist/esm/target/lib/server-node/funcs.js

@@ -23,7 +23,7 @@ export async function stop(server, settingsManager) {
             case 'patient':
                 break;
             default:
-                ((_) => { })(mode);
+                mode;
         }
         server.close((err) => {
             if (err) {

package/dist/esm/target/node-stricli-cli/NodeStricliCLIManager.d.ts

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

package/dist/esm/target/node-stricli-cli/NodeStricliCLIManager.js

@@ -0,0 +1,118 @@
+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 { buildApplication, buildCommand, buildRouteMap, run, } from '@stricli/core';
+import { inject, injectable } from 'inversify';
+import { WordingManager } from '../../i18n/index.js';
+import { ProductUCsLoader } from '../../product/index.js';
+import { ucifHint, ucifIsMandatory, ucifRepeatability, ucMountingPoint, } from '../../uc/index.js';
+import { CommandExecutor } from '../lib/cli/CommandExecutor.js';
+let NodeStricliCLIManager = class NodeStricliCLIManager {
+    commandExecutor;
+    productManifest;
+    productUCsLoader;
+    wordingManager;
+    constructor(commandExecutor, productManifest, productUCsLoader, wordingManager) {
+        this.commandExecutor = commandExecutor;
+        this.productManifest = productManifest;
+        this.productUCsLoader = productUCsLoader;
+        this.wordingManager = wordingManager;
+    }
+    async handleCommand({ appsRootPath, srcImporter, }) {
+        const ucs = await this.productUCsLoader.exec({
+            appsRootPath,
+            srcImporter,
+        });
+        const routes = {};
+        for (const uc of ucs) {
+            const mountingPoint = uc.def.ext?.cmd?.mountAt ?? ucMountingPoint(uc);
+            routes[mountingPoint] = buildCommand({
+                docs: {
+                    brief: this.wordingManager.uc(uc.def).desc ?? '',
+                },
+                func: async (flags) => {
+                    uc.fill(flags);
+                    await this.commandExecutor.exec({ uc });
+                },
+                parameters: {
+                    flags: {},
+                },
+            });
+            const { flags } = routes[mountingPoint].parameters;
+            if (!flags) {
+                throw new Error('Init the flags first');
+            }
+            for (const f of this.commandExecutor.fieldsForFlags(uc)) {
+                const { def } = f;
+                const { desc, label } = this.wordingManager.ucif(f);
+                const brief = desc ?? label;
+                const defaultValue = def.type.getDefaultValue();
+                const [isRepeatable, _max] = ucifRepeatability(def);
+                const options = def.type.getOptions();
+                const hasOptions = options && options.length > 0;
+                const hint = ucifHint(def);
+                const common = {
+                    brief,
+                    default: defaultValue,
+                    optional: !ucifIsMandatory(def),
+                    placeholder: hint ?? '',
+                    variadic: isRepeatable,
+                };
+                if (hasOptions) {
+                    flags[f.key] = {
+                        ...common,
+                        kind: 'enum',
+                        values: options?.map((o) => o.value),
+                    };
+                }
+                else {
+                    flags[f.key] = {
+                        ...common,
+                        kind: 'parsed',
+                        parse: (raw) => {
+                            def.type.assign(raw);
+                            const val = def.type.val();
+                            def.type.clear();
+                            return val;
+                        },
+                    };
+                }
+            }
+        }
+        const { desc, slogan } = this.wordingManager.p();
+        const root = buildRouteMap({
+            docs: {
+                brief: desc ?? slogan ?? '',
+            },
+            routes,
+        });
+        const app = buildApplication(root, {
+            name: this.productManifest.name,
+            versionInfo: {
+                currentVersion: await this.commandExecutor.version(),
+            },
+        });
+        await run(app, process.argv.slice(2), {
+            process: process,
+        });
+    }
+};
+NodeStricliCLIManager = __decorate([
+    injectable(),
+    __param(0, inject(CommandExecutor)),
+    __param(1, inject('ProductManifest')),
+    __param(2, inject(ProductUCsLoader)),
+    __param(3, inject(WordingManager)),
+    __metadata("design:paramtypes", [CommandExecutor, Object, ProductUCsLoader,
+        WordingManager])
+], NodeStricliCLIManager);
+export { NodeStricliCLIManager };

package/dist/esm/testing/AppTester.js

@@ -12,7 +12,6 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 import { inject, injectable } from 'inversify';
 import { I18nEN } from '../i18n/locales/en.js';
-import { I18nFR } from '../i18n/locales/fr.js';
 import { FAKE_USER_ADMIN, UCBuilder, ucHTTPContract, } from '../uc/index.js';
 // We inject directly the implementation because we'll generate all the reports and not only the one that is bound to the interface.
 // We can plan a setting à la Vitest where we specify the types of reports to generate though.
@@ -88,9 +87,13 @@ let AppTester = class AppTester {
         }
     }
     async checkAppI18n() {
+        if (!this.ucDefSourcesCheckerOutput) {
+            throw new Error('checkUCDSources must be called before checkAppI18n');
+        }
         const { errors } = await this.appI18nChecker.exec({
             appI18n: this.ctx.appI18n,
             appManifest: this.ctx.appManifest,
+            ucDefSourcesCheckerOutput: this.ucDefSourcesCheckerOutput,
         });
         if (errors.length > 0) {
             throw new Error(errors[0]);
@@ -302,15 +305,11 @@ let AppTester = class AppTester {
         const appLangCodes = Object.keys(appI18n);
         const coreI18n = {
             en: I18nEN,
-            fr: I18nFR,
         };
         const productI18n = {
             en: {
                 ...I18nEN,
             },
-            fr: {
-                ...I18nFR,
-            },
         };
         for (const l of appLangCodes) {
             if (!(l in coreI18n)) {

package/dist/esm/testing/UCDefASTParser.d.ts

@@ -1,21 +1,39 @@
 import type { ErrorMessage, FilePath } from '../dt/index.js';
 import type { UCDefLifecycle, UCMetadata, UCOutputPartIdx } from '../uc/index.js';
 import type { AppTesterOptsAllSet } from './opts.js';
-export interface OutputItemField<T extends string = string> {
+export interface OutputItemField<T = string> {
     err: ErrorMessage | null;
     value: T;
 }
+export type OutputItemFieldIOField = OutputItemField<{
+    /**
+     * @example `FreeTextShort`
+     */
+    dataType: string | null;
+    /**
+     * @example `name`
+     */
+    name: string | null;
+    /**
+     * @example `name: UCInputField<FreeTextShort>`
+     */
+    raw: string | null;
+    /**
+     * @example `UCInputField<FreeTextShort>`
+     */
+    type: string | null;
+}>;
 export interface OutputItem {
     constName: OutputItemField | null;
     externalImports: OutputItemField[] | null;
     filePath: OutputItemField | null;
     internalImports: OutputItemField[] | null;
     ioI: OutputItemField | null;
-    ioIFields: OutputItemField[] | null;
+    ioIFields: OutputItemFieldIOField[] | null;
     ioOPI0: OutputItemField | null;
-    ioOPI0Fields: OutputItemField[] | null;
+    ioOPI0Fields: OutputItemFieldIOField[] | null;
     ioOPI1: OutputItemField | null;
-    ioOPI1Fields: OutputItemField[] | null;
+    ioOPI1Fields: OutputItemFieldIOField[] | null;
     lifecycleClientPolicy: OutputItemField | null;
     lifecycleClientSteps: OutputItemField[] | null;
     lifecycleServerPolicy: OutputItemField | null;
@@ -29,10 +47,10 @@ export interface OutputItem {
 }
 export declare const OUTPUT_ITEM_FIELDS: (keyof OutputItem)[];
 export type OnImport = (name: string) => void;
-export type OnInputType = (name: string, fields: OutputItemField[]) => void;
+export type OnInputType = (name: string, fields: OutputItemFieldIOField[]) => void;
 export type OnMainStep = (lifecycle: UCDefLifecycle, step: string) => void;
 export type OnMetadata = (metadata: UCMetadata) => void;
-export type OnOPIType = (name: string, fields: OutputItemField[], idx: UCOutputPartIdx) => void;
+export type OnOPIType = (name: string, fields: OutputItemFieldIOField[], idx: UCOutputPartIdx) => void;
 export type OnPolicy = (lifecycle: UCDefLifecycle, name: string) => void;
 export type OnVariable = (name: string) => void;
 export interface UCDefASTParser {

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

@@ -11,7 +11,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 import { inject, injectable } from 'inversify';
-import { APP_DOCS_FILE_NAME, UC_INPUT_FIELD_PATTERN, UC_MAIN_STEP_PREFIX_REGULAR, } from '../../convention.js';
+import { APP_DOCS_FILE_NAME, UC_MAIN_STEP_PREFIX_REGULAR, } from '../../convention.js';
 import { OUTPUT_ITEM_FIELDS, } from '../UCDefASTParser.js';
 let SimpleAppDocsEmitter = class SimpleAppDocsEmitter {
     fsManager;
@@ -142,9 +142,8 @@ function diagramUCClientConfirm(participant, caller) {
     ];
 }
 function diagramUCFields(fields) {
-    return (fields
-        ?.map((f) => f.value.replace(new RegExp(UC_INPUT_FIELD_PATTERN.slice(1)), '$1'))
-        .join(LB) || '');
+    return (fields?.map((f) => `${f.value.name}: ${f.value.dataType}`).join(LB) ||
+        '');
 }
 function diagramUCMainSteps(participant, field) {
     return field.map((f) => `${participant}->>${participant}: ${f.value.replace(UC_MAIN_STEP_PREFIX_REGULAR, '').trim()}`);
@@ -171,7 +170,7 @@ function fmtTechSummaryField(field) {
 }
 function fmtTechSummaryFieldVal(field) {
     const { err, value } = field;
-    let res = value;
+    let res = (typeof value === 'string' ? value : value.raw) ?? '';
     if (err) {
         res += `❌ ${err}`;
     }

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

@@ -11,7 +11,8 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 import { inject, injectable } from 'inversify';
-import typescript, { isClassDeclaration, isObjectLiteralExpression, isPropertyAssignment, } from 'typescript';
+import typescript, { isClassDeclaration, isObjectLiteralExpression, isPropertyAssignment, SyntaxKind, } from 'typescript';
+// https://ts-ast-viewer.com
 // To avoid the following error when used in a consumer :
 // SyntaxError: Named export 'ModuleKind' not found. The requested module 'typescript' is a CommonJS module, which may not support all module.exports as named exports.
 // CommonJS modules can always be imported via the default export
@@ -99,20 +100,46 @@ let TypeScriptLibUCDefASTParser = class TypeScriptLibUCDefASTParser {
     }
     getTypeFields(node) {
         const type = this.typeChecker.getTypeAtLocation(node);
-        const fields = type.getProperties().map((p) => {
+        const fields = type
+            .getProperties()
+            .map((p) => {
             const field = {
                 err: null,
-                value: p.getName(),
+                value: {
+                    dataType: null,
+                    name: null,
+                    raw: null,
+                    type: null,
+                },
             };
             const declarations = p.getDeclarations();
-            if (declarations) {
-                const [first] = declarations;
-                if (first && isPropertySignature(first)) {
-                    field.value = first
-                        .getText()
-                        .replaceAll('\n', '')
-                        .replaceAll(';', '');
-                }
+            if (!declarations) {
+                return field;
+            }
+            const [first] = declarations;
+            if (first && isPropertySignature(first)) {
+                field.value.raw = first
+                    .getText()
+                    .replaceAll('\n', '')
+                    .replaceAll(';', '')
+                    .replaceAll(/\s+/g, ' ');
+                first.forEachChild((node1) => {
+                    if (isIdentifier(node1)) {
+                        field.value.name = node1.getText();
+                    }
+                    else if (isTypeReferenceNode(node1)) {
+                        field.value.type = node1.getText();
+                        node1.forEachChild((node2) => {
+                            if (isIdentifier(node2) ||
+                                isTypeReferenceNode(node2) ||
+                                node2.kind === SyntaxKind.BooleanKeyword ||
+                                node2.kind === SyntaxKind.NumberKeyword ||
+                                node2.kind === SyntaxKind.StringKeyword) {
+                                field.value.dataType = node2.getText();
+                            }
+                        });
+                    }
+                });
             }
             return field;
         });

package/dist/esm/testing/impl/VitestAppTestSuiteRunner.d.ts

@@ -5,7 +5,7 @@ export declare class VitestAppTestSuiteRunner implements AppTestSuiteRunner {
     private fsManager;
     private shellCommandExecutor;
     constructor(fsManager: FSManager, shellCommandExecutor: ShellCommandExecutor);
-    exec({ appPath, skipCoverage, updateSnapshots, }: Input): Promise<void>;
+    exec({ appPath, only, skipCoverage, updateSnapshots, }: Input): Promise<void>;
     coverageReportEntrypointPath(appPath: FilePath): Promise<FilePath>;
     private coverageReportPath;
 }

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

@@ -19,18 +19,33 @@ let VitestAppTestSuiteRunner = class VitestAppTestSuiteRunner {
         this.fsManager = fsManager;
         this.shellCommandExecutor = shellCommandExecutor;
     }
-    async exec({ appPath, skipCoverage, updateSnapshots, }) {
+    async exec({ appPath, only, skipCoverage, updateSnapshots, }) {
         const testPath = this.fsManager.path(appPath, APP_TEST_DIR_NAME);
         const args = [
             'run',
             '--color',
+            // https://vitest.dev/guide/cli.html#dir
             '--dir',
             appPath,
         ];
+        if (only) {
+            args.push(
+            // https://vitest.dev/guide/cli.html#testnamepattern
+            '--testNamePattern', only);
+        }
         if (!skipCoverage) {
-            args.push('--coverage.enabled', '--coverage.exclude', testPath, '--coverage.include', appPath, '--coverage.reportsDirectory', this.coverageReportPath(appPath));
+            args.push(
+            // https://vitest.dev/guide/cli.html#coverage-enabled
+            '--coverage.enabled', 
+            // https://vitest.dev/guide/cli.html#coverage-exclude
+            '--coverage.exclude', testPath, 
+            // https://vitest.dev/guide/cli.html#coverage-include
+            '--coverage.include', appPath, 
+            // https://vitest.dev/guide/cli.html#coverage-reportsdirectory
+            '--coverage.reportsDirectory', this.coverageReportPath(appPath));
         }
         if (updateSnapshots) {
+            // https://vitest.dev/guide/cli.html#update
             args.push('--update');
         }
         await this.shellCommandExecutor.exec({

package/dist/esm/testing/opts.js

@@ -4,7 +4,7 @@ export const DEFAULT_APP_TESTER_OPTS = {
         imports: {
             external: {
                 aliasPrefix: '@',
-                allowed: ['inversify', 'libmodulor'],
+                allowed: ['libmodulor', 'inversify'],
             },
             internal: {
                 maxDepth: '../../',

package/dist/esm/testing/workers/AppTestSuiteRunner.d.ts

@@ -1,7 +1,9 @@
 import type { FilePath } from '../../dt/index.js';
 import type { Worker } from '../../std/index.js';
+import type { UCName } from '../../uc/index.js';
 export interface Input {
     appPath: FilePath;
+    only: UCName | null;
     skipCoverage: boolean;
     updateSnapshots: boolean;
 }

package/dist/esm/testing/workers/UCExecutor.js

@@ -104,7 +104,7 @@ let UCExecutor = class UCExecutor {
                     break;
                 }
                 default:
-                    ((_) => { })(transportType);
+                    transportType;
             }
             if (!ucor) {
                 throw new Error(ERR_CLIENT_EXPECTED_UCOR(name));

package/dist/esm/testing/workers/checkers/AppI18nChecker.d.ts

@@ -1,10 +1,12 @@
 import type { AppManifest } from '../../../app/index.js';
 import type { ErrorMessage } from '../../../dt/index.js';
-import type { I18n } from '../../../i18n/index.js';
+import { type I18n } from '../../../i18n/index.js';
 import type { Worker } from '../../../std/index.js';
+import type { Output as UCDefSourcesCheckerOutput } from './UCDefSourcesChecker.js';
 export interface Input {
     appI18n: I18n;
     appManifest: Pick<AppManifest, 'languageCodes'>;
+    ucDefSourcesCheckerOutput: UCDefSourcesCheckerOutput;
 }
 export interface Output {
     errors: ErrorMessage[];
@@ -13,7 +15,11 @@ export declare class AppI18nChecker implements Worker<Input, Promise<Output>> {
     private static I18N_KEY_PATTERN;
     private output;
     constructor();
-    exec({ appI18n, appManifest }: Input): Promise<Output>;
+    exec({ appI18n, appManifest, ucDefSourcesCheckerOutput, }: Input): Promise<Output>;
     private makeSureLanguagesAreConsistent;
     private makeSureKeysAndLabelsAreValid;
+    private makeSureNonDefaultLanguagesAreFullyTranslated;
+    private checkUC;
+    private checkIOFields;
+    private checkKey;
 }

package/dist/esm/testing/workers/checkers/AppI18nChecker.js

@@ -9,9 +9,11 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 var AppI18nChecker_1;
 import { injectable } from 'inversify';
+import { I18N_DEFAULT_LANG, } from '../../../i18n/index.js';
 const ERR_I18N_MISMATCH = () => 'The languageCodes in app manifest must match with the keys in i18n';
 const ERR_I18N_KEY_INVALID = (key) => `The i18n key '${key}' must respect the i18n key pattern`;
-const ERR_I18N_LABEL_NO_DOT = (key) => `The i18n key '${key}' is a label, thus should not ends with a dot`;
+const ERR_I18N_LABEL_NO_DOT = (key) => `The i18n key '${key}' is a label, thus it should not end with a dot`;
+const ERR_I18N_MISSING_TRANS = (key, lang) => `The i18n key '${key}' is missing for lang '${lang}'`;
 let AppI18nChecker = class AppI18nChecker {
     static { AppI18nChecker_1 = this; }
     static I18N_KEY_PATTERN = /(dt_([A-Z][A-Za-z0-9]+)_([A-Za-z0-9]+)_(desc|label))|(err_([A-Za-z_]+))|(uc_([A-Z][A-Za-z0-9]+)_(client_confirm_(cancel|confirm|message|title)|desc|label|i_submit_(changing|idle|initializing|submitting)|op_(0|1)_(empty|label)))|(ucif_([a-z]([A-Za-z0-9]+)?)_(desc|label))|(ucof_([a-z]([A-Za-z0-9]+)?)_(desc|label))|(validation_([a-z]+)_([A-Z][A-Za-z0-9]+))/;
@@ -19,9 +21,10 @@ let AppI18nChecker = class AppI18nChecker {
     constructor() {
         this.output = { errors: [] };
     }
-    async exec({ appI18n, appManifest }) {
+    async exec({ appI18n, appManifest, ucDefSourcesCheckerOutput, }) {
         this.makeSureLanguagesAreConsistent(appI18n, appManifest);
         this.makeSureKeysAndLabelsAreValid(appI18n);
+        this.makeSureNonDefaultLanguagesAreFullyTranslated(appI18n, ucDefSourcesCheckerOutput);
         return this.output;
     }
     makeSureLanguagesAreConsistent(appI18n, appManifest) {
@@ -44,6 +47,45 @@ let AppI18nChecker = class AppI18nChecker {
             }
         }
     }
+    makeSureNonDefaultLanguagesAreFullyTranslated(i18n, ucDefSourcesCheckerOutput) {
+        for (const [lang, translations] of Object.entries(i18n)) {
+            if (lang === I18N_DEFAULT_LANG) {
+                // We assume the code is in English so it's fine not to have all the translations in this language.
+                // For instance, a field named "name" will be humanized as "Name", which is totally ok.
+                continue;
+            }
+            for (const { metadataName, ioIFields, ioOPI0Fields, ioOPI1Fields, } of ucDefSourcesCheckerOutput.items) {
+                this.checkUC(lang, translations, 'label', metadataName);
+                for (const [prefix, fields] of [
+                    ['ucif', ioIFields],
+                    ['ucof', ioOPI0Fields],
+                    ['ucof', ioOPI1Fields],
+                ]) {
+                    this.checkIOFields(lang, translations, prefix, 'label', fields);
+                }
+            }
+        }
+    }
+    checkUC(lang, translations, suffix, metadataName) {
+        if (!metadataName) {
+            return;
+        }
+        this.checkKey(lang, translations, `uc_${metadataName.value}_${suffix}`);
+    }
+    checkIOFields(lang, translations, prefix, suffix, fields) {
+        if (!fields) {
+            return;
+        }
+        for (const f of fields) {
+            this.checkKey(lang, translations, `${prefix}_${f.value.name}_${suffix}`);
+        }
+    }
+    checkKey(lang, translations, key) {
+        if (key in translations) {
+            return;
+        }
+        this.output.errors.push(ERR_I18N_MISSING_TRANS(key, lang));
+    }
 };
 AppI18nChecker = AppI18nChecker_1 = __decorate([
     injectable(),

package/dist/esm/testing/workers/checkers/UCDefSourcesChecker.js

@@ -18,7 +18,7 @@ const ERR_UCD_CONST_NAME = (name) => `The UCD const name '${name}' must follow t
 const ERR_UCD_FILE_SUFFIX = (fileName) => `The file '${fileName}' must end with ${UC_DEF_FILE_NAME_SUFFIX}`;
 const ERR_UCD_IMPORTS_EXTERNAL_ALLOWED = (aliasPrefix, allowed, text) => `External imports must be an alias '${aliasPrefix}*' or be one of ${allowed} (Got ${text})`;
 const ERR_UCD_IMPORTS_INTERNAL_MAX_DEPTH = (maxDepth) => `Internal imports must not be deeper than ${maxDepth}`;
-const ERR_UCD_INPUT_FIELD_PATTERN = () => `The input field def must match ${UC_INPUT_FIELD_PATTERN}`;
+const ERR_UCD_INPUT_FIELD_DECLARATION = (raw) => `The input field def must match 'name: UCInputFieldValue<DataType>' (Got '${raw}')`;
 const ERR_UCD_INPUT_TYPE_NAME = (ucName) => `The input type must be named ${ucName}${UC_INPUT_SUFFIX}`;
 const ERR_UCD_OPI_TYPE_NAME = (ucName, idx) => `The OPI must be named ${ucName}${UC_OPI_SUFFIX}${idx}`;
 // TODO : Improve the check* methods that look a little bit hacky
@@ -93,16 +93,16 @@ let UCDefSourcesChecker = class UCDefSourcesChecker {
         };
         item.ioIFields = fields;
         for (const f of item.ioIFields) {
-            const parts = f.value.split(':');
-            if (parts.length !== 2) {
-                continue;
+            const { dataType, name, raw, type } = f.value;
+            if (dataType &&
+                name &&
+                raw &&
+                type &&
+                type.match(new RegExp(UC_INPUT_FIELD_PATTERN)) !== null) {
+            }
+            else {
+                f.err = ERR_UCD_INPUT_FIELD_DECLARATION(raw);
             }
-            const [_name, type] = parts;
-            // trim because we process `name: Type` if the code is linted correctly
-            f.err =
-                type?.trim().match(new RegExp(UC_INPUT_FIELD_PATTERN)) !== null
-                    ? null
-                    : ERR_UCD_INPUT_FIELD_PATTERN();
         }
     }
     checkMainStep(lifecycle, step, item) {
@@ -120,7 +120,7 @@ let UCDefSourcesChecker = class UCDefSourcesChecker {
                 item.lifecycleServerSteps.push({ err: null, value: step });
                 break;
             default:
-                ((_) => { })(lifecycle);
+                lifecycle;
         }
     }
     checkMetadata(metadata, item) {
@@ -177,7 +177,7 @@ let UCDefSourcesChecker = class UCDefSourcesChecker {
                 };
                 break;
             default:
-                ((_) => { })(lifecycle);
+                lifecycle;
         }
     }
     async processFiles(appPath, paths) {

package/dist/esm/uc/impl/HTTPUCTransporter.js

@@ -51,7 +51,7 @@ let HTTPUCTransporter = class HTTPUCTransporter {
                 break;
             }
             default:
-                ((_) => { })(publicApiKeyCheckType);
+                publicApiKeyCheckType;
         }
         if (auth) {
             switch (authType) {
@@ -86,7 +86,7 @@ let HTTPUCTransporter = class HTTPUCTransporter {
                     break;
                 }
                 default:
-                    ((_) => { })(authType);
+                    authType;
             }
         }
         const res = await this.httpAPICaller.exec({

package/dist/esm/uc/impl/KnexUCDataStore.js

@@ -112,7 +112,7 @@ let KnexUCDataStore = class KnexUCDataStore {
             case 'sqlite3':
                 return [];
             default:
-                ((_) => { })(type);
+                (type);
                 return [];
         }
     }
@@ -156,7 +156,7 @@ let KnexUCDataStore = class KnexUCDataStore {
                 this.fillConfigForSQLite3();
                 break;
             default:
-                ((_) => { })(type);
+                (type);
         }
     }
     fillConfigForPG() {

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

@@ -48,7 +48,6 @@ export * from './utils/fmtVal.js';
 export * from './utils/recIs.js';
 export * from './utils/rInput.js';
 export * from './utils/rVal.js';
-export * from './utils/stripUCDLifecycleServer.js';
 export * from './utils/ucHTTPContract.js';
 export * from './utils/ucMountingPoint.js';
 export * from './value.js';

package/dist/esm/uc/index.js

@@ -48,7 +48,6 @@ export * from './utils/fmtVal.js';
 export * from './utils/recIs.js';
 export * from './utils/rInput.js';
 export * from './utils/rVal.js';
-export * from './utils/stripUCDLifecycleServer.js';
 export * from './utils/ucHTTPContract.js';
 export * from './utils/ucMountingPoint.js';
 export * from './value.js';