libmodulor 0.1.0 → 0.3.0

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

@@ -0,0 +1,94 @@
+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); }
+};
+var UCExecutor_1;
+import { inject, injectable } from 'inversify';
+import { UCBuilder, rInput, } from '../../uc/index.js';
+const ERR_CLIENT_EXPECTED_OUTPUT = (name) => `${name} client is expected to return an output but returned nothing`;
+const ERR_CLIENT_UNEXPECTED_OUTPUT = (name) => `${name} client is expected to return nothing but returned an output`;
+let UCExecutor = class UCExecutor {
+    static { UCExecutor_1 = this; }
+    cryptoManager;
+    ucBuilder;
+    ucManager;
+    static HASH_ALG = 'sha256';
+    static HASH_BTT_ENCODING = 'hex';
+    static HASH_SEP = '-';
+    constructor(cryptoManager, ucBuilder, ucManager) {
+        this.cryptoManager = cryptoManager;
+        this.ucBuilder = ucBuilder;
+        this.ucManager = ucManager;
+    }
+    async exec({ appManifest, auth, authName, inputFiller, inputFillerName, ucd, }) {
+        const out = {
+            args: {
+                auth,
+                authName,
+                inputFiller,
+                inputFillerName,
+            },
+            err: null,
+            hash: null,
+            io: {
+                i: null,
+                o: null,
+            },
+        };
+        await this.execClient(appManifest, ucd, out);
+        return {
+            out,
+        };
+    }
+    overrideUCManager(ucManager) {
+        this.ucManager = ucManager;
+    }
+    async execClient(appManifest, ucd, out) {
+        const { lifecycle: { client }, } = ucd;
+        if (!client) {
+            return;
+        }
+        const { args } = out;
+        const { auth, inputFiller } = args;
+        const { metadata: { name }, } = ucd;
+        const uc = this.ucBuilder.exec({
+            appManifest,
+            auth,
+            def: ucd,
+        });
+        inputFiller(uc);
+        const input = rInput(uc);
+        out.io.i = input;
+        out.hash = this.cryptoManager.hash(UCExecutor_1.HASH_ALG, [name, JSON.stringify(args), JSON.stringify(input)].join(UCExecutor_1.HASH_SEP), UCExecutor_1.HASH_BTT_ENCODING);
+        try {
+            const ucor = await this.ucManager.execClient(uc);
+            const output = ucor.output();
+            if (uc.hasOutputParts() && !output) {
+                throw new Error(ERR_CLIENT_EXPECTED_OUTPUT(name));
+            }
+            if (!uc.hasOutputParts() && output) {
+                throw new Error(ERR_CLIENT_UNEXPECTED_OUTPUT(name));
+            }
+            out.io.o = output ?? null;
+        }
+        catch (err) {
+            out.err = err;
+        }
+    }
+};
+UCExecutor = UCExecutor_1 = __decorate([
+    injectable(),
+    __param(0, inject('CryptoManager')),
+    __param(1, inject(UCBuilder)),
+    __param(2, inject('UCManager')),
+    __metadata("design:paramtypes", [Object, UCBuilder, Object])
+], UCExecutor);
+export { UCExecutor };

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

@@ -0,0 +1,19 @@
+import type { AppManifest } from '../../../app/index.js';
+import type { ErrorMessage } from '../../../dt/index.js';
+import type { I18n } from '../../../i18n/index.js';
+import type { Worker } from '../../../std/index.js';
+export interface Input {
+    appI18n: I18n;
+    appManifest: Pick<AppManifest, 'languageCodes'>;
+}
+export interface Output {
+    errors: ErrorMessage[];
+}
+export declare class AppI18nChecker implements Worker<Input, Promise<Output>> {
+    private static I18N_KEY_PATTERN;
+    private output;
+    constructor();
+    exec({ appI18n, appManifest }: Input): Promise<Output>;
+    private makeSureLanguagesAreConsistent;
+    private makeSureKeysAndLabelsAreValid;
+}

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

