libmodulor 0.1.0 → 0.2.0

package/dist/esm/uc/UC.js

@@ -0,0 +1,157 @@
+import { TFile, Validation } from '../dt/index.js';
+import { isBlank } from '../utils/index.js';
+import { UCInputField } from './UCInputField.js';
+import { UCInputFieldChangeOperator, ucifIsMandatory, ucifIsSensitive, ucifMustBeFilledManually, } from './input-field.js';
+import { AggregateInputDef } from './io/input/AggregateInput.js';
+import { ListInputDef } from './io/input/ListInput.js';
+export class UC {
+    appManifest;
+    def;
+    auth;
+    inputFields;
+    constructor(appManifest, def, auth) {
+        this.appManifest = appManifest;
+        this.def = def;
+        this.auth = auth;
+        const iFields = def.io.i?.fields;
+        this.inputFields = iFields
+            ? Object.entries(iFields).map(([key, def]) => new UCInputField(key, def))
+            : [];
+    }
+    clear() {
+        for (const f of this.inputFields) {
+            if (!ucifMustBeFilledManually(f.def)) {
+                continue;
+            }
+            f.clear();
+        }
+    }
+    clearSensitiveInputFields() {
+        for (const f of this.inputFieldsSensitive()) {
+            f.clear();
+        }
+    }
+    fill(input) {
+        for (const f of this.inputFields) {
+            f.setValue(UCInputFieldChangeOperator.SET, input[f.key]);
+        }
+        return this;
+    }
+    hasInputField(key) {
+        return this.inputFields.find((f) => f.key === key) !== undefined;
+    }
+    hasMediaInInput() {
+        return !!this.inputFields.find((f) => f.def.type instanceof TFile);
+    }
+    hasOutputParts() {
+        return !!this.def.io.o?.parts;
+    }
+    inputField(key) {
+        const field = this.inputFields.find((f) => f.key === key);
+        if (!field) {
+            throw new Error(`Input field ${key.toString()} does not exist`);
+        }
+        return field;
+    }
+    inputFieldsForForm() {
+        const ordered = this.inputFieldsOrdered().filter((f) => ucifMustBeFilledManually(f.def));
+        const dependencies = this.def.io.i?.dependencies;
+        if (!dependencies) {
+            return ordered;
+        }
+        return ordered.filter((f) => {
+            const deps = dependencies[f.key];
+            if (!deps) {
+                return true;
+            }
+            const depsValues = deps.map((fKey) => this.inputField(fKey).getValue());
+            const blankDepsValues = depsValues.filter((v) => isBlank(v));
+            return blankDepsValues.length === 0;
+        });
+    }
+    inputFieldsOrdered() {
+        const order = this.def.io.i?.order;
+        if (!order) {
+            return this.inputFields;
+        }
+        return this.inputFields.sort((a, b) => {
+            const idxA = order.indexOf(a.key);
+            const idxB = order.indexOf(b.key);
+            if (idxA < idxB) {
+                return -1;
+            }
+            if (idxA > idxB) {
+                return 1;
+            }
+            return 0;
+        });
+    }
+    inputFieldsInsensitive() {
+        return this.inputFields.filter((f) => !ucifIsSensitive(f.def));
+    }
+    inputFieldsSensitive() {
+        return this.inputFields.filter((f) => ucifIsSensitive(f.def));
+    }
+    needsInputFilling() {
+        const fields = this.inputFields;
+        if (fields.length === 0) {
+            return false;
+        }
+        const isListInput = Object.keys(ListInputDef.fields)
+            .sort((a, b) => a.localeCompare(b))
+            .join('') ===
+            fields
+                .map((f) => f.key)
+                .sort((a, b) => a.localeCompare(b))
+                .join('');
+        if (isListInput) {
+            return false;
+        }
+        return fields.filter((f) => ucifMustBeFilledManually(f.def)).length > 0;
+    }
+    needsOutputDisplay() {
+        return this.hasOutputParts();
+    }
+    operatesOnAggregate() {
+        const fields = this.inputFields;
+        const aggregateIdField = fields.find((f) => f.key === Object.keys(AggregateInputDef['fields'])[0]);
+        return !!aggregateIdField && ucifIsMandatory(aggregateIdField.def);
+    }
+    rVal0(key) {
+        return this.inputField(key).rVal0();
+    }
+    reqVal0(key) {
+        return this.inputField(key).reqVal0();
+    }
+    rValArr(key) {
+        return this.inputField(key).rValArr();
+    }
+    validate() {
+        for (const f of this.inputFields) {
+            const validation = f.validate();
+            if (!validation.isOK()) {
+                return [f, validation];
+            }
+        }
+        const combinedValidation = this.def.io.i?.validation;
+        if (!combinedValidation) {
+            return null;
+        }
+        const { or } = combinedValidation;
+        if (!or) {
+            return null;
+        }
+        const definedValues = or
+            .map((key) => !isBlank(this.inputField(key).getValue()))
+            .filter((v) => !!v);
+        if (definedValues.length === 0) {
+            const validation = new Validation();
+            validation.add({
+                constraint: 'fieldsOr',
+                expected: or.join(', '),
+            });
+            return [null, validation];
+        }
+        return null;
+    }
+}

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

