@sincpro/mobile 0.4.3 → 1.0.0

package/dist/domain/events/domain_event.js

@@ -0,0 +1,227 @@
+import { ValueObject } from "../../domain/entity/value_object";
+import { generateUUID } from "../../infrastructure/database/utils";
+import { currentChain, traceparent } from "../../infrastructure/event_chain";
+import { safeJsonParse, safeJsonStringify } from "../../tools/utils/serializer";
+import { chainAfter } from "./chain";
+import { textOf } from "./label";
+export var EEventStatus;
+(function (EEventStatus) {
+    EEventStatus["PENDING"] = "PENDING";
+    EEventStatus["PROCESSING"] = "PROCESSING";
+    EEventStatus["ACKNOWLEDGED"] = "ACKNOWLEDGED";
+    EEventStatus["FAILED"] = "FAILED";
+    EEventStatus["CANCELLED"] = "CANCELLED";
+})(EEventStatus || (EEventStatus = {}));
+const ENVELOPE_FIELDS = [
+    "name",
+    "label",
+    "requiresNetwork",
+    "uuid",
+    "createdAt",
+    "status",
+    "attempts",
+    "errorMessage",
+    "acknowledgedAt",
+    "failedAt",
+    "aggregateId",
+    "sourceId",
+    "correlationId",
+    "causationId",
+    "entityType",
+    "entityVersion",
+    "traceparent",
+    "sequence",
+];
+const ENVELOPE = new Set(ENVELOPE_FIELDS);
+const WIRE_KEYS = new Set([
+    ...ENVELOPE_FIELDS,
+    "id",
+    "created_at",
+    "entity_type",
+    "entity_id",
+    "correlation_id",
+    "causation_id",
+    "entity_version",
+]);
+export class DomainEvent extends ValueObject {
+    constructor(..._args) {
+        super();
+        const declared = new.target.label;
+        if (declared && typeof declared === "object") {
+            this.#label = { ...declared };
+        }
+    }
+    name = "";
+    label = "";
+    uuid = "";
+    createdAt = "";
+    aggregateId = null;
+    sourceId = null;
+    correlationId = null;
+    causationId = null;
+    entityType = "";
+    entityVersion = null;
+    traceparent = null;
+    sequence = 0;
+    #label = null;
+    static sanitize(data) {
+        if (data === null || data === undefined) {
+            return data;
+        }
+        if (data instanceof ValueObject) {
+            return safeJsonParse(data.asJSON());
+        }
+        if (Array.isArray(data)) {
+            return data.map((item) => DomainEvent.sanitize(item));
+        }
+        if (typeof data === "object" && data !== null) {
+            const result = {};
+            for (const [key, value] of Object.entries(data)) {
+                result[key] = DomainEvent.sanitize(value);
+            }
+            return result;
+        }
+        return data;
+    }
+    static create(data) {
+        const instance = new this();
+        if (data) {
+            const sanitized = DomainEvent.sanitize(data);
+            Object.assign(instance, sanitized);
+        }
+        Object.assign(instance, {
+            uuid: generateUUID(),
+            createdAt: new Date().toISOString(),
+        });
+        return instance;
+    }
+    static from(event) {
+        return this.fromJSON(event.asJSON());
+    }
+    static fromJSON(json) {
+        const written = (typeof json === "string" ? safeJsonParse(json) : { ...json });
+        if ("created_at" in written && !("createdAt" in written)) {
+            return DomainEvent.read(this, written);
+        }
+        const instance = new this();
+        Object.assign(instance, written);
+        return instance;
+    }
+    static read(ctor, written) {
+        const instance = new ctor();
+        const event = instance;
+        const shown = readLabel(written.label);
+        Object.assign(event, {
+            name: typeof written.name === "string" ? written.name : event.name,
+            uuid: asString(written.id, asString(written.uuid, event.uuid)),
+            label: shown.text || event.label,
+            createdAt: asString(written.created_at, asString(written.createdAt, "")),
+            entityType: asString(written.entity_type, ""),
+            aggregateId: asString(written.entity_id, null) || asString(written.aggregateId, null),
+            correlationId: asString(written.correlation_id, null),
+            causationId: asString(written.causation_id, null),
+            entityVersion: typeof written.entity_version === "number" ? written.entity_version : null,
+            traceparent: asString(written.traceparent, null),
+            sequence: typeof written.sequence === "number" ? written.sequence : 0,
+        });
+        event.#label = shown.label;
+        for (const [key, value] of Object.entries(written)) {
+            if (!WIRE_KEYS.has(key)) {
+                event[key] = value;
+            }
+        }
+        return instance;
+    }
+    withAggregateId(aggregateId) {
+        this.aggregateId = aggregateId;
+        return this;
+    }
+    withSourceId(sourceId) {
+        this.sourceId = sourceId;
+        return this;
+    }
+    withCorrelationId(correlationId) {
+        this.correlationId = correlationId;
+        return this;
+    }
+    withCausationId(causationId) {
+        this.causationId = causationId;
+        return this;
+    }
+    withEntityType(entityType) {
+        this.entityType = entityType;
+        return this;
+    }
+    withSequence(sequence) {
+        this.sequence = sequence;
+        return this;
+    }
+    causedBy(cause) {
+        const chain = chainAfter(cause.uuid, cause.correlationId, this.uuid);
+        this.causationId = chain.causationId;
+        this.correlationId = chain.correlationId;
+        return this;
+    }
+    applyChain(flowId) {
+        const cause = currentChain();
+        const chain = cause
+            ? chainAfter(cause.causationId, cause.correlationId, this.uuid)
+            : chainAfter(null, flowId, this.uuid);
+        this.causationId = chain.causationId;
+        this.correlationId = chain.correlationId;
+        if (!this.traceparent)
+            this.traceparent = traceparent();
+        return this;
+    }
+    labelText() {
+        return this.#label ?? this.label;
+    }
+    getBusinessPayload() {
+        const payload = {};
+        for (const [key, value] of Object.entries(this)) {
+            if (!ENVELOPE.has(key))
+                payload[key] = value;
+        }
+        return payload;
+    }
+    hasSameBusinessPayload(other) {
+        if (this.name !== other.name)
+            return false;
+        return (safeJsonStringify(this.getBusinessPayload()) ===
+            safeJsonStringify(other.getBusinessPayload()));
+    }
+    asJSON(pretty = false) {
+        const body = {
+            ...this.getBusinessPayload(),
+            name: this.name,
+            id: this.uuid,
+            label: this.#label ?? { default: this.label },
+            created_at: this.createdAt,
+            entity_type: this.entityType,
+            entity_id: this.aggregateId ?? "",
+            correlation_id: this.correlationId,
+            causation_id: this.causationId,
+            entity_version: this.entityVersion,
+            sequence: this.sequence,
+        };
+        if (this.traceparent)
+            body.traceparent = this.traceparent;
+        return safeJsonStringify(body, pretty);
+    }
+}
+function readLabel(label) {
+    if (typeof label === "string")
+        return { text: label, label: null };
+    if (label && typeof label === "object" && !Array.isArray(label)) {
+        const record = {};
+        for (const [key, value] of Object.entries(label)) {
+            if (typeof value === "string")
+                record[key] = value;
+        }
+        return { text: textOf(record), label: record };
+    }
+    return { text: "", label: null };
+}
+function asString(value, fallback) {
+    return typeof value === "string" ? value : fallback;
+}

