libmodulor 0.1.0 → 0.2.0

package/dist/esm/testing/UCDataStoreTester.js

@@ -0,0 +1,192 @@
+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 UCDataStoreTester_1;
+import { inject, injectable } from 'inversify';
+import { APP_NAME_PLACEHOLDER } from '../convention.js';
+import { TAmount, TCompanyName, } from '../dt/index.js';
+import { UCExecMode, } from '../uc/index.js';
+const ERR_SHOULD_NOT_EXIST_AFTER_DESTROY = 'It should not exist after destroy';
+const ERR_SHOULD_EXIST_AFTER_INSTALL = 'It should exist after install';
+const ERR_SHOULD_RETURN_X_RECORDS = (n) => `It should return ${n} record(s)`;
+let UCDataStoreTester = class UCDataStoreTester {
+    static { UCDataStoreTester_1 = this; }
+    clockManager;
+    cryptoManager;
+    static PROJECTION_NAME_1 = 'companies';
+    ucDataStore;
+    skipProjectionTesting = false;
+    entries;
+    exists;
+    filtersTestData;
+    readRes;
+    constructor(clockManager, cryptoManager) {
+        this.clockManager = clockManager;
+        this.cryptoManager = cryptoManager;
+        this.entries = this.buildEntries();
+        this.exists = false;
+        this.filtersTestData = this.buildFiltersTestData();
+    }
+    async exec({ ucDataStore }) {
+        this.ucDataStore = ucDataStore;
+        await ucDataStore.destroy();
+        this.exists = await ucDataStore.exists();
+        if (this.exists) {
+            throw new Error(ERR_SHOULD_NOT_EXIST_AFTER_DESTROY);
+        }
+        await ucDataStore.install();
+        this.exists = await ucDataStore.exists();
+        if (!this.exists) {
+            throw new Error(ERR_SHOULD_EXIST_AFTER_INSTALL);
+        }
+        this.readRes = await ucDataStore.read();
+        this.expectXRecords(0);
+        await this.insertEntries();
+        this.readRes = await ucDataStore.read();
+        this.expectXRecords(4);
+        for await (const [filters, expectedRecords] of this.filtersTestData) {
+            this.readRes = await ucDataStore.read({ filters });
+            this.expectXRecords(expectedRecords);
+        }
+        await ucDataStore.clear();
+        this.readRes = await ucDataStore.read();
+        this.expectXRecords(0);
+        await this.ucDataStore.write({
+            aggregateId: this.cryptoManager.randomUUID(),
+            appName: APP_NAME_PLACEHOLDER,
+            createdAt: new Date(),
+            data: null,
+            executionMode: UCExecMode.USER,
+            id: this.cryptoManager.randomUUID(),
+            input: this.buildUCInput(),
+            name: 'CreateX',
+            organizationId: null,
+            userId: this.cryptoManager.randomUUID(),
+        });
+        if (this.skipProjectionTesting) {
+            return;
+        }
+        const supportsTsvector = this.ucDataStore
+            .supportedSpecificBindings()
+            .includes('to_tsvector(?)');
+        const tags = ['advertising', 'cloud', "don't be evil"];
+        await this.ucDataStore.writeProjection(UCDataStoreTester_1.PROJECTION_NAME_1, {
+            id: this.cryptoManager.randomUUID(),
+            name: new TCompanyName().example(),
+            tags: supportsTsvector ? tags : JSON.stringify(tags),
+            turnover: new TAmount('EUR').example(),
+        }, { specificBindings: { tags: 'to_tsvector(?)' } });
+        await this.ucDataStore.readProjection(UCDataStoreTester_1.PROJECTION_NAME_1);
+    }
+    setSkipProjectionTesting(skipProjectionTesting) {
+        this.skipProjectionTesting = skipProjectionTesting;
+    }
+    buildEntries() {
+        return [
+            [
+                this.cryptoManager.randomUUID(),
+                APP_NAME_PLACEHOLDER,
+                ['CreateX', 'DeleteX'],
+                this.cryptoManager.randomUUID(),
+                this.cryptoManager.randomUUID(),
+            ],
+            [
+                this.cryptoManager.randomUUID(),
+                APP_NAME_PLACEHOLDER,
+                ['CreateX'],
+                null,
+                null,
+            ],
+            [
+                this.cryptoManager.randomUUID(),
+                APP_NAME_PLACEHOLDER,
+                ['CreateX'],
+                null,
+                null,
+            ],
+        ];
+    }
+    buildFiltersTestData() {
+        const entry = this.entries[0];
+        const [aggregateId, appName, ucNames, organizationId, userId] = entry;
+        const name = ucNames[0];
+        return [
+            [{ aggregateId }, 2],
+            [{ aggregateId: [aggregateId] }, 2],
+            [{ appName }, 4],
+            [{ appName: [appName] }, 4],
+            [{ name }, 3],
+            [{ name: [name] }, 3],
+            [{ organizationId: this.cryptoManager.randomUUID() }, 0],
+            [{ organizationId }, 2],
+            [{ organizationId: [organizationId] }, 2],
+            [{ userId: this.cryptoManager.randomUUID() }, 0],
+            [{ userId }, 2],
+            [{ userId: [userId] }, 2],
+            [
+                {
+                    idWithinInput: {
+                        externalId: this.cryptoManager.randomUUID(),
+                    },
+                },
+                0,
+            ],
+        ];
+    }
+    buildUCInput() {
+        return {
+            array: [12, 34],
+            boolean: true,
+            externalId: this.cryptoManager.randomUUID(),
+            float: 12.34,
+            int: 12,
+            object: {
+                boolean: true,
+                float: 12.34,
+                int: 12,
+                string: 'string',
+            },
+            string: 'string',
+        };
+    }
+    expectXRecords(n) {
+        if (this.readRes?.records.length !== n) {
+            throw new Error(ERR_SHOULD_RETURN_X_RECORDS(n));
+        }
+    }
+    async insertEntries() {
+        for await (const [i, [aggregateId, appName, ucNames, organizationId, userId],] of this.entries.entries()) {
+            for await (const [j, ucName] of ucNames.entries()) {
+                const createdAt = this.clockManager.time() + (i + 1) * (j + 1);
+                await this.ucDataStore.write({
+                    aggregateId,
+                    appName,
+                    createdAt: new Date(createdAt),
+                    data: null,
+                    executionMode: UCExecMode.USER,
+                    id: this.cryptoManager.randomUUID(),
+                    input: this.buildUCInput(),
+                    name: ucName,
+                    organizationId,
+                    userId,
+                });
+            }
+        }
+    }
+};
+UCDataStoreTester = UCDataStoreTester_1 = __decorate([
+    injectable(),
+    __param(0, inject('ClockManager')),
+    __param(1, inject('CryptoManager')),
+    __metadata("design:paramtypes", [Object, Object])
+], UCDataStoreTester);
+export { UCDataStoreTester };

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