@@ -0,0 +1,52 @@
+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 AppI18nChecker_1;
+import { injectable } from 'inversify';
+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`;
+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]+))/;
+    output;
+    constructor() {
+        this.output = { errors: [] };
+    }
+    async exec({ appI18n, appManifest }) {
+        this.makeSureLanguagesAreConsistent(appI18n, appManifest);
+        this.makeSureKeysAndLabelsAreValid(appI18n);
+        return this.output;
+    }
+    makeSureLanguagesAreConsistent(appI18n, appManifest) {
+        const inManifest = appManifest.languageCodes;
+        const inI18n = Object.keys(appI18n);
+        if (inManifest.join() !== inI18n.join()) {
+            this.output.errors.push(ERR_I18N_MISMATCH());
+        }
+    }
+    makeSureKeysAndLabelsAreValid(i18n) {
+        for (const [_, translations] of Object.entries(i18n)) {
+            for (const [key, translation] of Object.entries(translations)) {
+                const matches = key.match(AppI18nChecker_1.I18N_KEY_PATTERN);
+                if (!matches) {
+                    this.output.errors.push(ERR_I18N_KEY_INVALID(key));
+                }
+                if (key.endsWith('_label') && translation.endsWith('.')) {
+                    this.output.errors.push(ERR_I18N_LABEL_NO_DOT(key));
+                }
+            }
+        }
+    }
+};
+AppI18nChecker = AppI18nChecker_1 = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [])
+], AppI18nChecker);
+export { AppI18nChecker };

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

@@ -0,0 +1,16 @@
+import type { ErrorMessage } from '../../../dt/index.js';
+import type { FSManager, Worker } from '../../../std/index.js';
+import type { AppTesterCtx } from '../../ctx.js';
+export interface Input {
+    appPath: AppTesterCtx['appPath'];
+}
+export interface Output {
+    errors: ErrorMessage[];
+}
+export declare class AppIndexChecker implements Worker<Input, Promise<Output>> {
+    private fsManager;
+    private output;
+    constructor(fsManager: FSManager);
+    exec({ appPath }: Input): Promise<Output>;
+    private makeSureExposesNecessary;
+}

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

@@ -0,0 +1,41 @@
+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 { APP_INDEX_FILE_NAME } from '../../../convention.js';
+const ERR_INDEX_EXPOSE_NECESSARY = () => `The ${APP_INDEX_FILE_NAME} must expose the necessary : comment, I18n, Manifest`;
+let AppIndexChecker = class AppIndexChecker {
+    fsManager;
+    output;
+    constructor(fsManager) {
+        this.fsManager = fsManager;
+        this.output = { errors: [] };
+    }
+    async exec({ appPath }) {
+        const contents = await this.fsManager.cat(this.fsManager.path(appPath, APP_INDEX_FILE_NAME));
+        this.makeSureExposesNecessary(contents);
+        return this.output;
+    }
+    makeSureExposesNecessary(contents) {
+        if (!contents.includes("// Expose only what's necessary") ||
+            !contents.includes("export { I18n } from './src/i18n.js'") ||
+            !contents.includes("export { Manifest } from './src/manifest.js'")) {
+            this.output.errors.push(ERR_INDEX_EXPOSE_NECESSARY());
+        }
+    }
+};
+AppIndexChecker = __decorate([
+    injectable(),
+    __param(0, inject('FSManager')),
+    __metadata("design:paramtypes", [Object])
+], AppIndexChecker);
+export { AppIndexChecker };

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

@@ -0,0 +1,17 @@
+import type { AppManifest } from '../../../app/index.js';
+import type { ErrorMessage } from '../../../dt/index.js';
+import type { Worker } from '../../../std/index.js';
+import type { AppTesterCtx } from '../../ctx.js';
+export interface Input {
+    appManifest: AppManifest;
+    ucdRefs: AppTesterCtx['ucdRefs'];
+}
+export interface Output {
+    errors: ErrorMessage[];
+}
+export declare class AppManifestChecker implements Worker<Input, Promise<Output>> {
+    private output;
+    constructor();
+    exec({ appManifest, ucdRefs }: Input): Promise<Output>;
+    private makeSureUCsAreConsistent;
+}

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

@@ -0,0 +1,34 @@
+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);
+};
+import { injectable } from 'inversify';
+import { APP_SRC_DIR_NAME } from '../../../convention.js';
+const ERR_MANIFEST_UCDS_MISMATCH = () => `The app manifest must list the use cases the same way as the file system in ${APP_SRC_DIR_NAME}`;
+let AppManifestChecker = class AppManifestChecker {
+    output;
+    constructor() {
+        this.output = { errors: [] };
+    }
+    async exec({ appManifest, ucdRefs }) {
+        this.makeSureUCsAreConsistent(appManifest, ucdRefs);
+        return this.output;
+    }
+    makeSureUCsAreConsistent(appManifest, ucdRefs) {
+        const inManifest = Object.keys(appManifest.ucReg);
+        const inUCDefs = ucdRefs.map((ucdRef) => ucdRef.name);
+        if (inManifest.join() !== inUCDefs.join()) {
+            this.output.errors.push(ERR_MANIFEST_UCDS_MISMATCH());
+        }
+    }
+};
+AppManifestChecker = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [])
+], AppManifestChecker);
+export { AppManifestChecker };

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

@@ -0,0 +1,14 @@
+import type { ErrorMessage } from '../../../dt/index.js';
+import type { Worker } from '../../../std/index.js';
+import type { AppTesterUCDRef } from '../../ctx.js';
+export interface Input {
+    ucdRef: AppTesterUCDRef;
+}
+export interface Output {
+    errors: ErrorMessage[];
+}
+export declare class UCDefChecker implements Worker<Input, Promise<Output>> {
+    private output;
+    constructor();
+    exec({ ucdRef }: Input): Promise<Output>;
+}

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

@@ -0,0 +1,45 @@
+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);
+};
+import { injectable } from 'inversify';
+import { UC_DEF_FILE_NAME_SUFFIX, UC_DEF_SUFFIX } from '../../../convention.js';
+const ERR_UCD_EXPORT_ONLY = (fileName) => `${fileName} must export only the I/OPI types and the UCD. Make sure the client/server classes are not exported`;
+const ERR_UCD_SUFFIX = (fileName) => `${fileName} use case def must end with '${UC_DEF_SUFFIX}'`;
+const ERR_UCD_NAMES = (fileName, name, ucdKey) => `The file name and the const name must be the same as the name, prefixed with '${UC_DEF_SUFFIX}' (Got ${fileName} vs ${name} vs ${ucdKey})`;
+let UCDefChecker = class UCDefChecker {
+    output;
+    constructor() {
+        this.output = { errors: [] };
+    }
+    async exec({ ucdRef }) {
+        const { fileName, source } = ucdRef;
+        const keys = Object.keys(source);
+        if (keys.length !== 1) {
+            this.output.errors.push(ERR_UCD_EXPORT_ONLY(fileName));
+            return this.output;
+        }
+        const [ucdKey] = keys;
+        if (!ucdKey?.endsWith(UC_DEF_SUFFIX)) {
+            this.output.errors.push(ERR_UCD_SUFFIX(fileName));
+            return this.output;
+        }
+        const ucd = source[ucdKey];
+        const { metadata: { name }, } = ucd;
+        if (name !== fileName.replaceAll(UC_DEF_FILE_NAME_SUFFIX, '') ||
+            name !== ucdKey.replaceAll(UC_DEF_SUFFIX, '')) {
+            this.output.errors.push(ERR_UCD_NAMES(fileName, name, ucdKey));
+        }
+        return this.output;
+    }
+};
+UCDefChecker = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [])
+], UCDefChecker);
+export { UCDefChecker };

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

@@ -0,0 +1,27 @@
+import type { FSManager, Logger, Worker } from '../../../std/index.js';
+import { type OutputItem, type UCDefASTParser } from '../../UCDefASTParser.js';
+import type { AppTesterCtx } from '../../ctx.js';
+export interface Input {
+    ctx: AppTesterCtx;
+}
+export interface Output {
+    items: OutputItem[];
+}
+export declare class UCDefSourcesChecker implements Worker<Input, Promise<Output>> {
+    private fsManager;
+    private logger;
+    private ucDefASTParser;
+    private opts;
+    private output;
+    constructor(fsManager: FSManager, logger: Logger, ucDefASTParser: UCDefASTParser);
+    exec({ ctx }: Input): Promise<Output>;
+    private checkConstName;
+    private checkImport;
+    private checkInputType;
+    private checkMainStep;
+    private checkMetadata;
+    private checkOPIType;
+    private checkPolicy;
+    private processFiles;
+    private ucdsAbsolutePaths;
+}

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

@@ -0,0 +1,249 @@
+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 { APP_SRC_DIR_NAME, APP_SRC_UCDS_DIR_NAME, UC_DEF_FILE_NAME_SUFFIX, UC_DEF_SUFFIX, UC_INPUT_FIELD_PATTERN, UC_INPUT_SUFFIX, UC_OPI_SUFFIX, UC_POLICY_SUFFIX_FULL, } from '../../../convention.js';
+import { initOutputItem, } from '../../UCDefASTParser.js';
+import { optsAllSet } from '../../opts.js';
+const ERR_UCD_CONST_NAME = (name) => `The UCD const name '${name}' must follow the convention`;
+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_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}`;
+let UCDefSourcesChecker = class UCDefSourcesChecker {
+    fsManager;
+    logger;
+    ucDefASTParser;
+    opts;
+    output;
+    constructor(fsManager, logger, ucDefASTParser) {
+        this.fsManager = fsManager;
+        this.logger = logger;
+        this.ucDefASTParser = ucDefASTParser;
+        this.output = {
+            items: [],
+        };
+    }
+    async exec({ ctx }) {
+        const { appPath, opts } = ctx;
+        const startTime = new Date().getTime();
+        this.logger.debug('UCDefSourceChecker starting', {
+            appPath,
+            startTime,
+        });
+        this.opts = optsAllSet(opts);
+        const ucdsPaths = this.ucdsAbsolutePaths(ctx);
+        this.logger.debug('UCDefSourceChecker initializing');
+        await this.ucDefASTParser.init(this.opts, ucdsPaths);
+        this.logger.debug('UCDefSourceChecker transpiling');
+        await this.ucDefASTParser.transpile();
+        this.logger.debug('UCDefSourceChecker processing files');
+        this.output.items = await this.processFiles(appPath, ucdsPaths);
+        const duration = new Date().getTime() - startTime;
+        this.logger.debug('UCDefSourceChecker done', {
+            appPath,
+            duration: `${duration} ms`,
+        });
+        return this.output;
+    }
+    checkConstName(name, item) {
+        item.constName = {
+            err: name.endsWith(UC_DEF_SUFFIX) ? null : ERR_UCD_CONST_NAME(name),
+            value: name,
+        };
+    }
+    checkImport(name, item) {
+        const { external, internal } = this.opts.source.imports;
+        const isInternal = name.startsWith(internal.startChar);
+        if (isInternal) {
+            const { maxDepth } = internal;
+            item.internalImports?.push({
+                err: !name.startsWith(maxDepth)
+                    ? null
+                    : ERR_UCD_IMPORTS_INTERNAL_MAX_DEPTH(maxDepth),
+                value: name,
+            });
+            return;
+        }
+        const { aliasPrefix, allowed } = external;
+        item.externalImports?.push({
+            err: name.startsWith(aliasPrefix) || allowed.includes(name)
+                ? null
+                : ERR_UCD_IMPORTS_EXTERNAL_ALLOWED(aliasPrefix, allowed, name),
+            value: name,
+        });
+    }
+    checkInputType(name, fields, item) {
+        item.ioI = {
+            err: null,
+            value: name,
+        };
+        item.ioIFields = fields;
+        for (const f of item.ioIFields) {
+            const parts = f.value.split(':');
+            if (parts.length !== 2) {
+                continue;
+            }
+            const [_name, type] = parts;
+            f.err =
+                type?.trim().match(new RegExp(UC_INPUT_FIELD_PATTERN)) !== null
+                    ? null
+                    : ERR_UCD_INPUT_FIELD_PATTERN();
+        }
+    }
+    checkMainStep(lifecycle, step, item) {
+        switch (lifecycle) {
+            case 'client':
+                if (!item.lifecycleClientSteps) {
+                    item.lifecycleClientSteps = [];
+                }
+                item.lifecycleClientSteps.push({ err: null, value: step });
+                break;
+            case 'server':
+                if (!item.lifecycleServerSteps) {
+                    item.lifecycleServerSteps = [];
+                }
+                item.lifecycleServerSteps.push({ err: null, value: step });
+                break;
+            default:
+                ((_) => { })(lifecycle);
+        }
+    }
+    checkMetadata(metadata, item) {
+        item.metadataAction = {
+            err: null,
+            value: metadata.action,
+        };
+        item.metadataBeta = {
+            err: null,
+            value: metadata.beta?.toString() ?? '',
+        };
+        item.metadataIcon = {
+            err: null,
+            value: metadata.icon,
+        };
+        item.metadataName = {
+            err: null,
+            value: metadata.name,
+        };
+        item.metadataNew = {
+            err: null,
+            value: metadata.new?.toString() ?? '',
+        };
+        item.metadataSensitive = {
+            err: null,
+            value: metadata.sensitive?.toString() ?? '',
+        };
+    }
+    checkOPIType(name, fields, idx, item) {
+        const key = `ioOPI${idx}`;
+        item[key] = {
+            err: null,
+            value: name,
+        };
+        const fieldsKey = `${key}Fields`;
+        item[fieldsKey] = fields;
+        for (const f of item[fieldsKey]) {
+            f.err = null;
+        }
+    }
+    checkPolicy(lifecycle, name, item) {
+        switch (lifecycle) {
+            case 'client':
+                item.lifecycleClientPolicy = {
+                    err: null,
+                    value: name.replaceAll(UC_POLICY_SUFFIX_FULL, ''),
+                };
+                break;
+            case 'server':
+                item.lifecycleServerPolicy = {
+                    err: null,
+                    value: name.replaceAll(UC_POLICY_SUFFIX_FULL, ''),
+                };
+                break;
+            default:
+                ((_) => { })(lifecycle);
+        }
+    }
+    async processFiles(appPath, paths) {
+        const res = await Promise.all(paths.map(async (path) => {
+            const item = initOutputItem();
+            this.logger.trace('UCDefSourceChecker processing file', {
+                path,
+            });
+            await this.ucDefASTParser.processFile(path, (name) => this.checkImport(name, item), (name) => this.checkConstName(name, item), (name, fields) => this.checkInputType(name, fields, item), (name, fields, idx) => this.checkOPIType(name, fields, idx, item), (lifecycle, step) => this.checkMainStep(lifecycle, step, item), (lifecycle, name) => this.checkPolicy(lifecycle, name, item), (value) => this.checkMetadata(value, item));
+            const relativePath = path.replaceAll(appPath, '');
+            item.filePath = {
+                err: relativePath.endsWith(UC_DEF_FILE_NAME_SUFFIX)
+                    ? null
+                    : ERR_UCD_FILE_SUFFIX(relativePath),
+                value: relativePath,
+            };
+            if (item.ioI) {
+                item.ioI.err =
+                    item.ioI.value ===
+                        `${item.metadataName?.value}${UC_INPUT_SUFFIX}`
+                        ? null
+                        : ERR_UCD_INPUT_TYPE_NAME(item.metadataName?.value ?? '-');
+            }
+            if (item.ioOPI0) {
+                item.ioOPI0.err =
+                    item.ioOPI0.value ===
+                        `${item.metadataName?.value}${UC_OPI_SUFFIX}0`
+                        ? null
+                        : ERR_UCD_OPI_TYPE_NAME(item.metadataName?.value ?? '-', 0);
+            }
+            if (item.ioOPI1) {
+                item.ioOPI1.err =
+                    item.ioOPI1.value ===
+                        `${item.metadataName?.value}${UC_OPI_SUFFIX}1`
+                        ? null
+                        : ERR_UCD_OPI_TYPE_NAME(item.metadataName?.value ?? '-', 1);
+            }
+            return item;
+        }));
+        const errors = [];
+        for (const analysis of res) {
+            for (const [_k, analysisVal] of Object.entries(analysis)) {
+                if (!analysisVal) {
+                    continue;
+                }
+                const asArr = Array.isArray(analysisVal)
+                    ? analysisVal
+                    : [analysisVal];
+                for (const val of asArr) {
+                    const { err } = val;
+                    if (err) {
+                        errors.push(err);
+                    }
+                }
+            }
+        }
+        if (errors.length > 0) {
+            throw new Error(errors[0]);
+        }
+        return res;
+    }
+    ucdsAbsolutePaths(ctx) {
+        return ctx.ucdRefs.map(({ fileName }) => this.fsManager.path(ctx.appPath, APP_SRC_DIR_NAME, APP_SRC_UCDS_DIR_NAME, fileName));
+    }
+};
+UCDefSourcesChecker = __decorate([
+    injectable(),
+    __param(0, inject('FSManager')),
+    __param(1, inject('Logger')),
+    __param(2, inject('UCDefASTParser')),
+    __metadata("design:paramtypes", [Object, Object, Object])
+], UCDefSourcesChecker);
+export { UCDefSourcesChecker };

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

