libmodulor 0.18.1 → 0.20.0

package/dist/esm/testing/AppTester.js

@@ -29,6 +29,7 @@ import { AppManifestChecker } from './workers/checkers/AppManifestChecker.js';
 import { UCDefChecker } from './workers/checkers/UCDefChecker.js';
 import { UCDefSourcesChecker, } from './workers/checkers/UCDefSourcesChecker.js';
 import { UCExecutor, } from './workers/UCExecutor.js';
+const ERR_UCD_NOT_FOUND = (ucName) => `Could not find a ucd for ${ucName}`;
 let AppTester = class AppTester {
     appDocsEmitter;
     appFolderChecker;
@@ -50,6 +51,8 @@ let AppTester = class AppTester {
      */
     safeSrcImporter;
     // biome-ignore lint/suspicious/noExplicitAny: can be anything
+    ucds;
+    // biome-ignore lint/suspicious/noExplicitAny: can be anything
     testResults;
     testSummary;
     ucDefSourcesCheckerOutput;
@@ -66,6 +69,7 @@ let AppTester = class AppTester {
         this.ucDefChecker = ucDefChecker;
         this.ucDefSourcesChecker = ucDefSourcesChecker;
         this.ucExecutor = ucExecutor;
+        this.ucds = new Map();
         this.testResults = [];
         this.testSummary = {
             counts: {
@@ -115,13 +119,13 @@ let AppTester = class AppTester {
         });
     }
     async checkUC(ucdRef) {
-        const { errors } = await this.ucDefChecker.exec({ ucdRef });
+        const { errors, ucd } = await this.ucDefChecker.exec({ ucdRef });
         if (errors.length > 0) {
             throw new Error(errors[0]);
         }
-        const { source } = ucdRef;
-        const ucd = source[`${Object.keys(source)[0]}`];
-        return ucd;
+        if (ucd) {
+            this.ucds.set(ucdRef.name, ucd);
+        }
     }
     async execFlow(flow) {
         const output = [];
@@ -226,6 +230,13 @@ let AppTester = class AppTester {
     getCtx() {
         return this.ctx;
     }
+    getUCD(ucName) {
+        const ucd = this.ucds.get(ucName);
+        if (!ucd) {
+            throw new Error(ERR_UCD_NOT_FOUND(ucName));
+        }
+        return ucd;
+    }
     async init({ appPath, configurator, serverClientSettings, srcImporter, }) {
         this.configurator = configurator;
         this.safeSrcImporter = (path) => Promise.race([
@@ -243,6 +254,8 @@ let AppTester = class AppTester {
         await this.configurator.seed(this.ctx);
         await this.bindI18n();
         await this.bindServerClientSettings(serverClientSettings);
+    }
+    async initForUCExec() {
         await this.initI18n();
         await this.initServer();
     }

package/dist/esm/testing/UCDataStoreTester.js

@@ -16,7 +16,7 @@ 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_EXIST_AFTER_INIT = 'It should exist after init';
 const ERR_SHOULD_RETURN_X_RECORDS = (n) => `It should return ${n} record(s)`;
 /**
  * Test that a {@link UCDataStore} conforms to the spec
@@ -52,10 +52,10 @@ let UCDataStoreTester = class UCDataStoreTester {
         if (this.exists) {
             throw new Error(ERR_SHOULD_NOT_EXIST_AFTER_DESTROY);
         }
-        await ucDataStore.install();
+        await ucDataStore.init();
         this.exists = await ucDataStore.exists();
         if (!this.exists) {
-            throw new Error(ERR_SHOULD_EXIST_AFTER_INSTALL);
+            throw new Error(ERR_SHOULD_EXIST_AFTER_INIT);
         }
         this.readRes = await ucDataStore.read();
         this.expectXRecords(0);

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

@@ -52,14 +52,14 @@ const template = (serverPortRangeStart, idx, monkeyTestingTimeoutInMs) => `/*
 import { join } from 'node:path';
 
 import {
-    assert,
     type Arbitrary,
     type AsyncCommand,
-    type ModelRunSetup,
     anything,
+    assert,
     asyncModelRun,
     asyncProperty,
     commands,
+    type ModelRunSetup,
     record,
 } from 'fast-check';
 import {
@@ -70,7 +70,7 @@ import {
     type UCInput,
 } from 'libmodulor';
 import { newNodeAppTester } from 'libmodulor/node-test';
-import { afterAll, afterEach, describe, expect, test } from 'vitest';
+import { afterAll, afterEach, beforeAll, describe, expect, test } from 'vitest';
 
 import { Configurator } from './Configurator.js';
 
@@ -84,116 +84,92 @@ const runner = await newNodeAppTester(${serverPortRangeStart}, ${idx}, {
 const ctx = runner.getCtx();
 const logger = ctx.container.get<Logger>('Logger');
 
+const flows = await configurator.flows();
+
 afterAll(async () => {
     await runner.finalize();
 });
 
-test('Sources should be valid', async () => {
-    await runner.checkUCDSources();
-});
-
-test('Folder should be valid', async () => {
-    await runner.checkAppFolder();
-});
-
-test('${APP_MANIFEST_NAME} should be valid', async () => {
-    await runner.checkAppManifest();
-});
+describe('Check', () => {
+    test('Sources should be valid', async () => {
+        await runner.checkUCDSources();
+    });
 
-test('${APP_I18N_NAME} should be valid', async () => {
-    await runner.checkAppI18n();
-});
+    test('Folder should be valid', async () => {
+        await runner.checkAppFolder();
+    });
 
-test('${APP_INDEX_NAME} should be valid', async () => {
-    await runner.checkAppIndex();
-});
+    test('${APP_MANIFEST_NAME} should be valid', async () => {
+        await runner.checkAppManifest();
+    });
 
-const flows = await configurator.flows();
-describe.runIf(flows.length > 0)('Flows', async () => {
-    afterEach(async () => {
-        await configurator.clearExecution(ctx);
+    test('${APP_I18N_NAME} should be valid', async () => {
+        await runner.checkAppI18n();
     });
 
-    test.each(flows)('should execute flow $name', async (flow) => {
-        const output = await runner.execFlow(flow);
+    test('${APP_INDEX_NAME} should be valid', async () => {
+        await runner.checkAppIndex();
+    });
 
-        for (const out of output) {
-            if (out.err !== null) {
-                if (!(out.err instanceof CustomError)) {
-                    logger.error(out.err);
-                }
-                expect(out.err).toBeInstanceOf(CustomError);
-            }
-        }
+    describe.runIf(ctx.ucdRefs.length > 0)('Use Cases', () => {
+        describe.each(ctx.ucdRefs)('$name', async (ucdRef) => {
+            test('should be valid', async () => {
+                await runner.checkUC(ucdRef);
+            });
+        });
     });
 });
 
-const { ucdRefs } = ctx;
-describe.runIf(ucdRefs.length > 0)('Use Cases', () => {
-    describe.each(ucdRefs)('$name', async (ucdRef) => {
+describe('Run', async () => {
+    beforeAll(async () => {
+        await runner.initForUCExec();
+    });
+
+    describe.runIf(flows.length > 0)('Flows', async () => {
         afterEach(async () => {
             await configurator.clearExecution(ctx);
         });
 
-        // biome-ignore lint/suspicious/noExplicitAny: can be anything
-        let ucd: UCDef<any, any, any>;
-
-        test('should be valid', async () => {
-            ucd = await runner.checkUC(ucdRef);
-        });
-
-        const data = await runner.ucTestData(ucdRef);
-
-        test.each(data)(
-            'should execute with auth $authName and input $inputFillerName',
-            async ({ auth, authName, inputFiller, inputFillerName }) => {
-                const { out, sideEffects } = await runner.execUC({
-                    auth,
-                    authName: authName as UCAuthSetterName,
-                    inputFiller,
-                    inputFillerName,
-                    ucd,
-                });
+        test.each(flows)('should execute flow $name', async (flow) => {
+            const output = await runner.execFlow(flow);
 
+            for (const out of output) {
                 if (out.err !== null) {
                     if (!(out.err instanceof CustomError)) {
                         logger.error(out.err);
                     }
                     expect(out.err).toBeInstanceOf(CustomError);
                 }
+            }
+        });
+    });
 
-                const { hash } = out;
-                const assertion = hash
-                    ? (await configurator.specificAssertions())?.get(hash)
-                    : undefined;
-                if (assertion) {
-                    expect(out).toSatisfy(assertion);
-                } else {
-                    expect({ out, sideEffects }).toMatchSnapshot(
-                        \`hash = \${hash\}\`,
-                    );
-                }
-            },
-        );
-
-        test('should execute with monkey testing', async () => {
-            // Given
-            // biome-ignore lint/complexity/noBannedTypes: nothing for now
-            type Model = {};
-            // biome-ignore lint/complexity/noBannedTypes: nothing for now
-            type RealSystem = {};
-
-            class MyCommand<I extends UCInput | undefined = undefined>
-                implements AsyncCommand<Model, RealSystem>
-            {
-                constructor(private input: I) {}
-
-                public check(_m: Readonly<Model>): boolean {
-                    return true;
-                }
+    describe.runIf(ctx.ucdRefs.length > 0)('Use Cases', () => {
+        describe.each(ctx.ucdRefs)('$name', async (ucdRef) => {
+            afterEach(async () => {
+                await configurator.clearExecution(ctx);
+            });
+
+            // biome-ignore lint/suspicious/noExplicitAny: can be anything
+            let ucd: UCDef<any, any, any>;
 
-                public async run(_m: Model, _r: RealSystem): Promise<void> {
-                    const out = await runner.execMonkeyTest(ucd, this.input);
+            beforeAll(() => {
+                // biome-ignore lint/suspicious/noExplicitAny: can be anything
+                ucd = runner.getUCD<any, any, any>(ucdRef.name);
+            });
+
+            const data = await runner.ucTestData(ucdRef);
+
+            test.each(data)(
+                'should execute with auth $authName and input $inputFillerName',
+                async ({ auth, authName, inputFiller, inputFillerName }) => {
+                    const { out, sideEffects } = await runner.execUC({
+                        auth,
+                        authName: authName as UCAuthSetterName,
+                        inputFiller,
+                        inputFillerName,
+                        ucd,
+                    });
 
                     if (out.err !== null) {
                         if (!(out.err instanceof CustomError)) {
@@ -201,41 +177,82 @@ describe.runIf(ucdRefs.length > 0)('Use Cases', () => {
                         }
                         expect(out.err).toBeInstanceOf(CustomError);
                     }
-                }
 
-                public toString(): string {
-                    return \`\${ucd.metadata.name\}(\${JSON.stringify(this.input)\})\`;
+                    const { hash } = out;
+                    const assertion = hash
+                        ? (await configurator.specificAssertions())?.get(hash)
+                        : undefined;
+                    if (assertion) {
+                        expect(out).toSatisfy(assertion);
+                    } else {
+                        expect({ out, sideEffects }).toMatchSnapshot(
+                            \`hash = \${hash\}\`,
+                        );
+                    }
+                },
+            );
+
+            test('should execute with monkey testing', async () => {
+                // Given
+                // biome-ignore lint/complexity/noBannedTypes: nothing for now
+                type Model = {};
+                // biome-ignore lint/complexity/noBannedTypes: nothing for now
+                type RealSystem = {};
+
+                class MyCommand<I extends UCInput | undefined = undefined>
+                    implements AsyncCommand<Model, RealSystem>
+                {
+                    constructor(private input: I) {}
+
+                    public check(_m: Readonly<Model>): boolean {
+                        return true;
+                    }
+
+                    public async run(_m: Model, _r: RealSystem): Promise<void> {
+                        const out = await runner.execMonkeyTest(ucd, this.input);
+
+                        if (out.err !== null) {
+                            if (!(out.err instanceof CustomError)) {
+                                logger.error(out.err);
+                            }
+                            expect(out.err).toBeInstanceOf(CustomError);
+                        }
+                    }
+
+                    public toString(): string {
+                        return \`\${ucd.metadata.name\}(\${JSON.stringify(this.input)\})\`;
+                    }
                 }
-            }
 
-            const inputFields = ucd.io.i?.fields;
-            if (!inputFields || Object.keys(inputFields).length > 0) {
-                // Mainly to prevent monkey testing from running indefinitely
-                return;
-            }
+                const inputFields = ucd.io.i?.fields;
+                if (!inputFields || Object.keys(inputFields).length > 0) {
+                    // Mainly to prevent monkey testing from running indefinitely
+                    return;
+                }
 
-            // biome-ignore lint/suspicious/noExplicitAny: can be anything
-            const inputLike: Record<string, Arbitrary<any>> = {};
-            for (const k of Object.keys(inputFields)) {
-                inputLike[k] = anything();
-            }
-            const cmdArbs = record(inputLike, { requiredKeys: [] }).map(
-                (r) => new MyCommand(r),
-            );
+                // biome-ignore lint/suspicious/noExplicitAny: can be anything
+                const inputLike: Record<string, Arbitrary<any>> = {};
+                for (const k of Object.keys(inputFields)) {
+                    inputLike[k] = anything();
+                }
+                const cmdArbs = record(inputLike, { requiredKeys: [] }).map(
+                    (r) => new MyCommand(r),
+                );
 
-            const modelRunSetup: ModelRunSetup<Model, RealSystem> = () => ({
-                model: {},
-                real: {},
-            });
+                const modelRunSetup: ModelRunSetup<Model, RealSystem> = () => ({
+                    model: {},
+                    real: {},
+                });
 
-            // When
-            const property = asyncProperty(commands([cmdArbs]), (cmds) =>
-                asyncModelRun(modelRunSetup, cmds),
-            );
+                // When
+                const property = asyncProperty(commands([cmdArbs]), (cmds) =>
+                    asyncModelRun(modelRunSetup, cmds),
+                );
 
-            // Then
-            await assert(property);
-        }, ${monkeyTestingTimeoutInMs});
+                // Then
+                await assert(property);
+            }, ${monkeyTestingTimeoutInMs});
+        });
     });
 });
 `;

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

@@ -1,11 +1,10 @@
 import type { FilePath } from '../../dt/index.js';
-import type { FSManager, Logger, ShellCommandExecutor } from '../../std/index.js';
+import type { FSManager, ShellCommandExecutor } from '../../std/index.js';
 import type { AppTestSuiteRunner, Input } from '../workers/AppTestSuiteRunner.js';
 export declare class VitestAppTestSuiteRunner implements AppTestSuiteRunner {
     private fsManager;
-    private logger;
     private shellCommandExecutor;
-    constructor(fsManager: FSManager, logger: Logger, shellCommandExecutor: ShellCommandExecutor);
+    constructor(fsManager: FSManager, shellCommandExecutor: ShellCommandExecutor);
     exec({ appPath, skipCoverage, updateSnapshots, }: Input): Promise<void>;
     coverageReportEntrypointPath(appPath: FilePath): Promise<FilePath>;
     private coverageReportPath;

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

@@ -14,17 +14,16 @@ import { inject, injectable } from 'inversify';
 import { APP_TEST_DIR_NAME, APP_TEST_REPORTS_DIR_NAME, } from '../../convention.js';
 let VitestAppTestSuiteRunner = class VitestAppTestSuiteRunner {
     fsManager;
-    logger;
     shellCommandExecutor;
-    constructor(fsManager, logger, shellCommandExecutor) {
+    constructor(fsManager, shellCommandExecutor) {
         this.fsManager = fsManager;
-        this.logger = logger;
         this.shellCommandExecutor = shellCommandExecutor;
     }
     async exec({ appPath, skipCoverage, updateSnapshots, }) {
         const testPath = this.fsManager.path(appPath, APP_TEST_DIR_NAME);
         const args = [
             'run',
+            '--color',
             '--dir',
             appPath,
         ];
@@ -34,13 +33,13 @@ let VitestAppTestSuiteRunner = class VitestAppTestSuiteRunner {
         if (updateSnapshots) {
             args.push('--update');
         }
-        const output = await this.shellCommandExecutor.exec({
+        await this.shellCommandExecutor.exec({
             bin: './node_modules/.bin/vitest',
             opts: {
                 args,
+                streamData: true,
             },
         });
-        this.logger.info(output);
     }
     async coverageReportEntrypointPath(appPath) {
         return this.fsManager.path(this.coverageReportPath(appPath), 'index.html');
@@ -53,8 +52,7 @@ let VitestAppTestSuiteRunner = class VitestAppTestSuiteRunner {
 VitestAppTestSuiteRunner = __decorate([
     injectable(),
     __param(0, inject('FSManager')),
-    __param(1, inject('Logger')),
-    __param(2, inject('ShellCommandExecutor')),
-    __metadata("design:paramtypes", [Object, Object, Object])
+    __param(1, inject('ShellCommandExecutor')),
+    __metadata("design:paramtypes", [Object, Object])
 ], VitestAppTestSuiteRunner);
 export { VitestAppTestSuiteRunner };

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

@@ -1,11 +1,13 @@
 import type { ErrorMessage } from '../../../dt/index.js';
 import type { Worker } from '../../../std/index.js';
+import type { UCDef } from '../../../uc/index.js';
 import type { AppTesterUCDRef } from '../../ctx.js';
 export interface Input {
     ucdRef: AppTesterUCDRef;
 }
 export interface Output {
     errors: ErrorMessage[];
+    ucd: UCDef | null;
 }
 export declare class UCDefChecker implements Worker<Input, Promise<Output>> {
     private output;

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

@@ -15,7 +15,7 @@ const ERR_UCD_NAMES = (fileName, name, ucdKey) => `The file name and the const n
 let UCDefChecker = class UCDefChecker {
     output;
     constructor() {
-        this.output = { errors: [] };
+        this.output = { errors: [], ucd: null };
     }
     async exec({ ucdRef }) {
         const { fileName, source } = ucdRef;
@@ -35,6 +35,9 @@ let UCDefChecker = class UCDefChecker {
             name !== ucdKey.replaceAll(UC_DEF_SUFFIX, '')) {
             this.output.errors.push(ERR_UCD_NAMES(fileName, name, ucdKey));
         }
+        if (this.output.errors.length === 0) {
+            this.output.ucd = ucd;
+        }
         return this.output;
     }
 };

package/dist/esm/uc/data-store.d.ts

@@ -1,6 +1,6 @@
 import type { AppName } from '../app/index.js';
 import type { UIntQuantity, UUID } from '../dt/index.js';
-import type { Clearable, StringKeys } from '../utils/index.js';
+import type { Clearable, Initializable, StringKeys } from '../utils/index.js';
 import type { UCData } from './data.js';
 import type { UCExecMode } from './exec.js';
 import type { UCInput } from './input.js';
@@ -55,13 +55,12 @@ export interface UCDataStoreRecord<I extends UCInput | undefined = undefined, D
     organizationId: UUID | null;
     userId: UUID | null;
 }
-export interface UCDataStore extends Clearable {
+export interface UCDataStore extends Clearable, Initializable {
     destroy(): Promise<void>;
     exists(): Promise<boolean>;
-    initTx(): Promise<UCDataStoreTx['ref']>;
-    install(): Promise<void>;
     read<I extends UCInput | undefined = undefined, D extends UCData | null = null>(opts?: UCDataStoreReadOpts<I, D>): Promise<UCDataStoreReadResponse<I, D>>;
     readProjection<T extends object>(name: string, opts?: UCDataStoreReadProjectionOpts<T>): Promise<T[]>;
+    startTx(): Promise<UCDataStoreTx['ref']>;
     supportedSpecificBindings(): UCDataStoreWriteProjectionSpecificBinding[];
     testKey(encryptionKey: Uint8Array): Promise<void>;
     write<I extends UCInput | undefined = undefined, D extends UCData | null = null>(record: UCDataStoreRecord<I, D>, opts?: UCDataStoreWriteOpts): Promise<void>;

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

@@ -51,6 +51,7 @@ export class UCOutputBuilder {
         const idx = this.output.parts._0.items.findIndex(predicate);
         if (idx > -1) {
             this.output.parts._0.items.splice(idx, 1);
+            this.output.parts._0.total -= 1;
         }
         return this;
     }

package/dist/esm/uc/impl/CloudflareD1UCDataStore.d.ts

@@ -0,0 +1,34 @@
+import type { D1Database } from '@cloudflare/workers-types';
+import type { Configurable, SettingsManager } from '../../std/index.js';
+import type { UCData } from '../data.js';
+import type { UCDataStore, UCDataStoreReadOpts, UCDataStoreReadProjectionOpts, UCDataStoreReadResponse, UCDataStoreRecord, UCDataStoreTx, UCDataStoreWriteOpts, UCDataStoreWriteProjectionOpts, UCDataStoreWriteProjectionSpecificBinding } from '../data-store.js';
+import type { UCInput } from '../input.js';
+import type { UCSettings } from '../settings.js';
+type S = Pick<UCSettings, 'uc_data_store_ucs_dataset_name'>;
+export declare const ROW_COLS: (keyof UCDataStoreRecord)[];
+/**
+ * @alpha This implementation is still a WIP and needs improvement
+ */
+export declare class CloudflareD1UCDataStore implements Configurable<S>, UCDataStore {
+    protected settingsManager: SettingsManager<S>;
+    protected client?: D1Database | undefined;
+    constructor(settingsManager: SettingsManager<S>);
+    s(): S;
+    clear(): Promise<void>;
+    destroy(): Promise<void>;
+    exists(): Promise<boolean>;
+    init(): Promise<void>;
+    initSync(): void;
+    read<I extends UCInput | undefined = undefined, D extends UCData | null = null>(opts?: UCDataStoreReadOpts<I, D>): Promise<UCDataStoreReadResponse<I, D>>;
+    readProjection<T extends object>(_name: string, _opts?: UCDataStoreReadProjectionOpts<T>): Promise<T[]>;
+    startTx(): Promise<UCDataStoreTx['ref']>;
+    supportedSpecificBindings(): UCDataStoreWriteProjectionSpecificBinding[];
+    testKey(_encryptionKey: Uint8Array): Promise<void>;
+    write<I extends UCInput | undefined = undefined, D extends UCData | null = null>(record: UCDataStoreRecord<I, D>, _opts?: UCDataStoreWriteOpts): Promise<void>;
+    writeBulk<I extends UCInput | undefined = undefined, D extends UCData | null = null>(_records: UCDataStoreRecord<I, D>[], _opts?: UCDataStoreWriteOpts): Promise<void>;
+    writeProjection<T extends object>(_name: string, _data: T, _opts?: UCDataStoreWriteProjectionOpts): Promise<void>;
+    setClient(client: D1Database): void;
+    private assertClient;
+    private filter;
+}
+export {};