package/dist/domain/events/index.d.ts

@@ -0,0 +1,8 @@
+export * from "../../domain/connectivity/events";
+export * from "../../domain/events/catalog";
+export * from "../../domain/events/chain";
+export * from "../../domain/events/domain_event";
+export * from "../../domain/events/integration_event";
+export * from "../../domain/events/label";
+export * from "../../domain/print/events";
+export * from "../../domain/webview/events";

package/dist/domain/events/index.js

@@ -0,0 +1,8 @@
+export * from "../../domain/connectivity/events";
+export * from "../../domain/events/catalog";
+export * from "../../domain/events/chain";
+export * from "../../domain/events/domain_event";
+export * from "../../domain/events/integration_event";
+export * from "../../domain/events/label";
+export * from "../../domain/print/events";
+export * from "../../domain/webview/events";

package/dist/domain/events/integration_event.d.ts

@@ -0,0 +1,103 @@
+import { DomainEvent, EEventStatus } from "./domain_event";
+type Constructor<T> = new (...args: any[]) => T;
+export declare function IntegrationEventMixin<TBase extends Constructor<DomainEvent>>(Base: TBase): {
+    new (...args: any[]): {
+        status: EEventStatus;
+        attempts: number;
+        errorMessage: string | null;
+        acknowledgedAt: string | null;
+        failedAt: string | null;
+        readonly requiresNetwork: boolean;
+        markAsProcessing(): /*elided*/ any;
+        markAsAcknowledged(): /*elided*/ any;
+        markAsFailed(errorMessage: string): /*elided*/ any;
+        markAsCancelled(): /*elided*/ any;
+        retry(): /*elided*/ any;
+        cloneWithReset(): /*elided*/ any;
+        get isPending(): boolean;
+        get isProcessing(): boolean;
+        get isAcknowledged(): boolean;
+        get isFailed(): boolean;
+        get isCancelled(): boolean;
+        readonly name: string;
+        readonly label: string;
+        readonly uuid: string;
+        readonly createdAt: string;
+        aggregateId: string | null;
+        sourceId: string | null;
+        correlationId: string | null;
+        causationId: string | null;
+        entityType: string;
+        entityVersion: number | null;
+        traceparent: string | null;
+        sequence: number;
+        "__#private@#label": Record<string, string> | null;
+        withAggregateId(aggregateId: string): /*elided*/ any;
+        withSourceId(sourceId: string): /*elided*/ any;
+        withCorrelationId(correlationId: string): /*elided*/ any;
+        withCausationId(causationId: string | null): /*elided*/ any;
+        withEntityType(entityType: string): /*elided*/ any;
+        withSequence(sequence: number): /*elided*/ any;
+        causedBy(cause: DomainEvent): /*elided*/ any;
+        applyChain(flowId: string): /*elided*/ any;
+        labelText(): import("./label").LabelText;
+        getBusinessPayload(): Record<string, unknown>;
+        hasSameBusinessPayload(other: DomainEvent): boolean;
+        asJSON(pretty?: boolean): string;
+        fromJSON(json: any): /*elided*/ any;
+        clone(): /*elided*/ any;
+        equals(other: any): boolean;
+    };
+} & TBase;
+declare const IntegrationEvent_base: {
+    new (...args: any[]): {
+        status: EEventStatus;
+        attempts: number;
+        errorMessage: string | null;
+        acknowledgedAt: string | null;
+        failedAt: string | null;
+        readonly requiresNetwork: boolean;
+        markAsProcessing(): /*elided*/ any;
+        markAsAcknowledged(): /*elided*/ any;
+        markAsFailed(errorMessage: string): /*elided*/ any;
+        markAsCancelled(): /*elided*/ any;
+        retry(): /*elided*/ any;
+        cloneWithReset(): /*elided*/ any;
+        get isPending(): boolean;
+        get isProcessing(): boolean;
+        get isAcknowledged(): boolean;
+        get isFailed(): boolean;
+        get isCancelled(): boolean;
+        readonly name: string;
+        readonly label: string;
+        readonly uuid: string;
+        readonly createdAt: string;
+        aggregateId: string | null;
+        sourceId: string | null;
+        correlationId: string | null;
+        causationId: string | null;
+        entityType: string;
+        entityVersion: number | null;
+        traceparent: string | null;
+        sequence: number;
+        "__#private@#label": Record<string, string> | null;
+        withAggregateId(aggregateId: string): /*elided*/ any;
+        withSourceId(sourceId: string): /*elided*/ any;
+        withCorrelationId(correlationId: string): /*elided*/ any;
+        withCausationId(causationId: string | null): /*elided*/ any;
+        withEntityType(entityType: string): /*elided*/ any;
+        withSequence(sequence: number): /*elided*/ any;
+        causedBy(cause: DomainEvent): /*elided*/ any;
+        applyChain(flowId: string): /*elided*/ any;
+        labelText(): import("./label").LabelText;
+        getBusinessPayload(): Record<string, unknown>;
+        hasSameBusinessPayload(other: DomainEvent): boolean;
+        asJSON(pretty?: boolean): string;
+        fromJSON(json: any): /*elided*/ any;
+        clone(): /*elided*/ any;
+        equals(other: any): boolean;
+    };
+} & typeof DomainEvent;
+export declare class IntegrationEvent extends IntegrationEvent_base {
+}
+export {};