@@ -0,0 +1,23 @@
+import { type DataType, Validation } from '../dt/index.js';
+import type { UCFieldKey, UCWording } from './def.js';
+import { UCInputFieldChangeOperator, type UCInputFieldDef, type UCInputFieldValue } from './input-field.js';
+import { rVal0, rValArr, type reqVal0 } from './utils/rVal.js';
+export declare class UCInputField<T extends DataType> {
+    key: UCFieldKey;
+    def: UCInputFieldDef<T>;
+    private dynamicWording;
+    private value;
+    constructor(key: UCFieldKey, def: UCInputFieldDef<T>);
+    clear(): void;
+    getDynamicWording(): Partial<UCWording> | undefined;
+    getValue(): UCInputFieldValue<T>;
+    rVal0(): ReturnType<typeof rVal0<T>>;
+    reqVal0(): ReturnType<typeof reqVal0<T>>;
+    rValArr(): ReturnType<typeof rValArr<T>>;
+    setValue(op: UCInputFieldChangeOperator, value: UCInputFieldValue<T>): void;
+    updateDef(def: UCInputFieldDef<T>): void;
+    updateDynamicWording(dynamicWording: Partial<UCWording> | undefined): void;
+    updateType(type: UCInputFieldDef<T>['type']): void;
+    validateMandatoriness(): Validation;
+    validate(): Validation;
+}

package/dist/esm/uc/UCInputField.js