@@ -0,0 +1,43 @@
+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> {
+    err: ErrorMessage | null;
+    value: T;
+}
+export interface OutputItem {
+    constName: OutputItemField | null;
+    externalImports: OutputItemField[] | null;
+    filePath: OutputItemField | null;
+    internalImports: OutputItemField[] | null;
+    ioI: OutputItemField | null;
+    ioIFields: OutputItemField[] | null;
+    ioOPI0: OutputItemField | null;
+    ioOPI0Fields: OutputItemField[] | null;
+    ioOPI1: OutputItemField | null;
+    ioOPI1Fields: OutputItemField[] | null;
+    lifecycleClientPolicy: OutputItemField | null;
+    lifecycleClientSteps: OutputItemField[] | null;
+    lifecycleServerPolicy: OutputItemField | null;
+    lifecycleServerSteps: OutputItemField[] | null;
+    metadataAction: OutputItemField | null;
+    metadataBeta: OutputItemField | null;
+    metadataIcon: OutputItemField | null;
+    metadataName: OutputItemField | null;
+    metadataNew: OutputItemField | null;
+    metadataSensitive: OutputItemField | null;
+}
+export declare const OUTPUT_ITEM_FIELDS: (keyof OutputItem)[];
+export type OnImport = (name: string) => void;
+export type OnInputType = (name: string, fields: OutputItemField[]) => 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 OnPolicy = (lifecycle: UCDefLifecycle, name: string) => void;
+export type OnVariable = (name: string) => void;
+export interface UCDefASTParser {
+    init(opts: AppTesterOptsAllSet, ucdsPaths: FilePath[]): Promise<void>;
+    processFile(path: FilePath, onImport: OnImport, onVariable: OnVariable, onInputType: OnInputType, onOPIType: OnOPIType, onMainStep: OnMainStep, onPolicy: OnPolicy, onMetadata: OnMetadata): Promise<void>;
+    transpile(): Promise<void>;
+}
+export declare function initOutputItem(): OutputItem;