package/dist/domain/events/integration_event.js

@@ -0,0 +1,72 @@
+import { generateUUID } from "../../infrastructure/database/utils";
+import { DomainEvent, EEventStatus } from "./domain_event";
+export function IntegrationEventMixin(Base) {
+    return class extends Base {
+        // TS2545: a mixin class must declare a rest constructor.
+        // eslint-disable-next-line @typescript-eslint/no-useless-constructor
+        constructor(...args) {
+            super(...args);
+        }
+        status = EEventStatus.PENDING;
+        attempts = 0;
+        errorMessage = null;
+        acknowledgedAt = null;
+        failedAt = null;
+        requiresNetwork = false;
+        markAsProcessing() {
+            this.status = EEventStatus.PROCESSING;
+            this.attempts += 1;
+            return this;
+        }
+        markAsAcknowledged() {
+            this.status = EEventStatus.ACKNOWLEDGED;
+            this.acknowledgedAt = new Date().toISOString();
+            return this;
+        }
+        markAsFailed(errorMessage) {
+            this.status = EEventStatus.FAILED;
+            this.errorMessage = errorMessage;
+            this.failedAt = new Date().toISOString();
+            return this;
+        }
+        markAsCancelled() {
+            this.status = EEventStatus.CANCELLED;
+            return this;
+        }
+        retry() {
+            this.status = EEventStatus.PENDING;
+            this.errorMessage = null;
+            return this;
+        }
+        cloneWithReset() {
+            const clone = this.constructor.from(this);
+            Object.assign(clone, {
+                uuid: generateUUID(),
+                createdAt: new Date().toISOString(),
+                status: EEventStatus.PENDING,
+                attempts: 0,
+                errorMessage: null,
+                acknowledgedAt: null,
+                failedAt: null,
+            });
+            return clone;
+        }
+        get isPending() {
+            return this.status === EEventStatus.PENDING;
+        }
+        get isProcessing() {
+            return this.status === EEventStatus.PROCESSING;
+        }
+        get isAcknowledged() {
+            return this.status === EEventStatus.ACKNOWLEDGED;
+        }
+        get isFailed() {
+            return this.status === EEventStatus.FAILED;
+        }
+        get isCancelled() {
+            return this.status === EEventStatus.CANCELLED;
+        }
+    };
+}
+export class IntegrationEvent extends IntegrationEventMixin(DomainEvent) {
+}

