libmodulor 0.1.0 → 0.2.0

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

@@ -0,0 +1,71 @@
+export class UCOutputBuilder {
+    output = {
+        parts: {
+            _0: {
+                items: [],
+                total: 0,
+            },
+        },
+    };
+    add(item) {
+        this.output.parts._0.items.push(item);
+        this.output.parts._0.total += 1;
+        return this;
+    }
+    addAll(items) {
+        this.output.parts._0.items.push(...items);
+        this.output.parts._0.total += items.length;
+        return this;
+    }
+    addAll1(items) {
+        this.init1IfNecessary();
+        this.output.parts._1.items.push(...items);
+        this.output.parts._1.total += items.length;
+        return this;
+    }
+    add1(item) {
+        this.init1IfNecessary();
+        this.output.parts._1.items.push(item);
+        this.output.parts._1.total += 1;
+        return this;
+    }
+    count() {
+        return this.output.parts._0.total;
+    }
+    count1() {
+        this.init1IfNecessary();
+        return this.output.parts._1.total;
+    }
+    has(predicate) {
+        return !!this.output.parts._0.items.find(predicate);
+    }
+    get() {
+        return this.output;
+    }
+    remove(predicate) {
+        const idx = this.output.parts._0.items.findIndex(predicate);
+        if (idx > -1) {
+            this.output.parts._0.items.splice(idx, 1);
+        }
+        return this;
+    }
+    sort(sorter) {
+        this.output.parts._0.items.sort(sorter);
+        return this;
+    }
+    update(id, apply) {
+        const item = this.output.parts._0.items.find((i) => i.id === id);
+        if (item) {
+            apply(item);
+        }
+        return this;
+    }
+    init1IfNecessary() {
+        if (!this.output.parts._1) {
+            this.output.parts._1 = {
+                items: [],
+                total: 0,
+            };
+        }
+    }
+}

package/dist/esm/uc/helpers/UCOutputReader.d.ts

@@ -0,0 +1,43 @@
+import type { DataType } from '../../dt/index.js';
+import type { StringKeys } from '../../utils/index.js';
+import type { UC } from '../UC.js';
+import { UCOutputField } from '../UCOutputField.js';
+import type { UCDef } from '../def.js';
+import type { UCInput } from '../input.js';
+import type { UCOPIBase } from '../opi.js';
+import type { UCOutputPart, UCOutputPartDef } from '../output-part.js';
+import type { UCOutput, UCOutputPartIdx, UCOutputPartKey } from '../output.js';
+export interface UCOutputReaderPart<OPI extends UCOPIBase> {
+    fields: UCOutputField<OPI, any>[];
+    idx: UCOutputPartIdx;
+    items: UCOutputPart<OPI>['items'];
+    key: UCOutputPartKey<OPI>;
+    layout: UCOutputPartDef<OPI>['layout'];
+    pagination: Pick<UCOutputPart<OPI>, 'total'> & {
+        label: UCOutputReaderPaginationLabel;
+    };
+    related?: UCOutputPartDef<OPI>['related'];
+}
+export type UCOutputReaderPaginationLabel = `${number}/${number}`;
+export declare class UCOutputReader<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> {
+    private _ucd;
+    private _output;
+    private _part0;
+    private _part1;
+    constructor(_ucd: UCDef<I, OPI0, OPI1>, _output: UCOutput<OPI0, OPI1> | undefined);
+    field0<T extends DataType>(key: StringKeys<NonNullable<OPI0>>): UCOutputField<NonNullable<OPI0>, T>;
+    item00(): Pick<UCOutputReaderPart<NonNullable<OPI0>>, 'layout'> & {
+        item: UCOutputReaderPart<NonNullable<OPI0>>['items'][0];
+    };
+    canItem00(): boolean;
+    isEmpty(): boolean;
+    part<OPI extends UCOPIBase>(idx: UCOutputPartIdx): UCOutputReaderPart<OPI> | undefined;
+    part0(): UCOutputReaderPart<NonNullable<OPI0>>;
+    part1(): UCOutputReaderPart<NonNullable<OPI1>> | undefined;
+    parts(): [UCOutputReaderPart<NonNullable<OPI0>>] | [
+        UCOutputReaderPart<NonNullable<OPI0>>,
+        UCOutputReaderPart<NonNullable<OPI1>>
+    ];
+    output(): UCOutput<OPI0, OPI1> | undefined;
+    ucd(): UC<I, OPI0, OPI1>['def'];
+}

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