package/dist/esm/testing/UCDefASTParser.js

@@ -0,0 +1,44 @@
+export const OUTPUT_ITEM_FIELDS = [
+    'filePath',
+    'constName',
+    'metadataName',
+    'metadataAction',
+    'metadataBeta',
+    'metadataIcon',
+    'metadataNew',
+    'metadataSensitive',
+    'externalImports',
+    'internalImports',
+    'ioI',
+    'ioIFields',
+    'ioOPI0',
+    'ioOPI0Fields',
+    'ioOPI1',
+    'ioOPI1Fields',
+    'lifecycleClientPolicy',
+    'lifecycleServerPolicy',
+];
+export function initOutputItem() {
+    return {
+        constName: null,
+        externalImports: [],
+        filePath: null,
+        internalImports: [],
+        ioI: null,
+        ioIFields: [],
+        ioOPI0: null,
+        ioOPI0Fields: [],
+        ioOPI1: null,
+        ioOPI1Fields: [],
+        lifecycleClientPolicy: null,
+        lifecycleClientSteps: [],
+        lifecycleServerPolicy: null,
+        lifecycleServerSteps: [],
+        metadataAction: null,
+        metadataIcon: null,
+        metadataBeta: null,
+        metadataName: null,
+        metadataNew: null,
+        metadataSensitive: null,
+    };
+}

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

@@ -0,0 +1,18 @@
+import type { Container } from 'inversify';
+import type { AppI18n, AppManifest } from '../app/index.js';
+import type { FileName, FilePath } from '../dt/index.js';
+import type { UCDefSource, UCName } from '../uc/index.js';
+import type { AppTesterOpts } from './opts.js';
+export interface AppTesterUCDRef {
+    fileName: FileName;
+    name: UCName;
+    source: UCDefSource;
+}
+export interface AppTesterCtx {
+    appI18n: AppI18n;
+    appManifest: AppManifest;
+    appPath: FilePath;
+    container: Container;
+    opts: AppTesterOpts | undefined;
+    ucdRefs: AppTesterUCDRef[];
+}

package/dist/esm/testing/ctx.js

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

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

@@ -0,0 +1,13 @@
+import type { UCDef, UCInput } from '../uc/index.js';
+import type { AppTesterCtx } from './ctx.js';
+import type { UCExecutorExecOutput, Input as UCExecutorInput } from './workers/UCExecutor.js';
+export type AppTesterFlowExecOutput = UCExecutorExecOutput<any, any, any>[];
+export type AppTesterFlowInputOverride<I extends UCInput> = (output: AppTesterFlowExecOutput) => I;
+export type AppTesterFlow = Partial<Pick<UCExecutorInput, 'auth' | 'authName'>> & {
+    name: string;
+    setup?: (ctx: AppTesterCtx) => Promise<void>;
+    steps: [
+        UCDef<any, any, any>,
+        AppTesterFlowInputOverride<any> | null
+    ][];
+};

package/dist/esm/testing/flow.js

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

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

@@ -0,0 +1,7 @@
+import type { FSManager } from '../../std/index.js';
+import type { AppDocsEmitter, Input, Output } from '../workers/AppDocsEmitter.js';
+export declare class SimpleAppDocsEmitter implements AppDocsEmitter {
+    private fsManager;
+    constructor(fsManager: FSManager);
+    exec({ appPath, ucDefSourcesCheckerOutput, }: Input): Promise<Output>;
+}

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

