wsp-ms-core 1.0.76 → 1.0.78-beta

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { Pool, RowDataPacket, PoolConnection } from 'mysql2/promise';
 import { RequestHandler, ErrorRequestHandler } from 'express';
+import { Pool, RowDataPacket, PoolConnection } from 'mysql2/promise';
 
 declare abstract class ValueObject<TPrimitive = unknown> {
     protected readonly _value: TPrimitive;
@@ -12,27 +12,14 @@ declare abstract class ValueObject<TPrimitive = unknown> {
     equals(vo?: ValueObject<TPrimitive> | null): boolean;
 }
 
-type UUIDVersion = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8;
-interface UUIDValidationOptions {
-    /** Versiones permitidas (por defecto: 1–8) */
-    allowedVersions?: UUIDVersion[];
-    /** Permitir el NIL UUID "00000000-0000-0000-0000-000000000000" (por defecto: false) */
-    allowNil?: boolean;
-}
-declare class UUID extends ValueObject<string> {
-    static readonly NIL = "00000000-0000-0000-0000-000000000000";
-    private constructor();
-    protected validate(uuid: string): void;
-    toPrimitives(): Record<string, unknown>;
-    static create(uuid?: string): UUID;
-    static version(uuid: string): UUIDVersion | undefined;
-    static isNil(uuid: string): boolean;
-    static isRFCStyle(uuid: string): boolean;
-    static isValid(uuid: string, opts?: UUIDValidationOptions): boolean;
-}
-
 declare class DateTime extends ValueObject<string> {
     static readonly DEFAULT_FORMAT: string;
+    static readonly FORMAT: string;
+    static readonly FORMAT_Y_M = "Y-M";
+    static readonly FORMAT_Y_M_D = "Y-M-D";
+    static readonly FORMAT_Y_M_D_H_m_s = "Y-M-D H:M:S";
+    static readonly FORMAT_D_M_Y = "D-M-Y";
+    private static readonly FORMATS;
     private readonly _dt;
     private static fromLuxon;
     private static toUtcFormat;
@@ -58,25 +45,57 @@ declare class DateTime extends ValueObject<string> {
     get second(): number;
     getMonthName(locale?: string): string;
     getWeekdayName(locale?: string): string;
+    format(format: string): string;
     toPrimitives(): Record<string, unknown>;
     static create(input?: string | number): DateTime;
     static now(): DateTime;
 }
 
-declare class DomainEventStatus extends ValueObject<string> {
+declare abstract class BaseEvent {
+    private readonly _version;
+    private readonly _type;
+    private readonly _payload;
+    private readonly _occurredAt;
+    protected constructor(version: string, type: string, payload: Record<string, unknown>);
+    get version(): string;
+    get type(): string;
+    get payload(): Record<string, unknown>;
+    get ocurredAt(): DateTime;
+}
+
+type UUIDVersion = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8;
+interface UUIDValidationOptions {
+    /** Versiones permitidas (por defecto: 1–8) */
+    allowedVersions?: UUIDVersion[];
+    /** Permitir el NIL UUID "00000000-0000-0000-0000-000000000000" (por defecto: false) */
+    allowNil?: boolean;
+}
+declare class UUID extends ValueObject<string> {
+    static readonly NIL = "00000000-0000-0000-0000-000000000000";
+    private constructor();
+    protected validate(uuid: string): void;
+    toPrimitives(): Record<string, unknown>;
+    static create(uuid?: string): UUID;
+    static version(uuid: string): UUIDVersion | undefined;
+    static isNil(uuid: string): boolean;
+    static isRFCStyle(uuid: string): boolean;
+    static isValid(uuid: string, opts?: UUIDValidationOptions): boolean;
+}
+
+declare class ProcessStatus extends ValueObject<string> {
     static readonly SUPPORTED: readonly string[];
-    static readonly PENDING: DomainEventStatus;
-    static readonly PROCESSING: DomainEventStatus;
-    static readonly PROCESSED: DomainEventStatus;
-    static readonly FAILED: DomainEventStatus;
-    static readonly DEAD: DomainEventStatus;
+    static readonly PENDING: ProcessStatus;
+    static readonly PROCESSING: ProcessStatus;
+    static readonly PROCESSED: ProcessStatus;
+    static readonly FAILED: ProcessStatus;
+    static readonly DEAD: ProcessStatus;
     private constructor();
     protected validate(value: string): void;
     toPrimitives(): Record<string, unknown>;
-    static create(status: string): DomainEventStatus;
+    static create(status: string): ProcessStatus;
 }
 
-declare class DomainEvent {
+declare class OutboxRecord {
     private readonly _eventUuid;
     private readonly _eventType;
     private readonly _tenantUuid;
@@ -90,7 +109,7 @@ declare class DomainEvent {
     private _publishedAt;
     private _lastAttempt;
     private readonly _createdAt;
-    protected constructor(eventUuid: UUID, eventType: string, tenantUuid: UUID, aggregateUuid: UUID, aggregateType: string, topic: string, payload: string, status: DomainEventStatus, attempts: number, errorMessage: string | undefined, publishedAt: DateTime | undefined, lastAttempt: DateTime | undefined, createdAt: DateTime);
+    protected constructor(eventUuid: UUID, eventType: string, tenantUuid: UUID, aggregateUuid: UUID, aggregateType: string, topic: string, payload: string, status: ProcessStatus, attempts: number, errorMessage: string | undefined, publishedAt: DateTime | undefined, lastAttempt: DateTime | undefined, createdAt: DateTime);
     get eventUuid(): UUID;
     get tenantUuid(): UUID;
     get aggregateUuid(): UUID;
@@ -98,7 +117,7 @@ declare class DomainEvent {
     get eventType(): string;
     get topic(): string;
     get payload(): string;
-    get status(): DomainEventStatus;
+    get status(): ProcessStatus;
     get attempts(): number;
     get errorMessage(): string | undefined;
     get publishedAt(): DateTime | undefined;
@@ -109,7 +128,7 @@ declare class DomainEvent {
     markProcessing(): void;
     markWithError(error: string): void;
     toPrimitives(): Record<string, unknown>;
-    static reconstitute(data: Record<string, any>): DomainEvent;
+    static reconstitute(data: Record<string, any>): OutboxRecord;
 }
 
 interface BaseEntity {
@@ -120,26 +139,21 @@ interface BaseEntity {
 }
 declare abstract class DomainEntity<T extends BaseEntity> {
     protected readonly props: T;
-    protected _events: DomainEvent[];
+    protected _events: OutboxRecord[];
     protected constructor(props: T);
-    protected recordEvent(event: DomainEvent): void;
+    protected recordEvent(event: OutboxRecord): void;
     protected touch(): void;
     get uuid(): UUID;
     get createdAt(): DateTime;
     get updatedAt(): DateTime;
     get deletedAt(): DateTime | undefined;
     get isDeleted(): boolean;
-    pullEvents(): DomainEvent[];
+    pullEvents(): OutboxRecord[];
     abstract equals(entity?: DomainEntity<T>): boolean;
     abstract toProps(): T;
     abstract toPrimitives(): Record<string, unknown>;
 }
 
-declare abstract class DomainError extends Error {
-    readonly type: string;
-    protected constructor(type: string, message?: string);
-}
-
 declare abstract class BaseObject<T = unknown> {
     protected readonly props: T;
     protected constructor(props: T);
@@ -147,6 +161,11 @@ declare abstract class BaseObject<T = unknown> {
     abstract toPrimitives(): Record<string, unknown>;
 }
 
+declare abstract class DomainError extends Error {
+    readonly type: string;
+    protected constructor(type: string, message?: string);
+}
+
 declare class FatalError extends DomainError {
     constructor(type: string, message?: string);
 }
@@ -160,6 +179,102 @@ declare class UsageError extends DomainError {
     constructor(type: string, vars?: Record<string, any>);
 }
 
+declare class DomainEvent extends BaseEvent {
+    protected readonly _aggregateUuid: UUID;
+    protected readonly _aggregateType: string;
+    protected constructor(version: string, type: string, payload: Record<string, unknown>, aggregateUuid: UUID, aggregateType: string);
+    get aggregateUuid(): UUID;
+    get aggregateType(): string;
+}
+
+declare class PaymentGateway extends ValueObject<string> {
+    static readonly SUPPORTED: readonly string[];
+    private static readonly EXTERNALS;
+    static readonly MERCADOPAGO: PaymentGateway;
+    static readonly HANDY: PaymentGateway;
+    static readonly WONA_DEBIT: PaymentGateway;
+    static readonly WONA_CARD: PaymentGateway;
+    static readonly WONA_CASH: PaymentGateway;
+    static readonly WONA_TRANSFER: PaymentGateway;
+    static readonly WONA_MERCADOPAGO: PaymentGateway;
+    private constructor();
+    protected validate(value: string): void;
+    isExternal(): boolean;
+    toPrimitives(): Record<string, unknown>;
+    static create(gateway: string): PaymentGateway;
+}
+
+declare class PaymentStatus extends ValueObject<string> {
+    static readonly SUPPORTED: readonly string[];
+    static readonly DONE: PaymentStatus;
+    static readonly PENDING: PaymentStatus;
+    static readonly IN_PROGRESS: PaymentStatus;
+    static readonly FAILED: PaymentStatus;
+    static readonly CANCELED: PaymentStatus;
+    static readonly HOLD: PaymentStatus;
+    static readonly PENDING_REFUND: PaymentStatus;
+    static readonly REFUNDED: PaymentStatus;
+    private constructor();
+    protected validate(status: string): void;
+    get isDone(): boolean;
+    get isPending(): boolean;
+    get isInProgress(): boolean;
+    get isFailed(): boolean;
+    get isCanceled(): boolean;
+    get isHold(): boolean;
+    get isPendingRefund(): boolean;
+    get isRefunded(): boolean;
+    toPrimitives(): Record<string, unknown>;
+    static create(gateway: string): PaymentStatus;
+}
+
+declare class Country extends ValueObject<string> {
+    static COUNTRIES: {
+        [key: string]: {
+            alpha2: string;
+            alpha3: string;
+            numeric: string;
+            uuid: string;
+            phoneCode: string;
+            url: string;
+        };
+    };
+    private static readonly NAMES;
+    static readonly DEFAULT: Country;
+    static readonly ARGENTINA: Country;
+    static readonly ECUADOR: Country;
+    static readonly PERU: Country;
+    static readonly BRASIL: Country;
+    static readonly CHILE: Country;
+    static readonly VENEZUELA: Country;
+    static readonly COLOMBIA: Country;
+    static readonly BOLIVIA: Country;
+    static readonly PARAGUAY: Country;
+    static readonly USA: Country;
+    private readonly _name;
+    private readonly _alpha2;
+    private readonly _alpha3;
+    private readonly _numeric;
+    private readonly _uuid;
+    private readonly _phoneCode;
+    private readonly _url;
+    private constructor();
+    protected validate(country: string): void;
+    name(): string;
+    alpha2(): string;
+    alpha3(): string;
+    numeric(): string;
+    uuid(): string;
+    phoneCode(): string;
+    url(): string;
+    static findCountryByAlpha2(alpha2: string): Country;
+    static findCountryByUUID(uuid: string): Country;
+    static create(country: string): Country;
+    static createOrDefault(country: string): Country;
+    toPrimitives(): Record<string, unknown>;
+    static isValid(country: string): boolean;
+}
+
 declare class Currency extends ValueObject<string> {
     static readonly ALPHA_REGEX: RegExp;
     static readonly NUM_REGEX: RegExp;
@@ -252,58 +367,18 @@ declare class Price extends ValueObject<PriceProps> {
     static createFromPrimitives(data: Record<string, unknown>): Price;
 }
 
-declare class PaymentGateway extends ValueObject<string> {
-    static readonly SUPPORTED: readonly string[];
-    private static readonly EXTERNALS;
-    static readonly MERCADOPAGO: PaymentGateway;
-    static readonly HANDY: PaymentGateway;
-    static readonly WONA_DEBIT: PaymentGateway;
-    static readonly WONA_CARD: PaymentGateway;
-    static readonly WONA_CASH: PaymentGateway;
-    static readonly WONA_TRANSFER: PaymentGateway;
-    static readonly WONA_MERCADOPAGO: PaymentGateway;
-    private constructor();
-    protected validate(value: string): void;
-    isExternal(): boolean;
-    toPrimitives(): Record<string, unknown>;
-    static create(gateway: string): PaymentGateway;
-}
-
-declare class PaymentStatus extends ValueObject<string> {
-    static readonly SUPPORTED: readonly string[];
-    static readonly DONE: PaymentStatus;
-    static readonly PENDING: PaymentStatus;
-    static readonly IN_PROGRESS: PaymentStatus;
-    static readonly FAILED: PaymentStatus;
-    static readonly CANCELED: PaymentStatus;
-    static readonly HOLD: PaymentStatus;
-    static readonly PENDING_REFUND: PaymentStatus;
-    static readonly REFUNDED: PaymentStatus;
-    private constructor();
-    protected validate(status: string): void;
-    get isDone(): boolean;
-    get isPending(): boolean;
-    get isInProgress(): boolean;
-    get isFailed(): boolean;
-    get isCanceled(): boolean;
-    get isHold(): boolean;
-    get isPendingRefund(): boolean;
-    get isRefunded(): boolean;
-    toPrimitives(): Record<string, unknown>;
-    static create(gateway: string): PaymentStatus;
-}
-
 interface EventBusRepository {
-    create(event: DomainEvent): Promise<void>;
-    update(event: DomainEvent): Promise<void>;
-    listPending(limit: number): Promise<DomainEvent[]>;
+    create(event: OutboxRecord): Promise<void>;
+    update(event: OutboxRecord): Promise<void>;
+    listPending(limit: number): Promise<OutboxRecord[]>;
 }
 
-declare class EventBus {
-    private readonly repository;
-    constructor(repository: EventBusRepository);
-    publish(event: DomainEvent): Promise<void>;
-    publishMany(events: DomainEvent[]): Promise<void>;
+declare class IntegrationEvent extends BaseEvent {
+    protected readonly _aggregateUuid: UUID;
+    protected readonly _aggregateType: string;
+    protected constructor(version: string, type: string, payload: Record<string, unknown>, aggregateUuid: UUID, aggregateType: string);
+    get aggregateUuid(): UUID;
+    get aggregateType(): string;
 }
 
 interface DatabaseConnector<C extends DatabaseConnection = DatabaseConnection> {
@@ -327,6 +402,16 @@ interface UnitOfWork<C extends DatabaseConnection = DatabaseConnection> {
     execute<T>(fn: () => Promise<T>): Promise<T>;
 }
 
+type MapperEvent = (event: BaseEvent) => OutboxRecord;
+declare class EventBus {
+    private static readonly MAPPERS;
+    private readonly repository;
+    constructor(repository: EventBusRepository);
+    publish(event: BaseEvent): Promise<void>;
+    publishMany(events: BaseEvent[]): Promise<void>;
+    static addMapper(eventType: string, mapper: MapperEvent): void;
+}
+
 declare class BasicUnitOfWork implements UnitOfWork {
     readonly connection: DatabaseConnection;
     constructor(conn: DatabaseConnection);
@@ -339,21 +424,12 @@ declare class BasicUnitOfWorkFactory {
     create(): Promise<BasicUnitOfWork>;
 }
 
-interface EventMessage {
-    producer?: string;
-    eventUuid: string;
-    eventType: string;
-    tenantUuid: string;
-    topic: string;
-    payload: Record<string, any>;
-    date?: string;
-}
 interface EventManagerConnection {
     userName: string;
     password: string;
     brokers: string[];
 }
-type RouteCallback = (message: EventMessage) => void;
+type RouteCallback = (message: string) => void;
 interface RoutesCallbackList {
     [key: string]: RouteCallback;
 }
@@ -369,9 +445,9 @@ declare abstract class EventManager {
     protected _onCrash: CallableFunction | null;
     protected _onReconnect: CallableFunction | null;
     protected constructor(connection: EventManagerConnection);
-    protected execRoute(topic: string, message: EventMessage): Promise<void>;
+    protected execRoute(topic: string, message: string): Promise<void>;
     protected execCallback(callback: CallableFunction | null, data: any): Promise<void>;
-    abstract send(message: EventMessage): void;
+    abstract send(topic: string, message: string): void;
     abstract start(): void;
     abstract restart(): void;
     abstract stop(): void;
@@ -388,14 +464,6 @@ declare abstract class EventManager {
     get callbackList(): RoutesCallbackList;
 }
 
-interface Logger {
-    debug(type: string, message: string, meta?: Record<string, any>): void;
-    info(type: string, message: string, meta?: Record<string, any>): void;
-    warn(type: string, message: string, meta?: Record<string, any>): void;
-    error(type: string, message: string, meta?: Record<string, any>): void;
-    fatal(type: string, message: string, meta?: Record<string, any>): void;
-}
-
 interface HttpRequest {
     readonly headers: Record<string, string>;
     readonly params: Record<string, string>;
@@ -421,6 +489,14 @@ interface HttpController {
     handle(request: HttpRequest): Promise<HttpResponse>;
 }
 
+interface Logger {
+    debug(type: string, message: string, meta?: Record<string, any>): void;
+    info(type: string, message: string, meta?: Record<string, any>): void;
+    warn(type: string, message: string, meta?: Record<string, any>): void;
+    error(type: string, message: string, meta?: Record<string, any>): void;
+    fatal(type: string, message: string, meta?: Record<string, any>): void;
+}
+
 interface ErrorTemplate {
     type: string;
     languages: Record<string, string>;
@@ -448,27 +524,18 @@ declare class ErrorManager {
     static addTemplate(template: ErrorTemplate): void;
 }
 
-declare class MysqlConnector implements DatabaseConnector<MysqlConnection> {
-    static readonly DEFAULT_POOL_SIZE: number;
-    private readonly _pool;
-    constructor(pool?: Pool);
-    private wrap;
-    query(sql: string, params?: any[]): Promise<any[]>;
-    getConnection(): Promise<MysqlConnection>;
-    closePool(): Promise<void>;
-    static ping(): Promise<boolean>;
-}
-declare class MysqlConnection implements DatabaseConnection<string, any[], RowDataPacket> {
-    private readonly _conn;
-    constructor(conn: PoolConnection);
-    query<R = RowDataPacket>(statement: string, params?: any[]): Promise<R[]>;
-    begin(): Promise<void>;
-    commit(): Promise<void>;
-    rollback(): Promise<void>;
-    transaction<T>(fn: (conn: this) => Promise<T>): Promise<T>;
-    close(): Promise<void>;
+declare class EventBusMysqlRepository implements EventBusRepository {
+    private readonly connection;
+    constructor(connection: DatabaseConnection);
+    private eventToRowValues;
+    create(event: OutboxRecord): Promise<void>;
+    update(event: OutboxRecord): Promise<void>;
+    listPending(limit: number): Promise<OutboxRecord[]>;
 }
 
+declare function adaptExpressRoute(Controller: new () => HttpController): RequestHandler;
+declare function adaptExpressErrorHandler(errorManager: ErrorManager): ErrorRequestHandler;
+
 declare class HttpHealthCheckController implements HttpController {
     handle(request: HttpRequest): Promise<HttpResponse>;
 }
@@ -476,32 +543,40 @@ declare class HttpNotFoundController implements HttpController {
     handle(request: HttpRequest): Promise<HttpResponse>;
 }
 
-declare function adaptExpressRoute(Controller: new () => HttpController): RequestHandler;
-declare function adaptExpressErrorHandler(errorManager: ErrorManager): ErrorRequestHandler;
-
-declare class EventBusMysqlRepository implements EventBusRepository {
-    private readonly connection;
-    constructor(connection: DatabaseConnection);
-    private eventToRowValues;
-    create(event: DomainEvent): Promise<void>;
-    update(event: DomainEvent): Promise<void>;
-    listPending(limit: number): Promise<DomainEvent[]>;
-}
-
 declare class KafkaManager extends EventManager {
     private readonly kafka;
     private readonly consumer;
     private readonly producer;
     constructor(connection: EventManagerConnection);
     private run;
-    send(message: EventMessage): Promise<void>;
-    sendRaw(message: string, topic: string): Promise<void>;
+    send(topic: string, message: string): Promise<void>;
     start(autocommit?: boolean): Promise<void>;
     pause(): Promise<void>;
     restart(): Promise<void>;
     stop(): Promise<void>;
 }
 
+declare class MysqlConnector implements DatabaseConnector<MysqlConnection> {
+    static readonly DEFAULT_POOL_SIZE: number;
+    private readonly _pool;
+    constructor(pool?: Pool);
+    private wrap;
+    query(sql: string, params?: any[]): Promise<any[]>;
+    getConnection(): Promise<MysqlConnection>;
+    closePool(): Promise<void>;
+    static ping(): Promise<boolean>;
+}
+declare class MysqlConnection implements DatabaseConnection<string, any[], RowDataPacket> {
+    private readonly _conn;
+    constructor(conn: PoolConnection);
+    query<R = RowDataPacket>(statement: string, params?: any[]): Promise<R[]>;
+    begin(): Promise<void>;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+    transaction<T>(fn: (conn: this) => Promise<T>): Promise<T>;
+    close(): Promise<void>;
+}
+
 interface ExchangeRatesProps {
     base: Currency;
     rates: Record<string, number>;
@@ -520,4 +595,10 @@ declare class ExchangeRates extends BaseObject<ExchangeRatesProps> {
     static createFromPrimitives(data: any): ExchangeRates;
 }
 
-export { BaseEntity, BaseObject, BasicUnitOfWork, BasicUnitOfWorkFactory, Currency, DatabaseConnection, DatabaseConnector, DateTime, DomainEntity, DomainError, DomainEvent, DomainEventStatus, Email, ErrorManager, ErrorManagerHandleResult, ErrorTemplate, EventBus, EventBusMysqlRepository, EventBusRepository, EventManager, EventManagerConnection, EventMessage, ExchangeRates, FatalError, HttpController, HttpHealthCheckController, HttpNotFoundController, HttpRequest, HttpResponse, InternalError, KafkaManager, Language, Logger, MysqlConnection, MysqlConnector, PaymentGateway, PaymentStatus, Price, RouteCallback, RoutesCallbackList, UUID, UnitOfWork, UploadedFile, UsageError, ValueObject, adaptExpressErrorHandler, adaptExpressRoute };
+declare class StringVars {
+    static parse(str: string, ob: {
+        [key: string]: any;
+    }): string;
+}
+
+export { BaseEntity, BaseEvent, BaseObject, BasicUnitOfWork, BasicUnitOfWorkFactory, Country, Currency, DatabaseConnection, DatabaseConnector, DateTime, DomainEntity, DomainError, DomainEvent, Email, ErrorManager, ErrorManagerHandleResult, ErrorTemplate, EventBus, EventBusMysqlRepository, EventBusRepository, EventManager, EventManagerConnection, ExchangeRates, FatalError, HttpController, HttpHealthCheckController, HttpNotFoundController, HttpRequest, HttpResponse, IntegrationEvent, InternalError, KafkaManager, Language, Logger, MysqlConnection, MysqlConnector, OutboxRecord, PaymentGateway, PaymentStatus, Price, ProcessStatus, RouteCallback, RoutesCallbackList, StringVars, UUID, UnitOfWork, UploadedFile, UsageError, ValueObject, adaptExpressErrorHandler, adaptExpressRoute };