@@ -0,0 +1,117 @@
+import { UCOutputField } from '../UCOutputField.js';
+const ERR_NO_FIELD = (key) => `No field ${key} is defined for this use case`;
+const ERR_NO_IO_OUTPUT = 'No output is defined for this use case';
+const ERR_NO_IO_OUTPUT_PART = (idx) => `No output part ${idx} is defined for this use case`;
+const ERR_NO_ITEMS = 'No items are available';
+const ERR_NO_ITEM = 'No item is available';
+const ERR_TOO_MANY_ITEMS = 'Too many items are available. Do not use item00';
+export class UCOutputReader {
+    _ucd;
+    _output;
+    _part0;
+    _part1;
+    constructor(_ucd, _output) {
+        this._ucd = _ucd;
+        this._output = _output;
+    }
+    field0(key) {
+        const part = this.part0();
+        const field = part.fields.find((f) => f.key === key);
+        if (!field) {
+            throw new Error(ERR_NO_FIELD(key));
+        }
+        return field;
+    }
+    item00() {
+        const { io } = this._ucd;
+        if (!io.o) {
+            throw new Error(ERR_NO_IO_OUTPUT);
+        }
+        const { items, layout } = this.part0();
+        if (items.length === 0) {
+            throw new Error(ERR_NO_ITEMS);
+        }
+        if (items.length > 1) {
+            throw new Error(ERR_TOO_MANY_ITEMS);
+        }
+        const [item] = items;
+        if (!item) {
+            throw new Error(ERR_NO_ITEM);
+        }
+        return {
+            item,
+            layout,
+        };
+    }
+    canItem00() {
+        const { io } = this._ucd;
+        return (!!io.o?.parts?._0 &&
+            io.o?.parts?._1 === undefined &&
+            this._output !== undefined &&
+            this._output.parts._0.total === 1);
+    }
+    isEmpty() {
+        return this._output === undefined;
+    }
+    part(idx) {
+        const { io } = this._ucd;
+        if (!io.o?.parts) {
+            throw new Error(ERR_NO_IO_OUTPUT);
+        }
+        const key = `_${idx}`;
+        const partDef = io.o.parts[key];
+        if (!partDef) {
+            return undefined;
+        }
+        const { fields, layout, order, related } = partDef;
+        const fieldKeys = order ?? Object.keys(fields);
+        let items = [];
+        let total = 0;
+        const part = this._output?.parts[key];
+        if (part) {
+            items = part.items;
+            total = part.total;
+        }
+        return {
+            fields: fieldKeys.map((fieldKey) => new UCOutputField(fieldKey, fields[fieldKey])),
+            idx,
+            items,
+            key,
+            layout,
+            pagination: {
+                label: `${items.length}/${total}`,
+                total: total,
+            },
+            related,
+        };
+    }
+    part0() {
+        if (!this._part0) {
+            this._part0 = this.part(0);
+        }
+        if (!this._part0) {
+            throw new Error(ERR_NO_IO_OUTPUT_PART(0));
+        }
+        return this._part0;
+    }
+    part1() {
+        if (!this._part1) {
+            this._part1 = this.part(1);
+        }
+        return this._part1;
+    }
+    parts() {
+        const p0 = this.part0();
+        const p1 = this.part1();
+        if (!p1) {
+            return [p0];
+        }
+        return [p0, p1];
+    }
+    output() {
+        return this._output;
+    }
+    ucd() {
+        return this._ucd;
+    }
+}

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

@@ -0,0 +1,17 @@
+import type { Configurable, HTTPAPICaller, SettingsManager } from '../../std/index.js';
+import type { ServerClientManager, ServerClientManagerSettings } from '../../target/lib/client/ServerClientManager.js';
+import type { UC } from '../UC.js';
+import type { UCInput } from '../input.js';
+import type { UCOPIBase } from '../opi.js';
+import type { UCOutputOrNothing } from '../output.js';
+import type { UCTransporter } from '../transporter.js';
+type S = Pick<ServerClientManagerSettings, 'server_cookies_name_auth' | 'server_public_api_key_header_name'>;
+export declare class HTTPUCTransporter implements Configurable<S>, UCTransporter {
+    private httpAPICaller;
+    private serverClientManager;
+    private settingsManager;
+    constructor(httpAPICaller: HTTPAPICaller, serverClientManager: ServerClientManager, settingsManager: SettingsManager<S>);
+    s(): S;
+    send<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(uc: UC<I, OPI0, OPI1>): Promise<UCOutputOrNothing<OPI0, OPI1>>;
+}
+export {};