@@ -0,0 +1,161 @@
+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_DOCS_FILE_NAME, UC_INPUT_FIELD_PATTERN, UC_MAIN_STEP_PREFIX_REGULAR, } from '../../convention.js';
+import { OUTPUT_ITEM_FIELDS, } from '../UCDefASTParser.js';
+let SimpleAppDocsEmitter = class SimpleAppDocsEmitter {
+    fsManager;
+    constructor(fsManager) {
+        this.fsManager = fsManager;
+    }
+    async exec({ appPath, ucDefSourcesCheckerOutput, }) {
+        const outPath = this.fsManager.path(appPath, APP_DOCS_FILE_NAME);
+        const tpl = template(OUTPUT_ITEM_FIELDS, ucDefSourcesCheckerOutput.items);
+        await this.fsManager.touch(outPath, tpl);
+        return {
+            outPath,
+        };
+    }
+};
+SimpleAppDocsEmitter = __decorate([
+    injectable(),
+    __param(0, inject('FSManager')),
+    __metadata("design:paramtypes", [Object])
+], SimpleAppDocsEmitter);
+export { SimpleAppDocsEmitter };
+const template = (cols, items) => `<!---
+    All this code has been auto generated.
+    DO NOT EDIT.
+    Or be prepared to see all your changes erased at the next generation.
+-->
+
+# App
+
+## Use Cases
+
+${items
+    .map((item) => `### ${item.metadataName?.value}
+
+${diagram(item)}`)
+    .join('\n\n')}
+
+## Technical Summary
+
+|#|${cols.map((c) => c).join('|')}|
+|---|${cols.map((_c) => '---').join('|')}|
+${items.map((item, idx) => ['', idx + 1, ...cols.map((c) => fmtTechSummaryField(item[c])), ''].join('|')).join('\n')}
+`;
+const CHECK_POLICY = '🔐 Check policy';
+const CHECK_POLICY_COND = 'when any validation fails';
+const CHECK_POLICY_COND_ACTION = 'show failure';
+const CLIENT_CONFIRM_N_COND = 'when does not confirm';
+const CLIENT_CONFIRM_N_COND_ACTION = 'stop everything';
+const CLIENT_CONFIRM_Q = '❓ Sure';
+const CLIENT_CONFIRM_Y = 'Yes';
+const FILL = '✏️ Fill';
+const LB = '<br/>';
+const OK = '👍 OK';
+const SEND = '📤 Send';
+const SUBMIT = '↩️ Submit';
+const TRIGGER = '⤴️ Trigger';
+function diagram(item) {
+    const client = 'Client';
+    const server = 'Server';
+    const user = 'User';
+    const lines = [`actor ${user}`];
+    const { ioIFields, ioOPI0Fields, ioOPI1Fields, lifecycleClientPolicy, lifecycleClientSteps, lifecycleServerPolicy, lifecycleServerSteps, metadataSensitive, } = item;
+    let req = TRIGGER;
+    if (ioIFields && ioIFields.length > 0) {
+        req = `${FILL}${LB}${diagramUCFields(item.ioIFields)}`;
+    }
+    lines.push(`${user}->>+${client}: ${req}`);
+    lines.push(`${user}->>${client}: ${SUBMIT}`);
+    if (metadataSensitive?.value) {
+        lines.push(...diagramUCClientConfirm(client, user));
+    }
+    if (lifecycleClientPolicy) {
+        lines.push(...diagramUCPolicy(client, user, lifecycleClientPolicy));
+    }
+    if (lifecycleClientSteps) {
+        lines.push(...diagramUCMainSteps(client, lifecycleClientSteps));
+    }
+    const hasServer = item.lifecycleServerPolicy?.value;
+    if (hasServer) {
+        req = SEND;
+        if (ioIFields && ioIFields.length > 0) {
+            req = `${req}${LB}${diagramUCFields(item.ioIFields)}`;
+        }
+        lines.push(`${client}->>+${server}: ${req}`);
+        if (lifecycleServerPolicy) {
+            lines.push(...diagramUCPolicy(server, user, lifecycleServerPolicy));
+        }
+        if (lifecycleServerSteps) {
+            lines.push(...diagramUCMainSteps(server, lifecycleServerSteps));
+        }
+        let res = '';
+        if (ioOPI0Fields && ioOPI0Fields.length > 0) {
+            res += `${res}${LB}${diagramUCFields(item.ioOPI0Fields)}`;
+        }
+        if (ioOPI1Fields && ioOPI1Fields?.length > 0) {
+            res += `${res}${LB}${diagramUCFields(item.ioOPI1Fields)}`;
+        }
+        lines.push(`${server}-->>-${client}: ${OK}${res}`);
+    }
+    lines.push(`${client}-->>-${user}: ${OK}`);
+    return `\`\`\`mermaid
+sequenceDiagram
+    ${lines.join('\n    ')}
+\`\`\``;
+}
+function diagramUCClientConfirm(participant, caller) {
+    return [
+        `${participant}->>${caller}: ${CLIENT_CONFIRM_Q}`,
+        `${caller}->>${participant}: ${CLIENT_CONFIRM_Y}`,
+        `break ${CLIENT_CONFIRM_N_COND}`,
+        `    ${participant}-->${caller}: ${CLIENT_CONFIRM_N_COND_ACTION}`,
+        'end',
+    ];
+}
+function diagramUCFields(fields) {
+    return (fields
+        ?.map((f) => f.value.replace(new RegExp(UC_INPUT_FIELD_PATTERN.slice(1)), '$1'))
+        .join(LB) || '');
+}
+function diagramUCMainSteps(participant, field) {
+    return field.map((f) => `${participant}->>${participant}: ${f.value.replace(UC_MAIN_STEP_PREFIX_REGULAR, '').trim()}`);
+}
+function diagramUCPolicy(participant, caller, lifecyclePolicyField) {
+    return [
+        `${participant}->>${participant}: ${CHECK_POLICY} "${lifecyclePolicyField.value}"`,
+        `break ${CHECK_POLICY_COND}`,
+        `    ${participant}-->${caller}: ${CHECK_POLICY_COND_ACTION}`,
+        'end',
+    ];
+}
+function fmtTechSummaryField(field) {
+    if (!field) {
+        return '';
+    }
+    const values = Array.isArray(field) ? field : [field];
+    return values.map(fmtTechSummaryFieldVal).join('<br>');
+}
+function fmtTechSummaryFieldVal(field) {
+    const { err, value } = field;
+    let res = value;
+    if (err) {
+        res += `❌ ${err}`;
+    }
+    res = res.replace(/[\u00A0-\u9999<>\&]/g, (i) => `&#${i.charCodeAt(0)};`);
+    res = res.replaceAll('|', '\\|');
+    return res;
+}

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