@@ -0,0 +1,162 @@
+import { Validation } from '../dt/index.js';
+import { isBlank } from '../utils/index.js';
+import { UCInputFieldChangeOperator, ucifIsMandatory, ucifMustBeFilledManually, ucifRepeatability, } from './input-field.js';
+import { rVal0, rValArr } from './utils/rVal.js';
+import { ucifcoIsForArray } from './utils/ucifcoIsForArray.js';
+export class UCInputField {
+    key;
+    def;
+    dynamicWording;
+    value;
+    constructor(key, def) {
+        this.key = key;
+        this.def = def;
+        const initialValue = def.type.getInitialValue();
+        if (initialValue !== undefined) {
+            this.value = initialValue;
+        }
+    }
+    clear() {
+        this.value = undefined;
+        const initialValue = this.def.type.getInitialValue();
+        if (initialValue !== undefined) {
+            this.value = initialValue;
+        }
+    }
+    getDynamicWording() {
+        return this.dynamicWording;
+    }
+    getValue() {
+        return this.value;
+    }
+    rVal0() {
+        const val = rVal0(this.value);
+        if (!isBlank(val)) {
+            return val;
+        }
+        const defaultValue = this.def.type.getDefaultValue();
+        if (defaultValue !== undefined) {
+            return defaultValue;
+        }
+        return null;
+    }
+    reqVal0() {
+        if (!isBlank(this.value)) {
+            if (Array.isArray(this.value)) {
+                throw new Error('The value is an array. Use rValArr instead.');
+            }
+            return this.value;
+        }
+        const defaultValue = this.def.type.getDefaultValue();
+        if (defaultValue !== undefined) {
+            return defaultValue;
+        }
+        throw new Error(`${this.key.toString()} is not set and has no default value. Do not require it.`);
+    }
+    rValArr() {
+        if (!isBlank(this.value)) {
+            if (!Array.isArray(this.value)) {
+                throw new Error('The value is a primitive. Use reqVal0 instead.');
+            }
+            return this.value;
+        }
+        const defaultValue = this.def.type.getDefaultValue();
+        if (defaultValue !== undefined) {
+            return [defaultValue];
+        }
+        return [];
+    }
+    setValue(op, value) {
+        if (op === UCInputFieldChangeOperator.RESET) {
+            this.clear();
+            return;
+        }
+        const { type } = this.def;
+        type.assign(value);
+        const val = type.val();
+        if (val === undefined) {
+            return;
+        }
+        if (!ucifcoIsForArray(op)) {
+            switch (op) {
+                case UCInputFieldChangeOperator.SET:
+                    this.value = val;
+                    break;
+                default:
+                    ((_) => { })(op);
+            }
+            return;
+        }
+        const current = Array.isArray(this.value) ? this.value : [];
+        switch (op) {
+            case UCInputFieldChangeOperator.ADD:
+                this.value = current.concat([val]);
+                break;
+            case UCInputFieldChangeOperator.REMOVE:
+                this.value = current.filter((v) => v !== val);
+                break;
+            default:
+                ((_) => { })(op);
+        }
+    }
+    updateDef(def) {
+        this.def = def;
+    }
+    updateDynamicWording(dynamicWording) {
+        this.dynamicWording = dynamicWording;
+    }
+    updateType(type) {
+        this.def.type = type;
+    }
+    validateMandatoriness() {
+        const validation = new Validation();
+        const needsValidation = ucifMustBeFilledManually(this.def, { noContext: true }) &&
+            ucifIsMandatory(this.def) &&
+            isBlank(this.value);
+        if (!needsValidation) {
+            return validation;
+        }
+        validation.add({
+            constraint: 'mandatory',
+            expected: undefined,
+        });
+        return validation;
+    }
+    validate() {
+        const validation = this.validateMandatoriness();
+        if (this.value !== undefined && this.value !== null) {
+            const [isRepeatable] = ucifRepeatability(this.def);
+            if (!isRepeatable && Array.isArray(this.value)) {
+                validation.add({ constraint: 'type', expected: 'scalar' });
+            }
+            if (isRepeatable && !Array.isArray(this.value)) {
+                validation.add({ constraint: 'type', expected: 'array' });
+            }
+        }
+        const valueAsArr = rValArr(this.value);
+        for (const val of valueAsArr) {
+            const typeValidation = this.def.type.assign(val).validate();
+            if (!typeValidation.isOK()) {
+                validation.concat(typeValidation);
+            }
+        }
+        const { cardinality } = this.def;
+        if (cardinality) {
+            const { max, min } = cardinality;
+            const { length } = valueAsArr;
+            if (max !== undefined && length > max) {
+                validation.add({
+                    constraint: 'maxCount',
+                    expected: max,
+                });
+            }
+            if (min !== undefined && length < min) {
+                validation.add({
+                    constraint: 'minCount',
+                    expected: min,
+                });
+            }
+        }
+        return validation;
+    }
+}

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

@@ -0,0 +1,9 @@
+import type { DataType } from '../dt/index.js';
+import type { StringKeys } from '../utils/index.js';
+import type { UCOPIBase } from './opi.js';
+import type { UCOutputFieldDef } from './output-field.js';
+export declare class UCOutputField<OPI extends UCOPIBase, T extends DataType> {
+    key: StringKeys<OPI>;
+    def: UCOutputFieldDef<OPI, T>;
+    constructor(key: StringKeys<OPI>, def: UCOutputFieldDef<OPI, T>);
+}

package/dist/esm/uc/UCOutputField.js

@@ -0,0 +1,8 @@
+export class UCOutputField {
+    key;
+    def;
+    constructor(key, def) {
+        this.key = key;
+        this.def = def;
+    }
+}

package/dist/esm/uc/auth/consts.d.ts

@@ -0,0 +1,3 @@
+import type { UCAuth } from '../auth.js';
+export declare const FAKE_USER_ADMIN: UCAuth;
+export declare const FAKE_USER_REGULAR: UCAuth;

package/dist/esm/uc/auth/consts.js

@@ -0,0 +1,16 @@
+import { TPersonFirstname, TPersonInitials, TUUID } from '../../dt/index.js';
+export const FAKE_USER_ADMIN = {
+    organization: {
+        id: new TUUID().example(),
+    },
+    role: 'admin',
+    user: {
+        firstname: new TPersonFirstname().example(),
+        id: new TUUID().example(),
+        initials: new TPersonInitials().example(),
+    },
+};
+export const FAKE_USER_REGULAR = {
+    ...FAKE_USER_ADMIN,
+    role: 'regular',
+};

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

