@sincpro/mobile 0.4.4 → 1.0.0

package/dist/domain/entity/checks.js

@@ -0,0 +1,82 @@
+import { heldEntities, relations } from "../../domain/entity/relations";
+import { ChecksFailed, DomainValidationError } from "../../exceptions";
+const CHECK = Symbol("check");
+export function check(watches) {
+    return function (_target, _key, descriptor) {
+        descriptor.value[CHECK] = watches;
+        return descriptor;
+    };
+}
+function watchedNames(watches, entity) {
+    const names = [];
+    const proxy = new Proxy(entity, {
+        get(target, prop, receiver) {
+            if (typeof prop === "string" && prop !== "constructor")
+                names.push(prop);
+            return Reflect.get(target, prop, receiver);
+        },
+    });
+    watches(proxy);
+    return names;
+}
+function rulesOf(entity) {
+    const seen = new Set();
+    const rules = [];
+    let proto = Object.getPrototypeOf(entity);
+    while (proto && proto !== Object.prototype) {
+        for (const key of Object.getOwnPropertyNames(proto)) {
+            if (seen.has(key))
+                continue;
+            const value = proto[key];
+            const watches = value?.[CHECK];
+            if (!watches || typeof value !== "function")
+                continue;
+            seen.add(key);
+            rules.push({ name: key, watches, run: value.bind(entity) });
+        }
+        proto = Object.getPrototypeOf(proto);
+    }
+    return rules;
+}
+function failureOf(rule, run) {
+    try {
+        run();
+        return null;
+    }
+    catch (error) {
+        if (error instanceof DomainValidationError) {
+            return { rule, message: error.message };
+        }
+        throw error;
+    }
+}
+export function checkWarnings(entity, touched) {
+    return collect(entity, [], new Set(touched));
+}
+export function assertChecks(entity) {
+    const failures = collect(entity, [], null);
+    if (failures.length > 0)
+        throw new ChecksFailed(failures);
+}
+function collect(entity, path, touched) {
+    const failures = [];
+    for (const rule of rulesOf(entity)) {
+        if (touched) {
+            const fields = watchedNames(rule.watches, entity);
+            const reached = fields.some((field) => touched.has(field)) ||
+                (path.length > 0 && touched.has(path[0]));
+            if (!reached)
+                continue;
+        }
+        const failure = failureOf(rule.name, rule.run);
+        if (failure)
+            failures.push({ ...failure, path });
+    }
+    const record = entity;
+    for (const relation of relations(entity)) {
+        heldEntities(record[relation.field]).forEach((child, index) => {
+            failures.push(...collect(child, [...path, relation.field, String(index)], touched));
+        });
+    }
+    return failures;
+}

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