package/dist/domain/events/label.d.ts

@@ -0,0 +1,2 @@
+export type LabelText = string | Readonly<Record<string, string>>;
+export declare function textOf(label: LabelText | null | undefined, locale?: string | null): string;

package/dist/domain/events/label.js

@@ -0,0 +1,26 @@
+export function textOf(label, locale) {
+    if (typeof label === "string")
+        return label;
+    if (!label)
+        return "";
+    const table = label;
+    if (locale) {
+        const exact = table[locale];
+        if (exact)
+            return exact;
+        const language = locale.split("-")[0];
+        if (language && language !== locale && table[language])
+            return table[language];
+        if (table.default)
+            return table.default;
+    }
+    if (table.es)
+        return table.es;
+    if (table.default)
+        return table.default;
+    for (const value of Object.values(table)) {
+        if (value)
+            return value;
+    }
+    return "";
+}

package/dist/domain/index.d.ts

@@ -1,7 +1,6 @@
 export * from "../domain/connectivity";
 export * from "../domain/database";
 export * from "../domain/entity";
-export * from "../domain/event_sourcing";
 export * from "../domain/events";
 export * from "../domain/icon";
 export * from "../domain/receipt";

package/dist/domain/index.js

@@ -1,7 +1,6 @@
 export * from "../domain/connectivity";
 export * from "../domain/database";
 export * from "../domain/entity";
-export * from "../domain/event_sourcing";
 export * from "../domain/events";
 export * from "../domain/icon";
 export * from "../domain/receipt";

package/dist/domain/print/events.d.ts