@@ -0,0 +1,39 @@
+import type { AppManifest } from '../app/index.js';
+import { type DataType, Validation } from '../dt/index.js';
+import { UCInputField } from './UCInputField.js';
+import type { UCAuth } from './auth.js';
+import type { UCDef, UCFieldKey } from './def.js';
+import type { UCInput } from './input.js';
+import type { UCOPIBase } from './opi.js';
+import type { rVal0, rValArr, reqVal0 } from './utils/rVal.js';
+export type ArgsTuple<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> = ConstructorParameters<typeof UC<I, OPI0, OPI1>>;
+export type ArgsRecord<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> = {
+    appManifest: ArgsTuple<I, OPI0, OPI1>[0];
+    def: ArgsTuple<I, OPI0, OPI1>[1];
+    auth: ArgsTuple<I, OPI0, OPI1>[2];
+};
+export declare class UC<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> {
+    appManifest: AppManifest;
+    def: UCDef<I, OPI0, OPI1>;
+    auth: UCAuth | null;
+    inputFields: UCInputField<any>[];
+    constructor(appManifest: AppManifest, def: UCDef<I, OPI0, OPI1>, auth: UCAuth | null);
+    clear(): void;
+    clearSensitiveInputFields(): void;
+    fill(input: Partial<I>): this;
+    hasInputField(key: UCFieldKey): boolean;
+    hasMediaInInput(): boolean;
+    hasOutputParts(): boolean;
+    inputField<T extends DataType>(key: keyof NonNullable<I>): UCInputField<T>;
+    inputFieldsForForm(): UCInputField<any>[];
+    inputFieldsOrdered(): UCInputField<any>[];
+    inputFieldsInsensitive(): UCInputField<any>[];
+    inputFieldsSensitive(): UCInputField<any>[];
+    needsInputFilling(): boolean;
+    needsOutputDisplay(): boolean;
+    operatesOnAggregate(): boolean;
+    rVal0<T extends DataType>(key: keyof I): ReturnType<typeof rVal0<T>>;
+    reqVal0<T extends DataType>(key: keyof I): ReturnType<typeof reqVal0<T>>;
+    rValArr<T extends DataType>(key: keyof I): ReturnType<typeof rValArr<T>>;
+    validate(): [UCInputField<any> | null, Validation] | null;
+}