@@ -1,4 +1,5 @@
-import { type DomainEvent, type DomainEventClass, type EventData } from "../../domain/event_sourcing/domain_event";
+import { type DomainEvent, type DomainEventClass, type EventData } from "../../domain/events/domain_event";
+import { IntegrationEvent } from "../../domain/events/integration_event";
 import { IValueObject, ValueObject } from "./value_object";
 export declare enum ERemoteState {
     SYNCED = "SYNCED",
@@ -9,31 +10,32 @@ export interface IRemote {
     remoteId?: number;
     remoteRef?: string;
     remoteState: ERemoteState;
+    ackedVersion: number;
+    readonly isDirty: boolean;
     fromRemoteDTO: (data: any) => this;
     mergeWithRemote: (data: this) => void;
     remotePayload(): any;
 }
-export interface IEventSourced {
-    addDomainEvent<T extends DomainEvent>(EventClass: DomainEventClass<T>, payload?: EventData<T>): string;
-    addDomainEventWithEntity<T extends DomainEvent>(EventClass: DomainEventClass<T>): string;
-    getDomainEvents(): readonly DomainEvent[];
-    clearDomainEvents(): void;
-    publishAllDomainEvents(): Promise<void>;
-    publishAllDomainEventsSync(): Promise<void>;
-    publishDomainEvent<T extends DomainEvent>(EventClass: DomainEventClass<T>, payload: Partial<T>): Promise<void>;
-    publishDomainEventSync<T extends DomainEvent>(EventClass: DomainEventClass<T>, payload: Partial<T>): Promise<void>;
-    publishDomainEventWithEntity<T extends DomainEvent>(EventClass: DomainEventClass<T>): Promise<void>;
-    publishDomainEventWithEntitySync<T extends DomainEvent>(EventClass: DomainEventClass<T>): Promise<void>;
-    publishEventWith<T extends DomainEvent>(EventClass: DomainEventClass<T>, selector: (entity: this) => Partial<T>): Promise<void>;
-    publishEventWithSync<T extends DomainEvent>(EventClass: DomainEventClass<T>, selector: (entity: this) => Partial<T>): Promise<void>;
-    copyDomainEventsFrom(source: Entity): void;
-}
-export interface IEntity extends IEventSourced, IValueObject {
+export interface IEntity extends IValueObject {
     uuid: string;
     name?: string;
     eventIds: string[];
+    createdAt: string;
+    updatedAt: string | null;
+    version: number;
+    readonly isNew: boolean;
     equals(other: IEntity): boolean;
     clone(): this;
+    record<C extends DomainEventClass<DomainEvent>>(EventClass: C, payload?: EventData<InstanceType<C>>): string;
+    recordEntity<C extends DomainEventClass<DomainEvent>>(EventClass: C): string;
+    recordedEvents(): readonly DomainEvent[];
+    pullEvents(): DomainEvent[];
+    releaseDeliverable(): IntegrationEvent[];
+    restoreRecorded(events: readonly DomainEvent[]): void;
+    copyRecordedFrom(source: Entity): void;
+    replaceRecorded(events: readonly DomainEvent[]): void;
+    noteHeld(): void;
+    heldIds(field: string): readonly string[];
 }
 export interface IEntityRemote extends IEntity, IRemote {
 }
@@ -41,11 +43,16 @@ export declare class Entity extends ValueObject implements IEntity {
     uuid: string;
     name?: string;
     eventIds: string[];
-    protected _domainEventsV2: DomainEvent[];
-    protected _correlationIdV2: string | null;
+    createdAt: string;
+    updatedAt: string | null;
+    version: number;
+    protected _recordedEvents: DomainEvent[];
+    protected _correlationId: string | null;
+    private _held;
     protected readonly REPOSITORY: string | null;
     protected constructor();
     static obj<T>(data?: Partial<T>): T;
+    get isNew(): boolean;
     /**
      * Resolves domain events collection in runtime from repository.
      * Uses @mapped decorator to automatically query events by eventIds.
@@ -66,24 +73,23 @@ export declare class Entity extends ValueObject implements IEntity {
      */
     reload(): Promise<this>;
     equals(other: any): boolean;
-    addDomainEvent<T extends DomainEvent>(EventClass: DomainEventClass<T>, payload?: EventData<T>): string;
-    addDomainEventWithEntity<T extends DomainEvent>(EventClass: DomainEventClass<T>): string;
-    getDomainEvents(): readonly DomainEvent[];
-    copyDomainEventsFrom(source: Entity): void;
-    clearDomainEvents(): void;
-    publishAllDomainEvents(): Promise<void>;
-    publishAllDomainEventsSync(): Promise<void>;
-    publishDomainEvent<T extends DomainEvent>(EventClass: DomainEventClass<T>, payload: Partial<T>): Promise<void>;
-    publishDomainEventSync<T extends DomainEvent>(EventClass: DomainEventClass<T>, payload: Partial<T>): Promise<void>;
-    publishDomainEventWithEntity<T extends DomainEvent>(EventClass: DomainEventClass<T>): Promise<void>;
-    publishDomainEventWithEntitySync<T extends DomainEvent>(EventClass: DomainEventClass<T>): Promise<void>;
-    publishEventWith<T extends DomainEvent>(EventClass: DomainEventClass<T>, selector: (entity: this) => Partial<T>): Promise<void>;
-    publishEventWithSync<T extends DomainEvent>(EventClass: DomainEventClass<T>, selector: (entity: this) => Partial<T>): Promise<void>;
+    record<C extends DomainEventClass<DomainEvent>>(EventClass: C, payload?: EventData<InstanceType<C>>): string;
+    recordEntity<C extends DomainEventClass<DomainEvent>>(EventClass: C): string;
+    recordedEvents(): readonly DomainEvent[];
+    pullEvents(): DomainEvent[];
+    releaseDeliverable(): IntegrationEvent[];
+    restoreRecorded(events: readonly DomainEvent[]): void;
+    replaceRecorded(events: readonly DomainEvent[]): void;
+    copyRecordedFrom(source: Entity): void;
+    noteHeld(): void;
+    heldIds(field: string): readonly string[];
+    private stageDomainEvent;
 }
 export declare class RemoteEntity extends Entity implements IRemote {
     remoteId?: number;
     remoteRef?: string;
     remoteState: ERemoteState;
+    ackedVersion: number;
     protected constructor();
     static fromRemoteDTO(data: any): RemoteEntity;
     fromRemoteDTO(data: any): this;
@@ -101,6 +107,7 @@ export declare class RemoteEntity extends Entity implements IRemote {
      * const refreshed = await product.reloadByRemoteId();
      */
     reloadByRemoteId(): Promise<this>;
+    get isDirty(): boolean;
     mergeWithRemote(data: this): void;
     remotePayload(): any;
     markAsSynced(): void;

package/dist/domain/entity/entity.js

@@ -7,12 +7,13 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-import { ECommonRepository } from "../../domain/repositories";
+import { IntegrationEvent } from "../../domain/events/integration_event";
+import { ECommonRepository } from "../../domain/repositories/catalog";
 import { DomainValidationError } from "../../exceptions";
 import { mapped, resolveEntity } from "../../infrastructure/database";
 import { generateUUID } from "../../infrastructure/database/utils";
 import { loggerQueueProcessor } from "../../infrastructure/logger";
-import { EventBus } from "../../infrastructure/workers";
+import { heldEntities, relations } from "./relations";
 import { ValueObject } from "./value_object";
 export var ERemoteState;
 (function (ERemoteState) {
@@ -24,8 +25,12 @@ export class Entity extends ValueObject {
     uuid;
     name;
     eventIds = [];
-    _domainEventsV2 = [];
-    _correlationIdV2 = null;
+    createdAt = "";
+    updatedAt = null;
+    version = 0;
+    _recordedEvents = [];
+    _correlationId = null;
+    _held = {};
     REPOSITORY = null;
     constructor() {
         super();
@@ -38,8 +43,17 @@ export class Entity extends ValueObject {
         if (!instance.uuid) {
             instance.uuid = generateUUID();
         }
+        if (!instance.createdAt) {
+            instance.createdAt = new Date().toISOString();
+        }
+        if (typeof instance.version !== "number") {
+            instance.version = 0;
+        }
         return instance;
     }
+    get isNew() {
+        return this.version === 0;
+    }
     /**
      * Resolves domain events collection in runtime from repository.
      * Uses @mapped decorator to automatically query events by eventIds.
@@ -73,118 +87,81 @@ export class Entity extends ValueObject {
             return false;
         return this.uuid === other.uuid;
     }
-    addDomainEvent(EventClass, payload) {
-        const event = EventClass.create(payload);
-        const existingEvent = this._domainEventsV2.find((e) => e.hasSameBusinessPayload(event));
-        if (existingEvent) {
-            loggerQueueProcessor.warn(`class ${this.constructor.name} - V2 Event: '${event.name}' with identical payload already exists for entity '${this.uuid}'. Skipping duplicate.`);
-            return existingEvent.uuid;
+    record(EventClass, payload) {
+        return this.stageDomainEvent(EventClass.create(payload));
+    }
+    recordEntity(EventClass) {
+        return this.stageDomainEvent(EventClass.create({ record: this }));
+    }
+    recordedEvents() {
+        return this._recordedEvents.map((event) => event.clone());
+    }
+    pullEvents() {
+        const events = this._recordedEvents;
+        this._recordedEvents = [];
+        this._correlationId = null;
+        return events;
+    }
+    releaseDeliverable() {
+        const kept = [];
+        const released = [];
+        for (const event of this._recordedEvents) {
+            if (event instanceof IntegrationEvent)
+                released.push(event);
+            else
+                kept.push(event);
         }
-        if (!this._correlationIdV2) {
-            this._correlationIdV2 = generateUUID();
+        this._recordedEvents = kept;
+        if (kept.length === 0)
+            this._correlationId = null;
+        if (released.length > 0) {
+            const gone = new Set(released.map((event) => event.uuid));
+            this.eventIds = this.eventIds.filter((id) => !gone.has(id));
         }
-        event
-            .withAggregateId(this.uuid)
-            .withCorrelationId(this._correlationIdV2)
-            .withSequence(this._domainEventsV2.length + 1);
-        this._domainEventsV2.push(event);
-        this.eventIds.push(event.uuid);
-        return event.uuid;
+        return released;
     }
-    addDomainEventWithEntity(EventClass) {
-        const event = EventClass.create({ record: this });
-        const existingEvent = this._domainEventsV2.find((e) => e.hasSameBusinessPayload(event));
-        if (existingEvent) {
-            loggerQueueProcessor.warn(`class ${this.constructor.name} - V2 Event: '${event.name}' with identical payload already exists for entity '${this.uuid}'. 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);
-        return event.uuid;
-    }
-    getDomainEvents() {
-        return this._domainEventsV2.map((e) => e.clone());
-    }
-    copyDomainEventsFrom(source) {
-        for (const event of source.getDomainEvents()) {
-            const clonedEvent = event
-                .clone()
-                .withAggregateId(this.uuid)
-                .withCorrelationId(this._correlationIdV2 || generateUUID())
-                .withSequence(this._domainEventsV2.length + 1);
-            this._domainEventsV2.push(clonedEvent);
-            this.eventIds.push(clonedEvent.uuid);
+    restoreRecorded(events) {
+        for (const event of events) {
+            this._recordedEvents.push(event);
+            if (!this.eventIds.includes(event.uuid))
+                this.eventIds.push(event.uuid);
         }
     }
-    clearDomainEvents() {
-        this._domainEventsV2 = [];
-        this._correlationIdV2 = null;
+    replaceRecorded(events) {
+        this._recordedEvents = [...events];
     }
-    async publishAllDomainEvents() {
-        const events = this._domainEventsV2;
-        if (events.length > 1) {
-            loggerQueueProcessor.info(`class ${this.constructor.name} - Publishing total [${events.length}] V2 domain events for entity '${this.uuid}'`);
+    copyRecordedFrom(source) {
+        for (const event of source.recordedEvents()) {
+            this.stageDomainEvent(event.clone());
         }
-        for (const event of events) {
-            await EventBus.publish(event);
-        }
-        this.clearDomainEvents();
     }
-    async publishAllDomainEventsSync() {
-        const events = this._domainEventsV2;
-        if (events.length > 1) {
-            loggerQueueProcessor.info(`class ${this.constructor.name} - Publishing total [${events.length}] V2 domain events for entity '${this.uuid}'`);
-        }
-        const errors = [];
-        for (const event of events) {
-            try {
-                await EventBus.publishSync(event);
-            }
-            catch (error) {
-                loggerQueueProcessor.warn(`class ${this.constructor.name} - Error publishing V2 domain event '${event.name}' for entity '${this.uuid}': ${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}`);
+    noteHeld() {
+        const held = {};
+        for (const relation of relations(this)) {
+            held[relation.field] = heldEntities(this[relation.field]).map((child) => child.uuid);
         }
+        this._held = held;
     }
-    async publishDomainEvent(EventClass, payload) {
-        this.addDomainEvent(EventClass, payload);
-        await this.publishAllDomainEvents();
-    }
-    async publishDomainEventSync(EventClass, payload) {
-        this.addDomainEvent(EventClass, payload);
-        await this.publishAllDomainEventsSync();
-    }
-    async publishDomainEventWithEntity(EventClass) {
-        this.addDomainEventWithEntity(EventClass);
-        await this.publishAllDomainEvents();
-    }
-    async publishDomainEventWithEntitySync(EventClass) {
-        this.addDomainEventWithEntity(EventClass);
-        await this.publishAllDomainEventsSync();
-    }
-    async publishEventWith(EventClass, selector) {
-        const event = EventClass.create(selector(this));
-        event.withAggregateId(this.uuid);
-        this._domainEventsV2.push(event);
-        await this.publishAllDomainEvents();
+    heldIds(field) {
+        return this._held[field] ?? [];
     }
-    async publishEventWithSync(EventClass, selector) {
-        const event = EventClass.create(selector(this));
-        event.withAggregateId(this.uuid);
-        this._domainEventsV2.push(event);
-        await this.publishAllDomainEventsSync();
+    stageDomainEvent(event) {
+        const existingEvent = this._recordedEvents.find((recorded) => recorded.hasSameBusinessPayload(event));
+        if (existingEvent) {
+            loggerQueueProcessor.warn(`class ${this.constructor.name} - Event '${event.name}' is already recorded for '${this.uuid}' with the same payload. Skipping.`);
+            return existingEvent.uuid;
+        }
+        if (!this._correlationId) {
+            this._correlationId = generateUUID();
+        }
+        event
+            .withEntityType(this.constructor.name)
+            .withAggregateId(this.uuid)
+            .withSequence(this._recordedEvents.length + 1)
+            .applyChain(this._correlationId);
+        this._recordedEvents.push(event);
+        this.eventIds.push(event.uuid);
+        return event.uuid;
     }
 }
 __decorate([
@@ -196,6 +173,7 @@ export class RemoteEntity extends Entity {
     remoteId;
     remoteRef;
     remoteState = ERemoteState.PENDING;
+    ackedVersion = 0;
     constructor() {
         super();
     }
@@ -224,12 +202,23 @@ export class RemoteEntity extends Entity {
         }
         return (await resolveEntity(this.REPOSITORY, this.remoteId, true));
     }
+    get isDirty() {
+        return this.version === 0 || this.version !== this.ackedVersion;
+    }
     mergeWithRemote(data) {
         const preservedUuid = this.uuid;
         const preservedEventIds = this.eventIds;
+        const preservedVersion = this.version;
+        const preservedAcked = this.ackedVersion;
+        const preservedState = this.remoteState;
+        const preservedCreatedAt = this.createdAt;
         Object.assign(this, data);
         this.uuid = preservedUuid;
         this.eventIds = preservedEventIds;
+        this.version = preservedVersion;
+        this.ackedVersion = preservedAcked;
+        this.remoteState = preservedState;
+        this.createdAt = preservedCreatedAt;
     }
     remotePayload() {
         throw new Error(`${this.name}.remotePayload debe ser implementado`);

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

@@ -1,15 +1,10 @@
-import { DomainEvent, type DomainEventClass } from "../../domain/event_sourcing/domain_event";
+import { type DocumentCriteria } from "../../domain/database/criteria";
+import { type DomainEventClass, type EventData } from "../../domain/events/domain_event";
+import { type IntegrationEvent } from "../../domain/events/integration_event";
 import { type Entity, type RemoteEntity } from "./entity";
 import { ValueObject } from "./value_object";
-export type CriteriaOperator = "=" | "!=" | "in" | "not_in" | "like" | ">" | "<" | ">=" | "<=";
-export interface ICriteria<T = any> {
-    field: keyof T;
-    operator: CriteriaOperator;
-    value: any;
-}
 /**
- * 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]);
@@ -25,15 +20,15 @@ export interface ICriteria<T = any> {
  * 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 declare class EntityCollection<T extends Entity> extends ValueObject {
     uuid: string;
     eventIds: string[];
     private entities;
-    private _domainEventsV2;
-    private _correlationIdV2;
+    private _recordedEvents;
+    private _correlationId;
     constructor(entities?: T[]);
     /** Factory method for creating instances - override in subclasses */
     protected createInstance(entities: T[]): this;
@@ -236,16 +231,11 @@ export declare class EntityCollection<T extends Entity> extends ValueObject {
      * const entity = byUuid.get("abc-123"); // Fast lookup
      */
     toMapByUuid(): Map<string, T>;
-    addDomainEvent<E extends DomainEvent>(EventClass: DomainEventClass<E>, payload: Partial<E>): string;
-    addDomainEventWithEntities<E extends DomainEvent>(EventClass: DomainEventClass<E>): string;
-    getDomainEvents(): readonly DomainEvent[];
-    clearDomainEvents(): void;
-    publishAllDomainEvents(): Promise<void>;
-    publishAllDomainEventsSync(): Promise<void>;
-    publishDomainEvent<E extends DomainEvent>(EventClass: DomainEventClass<E>, payload: Partial<E>): Promise<void>;
-    publishDomainEventSync<E extends DomainEvent>(EventClass: DomainEventClass<E>, payload: Partial<E>): Promise<void>;
-    publishDomainEventWithEntities<E extends DomainEvent>(EventClass: DomainEventClass<E>): Promise<void>;
-    publishDomainEventWithEntitiesSync<E extends DomainEvent>(EventClass: DomainEventClass<E>): Promise<void>;
+    record<C extends DomainEventClass<IntegrationEvent>>(EventClass: C, payload: EventData<InstanceType<C>>): string;
+    recordEntities<C extends DomainEventClass<IntegrationEvent>>(EventClass: C): string;
+    private stageDomainEvent;
+    recordedEvents(): readonly IntegrationEvent[];
+    pullEvents(): IntegrationEvent[];
     /**
      * Serializes collection as array of entity JSONs.
      * Collection is a manager, not an entity, so it serializes as pure entity list.
@@ -255,14 +245,9 @@ export declare class EntityCollection<T extends Entity> extends ValueObject {
      */
     asJSON(pretty?: boolean): string;
     /**
-     * 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: ICriteria<T>[]): this;
+    findByCriteria(criteria: DocumentCriteria<T>): this;
     /**
      * Deserializes collection from array of entity JSONs.
      * Collection is a manager, not an entity, so it deserializes from pure entity list.