package/dist/esm/uc/impl/HTTPUCTransporter.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 { inject, injectable } from 'inversify';
+import { DEFAULT_UC_SEC_AT, DEFAULT_UC_SEC_PAKCT } from '../sec/consts.js';
+import { rInput } from '../utils/rInput.js';
+import { ucHTTPContract } from '../utils/ucHTTPContract.js';
+let HTTPUCTransporter = class HTTPUCTransporter {
+    httpAPICaller;
+    serverClientManager;
+    settingsManager;
+    constructor(httpAPICaller, serverClientManager, settingsManager) {
+        this.httpAPICaller = httpAPICaller;
+        this.serverClientManager = serverClientManager;
+        this.settingsManager = settingsManager;
+    }
+    s() {
+        return {
+            server_cookies_name_auth: this.settingsManager.get()('server_cookies_name_auth'),
+            server_public_api_key_header_name: this.settingsManager.get()('server_public_api_key_header_name'),
+        };
+    }
+    async send(uc) {
+        const { auth, def: { sec }, } = uc;
+        const baseURL = await this.serverClientManager.baseURL({ auth });
+        const { contentType, envelope, method, path } = ucHTTPContract(uc);
+        const additionalHeaders = {};
+        let authorizationHeader = undefined;
+        let basicAuth = undefined;
+        const authType = sec?.authType ?? DEFAULT_UC_SEC_AT;
+        const publicApiKeyCheckType = sec?.publicApiKeyCheckType ?? DEFAULT_UC_SEC_PAKCT;
+        switch (publicApiKeyCheckType) {
+            case 'off':
+                break;
+            case 'on': {
+                const publicApiKey = await this.serverClientManager.publicApiKey();
+                const headerName = this.s().server_public_api_key_header_name;
+                if (headerName && publicApiKey) {
+                    additionalHeaders[headerName] = publicApiKey;
+                }
+                break;
+            }
+            default:
+                ((_) => { })(publicApiKeyCheckType);
+        }
+        if (auth) {
+            switch (authType) {
+                case 'basic': {
+                    const basic = await this.serverClientManager.authBasic({
+                        auth,
+                    });
+                    if (basic) {
+                        basicAuth = basic;
+                    }
+                    break;
+                }
+                case 'apiKey': {
+                    const apiKey = await this.serverClientManager.authApiKey({
+                        auth,
+                    });
+                    if (apiKey) {
+                        authorizationHeader = {
+                            prefix: 'Bearer',
+                            value: apiKey,
+                        };
+                    }
+                    break;
+                }
+                case 'jwt': {
+                    const jwt = await this.serverClientManager.authJWT({
+                        auth,
+                    });
+                    if (jwt) {
+                        additionalHeaders['Cookie'] =
+                            `${this.s().server_cookies_name_auth}=${jwt}`;
+                    }
+                    break;
+                }
+                default:
+                    ((_) => { })(authType);
+            }
+        }
+        const res = await this.httpAPICaller.exec({
+            additionalHeadersBuilder: async () => additionalHeaders,
+            authorizationHeader,
+            basicAuth,
+            contentType,
+            errBuilder: async (error) => error.message,
+            method,
+            req: {
+                builder: async () => rInput(uc, { ignoreUndefined: true }),
+                envelope,
+            },
+            urlBuilder: async () => `${baseURL}${path}`,
+        });
+        if (!res || Object.keys(res).length === 0) {
+            return;
+        }
+        return res;
+    }
+};
+HTTPUCTransporter = __decorate([
+    injectable(),
+    __param(0, inject('HTTPAPICaller')),
+    __param(1, inject('ServerClientManager')),
+    __param(2, inject('SettingsManager')),
+    __metadata("design:paramtypes", [Object, Object, Object])
+], HTTPUCTransporter);
+export { HTTPUCTransporter };

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

@@ -0,0 +1,22 @@
+import type { UCDataStore, UCDataStoreReadOpts, UCDataStoreReadResponse, UCDataStoreRecord, UCDataStoreTx, UCDataStoreWriteProjectionSpecificBinding } from '../data-store.js';
+import type { UCData } from '../data.js';
+import type { UCInput } from '../input.js';
+type TxState = 'committed' | 'pending' | 'rollbacked';
+export declare class InMemoryUCDataStore implements UCDataStore {
+    entries: UCDataStoreRecord<any, any>[];
+    tx: TxState | undefined;
+    constructor();
+    clear(): Promise<void>;
+    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>(): Promise<T[]>;
+    supportedSpecificBindings(): UCDataStoreWriteProjectionSpecificBinding[];
+    testKey(): Promise<void>;
+    write<I extends UCInput | undefined = undefined, D extends UCData | null = null>(record: UCDataStoreRecord<I, D>): Promise<void>;
+    writeBulk<I extends UCInput | undefined = undefined, D extends UCData | null = null>(records: UCDataStoreRecord<I, D>[]): Promise<void>;
+    writeProjection(): Promise<void>;
+}
+export {};

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