@@ -1,10 +1,14 @@
-import { DomainEvent } from "../../domain/event_sourcing";
-export declare class PrintImageRequestedEvent extends DomainEvent {
+import { IntegrationEvent } from "../../domain/events/integration_event";
+export declare class PrintImageRequestedEvent extends IntegrationEvent {
     static readonly name = "common.print.v1.image_requested";
-    static readonly label = "Imprimiendo...";
+    static readonly label: {
+        es: string;
+        en: string;
+    };
     static readonly requiresNetwork = false;
+    static readonly ui = true;
     readonly name = "common.print.v1.image_requested";
-    readonly label = "Imprimiendo...";
+    readonly label: string;
     readonly requiresNetwork = false;
     imageBase64: string;
     width: number;

package/dist/domain/print/events.js

@@ -1,10 +1,15 @@
-import { DomainEvent } from "../../domain/event_sourcing";
-export class PrintImageRequestedEvent extends DomainEvent {
+import { IntegrationEvent } from "../../domain/events/integration_event";
+import { textOf } from "../../domain/events/label";
+export class PrintImageRequestedEvent extends IntegrationEvent {
     static name = "common.print.v1.image_requested";
-    static label = "Imprimiendo...";
+    static label = {
+        es: "Imprimiendo...",
+        en: "Printing...",
+    };
     static requiresNetwork = false;
+    static ui = true;
     name = PrintImageRequestedEvent.name;
-    label = PrintImageRequestedEvent.label;
+    label = textOf(PrintImageRequestedEvent.label);
     requiresNetwork = PrintImageRequestedEvent.requiresNetwork;
     imageBase64 = "";
     width = 0;

package/dist/domain/repositories/document_store.d.ts

@@ -0,0 +1,33 @@
+import { type CompiledCriteria } from "../../domain/database/criteria_sql";
+import { type IntegrationEvent } from "../../domain/events/integration_event";
+export declare enum StoreMode {
+    LOCAL = "local",
+    RELAY = "relay"
+}
+export type ColumnValue = string | number | null;
+export interface DocumentRow {
+    uuid: string;
+    version: number;
+    data: string;
+    columns: Record<string, ColumnValue>;
+}
+export interface DocumentStore {
+    readonly table: string;
+    read(uuid: string): Promise<DocumentRow | null>;
+    readSync?(uuid: string): DocumentRow | null;
+    insert(row: DocumentRow): Promise<void>;
+    update(row: DocumentRow, expectedVersion: number): Promise<boolean>;
+    upsert(row: DocumentRow): Promise<void>;
+    remove(uuid: string): Promise<void>;
+    list(): Promise<DocumentRow[]>;
+    selectMatching(compiled: CompiledCriteria): Promise<DocumentRow[]>;
+    hasColumn(name: string): boolean;
+    selectBy(column: string, value: ColumnValue): Promise<DocumentRow[]>;
+    selectBySync?(column: string, value: ColumnValue): DocumentRow[];
+    inTransaction(): boolean;
+    transaction<T>(work: () => Promise<T>): Promise<T>;
+}
+export interface Outbox {
+    save(event: IntegrationEvent): Promise<void>;
+    schedule(): void;
+}

package/dist/domain/repositories/document_store.js

@@ -0,0 +1,5 @@
+export var StoreMode;
+(function (StoreMode) {
+    StoreMode["LOCAL"] = "local";
+    StoreMode["RELAY"] = "relay";
+})(StoreMode || (StoreMode = {}));

package/dist/domain/repositories/hooks.d.ts

@@ -0,0 +1,23 @@
+import { type Entity } from "../../domain/entity/entity";
+import { type AnyClass } from "../../domain/entity/relations";
+export interface Hook<T extends Entity = Entity> {
+    after_read?(record: T): void | Promise<void>;
+    before_save?(record: T): void | Promise<void>;
+    after_save?(record: T): void | Promise<void>;
+    before_create?(record: T): void | Promise<void>;
+    after_create?(record: T): void | Promise<void>;
+    before_update?(record: T): void | Promise<void>;
+    after_update?(record: T): void | Promise<void>;
+    before_remove?(record: T): void | Promise<void>;
+    after_remove?(record: T): void | Promise<void>;
+    after_search?(records: readonly T[]): void | Promise<void>;
+}
+export type HookMoment = "after_read" | "before_save" | "after_save" | "before_create" | "after_create" | "before_update" | "after_update" | "before_remove" | "after_remove" | "after_search";
+export declare class Hooks {
+    private readonly pairs;
+    on<T extends Entity>(type: AnyClass<T>, hook: Hook<T>): this;
+    of(record: Entity): Hook[];
+    ofType(type: AnyClass<Entity>): Hook[];
+}
+export declare function fireHooks(hooks: readonly Hook[], moment: Exclude<HookMoment, "after_search">, record: Entity): Promise<void>;
+export declare function fireSearch(hooks: readonly Hook[], records: readonly Entity[]): Promise<void>;

package/dist/domain/repositories/hooks.js

@@ -0,0 +1,32 @@
+export class Hooks {
+    pairs = [];
+    on(type, hook) {
+        this.pairs.push({ type: type, hook });
+        return this;
+    }
+    of(record) {
+        return this.pairs
+            .filter((pair) => record instanceof pair.type)
+            .map((pair) => pair.hook);
+    }
+    ofType(type) {
+        return this.pairs
+            .filter((pair) => type === pair.type ||
+            type.prototype instanceof
+                pair.type)
+            .map((pair) => pair.hook);
+    }
+}
+export async function fireHooks(hooks, moment, record) {
+    for (const hook of hooks) {
+        const method = hook[moment];
+        if (method)
+            await method.call(hook, record);
+    }
+}
+export async function fireSearch(hooks, records) {
+    for (const hook of hooks) {
+        if (hook.after_search)
+            await hook.after_search(records);
+    }
+}

package/dist/domain/repositories/index.d.ts

@@ -0,0 +1,4 @@
+export * from "../../domain/repositories/catalog";
+export * from "../../domain/repositories/document_store";
+export * from "../../domain/repositories/hooks";
+export * from "../../domain/repositories/repository";

package/dist/domain/repositories/index.js

@@ -0,0 +1,4 @@
+export * from "../../domain/repositories/catalog";
+export * from "../../domain/repositories/document_store";
+export * from "../../domain/repositories/hooks";
+export * from "../../domain/repositories/repository";

package/dist/domain/{database → repositories}/repository.d.ts

@@ -1,12 +1,18 @@
+import { type DocumentCriteria } from "../../domain/database/criteria";
 import { Entity, ERemoteState, RemoteEntity } from "../../domain/entity/entity";
-import { EntityCollection, ICriteria, RemoteEntityCollection } from "../../domain/entity/entity_collection";
+import { EntityCollection, RemoteEntityCollection } from "../../domain/entity/entity_collection";
+import { type IntegrationEvent } from "../../domain/events/integration_event";
 export interface IRepository<T extends Entity, C extends EntityCollection<T>> {
-    save(entity: T | T[] | C): Promise<void>;
+    save(entity: T | T[] | C, options?: {
+        deliver?: boolean;
+    }): Promise<void>;
+    upsert(entity: T | T[] | C): Promise<void>;
     remove(entity: T | T[]): Promise<void>;
+    publish(events: readonly IntegrationEvent[]): Promise<void>;
     findById(id: string): Promise<T | null>;
     findByIds(ids: string[]): Promise<C>;
     findAll(): Promise<C>;
-    findByCriteria(criteria: ICriteria<T>[]): Promise<C>;
+    findByCriteria(criteria: DocumentCriteria<T>): Promise<C>;
     findByIdSync?(id: string): T | null;
     findByIdsSync?(ids: string[]): C;
 }

package/dist/domain/settings.d.ts

@@ -1,5 +1,8 @@
 export declare enum ECommonSetting {
-    SELECTED_PRINTER = "common.selected_printer"
+    SELECTED_PRINTER = "common.selected_printer",
+    UI_QUEUE = "ui.queue",
+    UI_CRON = "ui.cron",
+    UI_DEVICE = "ui.device"
 }
 export interface ISetting {
     key: string;

package/dist/domain/settings.js

@@ -1,4 +1,7 @@
 export var ECommonSetting;
 (function (ECommonSetting) {
     ECommonSetting["SELECTED_PRINTER"] = "common.selected_printer";
+    ECommonSetting["UI_QUEUE"] = "ui.queue";
+    ECommonSetting["UI_CRON"] = "ui.cron";
+    ECommonSetting["UI_DEVICE"] = "ui.device";
 })(ECommonSetting || (ECommonSetting = {}));