@@ -0,0 +1,13 @@
+import type { PersonFirstname, PersonInitials, UUID } from '../dt/index.js';
+export type UCAuthRole = 'admin' | 'regular' | (string & {});
+export interface UCAuth {
+    organization: {
+        id: UUID;
+    };
+    role: UCAuthRole;
+    user: {
+        firstname: PersonFirstname;
+        id: UUID;
+        initials: PersonInitials;
+    };
+}

package/dist/esm/uc/auth.js

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

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

@@ -0,0 +1,19 @@
+import type { Class } from '../utils/index.js';
+import type { UCDef } from './def.js';
+import type { UCInput } from './input.js';
+import type { UCMain } from './main.js';
+import type { UCOPIBase } from './opi.js';
+import type { UCPolicy } from './policy.js';
+export interface UCClientDef<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> {
+    main: Class<UCMain<I, OPI0, OPI1>>;
+    policy: Class<UCPolicy<I, OPI0, OPI1>>;
+}
+export interface UCClientConfirmConfig {
+    cancel: string;
+    confirm: string;
+    message: string | null;
+    title: string;
+}
+export interface UCClientConfirmManager {
+    exec<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(ucd: UCDef<I, OPI0, OPI1>): Promise<boolean>;
+}

package/dist/esm/uc/client.js

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

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

@@ -0,0 +1,71 @@
+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 { UCData } from './data.js';
+import type { UCExecMode } from './exec.js';
+import type { UCInput } from './input.js';
+import type { UCName } from './metadata.js';
+export type UCDataStoreDatasetName = string;
+interface UCDataStoreQueryOpts {
+}
+export type UCDataStoreReadFilter<T> = T | T[];
+export interface UCDataStoreReadFilters<I extends UCInput | undefined = undefined, D extends UCData | null = null> {
+    aggregateId?: UCDataStoreReadFilter<UCDataStoreRecord<I, D>['aggregateId']> | undefined;
+    appName?: UCDataStoreReadFilter<UCDataStoreRecord<I, D>['appName']> | undefined;
+    idWithinInput?: Partial<{
+        [key in StringKeys<NonNullable<I>>]: UUID;
+    }> | undefined;
+    name?: UCDataStoreReadFilter<UCDataStoreRecord<I, D>['name']> | undefined;
+    organizationId?: UCDataStoreReadFilter<UCDataStoreRecord<I, D>['organizationId']> | undefined;
+    userId?: UCDataStoreReadFilter<UCDataStoreRecord<I, D>['userId']> | undefined;
+}
+export interface UCDataStoreReadOpts<I extends UCInput | undefined = undefined, D extends UCData | null = null> extends UCDataStoreQueryOpts {
+    filters?: UCDataStoreReadFilters<I, D>;
+}
+export type UCDataStoreReadProjectionOrderBy = 'asc' | 'desc';
+export interface UCDataStoreReadProjectionOpts<T extends object> {
+    limit?: UIntQuantity;
+    orderBy?: Partial<Record<keyof T, UCDataStoreReadProjectionOrderBy>>;
+}
+export interface UCDataStoreReadResponse<I extends UCInput | undefined = undefined, D extends UCData | null = null> {
+    records: UCDataStoreRecord<I, D>[];
+}
+export interface UCDataStoreTx {
+    ref: {
+        commit: () => Promise<void>;
+        rollback: () => Promise<void>;
+    };
+}
+export interface UCDataStoreWriteOpts extends UCDataStoreQueryOpts {
+    tx?: UCDataStoreTx | undefined;
+}
+export type UCDataStoreWriteProjectionSpecificBinding = 'to_tsvector(?)' | (string & {});
+export interface UCDataStoreWriteProjectionOpts extends UCDataStoreWriteOpts {
+    specificBindings?: Record<string, 'to_tsvector(?)' | (string & {})> | undefined;
+}
+export interface UCDataStoreRecord<I extends UCInput | undefined = undefined, D extends UCData | null = null> {
+    aggregateId: UUID;
+    appName: AppName;
+    createdAt: Date;
+    data: D | null;
+    executionMode: UCExecMode;
+    id: UUID;
+    input: I | null;
+    name: UCName;
+    organizationId: UUID | null;
+    userId: UUID | null;
+}
+export interface UCDataStore extends Clearable {
+    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>;
+}
+export {};