@@ -0,0 +1,97 @@
+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';
+const ERR = 'Method not implemented.';
+function predicate(key, filter) {
+    if (filter === null) {
+        return (r) => r[key] === null;
+    }
+    if (Array.isArray(filter)) {
+        return (r) => r[key] !== null && filter.includes(r[key]);
+    }
+    return (r) => r[key] === filter;
+}
+let InMemoryUCDataStore = class InMemoryUCDataStore {
+    entries;
+    tx;
+    constructor() {
+        this.entries = [];
+    }
+    async clear() {
+        this.entries = [];
+    }
+    async destroy() {
+        this.entries = [];
+    }
+    async exists() {
+        return this.entries.length > 0;
+    }
+    async initTx() {
+        this.tx = 'pending';
+        return {
+            commit: async () => {
+                this.tx = 'committed';
+            },
+            rollback: async () => {
+                this.tx = 'rollbacked';
+                this.entries = [];
+            },
+        };
+    }
+    async install() {
+    }
+    async read(opts) {
+        let items = this
+            .entries;
+        if (opts?.filters) {
+            const { aggregateId, appName, name, organizationId, userId } = opts.filters;
+            if (aggregateId !== undefined) {
+                items = items.filter(predicate('aggregateId', aggregateId));
+            }
+            if (appName !== undefined) {
+                items = items.filter(predicate('appName', appName));
+            }
+            if (name !== undefined) {
+                items = items.filter(predicate('name', name));
+            }
+            if (organizationId !== undefined) {
+                items = items.filter(predicate('organizationId', organizationId));
+            }
+            if (userId !== undefined) {
+                items = items.filter(predicate('userId', userId));
+            }
+        }
+        return {
+            records: items,
+        };
+    }
+    async readProjection() {
+        return [];
+    }
+    supportedSpecificBindings() {
+        return [];
+    }
+    async testKey() {
+    }
+    async write(record) {
+        this.writeBulk([record]);
+    }
+    async writeBulk(records) {
+        this.entries.push(...records);
+    }
+    async writeProjection() {
+        throw new Error(ERR);
+    }
+};
+InMemoryUCDataStore = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [])
+], InMemoryUCDataStore);
+export { InMemoryUCDataStore };

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

@@ -0,0 +1,43 @@
+import { type Knex } from 'knex';
+import type { FilePath, UIntQuantity } from '../../dt/index.js';
+import type { Configurable, Settings, SettingsManager } from '../../std/index.js';
+import type { UCDataStore, UCDataStoreReadOpts, UCDataStoreReadProjectionOpts, UCDataStoreReadResponse, UCDataStoreRecord, UCDataStoreTx, UCDataStoreWriteOpts, UCDataStoreWriteProjectionOpts, UCDataStoreWriteProjectionSpecificBinding } from '../data-store.js';
+import type { UCData } from '../data.js';
+import type { UCInput } from '../input.js';
+import type { UCSettings } from '../settings.js';
+export interface KnexUCDataStoreSettings extends Settings {
+    knex_uc_data_store_conn_string: `postgresql://${string}`;
+    knex_uc_data_store_file_path: FilePath | ':memory:';
+    knex_uc_data_store_pool_max: UIntQuantity;
+    knex_uc_data_store_pool_min: UIntQuantity;
+    knex_uc_data_store_type: 'pg' | 'sqlite3';
+}
+type S = KnexUCDataStoreSettings & Pick<UCSettings, 'uc_data_store_ucs_dataset_name'>;
+export declare class KnexUCDataStore implements Configurable<S>, UCDataStore {
+    protected settingsManager: SettingsManager<S>;
+    protected config: Knex.Config;
+    protected client: Knex;
+    constructor(settingsManager: SettingsManager<S>);
+    s(): S;
+    clear(): Promise<void>;
+    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[]>;
+    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>;
+    private fillConfig;
+    private fillConfigForPG;
+    private fillConfigForSQLite3;
+    private filter;
+    private mapRecordToRow;
+    private mapRowToRecord;
+    private parseJSONColIfNecessary;
+    private migration001CreateMainTable;
+}
+export {};