@@ -0,0 +1,14 @@
+import type { AppTesterConfigurator, AppTesterConfiguratorAuthSettersConfig, AppTesterConfiguratorInputFillers, AppTesterConfiguratorSideEffects, AppTesterConfiguratorSpecificAssertions } from '../AppTesterConfigurator.js';
+import type { AppTesterCtx } from '../ctx.js';
+import type { AppTesterFlow } from '../flow.js';
+export declare class SimpleAppTesterConfigurator implements AppTesterConfigurator {
+    authSettersConfig(): Promise<AppTesterConfiguratorAuthSettersConfig | undefined>;
+    bindImplementations(ctx: AppTesterCtx): Promise<void>;
+    clearExecution(ctx: AppTesterCtx): Promise<void>;
+    flows(): Promise<AppTesterFlow[]>;
+    inputFillers(): Promise<AppTesterConfiguratorInputFillers | undefined>;
+    opts(): Promise<AppTesterCtx['opts']>;
+    seed(_ctx: AppTesterCtx): Promise<void>;
+    sideEffects(_ctx: AppTesterCtx): Promise<AppTesterConfiguratorSideEffects | undefined>;
+    specificAssertions(): Promise<AppTesterConfiguratorSpecificAssertions | undefined>;
+}

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

@@ -0,0 +1,34 @@
+import { PRODUCT_NAME_PLACEHOLDER } from '../../convention.js';
+export class SimpleAppTesterConfigurator {
+    async authSettersConfig() {
+        return undefined;
+    }
+    async bindImplementations(ctx) {
+        const { container } = ctx;
+        container.bind('ProductManifest').toConstantValue({
+            appReg: [{ name: ctx.appManifest.name }],
+            name: PRODUCT_NAME_PLACEHOLDER,
+        });
+    }
+    async clearExecution(ctx) {
+        const { container } = ctx;
+        await container.get('UCDataStore').clear();
+    }
+    async flows() {
+        return [];
+    }
+    async inputFillers() {
+        return undefined;
+    }
+    async opts() {
+        return undefined;
+    }
+    async seed(_ctx) {
+    }
+    async sideEffects(_ctx) {
+        return undefined;
+    }
+    async specificAssertions() {
+        return undefined;
+    }
+}

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

@@ -0,0 +1,10 @@
+import type { FilePath } from '../../dt/index.js';
+import type { FSManager } from '../../std/index.js';
+import type { AppTestReportEmitter, Input, Output } from '../workers/AppTestReportEmitter.js';
+export declare class SimpleHTMLAppTestReportEmitter implements AppTestReportEmitter {
+    private fsManager;
+    constructor(fsManager: FSManager);
+    exec({ appPath, testResults, testSummary, }: Input): Promise<Output>;
+    entrypointPath(appPath: FilePath): Promise<FilePath>;
+    private reportPath;
+}