wsp-ms-core 1.0.77 → 1.0.78-beta-1

package/dist/index.js

@@ -166,6 +166,32 @@ _DateTime.FORMATS = {
 };
 var DateTime = _DateTime;
 
+// src/domain/contracts/BaseEvent.ts
+var BaseEvent = class {
+  constructor(tenantUuid, version, type, payload) {
+    this._tenantUuid = tenantUuid;
+    this._version = version;
+    this._type = type;
+    this._payload = payload;
+    this._occurredAt = DateTime.now();
+  }
+  get tenantUuid() {
+    return this._tenantUuid;
+  }
+  get version() {
+    return this._version;
+  }
+  get type() {
+    return this._type;
+  }
+  get payload() {
+    return this._payload;
+  }
+  get ocurredAt() {
+    return this._occurredAt;
+  }
+};
+
 // src/domain/contracts/DomainEntity.ts
 var DomainEntity = class {
   constructor(props) {
@@ -200,6 +226,13 @@ var DomainEntity = class {
   }
 };
 
+// src/domain/contracts/BaseObject.ts
+var BaseObject = class {
+  constructor(props) {
+    this.props = props;
+  }
+};
+
 // src/domain/contracts/DomainError.ts
 var DomainError = class extends Error {
   constructor(type, message = "") {
@@ -208,101 +241,34 @@ var DomainError = class extends Error {
   }
 };
 
-// src/domain/errors/InternalError.ts
-var InternalError = class extends DomainError {
+// src/domain/errors/FatalError.ts
+var FatalError = class extends DomainError {
   constructor(type, message = "") {
     super(type, message);
   }
 };
 
-// src/domain/value-objects/UUID.ts
-import * as crypto from "crypto";
-var _UUID = class _UUID extends ValueObject {
-  constructor(value) {
-    super(value);
-  }
-  validate(uuid) {
-    if (!_UUID.isValid(uuid)) {
-      throw new InternalError(`Invalid uuid <${uuid}>`);
-    }
-  }
-  toPrimitives() {
-    return { value: this.value };
-  }
-  static create(uuid) {
-    return new _UUID(uuid ?? crypto.randomUUID());
-  }
-  static version(uuid) {
-    const m = /^[0-9a-f]{8}-[0-9a-f]{4}-([1-8])[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.exec(uuid);
-    return m ? Number(m[1]) : void 0;
-  }
-  static isNil(uuid) {
-    return /^0{8}-0{4}-0{4}-0{4}-0{12}$/i.test(uuid);
-  }
-  static isRFCStyle(uuid) {
-    return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(uuid);
-  }
-  static isValid(uuid, opts = {}) {
-    const allowed = opts.allowedVersions ?? [1, 2, 3, 4, 5, 6, 7, 8];
-    const allowNil = opts.allowNil ?? false;
-    if (allowNil && _UUID.isNil(uuid))
-      return true;
-    if (!_UUID.isRFCStyle(uuid))
-      return false;
-    const v = _UUID.version(uuid);
-    return !!v && allowed.includes(v);
+// src/domain/errors/InternalError.ts
+var InternalError = class extends DomainError {
+  constructor(type, message = "") {
+    super(type, message);
   }
 };
-_UUID.NIL = "00000000-0000-0000-0000-000000000000";
-var UUID = _UUID;
 
-// src/domain/value-objects/DomainEventStatus.ts
-var _DomainEventStatus = class _DomainEventStatus extends ValueObject {
-  constructor(status) {
-    super(status.trim().toUpperCase());
-  }
-  validate(value) {
-    if (!_DomainEventStatus.SUPPORTED.includes(value)) {
-      throw new InternalError(`Domain event status <${value}> is not supported`);
-    }
-  }
-  toPrimitives() {
-    return void 0;
-  }
-  static create(status) {
-    return new _DomainEventStatus(status);
+// src/domain/errors/UsageError.ts
+var UsageError = class extends DomainError {
+  constructor(type, vars = {}) {
+    super(type);
+    this.vars = vars;
   }
 };
-_DomainEventStatus.SUPPORTED = ["PENDING", "PROCESSING", "PROCESSED", "FAILED", "DEAD"];
-_DomainEventStatus.PENDING = new _DomainEventStatus("PENDING");
-_DomainEventStatus.PROCESSING = new _DomainEventStatus("PROCESSING");
-_DomainEventStatus.PROCESSED = new _DomainEventStatus("PROCESSED");
-_DomainEventStatus.FAILED = new _DomainEventStatus("FAILED");
-_DomainEventStatus.DEAD = new _DomainEventStatus("DEAD");
-var DomainEventStatus = _DomainEventStatus;
 
-// src/domain/contracts/DomainEvent.ts
-var DomainEvent = class _DomainEvent {
-  constructor(eventUuid, eventType, tenantUuid, aggregateUuid, aggregateType, topic, payload, status, attempts, errorMessage, publishedAt, lastAttempt, createdAt) {
-    this._eventUuid = eventUuid;
-    this._tenantUuid = tenantUuid;
+// src/domain/events/DomainEvent.ts
+var DomainEvent = class extends BaseEvent {
+  constructor(tenantUuid, version, type, payload, aggregateUuid, aggregateType) {
+    super(tenantUuid, version, type, payload);
     this._aggregateUuid = aggregateUuid;
     this._aggregateType = aggregateType;
-    this._eventType = eventType;
-    this._topic = topic;
-    this._payload = payload;
-    this._status = status;
-    this._attempts = attempts;
-    this._errorMessage = errorMessage;
-    this._publishedAt = publishedAt;
-    this._lastAttempt = lastAttempt;
-    this._createdAt = createdAt;
-  }
-  get eventUuid() {
-    return this._eventUuid;
-  }
-  get tenantUuid() {
-    return this._tenantUuid;
   }
   get aggregateUuid() {
     return this._aggregateUuid;
@@ -310,169 +276,98 @@ var DomainEvent = class _DomainEvent {
   get aggregateType() {
     return this._aggregateType;
   }
-  get eventType() {
-    return this._eventType;
-  }
-  get topic() {
-    return this._topic;
-  }
-  get payload() {
-    return this._payload;
-  }
-  get status() {
-    return this._status;
-  }
-  get attempts() {
-    return this._attempts;
-  }
-  get errorMessage() {
-    return this._errorMessage;
+};
+
+// src/domain/value-objects/payments/PaymentGateway.ts
+var _PaymentGateway = class _PaymentGateway extends ValueObject {
+  constructor(gateway) {
+    super(gateway);
   }
-  get publishedAt() {
-    return this._publishedAt;
+  validate(value) {
+    if (!_PaymentGateway.SUPPORTED.includes(value)) {
+      throw new InternalError(`Payment gateway <${value}> is not supported`);
+    }
   }
-  get lastAttempt() {
-    return this._lastAttempt;
+  isExternal() {
+    return _PaymentGateway.EXTERNALS.includes(this.value);
   }
-  get createdAt() {
-    return this._createdAt;
+  toPrimitives() {
+    return { value: this.value };
   }
-  incrementAttempts() {
-    this._attempts++;
-    this._lastAttempt = DateTime.now();
+  static create(gateway) {
+    return new _PaymentGateway(gateway.trim().toUpperCase());
   }
-  markProcessed() {
-    this._status = DomainEventStatus.PROCESSED;
-    this._publishedAt = DateTime.now();
+};
+_PaymentGateway.SUPPORTED = [
+  "MERCADOPAGO",
+  "HANDY",
+  "WONA_DEBIT",
+  "WONA_CARD",
+  "WONA_CASH",
+  "WONA_TRANSFER",
+  "WONA_MERCADOPAGO"
+];
+_PaymentGateway.EXTERNALS = ["MERCADOPAGO", "STRIPE"];
+_PaymentGateway.MERCADOPAGO = new _PaymentGateway("MERCADOPAGO");
+_PaymentGateway.HANDY = new _PaymentGateway("HANDY");
+_PaymentGateway.WONA_DEBIT = new _PaymentGateway("WONA_DEBIT");
+_PaymentGateway.WONA_CARD = new _PaymentGateway("WONA_CARD");
+_PaymentGateway.WONA_CASH = new _PaymentGateway("WONA_CASH");
+_PaymentGateway.WONA_TRANSFER = new _PaymentGateway("WONA_TRANSFER");
+_PaymentGateway.WONA_MERCADOPAGO = new _PaymentGateway("WONA_MERCADOPAGO");
+var PaymentGateway = _PaymentGateway;
+
+// src/domain/value-objects/payments/PaymentStatus.ts
+var _PaymentStatus = class _PaymentStatus extends ValueObject {
+  constructor(status) {
+    super(status);
   }
-  markProcessing() {
-    this.incrementAttempts();
-    this._status = DomainEventStatus.PROCESSING;
+  validate(status) {
+    if (!_PaymentStatus.SUPPORTED.includes(status)) {
+      throw new InternalError(`Payment status <${status}> is not supported`);
+    }
   }
-  markWithError(error) {
-    this._status = this.attempts < 5 ? DomainEventStatus.FAILED : DomainEventStatus.DEAD;
-    this._errorMessage = error;
+  get isDone() {
+    return this.value === "DONE";
   }
-  toPrimitives() {
-    return {
-      eventUuid: this.eventUuid.value,
-      eventType: this.eventType,
-      tenantUuid: this.tenantUuid.value,
-      aggregateUuid: this.aggregateUuid.value,
-      aggregateType: this.aggregateType,
-      topic: this.topic,
-      payload: this.payload,
-      status: this.status.value,
-      attempts: this.attempts,
-      errorMessage: this.errorMessage ?? void 0,
-      publishedAt: this.publishedAt?.value ?? void 0,
-      lastAttempt: this.lastAttempt?.value ?? void 0,
-      createdAt: this.createdAt.value
-    };
+  get isPending() {
+    return this.value === "PENDING";
   }
-  static reconstitute(data) {
-    return new _DomainEvent(
-      UUID.create(data.event_uuid),
-      String(data.event_type),
-      UUID.create(data.tenant_uuid),
-      UUID.create(data.aggregate_uuid),
-      String(data.aggregate_type),
-      String(data.topic),
-      String(data.payload),
-      DomainEventStatus.create(data.status),
-      Number(data.attempts),
-      data.error_message ?? void 0,
-      data.published_at ? DateTime.create(data.published_at) : void 0,
-      data.last_attempt ? DateTime.create(data.last_attempt) : void 0,
-      data.created_at ? DateTime.create(data.created_at) : void 0
-    );
+  get isInProgress() {
+    return this.value === "IN_PROGRESS";
   }
-};
-
-// src/domain/contracts/BaseObject.ts
-var BaseObject = class {
-  constructor(props) {
-    this.props = props;
+  get isFailed() {
+    return this.value === "FAILED";
   }
-};
-
-// src/domain/errors/FatalError.ts
-var FatalError = class extends DomainError {
-  constructor(type, message = "") {
-    super(type, message);
+  get isCanceled() {
+    return this.value === "CANCELED";
   }
-};
-
-// src/domain/errors/UsageError.ts
-var UsageError = class extends DomainError {
-  constructor(type, vars = {}) {
-    super(type);
-    this.vars = vars;
+  get isHold() {
+    return this.value === "HOLD";
   }
-};
-
-// src/domain/value-objects/Currency.ts
-var _Currency = class _Currency extends ValueObject {
-  constructor(alpha) {
-    super(alpha.toUpperCase().trim());
-    this.numeric = _Currency.ALPHA_TO_NUM[this.value];
+  get isPendingRefund() {
+    return this.value === "PENDING_REFUND";
   }
-  validate(alpha) {
-    const code = alpha.toUpperCase().trim();
-    if (!_Currency.ALPHA_REGEX.test(code)) {
-      throw new Error(`Currency code <${alpha}> is not a valid ISO\u20114217 alpha value`);
-    }
-    if (!(code in _Currency.ALPHA_TO_NUM)) {
-      throw new Error(`Currency <${code}> is not supported`);
-    }
+  get isRefunded() {
+    return this.value === "REFUNDED";
   }
   toPrimitives() {
-    return {
-      value: this.value
-    };
-  }
-  static create(raw) {
-    if (typeof raw === "number" || _Currency.NUM_REGEX.test(raw)) {
-      const num = Number(raw);
-      const alpha = _Currency.NUM_TO_ALPHA[num];
-      if (!alpha) {
-        throw new Error(`Numeric currency <${raw}> is not supported`);
-      }
-      return new _Currency(alpha);
-    }
-    return new _Currency(String(raw));
+    return { value: this.value };
   }
-  static isValid(raw) {
-    try {
-      _Currency.create(raw);
-      return true;
-    } catch {
-      return false;
-    }
+  static create(gateway) {
+    return new _PaymentStatus(gateway.trim().toUpperCase());
   }
 };
-_Currency.ALPHA_REGEX = /^[A-Z]{3}$/u;
-_Currency.NUM_REGEX = /^\d{3}$/u;
-_Currency.ALPHA_TO_NUM = {
-  USD: 840,
-  EUR: 978,
-  UYU: 858,
-  ARS: 32,
-  BRL: 986
-};
-_Currency.NUM_TO_ALPHA = Object.entries(_Currency.ALPHA_TO_NUM).reduce(
-  (acc, [alpha, num]) => {
-    acc[num] = alpha;
-    return acc;
-  },
-  {}
-);
-_Currency.USD = new _Currency("USD");
-_Currency.EUR = new _Currency("EUR");
-_Currency.UYU = new _Currency("UYU");
-_Currency.ARS = new _Currency("ARS");
-_Currency.BRL = new _Currency("BRL");
-var Currency = _Currency;
+_PaymentStatus.SUPPORTED = ["DONE", "PENDING", "FAILED", "CANCELED", "HOLD", "PENDING_REFUND", "REFUNDED", "IN_PROGRESS"];
+_PaymentStatus.DONE = new _PaymentStatus("DONE");
+_PaymentStatus.PENDING = new _PaymentStatus("PENDING");
+_PaymentStatus.IN_PROGRESS = new _PaymentStatus("IN_PROGRESS");
+_PaymentStatus.FAILED = new _PaymentStatus("FAILED");
+_PaymentStatus.CANCELED = new _PaymentStatus("CANCELED");
+_PaymentStatus.HOLD = new _PaymentStatus("HOLD");
+_PaymentStatus.PENDING_REFUND = new _PaymentStatus("PENDING_REFUND");
+_PaymentStatus.REFUNDED = new _PaymentStatus("REFUNDED");
+var PaymentStatus = _PaymentStatus;
 
 // src/utils/StringVars.ts
 var StringVars = class {
@@ -765,6 +660,69 @@ _Country.PARAGUAY = new _Country("PARAGUAY");
 _Country.USA = new _Country("USA");
 var Country = _Country;
 
+// src/domain/value-objects/Currency.ts
+var _Currency = class _Currency extends ValueObject {
+  constructor(alpha) {
+    super(alpha.toUpperCase().trim());
+    this.numeric = _Currency.ALPHA_TO_NUM[this.value];
+  }
+  validate(alpha) {
+    const code = alpha.toUpperCase().trim();
+    if (!_Currency.ALPHA_REGEX.test(code)) {
+      throw new Error(`Currency code <${alpha}> is not a valid ISO\u20114217 alpha value`);
+    }
+    if (!(code in _Currency.ALPHA_TO_NUM)) {
+      throw new Error(`Currency <${code}> is not supported`);
+    }
+  }
+  toPrimitives() {
+    return {
+      value: this.value
+    };
+  }
+  static create(raw) {
+    if (typeof raw === "number" || _Currency.NUM_REGEX.test(raw)) {
+      const num = Number(raw);
+      const alpha = _Currency.NUM_TO_ALPHA[num];
+      if (!alpha) {
+        throw new Error(`Numeric currency <${raw}> is not supported`);
+      }
+      return new _Currency(alpha);
+    }
+    return new _Currency(String(raw));
+  }
+  static isValid(raw) {
+    try {
+      _Currency.create(raw);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+_Currency.ALPHA_REGEX = /^[A-Z]{3}$/u;
+_Currency.NUM_REGEX = /^\d{3}$/u;
+_Currency.ALPHA_TO_NUM = {
+  USD: 840,
+  EUR: 978,
+  UYU: 858,
+  ARS: 32,
+  BRL: 986
+};
+_Currency.NUM_TO_ALPHA = Object.entries(_Currency.ALPHA_TO_NUM).reduce(
+  (acc, [alpha, num]) => {
+    acc[num] = alpha;
+    return acc;
+  },
+  {}
+);
+_Currency.USD = new _Currency("USD");
+_Currency.EUR = new _Currency("EUR");
+_Currency.UYU = new _Currency("UYU");
+_Currency.ARS = new _Currency("ARS");
+_Currency.BRL = new _Currency("BRL");
+var Currency = _Currency;
+
 // src/domain/value-objects/Email.ts
 var _Email = class _Email extends ValueObject {
   constructor(email) {
@@ -958,111 +916,110 @@ _Price.MIN_AMOUNT = -1e6;
 _Price.MAX_AMOUNT = 1e9;
 var Price = _Price;
 
-// src/domain/value-objects/payments/PaymentGateway.ts
-var _PaymentGateway = class _PaymentGateway extends ValueObject {
-  constructor(gateway) {
-    super(gateway);
+// src/domain/value-objects/ProcessStatus.ts
+var _ProcessStatus = class _ProcessStatus extends ValueObject {
+  constructor(status) {
+    super(status.trim().toUpperCase());
   }
   validate(value) {
-    if (!_PaymentGateway.SUPPORTED.includes(value)) {
-      throw new InternalError(`Payment gateway <${value}> is not supported`);
+    if (!_ProcessStatus.SUPPORTED.includes(value)) {
+      throw new InternalError(`Domain event status <${value}> is not supported`);
     }
   }
-  isExternal() {
-    return _PaymentGateway.EXTERNALS.includes(this.value);
-  }
   toPrimitives() {
-    return { value: this.value };
+    return void 0;
   }
-  static create(gateway) {
-    return new _PaymentGateway(gateway.trim().toUpperCase());
+  static create(status) {
+    return new _ProcessStatus(status);
   }
 };
-_PaymentGateway.SUPPORTED = [
-  "MERCADOPAGO",
-  "HANDY",
-  "WONA_DEBIT",
-  "WONA_CARD",
-  "WONA_CASH",
-  "WONA_TRANSFER",
-  "WONA_MERCADOPAGO"
-];
-_PaymentGateway.EXTERNALS = ["MERCADOPAGO", "STRIPE"];
-_PaymentGateway.MERCADOPAGO = new _PaymentGateway("MERCADOPAGO");
-_PaymentGateway.HANDY = new _PaymentGateway("HANDY");
-_PaymentGateway.WONA_DEBIT = new _PaymentGateway("WONA_DEBIT");
-_PaymentGateway.WONA_CARD = new _PaymentGateway("WONA_CARD");
-_PaymentGateway.WONA_CASH = new _PaymentGateway("WONA_CASH");
-_PaymentGateway.WONA_TRANSFER = new _PaymentGateway("WONA_TRANSFER");
-_PaymentGateway.WONA_MERCADOPAGO = new _PaymentGateway("WONA_MERCADOPAGO");
-var PaymentGateway = _PaymentGateway;
+_ProcessStatus.SUPPORTED = ["PENDING", "PROCESSING", "PROCESSED", "FAILED", "DEAD"];
+_ProcessStatus.PENDING = new _ProcessStatus("PENDING");
+_ProcessStatus.PROCESSING = new _ProcessStatus("PROCESSING");
+_ProcessStatus.PROCESSED = new _ProcessStatus("PROCESSED");
+_ProcessStatus.FAILED = new _ProcessStatus("FAILED");
+_ProcessStatus.DEAD = new _ProcessStatus("DEAD");
+var ProcessStatus = _ProcessStatus;
 
-// src/domain/value-objects/payments/PaymentStatus.ts
-var _PaymentStatus = class _PaymentStatus extends ValueObject {
-  constructor(status) {
-    super(status);
+// src/domain/value-objects/UUID.ts
+import * as crypto from "crypto";
+var _UUID = class _UUID extends ValueObject {
+  constructor(value) {
+    super(value);
   }
-  validate(status) {
-    if (!_PaymentStatus.SUPPORTED.includes(status)) {
-      throw new InternalError(`Payment status <${status}> is not supported`);
+  validate(uuid) {
+    if (!_UUID.isValid(uuid)) {
+      throw new InternalError(`Invalid uuid <${uuid}>`);
     }
   }
-  get isDone() {
-    return this.value === "DONE";
-  }
-  get isPending() {
-    return this.value === "PENDING";
+  toPrimitives() {
+    return { value: this.value };
   }
-  get isInProgress() {
-    return this.value === "IN_PROGRESS";
+  static create(uuid) {
+    return new _UUID(uuid ?? crypto.randomUUID());
   }
-  get isFailed() {
-    return this.value === "FAILED";
+  static version(uuid) {
+    const m = /^[0-9a-f]{8}-[0-9a-f]{4}-([1-8])[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.exec(uuid);
+    return m ? Number(m[1]) : void 0;
   }
-  get isCanceled() {
-    return this.value === "CANCELED";
+  static isNil(uuid) {
+    return /^0{8}-0{4}-0{4}-0{4}-0{12}$/i.test(uuid);
   }
-  get isHold() {
-    return this.value === "HOLD";
+  static isRFCStyle(uuid) {
+    return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(uuid);
   }
-  get isPendingRefund() {
-    return this.value === "PENDING_REFUND";
+  static isValid(uuid, opts = {}) {
+    const allowed = opts.allowedVersions ?? [1, 2, 3, 4, 5, 6, 7, 8];
+    const allowNil = opts.allowNil ?? false;
+    if (allowNil && _UUID.isNil(uuid))
+      return true;
+    if (!_UUID.isRFCStyle(uuid))
+      return false;
+    const v = _UUID.version(uuid);
+    return !!v && allowed.includes(v);
   }
-  get isRefunded() {
-    return this.value === "REFUNDED";
+};
+_UUID.NIL = "00000000-0000-0000-0000-000000000000";
+var UUID = _UUID;
+
+// src/application/contracts/IntegrationEvent.ts
+var IntegrationEvent = class extends BaseEvent {
+  constructor(tenantUuid, version, type, payload, aggregateUuid, aggregateType) {
+    super(tenantUuid, version, type, payload);
+    this._aggregateUuid = aggregateUuid;
+    this._aggregateType = aggregateType;
   }
-  toPrimitives() {
-    return { value: this.value };
+  get aggregateUuid() {
+    return this._aggregateUuid;
   }
-  static create(gateway) {
-    return new _PaymentStatus(gateway.trim().toUpperCase());
+  get aggregateType() {
+    return this._aggregateType;
   }
 };
-_PaymentStatus.SUPPORTED = ["DONE", "PENDING", "FAILED", "CANCELED", "HOLD", "PENDING_REFUND", "REFUNDED", "IN_PROGRESS"];
-_PaymentStatus.DONE = new _PaymentStatus("DONE");
-_PaymentStatus.PENDING = new _PaymentStatus("PENDING");
-_PaymentStatus.IN_PROGRESS = new _PaymentStatus("IN_PROGRESS");
-_PaymentStatus.FAILED = new _PaymentStatus("FAILED");
-_PaymentStatus.CANCELED = new _PaymentStatus("CANCELED");
-_PaymentStatus.HOLD = new _PaymentStatus("HOLD");
-_PaymentStatus.PENDING_REFUND = new _PaymentStatus("PENDING_REFUND");
-_PaymentStatus.REFUNDED = new _PaymentStatus("REFUNDED");
-var PaymentStatus = _PaymentStatus;
 
 // src/application/event-bus/EventBus.ts
-var EventBus = class {
+var _EventBus = class _EventBus {
   constructor(repository) {
     this.repository = repository;
   }
   async publish(event) {
-    await this.repository.create(event);
+    const mapper = _EventBus.MAPPERS.get(event.type);
+    if (!mapper) {
+      throw new InternalError(ErrorManager.APP_ERRORS.PROCESS, `Eventbus mapper not found for <${event.type}>`);
+    }
+    await this.repository.create(mapper(event));
   }
   async publishMany(events) {
     for (let event of events) {
       await this.publish(event);
     }
   }
+  static addMapper(eventType, mapper) {
+    _EventBus.MAPPERS.set(eventType, mapper);
+  }
 };
+_EventBus.MAPPERS = /* @__PURE__ */ new Map();
+var EventBus = _EventBus;
 
 // src/application/unit-of-work/BasicUnitOfWork.ts
 var BasicUnitOfWork = class {
@@ -1152,104 +1109,164 @@ var EventManager = class {
   }
 };
 
-// src/infrastructure/mysql/Mysql.ts
-import { createPool } from "mysql2/promise";
-var _MysqlConnector = class _MysqlConnector {
-  constructor(pool) {
-    this._pool = pool ?? createPool({
-      host: process.env.DB_HOST,
-      port: Number(process.env.DB_PORT ?? 3306),
-      user: process.env.DB_USER,
-      password: process.env.DB_PASSWORD,
-      database: process.env.DB_DATABASE,
-      dateStrings: true,
-      connectionLimit: Number(process.env.DB_POOL_SIZE) || _MysqlConnector.DEFAULT_POOL_SIZE,
-      decimalNumbers: true
-    });
+// src/infrastructure/contracts/OutboxRecord.ts
+var OutboxRecord = class _OutboxRecord {
+  constructor(eventUuid, eventType, tenantUuid, aggregateUuid, aggregateType, topic, payload, status, attempts, errorMessage, publishedAt, lastAttempt, createdAt) {
+    this._eventUuid = eventUuid;
+    this._tenantUuid = tenantUuid;
+    this._aggregateUuid = aggregateUuid;
+    this._aggregateType = aggregateType;
+    this._eventType = eventType;
+    this._topic = topic;
+    this._payload = payload;
+    this._status = status;
+    this._attempts = attempts;
+    this._errorMessage = errorMessage;
+    this._publishedAt = publishedAt;
+    this._lastAttempt = lastAttempt;
+    this._createdAt = createdAt;
   }
-  async wrap(conn) {
-    return new MysqlConnection(conn);
+  get eventUuid() {
+    return this._eventUuid;
   }
-  async query(sql, params = []) {
-    const [rows] = await this._pool.query(sql, params);
-    return rows;
+  get tenantUuid() {
+    return this._tenantUuid;
   }
-  async getConnection() {
-    const conn = await this._pool.getConnection();
-    return this.wrap(conn);
+  get aggregateUuid() {
+    return this._aggregateUuid;
   }
-  async closePool() {
-    await this._pool.end();
+  get aggregateType() {
+    return this._aggregateType;
   }
-  static async ping() {
-    const connector = new _MysqlConnector();
-    try {
-      const conn = await connector._pool.getConnection();
-      await conn.ping();
-      conn.release();
-      return true;
-    } catch {
-      return false;
-    } finally {
-      await connector.closePool();
-    }
+  get eventType() {
+    return this._eventType;
   }
-};
-_MysqlConnector.DEFAULT_POOL_SIZE = 20;
-var MysqlConnector = _MysqlConnector;
-var MysqlConnection = class {
-  constructor(conn) {
-    this._conn = conn;
+  get topic() {
+    return this._topic;
   }
-  async query(statement, params = []) {
-    const [rows] = await this._conn.query(statement, params);
-    return rows;
+  get payload() {
+    return this._payload;
   }
-  async begin() {
-    await this._conn.beginTransaction();
+  get status() {
+    return this._status;
   }
-  async commit() {
-    await this._conn.commit();
+  get attempts() {
+    return this._attempts;
   }
-  async rollback() {
-    await this._conn.rollback();
+  get errorMessage() {
+    return this._errorMessage;
   }
-  async transaction(fn) {
-    await this.begin();
-    try {
-      const result = await fn(this);
-      await this.commit();
-      return result;
-    } catch (err) {
-      await this.rollback();
-      throw err;
-    }
+  get publishedAt() {
+    return this._publishedAt;
+  }
+  get lastAttempt() {
+    return this._lastAttempt;
+  }
+  get createdAt() {
+    return this._createdAt;
+  }
+  incrementAttempts() {
+    this._attempts++;
+    this._lastAttempt = DateTime.now();
+  }
+  markProcessed() {
+    this._status = ProcessStatus.PROCESSED;
+    this._publishedAt = DateTime.now();
+  }
+  markProcessing() {
+    this.incrementAttempts();
+    this._status = ProcessStatus.PROCESSING;
+  }
+  markWithError(error) {
+    this._status = this.attempts < 5 ? ProcessStatus.FAILED : ProcessStatus.DEAD;
+    this._errorMessage = error;
+  }
+  toPrimitives() {
+    return {
+      eventUuid: this.eventUuid.value,
+      eventType: this.eventType,
+      tenantUuid: this.tenantUuid.value,
+      aggregateUuid: this.aggregateUuid.value,
+      aggregateType: this.aggregateType,
+      topic: this.topic,
+      payload: this.payload,
+      status: this.status.value,
+      attempts: this.attempts,
+      errorMessage: this.errorMessage ?? void 0,
+      publishedAt: this.publishedAt?.value ?? void 0,
+      lastAttempt: this.lastAttempt?.value ?? void 0,
+      createdAt: this.createdAt.value
+    };
   }
-  async close() {
-    await this._conn.release();
+  static reconstitute(data) {
+    return new _OutboxRecord(
+      UUID.create(data.event_uuid),
+      String(data.event_type),
+      UUID.create(data.tenant_uuid),
+      UUID.create(data.aggregate_uuid),
+      String(data.aggregate_type),
+      String(data.topic),
+      String(data.payload),
+      ProcessStatus.create(data.status),
+      Number(data.attempts),
+      data.error_message ?? void 0,
+      data.published_at ? DateTime.create(data.published_at) : void 0,
+      data.last_attempt ? DateTime.create(data.last_attempt) : void 0,
+      data.created_at ? DateTime.create(data.created_at) : void 0
+    );
   }
 };
 
-// src/infrastructure/http/DefaultController.ts
-var HttpHealthCheckController = class {
-  async handle(request) {
-    return {
-      statusCode: 200,
-      body: {
-        date: DateTime.create().value,
-        code: 200
-      }
-    };
+// src/infrastructure/event-bus/EventBusMysqlRepository.ts
+var EventBusMysqlRepository = class {
+  constructor(connection) {
+    this.connection = connection;
   }
-};
-var HttpNotFoundController = class {
-  async handle(request) {
-    return {
-      statusCode: 404,
-      body: {
-        message: `Route ${request.headers.location} not found`
-      }
-    };
+  eventToRowValues(e) {
+    return [
+      e.eventUuid.value,
+      e.eventType,
+      e.tenantUuid.value,
+      e.aggregateUuid.value,
+      e.aggregateType,
+      e.topic,
+      e.payload,
+      e.status.value,
+      e.attempts,
+      e.errorMessage,
+      e.publishedAt?.value,
+      e.lastAttempt?.value,
+      e.createdAt.value
+    ];
+  }
+  async create(event) {
+    const values = this.eventToRowValues(event);
+    await this.connection.query(
+      `INSERT INTO events_outbox (event_uuid, event_type, tenant_uuid, aggregate_uuid, aggregate_type, topic, 
+                           payload, status, attempts, error_message, published_at, last_attempt, created_at)
+             VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      values
+    );
+  }
+  async update(event) {
+    const values = [event.status.value, event.attempts, event.errorMessage, event.publishedAt?.value, event.lastAttempt?.value, event.eventUuid.value];
+    await this.connection.query(
+      `UPDATE events_outbox
+             SET status          = ?,
+                 attempts        = ?,
+                 error_message   = ?,
+                 published_at    = ?,
+                 last_attempt    = ?
+             WHERE event_uuid = ?`,
+      values
+    );
+  }
+  async listPending(limit) {
+    const result = await this.connection.query(
+      `SELECT * FROM events_outbox WHERE status IN ('PENDING','FAILED') AND published_at IS NULL LIMIT 50`,
+      []
+    );
+    return result.length > 0 ? result.map((r) => OutboxRecord.reconstitute(r)) : [];
   }
 };
 
@@ -1383,56 +1400,26 @@ function adaptExpressErrorHandler(errorManager) {
   };
 }
 
-// src/infrastructure/event-bus/EventBusMysqlRepository.ts
-var EventBusMysqlRepository = class {
-  constructor(connection) {
-    this.connection = connection;
-  }
-  eventToRowValues(e) {
-    return [
-      e.eventUuid.value,
-      e.eventType,
-      e.tenantUuid.value,
-      e.aggregateUuid.value,
-      e.aggregateType,
-      e.topic,
-      e.payload,
-      e.status.value,
-      e.attempts,
-      e.errorMessage,
-      e.publishedAt?.value,
-      e.lastAttempt?.value,
-      e.createdAt.value
-    ];
-  }
-  async create(event) {
-    const values = this.eventToRowValues(event);
-    await this.connection.query(
-      `INSERT INTO events_outbox (event_uuid, event_type, tenant_uuid, aggregate_uuid, aggregate_type, topic, 
-                           payload, status, attempts, error_message, published_at, last_attempt, created_at)
-             VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-      values
-    );
-  }
-  async update(event) {
-    const values = [event.status.value, event.attempts, event.errorMessage, event.publishedAt?.value, event.lastAttempt?.value, event.eventUuid.value];
-    await this.connection.query(
-      `UPDATE events_outbox
-             SET status          = ?,
-                 attempts        = ?,
-                 error_message   = ?,
-                 published_at    = ?,
-                 last_attempt    = ?
-             WHERE event_uuid = ?`,
-      values
-    );
+// src/infrastructure/http/DefaultController.ts
+var HttpHealthCheckController = class {
+  async handle(request) {
+    return {
+      statusCode: 200,
+      body: {
+        date: DateTime.create().value,
+        code: 200
+      }
+    };
   }
-  async listPending(limit) {
-    const result = await this.connection.query(
-      `SELECT * FROM events_outbox WHERE status IN ('PENDING','FAILED') AND published_at IS NULL LIMIT 50`,
-      []
-    );
-    return result.length > 0 ? result.map((r) => DomainEvent.reconstitute(r)) : [];
+};
+var HttpNotFoundController = class {
+  async handle(request) {
+    return {
+      statusCode: 404,
+      body: {
+        message: `Route ${request.headers.location} not found`
+      }
+    };
   }
 };
 
@@ -1473,8 +1460,7 @@ var KafkaManager = class extends EventManager {
         eachMessage: async ({ topic, partition, message, heartbeat }) => {
           try {
             await this.execCallback(this._onMessage, `[New message detected for ${topic}]: ${message.value?.toString()}`);
-            const evt = JSON.parse(String(message.value?.toString()));
-            await this.execRoute(topic, evt);
+            await this.execRoute(topic, String(message.value?.toString()));
             const next = (BigInt(message.offset) + 1n).toString();
             await this.consumer.commitOffsets([{ topic, partition, offset: next }]);
             await heartbeat();
@@ -1490,28 +1476,12 @@ var KafkaManager = class extends EventManager {
       await this.execCallback(this._onError, new InternalError(ErrorManager.APP_ERRORS.PROCESS, error.toString()));
     }
   }
-  async send(message) {
-    if (!message.producer) {
-      message.producer = process.env.NAME && process.env.ENVIRONMENT ? `${process.env.NAME}-${process.env.ENVIRONMENT}` : "unknown";
-    }
-    if (!message.date) {
-      message.date = DateTime.now().value;
-    }
-    try {
-      if (!this.producer) {
-        throw new InternalError(ErrorManager.APP_ERRORS.PROCESS, "Producer not initialized");
-      }
-      await this.producer.connect();
-      await this.producer.send({
-        topic: message.topic,
-        messages: [{ value: JSON.stringify({ producer: message.producer, data: message }) }]
-      });
-      await this.producer.disconnect();
-    } catch (error) {
-      throw new InternalError(error.toString());
-    }
-  }
-  async sendRaw(message, topic) {
+  async send(topic, message) {
+    const evt = {
+      date: DateTime.now().value,
+      producer: process.env.NAME && process.env.ENVIRONMENT ? `${process.env.NAME}-${process.env.ENVIRONMENT}` : "unknown",
+      data: message
+    };
     try {
       if (!this.producer) {
         throw new InternalError(ErrorManager.APP_ERRORS.PROCESS, "Producer not initialized");
@@ -1519,7 +1489,7 @@ var KafkaManager = class extends EventManager {
       await this.producer.connect();
       await this.producer.send({
         topic,
-        messages: [{ value: message }]
+        messages: [{ value: JSON.stringify(evt) }]
       });
       await this.producer.disconnect();
     } catch (error) {
@@ -1543,6 +1513,84 @@ var KafkaManager = class extends EventManager {
   }
 };
 
+// src/infrastructure/mysql/Mysql.ts
+import { createPool } from "mysql2/promise";
+var _MysqlConnector = class _MysqlConnector {
+  constructor(pool) {
+    this._pool = pool ?? createPool({
+      host: process.env.DB_HOST,
+      port: Number(process.env.DB_PORT ?? 3306),
+      user: process.env.DB_USER,
+      password: process.env.DB_PASSWORD,
+      database: process.env.DB_DATABASE,
+      dateStrings: true,
+      connectionLimit: Number(process.env.DB_POOL_SIZE) || _MysqlConnector.DEFAULT_POOL_SIZE,
+      decimalNumbers: true
+    });
+  }
+  async wrap(conn) {
+    return new MysqlConnection(conn);
+  }
+  async query(sql, params = []) {
+    const [rows] = await this._pool.query(sql, params);
+    return rows;
+  }
+  async getConnection() {
+    const conn = await this._pool.getConnection();
+    return this.wrap(conn);
+  }
+  async closePool() {
+    await this._pool.end();
+  }
+  static async ping() {
+    const connector = new _MysqlConnector();
+    try {
+      const conn = await connector._pool.getConnection();
+      await conn.ping();
+      conn.release();
+      return true;
+    } catch {
+      return false;
+    } finally {
+      await connector.closePool();
+    }
+  }
+};
+_MysqlConnector.DEFAULT_POOL_SIZE = 20;
+var MysqlConnector = _MysqlConnector;
+var MysqlConnection = class {
+  constructor(conn) {
+    this._conn = conn;
+  }
+  async query(statement, params = []) {
+    const [rows] = await this._conn.query(statement, params);
+    return rows;
+  }
+  async begin() {
+    await this._conn.beginTransaction();
+  }
+  async commit() {
+    await this._conn.commit();
+  }
+  async rollback() {
+    await this._conn.rollback();
+  }
+  async transaction(fn) {
+    await this.begin();
+    try {
+      const result = await fn(this);
+      await this.commit();
+      return result;
+    } catch (err) {
+      await this.rollback();
+      throw err;
+    }
+  }
+  async close() {
+    await this._conn.release();
+  }
+};
+
 // src/utils/ExchangeRates.ts
 var ExchangeRates = class _ExchangeRates extends BaseObject {
   constructor(props) {
@@ -1595,6 +1643,7 @@ var ExchangeRates = class _ExchangeRates extends BaseObject {
   }
 };
 export {
+  BaseEvent,
   BaseObject,
   BasicUnitOfWork,
   BasicUnitOfWorkFactory,
@@ -1604,7 +1653,6 @@ export {
   DomainEntity,
   DomainError,
   DomainEvent,
-  DomainEventStatus,
   Email,
   ErrorManager,
   EventBus,
@@ -1614,14 +1662,18 @@ export {
   FatalError,
   HttpHealthCheckController,
   HttpNotFoundController,
+  IntegrationEvent,
   InternalError,
   KafkaManager,
   Language,
   MysqlConnection,
   MysqlConnector,
+  OutboxRecord,
   PaymentGateway,
   PaymentStatus,
   Price,
+  ProcessStatus,
+  StringVars,
   UUID,
   UsageError,
   ValueObject,