@sincpro/mobile 0.1.0

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

@@ -0,0 +1,109 @@
+import { type DomainEvent, type DomainEventClass, type EventData } from "../../domain/event_sourcing/domain_event";
+import { IValueObject, ValueObject } from "./value_object";
+export declare enum ERemoteState {
+    SYNCED = "SYNCED",
+    PENDING = "PENDING",
+    FAILED = "FAILED"
+}
+export interface IRemote {
+    remoteId?: number;
+    remoteRef?: string;
+    remoteState: ERemoteState;
+    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 {
+    uuid: string;
+    name?: string;
+    eventIds: string[];
+    equals(other: IEntity): boolean;
+    clone(): this;
+}
+export interface IEntityRemote extends IEntity, IRemote {
+}
+export declare class Entity extends ValueObject implements IEntity {
+    uuid: string;
+    name?: string;
+    eventIds: string[];
+    protected _domainEventsV2: DomainEvent[];
+    protected _correlationIdV2: string | null;
+    protected readonly REPOSITORY: string | null;
+    protected constructor();
+    static obj<T>(data?: Partial<T>): T;
+    /**
+     * Resolves domain events collection in runtime from repository.
+     * Uses @mapped decorator to automatically query events by eventIds.
+     * Returns fresh data on every access (no cache).
+     */
+    get events(): DomainEvent[];
+    /**
+     * Reloads this entity from database using its uuid.
+     * Returns a fresh copy with latest data from persistence layer.
+     *
+     * @returns Fresh entity instance from database
+     * @throws DomainValidationError if REPOSITORY is not defined in subclass
+     *
+     * @example
+     * const customer = await customerRepo.findById(uuid);
+     * // ... some time passes ...
+     * const refreshed = await customer.reload();
+     */
+    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>;
+}
+export declare class RemoteEntity extends Entity implements IRemote {
+    remoteId?: number;
+    remoteRef?: string;
+    remoteState: ERemoteState;
+    protected constructor();
+    static fromRemoteDTO(data: any): RemoteEntity;
+    fromRemoteDTO(data: any): this;
+    /**
+     * Reloads this entity from database using its remoteId.
+     * Returns a fresh copy with latest data from persistence layer.
+     * Uses remote lookup (findByRemoteIdSync) instead of uuid.
+     *
+     * @returns Fresh entity instance from database
+     * @throws DomainValidationError if REPOSITORY is not defined in subclass
+     *
+     * @example
+     * const product = await productRepo.findByRemoteId(123);
+     * // ... some time passes ...
+     * const refreshed = await product.reloadByRemoteId();
+     */
+    reloadByRemoteId(): Promise<this>;
+    mergeWithRemote(data: this): void;
+    remotePayload(): any;
+    markAsSynced(): void;
+    markAsPending(): void;
+    markAsFailed(): void;
+}

package/dist/domain/entity/entity.js

@@ -0,0 +1,246 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { ECommonRepository } from "../../domain/repositories";
+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 { ValueObject } from "./value_object";
+export var ERemoteState;
+(function (ERemoteState) {
+    ERemoteState["SYNCED"] = "SYNCED";
+    ERemoteState["PENDING"] = "PENDING";
+    ERemoteState["FAILED"] = "FAILED";
+})(ERemoteState || (ERemoteState = {}));
+export class Entity extends ValueObject {
+    uuid;
+    name;
+    eventIds = [];
+    _domainEventsV2 = [];
+    _correlationIdV2 = null;
+    REPOSITORY = null;
+    constructor() {
+        super();
+    }
+    static obj(data) {
+        const instance = new this();
+        if (data) {
+            Object.assign(instance, data);
+        }
+        if (!instance.uuid) {
+            instance.uuid = generateUUID();
+        }
+        return instance;
+    }
+    /**
+     * Resolves domain events collection in runtime from repository.
+     * Uses @mapped decorator to automatically query events by eventIds.
+     * Returns fresh data on every access (no cache).
+     */
+    get events() {
+        return [];
+    }
+    /**
+     * Reloads this entity from database using its uuid.
+     * Returns a fresh copy with latest data from persistence layer.
+     *
+     * @returns Fresh entity instance from database
+     * @throws DomainValidationError if REPOSITORY is not defined in subclass
+     *
+     * @example
+     * const customer = await customerRepo.findById(uuid);
+     * // ... some time passes ...
+     * const refreshed = await customer.reload();
+     */
+    async reload() {
+        if (!this.REPOSITORY) {
+            throw new DomainValidationError(`Entity ${this.constructor.name} does not have a repository defined for refreshing`);
+        }
+        return (await resolveEntity(this.REPOSITORY, this.uuid));
+    }
+    equals(other) {
+        if (!other)
+            return false;
+        if (!this.uuid || !other.uuid)
+            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;
+        }
+        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;
+    }
+    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);
+        }
+    }
+    clearDomainEvents() {
+        this._domainEventsV2 = [];
+        this._correlationIdV2 = null;
+    }
+    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}'`);
+        }
+        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}`);
+        }
+    }
+    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();
+    }
+    async publishEventWithSync(EventClass, selector) {
+        const event = EventClass.create(selector(this));
+        event.withAggregateId(this.uuid);
+        this._domainEventsV2.push(event);
+        await this.publishAllDomainEventsSync();
+    }
+}
+__decorate([
+    mapped(ECommonRepository.DOMAIN_EVENT, "eventIds"),
+    __metadata("design:type", Array),
+    __metadata("design:paramtypes", [])
+], Entity.prototype, "events", null);
+export class RemoteEntity extends Entity {
+    remoteId;
+    remoteRef;
+    remoteState = ERemoteState.PENDING;
+    constructor() {
+        super();
+    }
+    static fromRemoteDTO(data) {
+        throw new Error(`${this.name}.fromRemoteDTO debe ser implementado`);
+    }
+    fromRemoteDTO(data) {
+        return this.constructor.fromRemoteDTO(data);
+    }
+    /**
+     * Reloads this entity from database using its remoteId.
+     * Returns a fresh copy with latest data from persistence layer.
+     * Uses remote lookup (findByRemoteIdSync) instead of uuid.
+     *
+     * @returns Fresh entity instance from database
+     * @throws DomainValidationError if REPOSITORY is not defined in subclass
+     *
+     * @example
+     * const product = await productRepo.findByRemoteId(123);
+     * // ... some time passes ...
+     * const refreshed = await product.reloadByRemoteId();
+     */
+    async reloadByRemoteId() {
+        if (!this.REPOSITORY) {
+            throw new DomainValidationError(`Entity ${this.constructor.name} does not have a repository defined for refreshing`);
+        }
+        return (await resolveEntity(this.REPOSITORY, this.remoteId, true));
+    }
+    mergeWithRemote(data) {
+        const preservedUuid = this.uuid;
+        const preservedEventIds = this.eventIds;
+        Object.assign(this, data);
+        this.uuid = preservedUuid;
+        this.eventIds = preservedEventIds;
+    }
+    remotePayload() {
+        throw new Error(`${this.name}.remotePayload debe ser implementado`);
+    }
+    markAsSynced() {
+        this.remoteState = ERemoteState.SYNCED;
+    }
+    markAsPending() {
+        this.remoteState = ERemoteState.PENDING;
+    }
+    markAsFailed() {
+        this.remoteState = ERemoteState.FAILED;
+    }
+}