@sincpro/mobile 0.4.4 → 1.0.0

package/dist/domain/entity/entity_collection.js

@@ -1,12 +1,11 @@
+import { rowsMatching, } from "../../domain/database/criteria";
 import { generateUUID } from "../../infrastructure/database/utils";
 import { loggerQueueProcessor } from "../../infrastructure/logger";
-import { EventBus } from "../../infrastructure/workers";
 import { convertToArray } from "../../tools/utils/collections";
 import { safeJsonStringify } from "../../tools/utils/serializer";
 import { ValueObject } from "./value_object";
 /**
- * Type-safe, immutable collection for Entity aggregates with event sourcing support.
- * Implements IEventSourced for domain event publishing and provides functional operations.
+ * Collection of aggregates. Records integration events for the set and offers the list operations.
  *
  * @example
  * const collection = new EntityCollection([priceList1, priceList2]);
@@ -22,15 +21,15 @@ import { ValueObject } from "./value_object";
  * const union = collection1.union(collection2);
  * const common = collection1.intersect(collection2);
  *
- * // Event sourcing
- * await collection.publishEventWith(PRICE_LISTS_SYNCED, pl => ({ id: pl.remoteId, name: pl.name }));
+ * // Record an integration event for the set
+ * collection.record(PriceListsSynced, { count: collection.length });
  */
 export class EntityCollection extends ValueObject {
     uuid;
     eventIds = [];
     entities = [];
-    _domainEventsV2 = [];
-    _correlationIdV2 = null;
+    _recordedEvents = [];
+    _correlationId = null;
     constructor(entities = []) {
         super();
         this.uuid = generateUUID();
@@ -457,100 +456,43 @@ export class EntityCollection extends ValueObject {
     toMapByUuid() {
         return this.toMap((e) => e.uuid);
     }
-    // ============================================
-    // V2 METHODS - DomainEvent class-based system
-    // ============================================
-    addDomainEvent(EventClass, payload) {
-        const event = EventClass.create(payload);
-        const existingEvent = this._domainEventsV2.find((e) => e.hasSameBusinessPayload(event));
-        if (existingEvent) {
-            loggerQueueProcessor.warn(`EntityCollection - V2 Event: '${event.name}' with identical payload already exists. Skipping duplicate.`);
-            return existingEvent.uuid;
-        }
-        if (!this._correlationIdV2) {
-            this._correlationIdV2 = generateUUID();
-        }
-        event
-            .withAggregateId(this.uuid)
-            .withCorrelationId(this._correlationIdV2)
-            .withSequence(this._domainEventsV2.length + 1);
-        this._domainEventsV2.push(event);
-        this.eventIds.push(event.uuid);
-        for (const entity of this.entities) {
-            entity.eventIds.push(event.uuid);
-        }
-        return event.uuid;
+    record(EventClass, payload) {
+        return this.stageDomainEvent(EventClass.create(payload));
     }
-    addDomainEventWithEntities(EventClass) {
-        const event = EventClass.create({
+    recordEntities(EventClass) {
+        return this.stageDomainEvent(EventClass.create({
             records: this.entities.map((e) => e.asJSON()),
-        });
-        const existingEvent = this._domainEventsV2.find((e) => e.hasSameBusinessPayload(event));
+        }));
+    }
+    stageDomainEvent(event) {
+        const existingEvent = this._recordedEvents.find((e) => e.hasSameBusinessPayload(event));
         if (existingEvent) {
-            loggerQueueProcessor.warn(`EntityCollection - V2 Event: '${event.name}' with identical payload already exists. Skipping duplicate.`);
+            loggerQueueProcessor.warn(`EntityCollection - Event '${event.name}' is already recorded with the same payload. Skipping.`);
             return existingEvent.uuid;
         }
-        if (!this._correlationIdV2) {
-            this._correlationIdV2 = generateUUID();
+        if (!this._correlationId) {
+            this._correlationId = generateUUID();
         }
         event
+            .withEntityType(this.constructor.name)
             .withAggregateId(this.uuid)
-            .withCorrelationId(this._correlationIdV2)
-            .withSequence(this._domainEventsV2.length + 1);
-        this._domainEventsV2.push(event);
+            .withSequence(this._recordedEvents.length + 1)
+            .applyChain(this._correlationId);
+        this._recordedEvents.push(event);
         this.eventIds.push(event.uuid);
         for (const entity of this.entities) {
             entity.eventIds.push(event.uuid);
         }
         return event.uuid;
     }
-    getDomainEvents() {
-        return this._domainEventsV2.map((e) => e.clone());
+    recordedEvents() {
+        return this._recordedEvents.map((event) => event.clone());
     }
-    clearDomainEvents() {
-        this._domainEventsV2 = [];
-        this._correlationIdV2 = null;
-    }
-    async publishAllDomainEvents() {
-        const events = this._domainEventsV2;
-        for (const event of events) {
-            await EventBus.publish(event);
-        }
-        this.clearDomainEvents();
-    }
-    async publishAllDomainEventsSync() {
-        const events = this._domainEventsV2;
-        const errors = [];
-        for (const event of events) {
-            try {
-                await EventBus.publishSync(event);
-            }
-            catch (error) {
-                loggerQueueProcessor.warn(`EntityCollection - Error publishing V2 domain event '${event.name}': ${error.message}`);
-                errors.push(error);
-            }
-        }
-        this.clearDomainEvents();
-        if (errors.length > 0) {
-            const errorList = errors.map((e) => `  - ${e.message}`).join("\n");
-            throw new Error(`Errors occurred while publishing V2 domain events synchronously:\n${errorList}`);
-        }
-    }
-    async publishDomainEvent(EventClass, payload) {
-        this.addDomainEvent(EventClass, payload);
-        await this.publishAllDomainEvents();
-    }
-    async publishDomainEventSync(EventClass, payload) {
-        this.addDomainEvent(EventClass, payload);
-        await this.publishAllDomainEventsSync();
-    }
-    async publishDomainEventWithEntities(EventClass) {
-        this.addDomainEventWithEntities(EventClass);
-        await this.publishAllDomainEvents();
-    }
-    async publishDomainEventWithEntitiesSync(EventClass) {
-        this.addDomainEventWithEntities(EventClass);
-        await this.publishAllDomainEventsSync();
+    pullEvents() {
+        const events = this._recordedEvents;
+        this._recordedEvents = [];
+        this._correlationId = null;
+        return events;
     }
     /**
      * Serializes collection as array of entity JSONs.
@@ -566,43 +508,10 @@ export class EntityCollection extends ValueObject {
         return this.entities.map((e) => e.asJSON(pretty));
     }
     /**
-     * Filters entities using criteria array. All criteria must match (AND).
-     * @example
-     * const filtered = collection.findByCriteria([
-     *   { field: 'customerId', operator: '=', value: 123 },
-     *   { field: 'state', operator: 'in', value: ['draft', 'posted'] }
-     * ]);
+     * The entities that answer a criteria. The filter is `selection`.
      */
     findByCriteria(criteria) {
-        const filtered = this.filter((entity) => {
-            return criteria.every((c) => {
-                const fieldValue = entity[c.field];
-                switch (c.operator) {
-                    case "=":
-                        return fieldValue === c.value;
-                    case "!=":
-                        return fieldValue !== c.value;
-                    case "in":
-                        return Array.isArray(c.value) && c.value.includes(fieldValue);
-                    case "not_in":
-                        return Array.isArray(c.value) && !c.value.includes(fieldValue);
-                    case "like":
-                        return (typeof fieldValue === "string" &&
-                            fieldValue.toLowerCase().includes(String(c.value).toLowerCase()));
-                    case ">":
-                        return fieldValue > c.value;
-                    case "<":
-                        return fieldValue < c.value;
-                    case ">=":
-                        return fieldValue >= c.value;
-                    case "<=":
-                        return fieldValue <= c.value;
-                    default:
-                        return false;
-                }
-            });
-        });
-        return this.createInstance(filtered.toArray());
+        return this.createInstance(rowsMatching(this.toArray(), criteria));
     }
     /**
      * Deserializes collection from array of entity JSONs.

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

@@ -1,3 +1,8 @@
+export * from "../../domain/entity/change_tracking";
+export * from "../../domain/entity/checks";
 export * from "../../domain/entity/entity";
 export * from "../../domain/entity/entity_collection";
+export * from "../../domain/entity/reconcile";
+export * from "../../domain/entity/relations";
 export * from "../../domain/entity/value_object";
+export * from "../../domain/entity/values";

package/dist/domain/entity/index.js

@@ -1,3 +1,8 @@
+export * from "../../domain/entity/change_tracking";
+export * from "../../domain/entity/checks";
 export * from "../../domain/entity/entity";
 export * from "../../domain/entity/entity_collection";
+export * from "../../domain/entity/reconcile";
+export * from "../../domain/entity/relations";
 export * from "../../domain/entity/value_object";
+export * from "../../domain/entity/values";

package/dist/domain/entity/reconcile.d.ts

@@ -0,0 +1,7 @@
+import { RemoteEntity } from "./entity";
+export type ReconciliationWrite = "insert" | "replace" | "keep";
+export interface Reconciliation<T extends RemoteEntity> {
+    entity: T;
+    write: ReconciliationWrite;
+}
+export declare function reconcile<T extends RemoteEntity>(local: T | null, incoming: T): Reconciliation<T>;

package/dist/domain/entity/reconcile.js

@@ -0,0 +1,12 @@
+import { acceptNextWrite } from "./remote_sync";
+export function reconcile(local, incoming) {
+    if (!local) {
+        acceptNextWrite(incoming, incoming.remoteId);
+        return { entity: incoming, write: "insert" };
+    }
+    if (local.isDirty)
+        return { entity: local, write: "keep" };
+    local.mergeWithRemote(incoming);
+    acceptNextWrite(local, incoming.remoteId ?? local.remoteId);
+    return { entity: local, write: "replace" };
+}

package/dist/domain/entity/relations.d.ts

@@ -0,0 +1,27 @@
+export declare enum RelationCascade {
+    SAVE_AND_REMOVE = "save_and_remove",
+    SAVE = "save",
+    UPDATE = "update",
+    REMOVE = "remove",
+    UPDATE_AND_REMOVE = "update_and_remove"
+}
+export interface Relation {
+    field: string;
+    type: AnyClass<{
+        uuid: string;
+    }>;
+    cascade: RelationCascade;
+}
+export type AnyClass<T> = Function & {
+    prototype: T;
+};
+export declare function relation(type: AnyClass<{
+    uuid: string;
+}>, cascade?: RelationCascade): (target: object, propertyKey: string) => void;
+export declare function relations(entity: object): Relation[];
+export declare function relationWrites(relation: Relation): boolean;
+export declare function relationPersists(relation: Relation, isNew: boolean): boolean;
+export declare function relationRemoves(relation: Relation): boolean;
+export declare function heldEntities(value: unknown): {
+    uuid: string;
+}[];

package/dist/domain/entity/relations.js

@@ -0,0 +1,69 @@
+const RELATION = Symbol("relation");
+export var RelationCascade;
+(function (RelationCascade) {
+    RelationCascade["SAVE_AND_REMOVE"] = "save_and_remove";
+    RelationCascade["SAVE"] = "save";
+    RelationCascade["UPDATE"] = "update";
+    RelationCascade["REMOVE"] = "remove";
+    RelationCascade["UPDATE_AND_REMOVE"] = "update_and_remove";
+})(RelationCascade || (RelationCascade = {}));
+export function relation(type, cascade = RelationCascade.SAVE_AND_REMOVE) {
+    return function (target, propertyKey) {
+        const ctor = target.constructor;
+        const relationsOfCtor = ctor[RELATION] ?? [];
+        if (!relationsOfCtor.some((item) => item.field === propertyKey)) {
+            relationsOfCtor.push({ field: propertyKey, type, cascade });
+        }
+        ctor[RELATION] = relationsOfCtor;
+    };
+}
+export function relations(entity) {
+    const found = [];
+    let ctor = entity.constructor;
+    while (ctor && ctor !== Function.prototype) {
+        const declared = ctor[RELATION];
+        if (declared)
+            found.push(...declared);
+        ctor = Object.getPrototypeOf(ctor);
+    }
+    return found;
+}
+export function relationWrites(relation) {
+    return relation.cascade !== RelationCascade.REMOVE;
+}
+export function relationPersists(relation, isNew) {
+    switch (relation.cascade) {
+        case RelationCascade.SAVE:
+        case RelationCascade.SAVE_AND_REMOVE:
+            return true;
+        case RelationCascade.UPDATE:
+        case RelationCascade.UPDATE_AND_REMOVE:
+            return !isNew;
+        case RelationCascade.REMOVE:
+            return false;
+    }
+}
+export function relationRemoves(relation) {
+    switch (relation.cascade) {
+        case RelationCascade.SAVE_AND_REMOVE:
+        case RelationCascade.UPDATE_AND_REMOVE:
+        case RelationCascade.REMOVE:
+            return true;
+        case RelationCascade.SAVE:
+        case RelationCascade.UPDATE:
+            return false;
+    }
+}
+export function heldEntities(value) {
+    if (Array.isArray(value))
+        return value.filter(isEntity);
+    if (isEntity(value))
+        return [value];
+    return [];
+}
+function isEntity(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "uuid" in value &&
+        typeof value.uuid === "string");
+}

package/dist/domain/entity/remote_sync.d.ts

@@ -0,0 +1,4 @@
+import { RemoteEntity } from "./entity";
+export declare function acceptNextWrite(entity: RemoteEntity, remoteId?: number): void;
+export declare function takeAcceptedWrite(entity: RemoteEntity): boolean;
+export declare function applyAcknowledgement(entity: RemoteEntity, remoteId?: number): void;

package/dist/domain/entity/remote_sync.js

@@ -0,0 +1,19 @@
+import { ERemoteState } from "./entity";
+const acceptedWrites = new WeakSet();
+export function acceptNextWrite(entity, remoteId) {
+    if (remoteId !== undefined)
+        entity.remoteId = remoteId;
+    acceptedWrites.add(entity);
+}
+export function takeAcceptedWrite(entity) {
+    if (!acceptedWrites.has(entity))
+        return false;
+    acceptedWrites.delete(entity);
+    return true;
+}
+export function applyAcknowledgement(entity, remoteId) {
+    if (remoteId !== undefined)
+        entity.remoteId = remoteId;
+    entity.ackedVersion = entity.version;
+    entity.remoteState = ERemoteState.SYNCED;
+}

package/dist/domain/entity/values.d.ts

@@ -0,0 +1,6 @@
+export interface ValueRule<T> {
+    readonly name: string;
+    holds(value: T): boolean;
+    parse(value: T): T;
+}
+export declare function valueRule<T>(name: string, holds: (value: T) => boolean): ValueRule<T>;

package/dist/domain/entity/values.js

@@ -0,0 +1,13 @@
+import { DomainValidationError } from "../../exceptions";
+export function valueRule(name, holds) {
+    return {
+        name,
+        holds,
+        parse(value) {
+            if (!holds(value)) {
+                throw new DomainValidationError(`${name} does not hold`);
+            }
+            return value;
+        },
+    };
+}

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

@@ -0,0 +1,29 @@
+import { IntegrationEvent } from "../../domain/events/integration_event";
+import { ISetting } from "../../domain/settings";
+export declare class ActivateDomainEvent extends IntegrationEvent {
+    static readonly name = "common.domain.activate";
+    static readonly label = "Activar dominio";
+    static readonly requiresNetwork = false;
+    readonly name = "common.domain.activate";
+    readonly label = "Activar dominio";
+    readonly requiresNetwork = false;
+    domain: string;
+}
+export declare class DeactivateDomainEvent extends IntegrationEvent {
+    static readonly name = "common.domain.deactivate";
+    static readonly label = "Desactivar dominio";
+    static readonly requiresNetwork = false;
+    readonly name = "common.domain.deactivate";
+    readonly label = "Desactivar dominio";
+    readonly requiresNetwork = false;
+    domain: string;
+}
+export declare class NewAppSettingsEvent extends IntegrationEvent {
+    static readonly name = "common.settings.added";
+    static readonly label = "Nuevas configuraciones";
+    static readonly requiresNetwork = false;
+    readonly name = "common.settings.added";
+    readonly label = "Nuevas configuraciones";
+    readonly requiresNetwork = false;
+    settings: ISetting[];
+}

package/dist/domain/{events.js → events/catalog.js}

@@ -1,10 +1,6 @@
-import { DomainEvent } from "../domain/event_sourcing/domain_event";
-export * from "../domain/connectivity/events";
-export * from "../domain/event_sourcing/event";
-export * from "../domain/print/events";
-export * from "../domain/webview/events";
-export class ActivateDomainEvent extends DomainEvent {
-    static name = "common.domain.v2.activate";
+import { IntegrationEvent } from "../../domain/events/integration_event";
+export class ActivateDomainEvent extends IntegrationEvent {
+    static name = "common.domain.activate";
     static label = "Activar dominio";
     static requiresNetwork = false;
     name = ActivateDomainEvent.name;
@@ -12,8 +8,8 @@ export class ActivateDomainEvent extends DomainEvent {
     requiresNetwork = ActivateDomainEvent.requiresNetwork;
     domain = "";
 }
-export class DeactivateDomainEvent extends DomainEvent {
-    static name = "common.domain.v2.deactivate";
+export class DeactivateDomainEvent extends IntegrationEvent {
+    static name = "common.domain.deactivate";
     static label = "Desactivar dominio";
     static requiresNetwork = false;
     name = DeactivateDomainEvent.name;
@@ -21,8 +17,8 @@ export class DeactivateDomainEvent extends DomainEvent {
     requiresNetwork = DeactivateDomainEvent.requiresNetwork;
     domain = "";
 }
-export class NewAppSettingsEvent extends DomainEvent {
-    static name = "common.settings.v2.added_new_settings";
+export class NewAppSettingsEvent extends IntegrationEvent {
+    static name = "common.settings.added";
     static label = "Nuevas configuraciones";
     static requiresNetwork = false;
     name = NewAppSettingsEvent.name;

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

@@ -0,0 +1,5 @@
+export type Chain = {
+    causationId: string | null;
+    correlationId: string;
+};
+export declare function chainAfter(causeId: string | null, causeCorrelation: string | null, ownId: string): Chain;

package/dist/domain/events/chain.js

@@ -0,0 +1,6 @@
+export function chainAfter(causeId, causeCorrelation, ownId) {
+    return {
+        causationId: causeId,
+        correlationId: causeCorrelation || causeId || ownId,
+    };
+}

package/dist/domain/{event_sourcing → events}/domain_event.d.ts

@@ -1,4 +1,5 @@
 import { ValueObject } from "../../domain/entity/value_object";
+import { type LabelText } from "./label";
 export type HandlerFn<T> = (payload: T) => Promise<void>;
 export type EventName = string;
 export interface IEventHandler<Payload = any> {
@@ -12,47 +13,44 @@ export declare enum EEventStatus {
     FAILED = "FAILED",
     CANCELLED = "CANCELLED"
 }
-type InfrastructureFields = "name" | "label" | "requiresNetwork" | "uuid" | "createdAt" | "status" | "attempts" | "errorMessage" | "acknowledgedAt" | "failedAt" | "aggregateId" | "sourceId" | "correlationId" | "sequence";
+declare const ENVELOPE_FIELDS: readonly ["name", "label", "requiresNetwork", "uuid", "createdAt", "status", "attempts", "errorMessage", "acknowledgedAt", "failedAt", "aggregateId", "sourceId", "correlationId", "causationId", "entityType", "entityVersion", "traceparent", "sequence"];
+type EnvelopeFields = (typeof ENVELOPE_FIELDS)[number];
 export type DomainEventClass<T extends DomainEvent> = {
-    new (): T;
+    new (...args: any[]): T;
     create(data?: EventData<T>): T;
 };
-export type EventData<T extends DomainEvent> = Omit<Partial<T>, InfrastructureFields>;
+export type EventData<T extends DomainEvent> = Omit<Partial<T>, EnvelopeFields>;
 export declare class DomainEvent extends ValueObject {
+    #private;
+    constructor(..._args: any[]);
     readonly name: string;
     readonly label: string;
-    readonly requiresNetwork: boolean;
     readonly uuid: string;
     readonly createdAt: string;
-    status: EEventStatus;
-    attempts: number;
-    errorMessage: string | null;
-    acknowledgedAt: string | null;
-    failedAt: string | null;
     aggregateId: string | null;
     sourceId: string | null;
     correlationId: string | null;
+    causationId: string | null;
+    entityType: string;
+    entityVersion: number | null;
+    traceparent: string | null;
     sequence: number;
     private static sanitize;
-    static create<T extends DomainEvent>(this: new () => T, data?: EventData<T>): T;
+    static create<T extends DomainEvent>(this: new (...args: any[]) => T, data?: EventData<T>): T;
     static from<T extends DomainEvent>(this: new () => T, event: DomainEvent): T;
-    cloneWithReset(): this;
+    static fromJSON<T>(this: new () => T, json: unknown): T;
+    private static read;
     withAggregateId(aggregateId: string): this;
     withSourceId(sourceId: string): this;
     withCorrelationId(correlationId: string): this;
+    withCausationId(causationId: string | null): this;
+    withEntityType(entityType: string): this;
     withSequence(sequence: number): this;
+    causedBy(cause: DomainEvent): this;
+    applyChain(flowId: string): this;
+    labelText(): LabelText;
     getBusinessPayload(): Record<string, unknown>;
     hasSameBusinessPayload(other: DomainEvent): boolean;
-    markAsProcessing(): this;
-    markAsAcknowledged(): this;
-    markAsFailed(errorMessage: string): this;
-    markAsCancelled(): this;
-    retry(): this;
-    get isPending(): boolean;
-    get isProcessing(): boolean;
-    get isAcknowledged(): boolean;
-    get isFailed(): boolean;
-    get isCancelled(): boolean;
-    get isPartOfTransaction(): boolean;
+    asJSON(pretty?: boolean): string;
 }
 export {};