package/dist/esm/uc/data-store.js

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

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

@@ -0,0 +1,2 @@
+export interface UCData {
+}

package/dist/esm/uc/data.js

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

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

@@ -0,0 +1,33 @@
+import type { UC_DEF_SUFFIX } from '../convention.js';
+import type { UCClientDef } from './client.js';
+import type { UCExt } from './ext.js';
+import type { UCInput, UCInputDef } from './input.js';
+import type { UCMetadata, UCName } from './metadata.js';
+import type { UCOPIBase } from './opi.js';
+import type { UCOutputDef } from './output.js';
+import type { UCSec } from './sec.js';
+import type { UCServerDef } from './server.js';
+export type UCDefSource = any;
+export type UCDefSourceRaw = string;
+export type UCDefSourceSafe<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> = {
+    [key: `${UCName}${typeof UC_DEF_SUFFIX}`]: UCDef<I, OPI0, OPI1>;
+};
+export type UCDefLifecycle = 'client' | 'server';
+export interface UCDef<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> {
+    ext?: UCExt<OPI0, OPI1>;
+    io: {
+        i?: UCInputDef<NonNullable<I>>;
+        o?: UCOutputDef<OPI0, OPI1>;
+    };
+    lifecycle: {
+        client?: UCClientDef<I, OPI0, OPI1>;
+        server?: UCServerDef<I, OPI0, OPI1> | true;
+    };
+    metadata: UCMetadata;
+    sec?: UCSec;
+}
+export interface UCWording {
+    desc: string | null;
+    label: string;
+}
+export type UCFieldKey = string;

package/dist/esm/uc/def.js

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

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

@@ -0,0 +1,7 @@
+export declare enum UCExecMode {
+    AUTO = "auto",
+    USER = "user"
+}
+export type UCExecState = 'changing' | 'idle' | 'initializing' | 'submitting';
+export declare function ucIsDisabled(execState: UCExecState): boolean;
+export declare function ucIsLoading(execState: UCExecState): boolean;

package/dist/esm/uc/exec.js

@@ -0,0 +1,11 @@
+export var UCExecMode;
+(function (UCExecMode) {
+    UCExecMode["AUTO"] = "auto";
+    UCExecMode["USER"] = "user";
+})(UCExecMode || (UCExecMode = {}));
+export function ucIsDisabled(execState) {
+    return execState !== 'idle';
+}
+export function ucIsLoading(execState) {
+    return execState === 'submitting';
+}

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

@@ -0,0 +1,14 @@
+import type { HTTPMethod, URLPath } from '../dt/index.js';
+import type { UCOPIBase } from './opi.js';
+import type { UCOutput } from './output.js';
+import type { UCMountingPoint } from './utils/ucMountingPoint.js';
+export interface UCExt<OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> {
+    cmd?: {
+        mountAt?: UCMountingPoint;
+    };
+    http?: {
+        method?: HTTPMethod;
+        mountAt?: `/${URLPath}`;
+        transform?: <T extends object>(output: UCOutput<OPI0, OPI1>) => T;
+    };
+}

package/dist/esm/uc/ext.js

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

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

@@ -0,0 +1,3 @@
+import type { FilePath } from '../dt/index.js';
+export type UCFileInputFieldRefPrefix = '$ref:';
+export type UCFileInputFieldRef = `${UCFileInputFieldRefPrefix}${FilePath}`;

package/dist/esm/uc/file.js

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

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

@@ -0,0 +1,18 @@
+import type { UIntQuantity, UUID } from '../../dt/index.js';
+import type { UCOPIBase } from '../opi.js';
+import type { UCOutput } from '../output.js';
+export declare class UCOutputBuilder<OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> {
+    private output;
+    add(item: NonNullable<OPI0>): this;
+    addAll(items: NonNullable<OPI0>[]): this;
+    addAll1(items: NonNullable<OPI1>[]): this;
+    add1(item: NonNullable<OPI1>): this;
+    count(): UIntQuantity;
+    count1(): UIntQuantity;
+    has(predicate: (item: OPI0) => boolean): boolean;
+    get(): UCOutput<OPI0, OPI1>;
+    remove(predicate: (item: OPI0) => boolean): this;
+    sort(sorter: (a: OPI0, b: OPI0) => number): this;
+    update(id: UUID, apply: (item: OPI0) => void): this;
+    private init1IfNecessary;
+}