wsp-ms-core 1.0.7 → 1.0.8-7.6

package/dist/index.js

@@ -7,6 +7,9 @@ var ValueObject = class {
     this.validate(value);
     this._value = Object.freeze(value);
   }
+  toProps() {
+    return this._value;
+  }
   get value() {
     return this._value;
   }
@@ -100,6 +103,21 @@ var _DateTime = class _DateTime extends ValueObject {
   getWeekdayName(locale = "en") {
     return this._dt.setLocale(locale).toFormat("cccc");
   }
+  getDayName(locale = "en") {
+    return this._dt.setLocale(locale).toFormat("EEEE");
+  }
+  format(format) {
+    if (!_DateTime.FORMATS.hasOwnProperty(format)) {
+      throw new Error(`Invalid format: ${format}`);
+    }
+    const formatString = _DateTime.FORMATS[format];
+    return this._dt.toFormat(formatString);
+  }
+  toPrimitives() {
+    return {
+      value: this.value
+    };
+  }
   static create(input) {
     if (input === void 0) {
       return new _DateTime(_DateTime.toUtcFormat(LuxonDateTime.now()));
@@ -115,39 +133,106 @@ var _DateTime = class _DateTime extends ValueObject {
     }
     return new _DateTime(input);
   }
+  static now() {
+    return _DateTime.create();
+  }
 };
 _DateTime.DEFAULT_FORMAT = "yyyy-MM-dd HH:mm:ss";
+_DateTime.FORMAT = "Y-M-D H:M:S";
+_DateTime.FORMAT_Y_M = "Y-M";
+_DateTime.FORMAT_Y_M_D = "Y-M-D";
+_DateTime.FORMAT_Y_M_D_H_m_s = "Y-M-D H:M:S";
+_DateTime.FORMAT_D_M_Y = "D-M-Y";
+_DateTime.FORMATS = {
+  "Y-M": "yyyy-MM",
+  "Y-M-D": "yyyy-MM-dd",
+  "D/M/Y": "dd/MM/yyyy",
+  "Y/M/D": "yyyy/MM/dd",
+  "D-M-Y": "dd-MM-yyyy",
+  "Y.M.D": "yyyy.MM.dd",
+  "D.M.Y": "dd.MM.yyyy",
+  "Y-M-D H:M": "yyyy-MM-dd HH:mm",
+  "D/M/Y H:M": "dd/MM/yyyy HH:mm",
+  "Y/M/D H:M": "yyyy/MM/dd HH:mm",
+  "D-M-Y H:M": "dd-MM-yyyy HH:mm",
+  "Y.M.D H:M": "yyyy.MM.dd HH:mm",
+  "D.M.Y H:M": "dd.MM.yyyy HH:mm",
+  "Y-M-D H:M:S": "yyyy-MM-dd HH:mm:ss",
+  "Y-M-D H:M:S:SSS": "yyyy-MM-dd HH:mm:ss.SSS",
+  "D/M/Y H:M:S": "dd/MM/yyyy HH:mm:ss",
+  "Y/M/D H:M:S": "yyyy/MM/dd HH:mm:ss",
+  "D-M-Y H:M:S": "dd-MM-yyyy HH:mm:ss",
+  "Y.M.D H:M:S": "yyyy.MM.dd HH:mm:ss",
+  "D.M.Y H:M:S": "dd.MM.yyyy HH:mm:ss",
+  "H:M": "HH:mm",
+  "H:M:S": "HH:mm:ss"
+};
 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(uuid, props, audit) {
-    this.uuid = uuid;
+  constructor(props) {
+    this._events = [];
     this.props = props;
-    this._createdAt = audit?.createdAt ?? DateTime.create();
-    this._updatedAt = audit?.updatedAt ?? this.createdAt;
-    this._deletedAt = audit?.deletedAt;
+  }
+  recordEvent(event) {
+    this._events.push(event);
   }
   touch() {
-    this._updatedAt = DateTime.create();
+    this.props.updatedAt = DateTime.now();
+  }
+  get uuid() {
+    return this.props.uuid;
   }
   get createdAt() {
-    return this._createdAt;
+    return this.props.createdAt;
   }
   get updatedAt() {
-    return this._updatedAt;
+    return this.props.updatedAt;
   }
   get deletedAt() {
-    return this._deletedAt;
+    return this.props.deletedAt;
   }
   get isDeleted() {
-    return Boolean(this._deletedAt);
+    return Boolean(this.props.deletedAt);
   }
-  softDelete() {
-    if (!this._deletedAt) {
-      this._deletedAt = DateTime.create();
-      this.touch();
-    }
+  pullEvents() {
+    const events = this._events;
+    this._events = [];
+    return events;
+  }
+};
+
+// src/domain/contracts/BaseObject.ts
+var BaseObject = class {
+  constructor(props) {
+    this.props = props;
   }
 };
 
@@ -159,20 +244,6 @@ var DomainError = class extends Error {
   }
 };
 
-// src/domain/contracts/DomainEvent.ts
-var DomainEvent = class {
-  constructor(payload) {
-    this._payload = payload;
-    this._occurredAt = DateTime.create();
-  }
-  get payload() {
-    return this._payload;
-  }
-  get occurredAt() {
-    return this._occurredAt;
-  }
-};
-
 // src/domain/errors/FatalError.ts
 var FatalError = class extends DomainError {
   constructor(type, message = "") {
@@ -195,6 +266,424 @@ var UsageError = class extends DomainError {
   }
 };
 
+// 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;
+  }
+  get aggregateUuid() {
+    return this._aggregateUuid;
+  }
+  get aggregateType() {
+    return this._aggregateType;
+  }
+};
+
+// src/domain/value-objects/payments/PaymentGateway.ts
+var _PaymentGateway = class _PaymentGateway extends ValueObject {
+  constructor(gateway) {
+    super(gateway);
+  }
+  validate(value) {
+    if (!_PaymentGateway.SUPPORTED.includes(value)) {
+      throw new InternalError(`Payment gateway <${value}> is not supported`);
+    }
+  }
+  isExternal() {
+    return _PaymentGateway.EXTERNALS.includes(this.value);
+  }
+  get isMercadoPago() {
+    return this.equals(_PaymentGateway.MERCADOPAGO);
+  }
+  get isHandy() {
+    return this.equals(_PaymentGateway.HANDY);
+  }
+  get isWonaDebit() {
+    return this.equals(_PaymentGateway.WONA_DEBIT);
+  }
+  get isWonaCard() {
+    return this.equals(_PaymentGateway.WONA_CARD);
+  }
+  get isWonaCash() {
+    return this.equals(_PaymentGateway.WONA_CASH);
+  }
+  get isWonaTransfer() {
+    return this.equals(_PaymentGateway.WONA_TRANSFER);
+  }
+  get isWonaMercadoPago() {
+    return this.equals(_PaymentGateway.WONA_MERCADOPAGO);
+  }
+  toPrimitives() {
+    return { value: this.value };
+  }
+  static create(gateway) {
+    return new _PaymentGateway(gateway.trim().toUpperCase());
+  }
+};
+_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);
+  }
+  validate(status) {
+    if (!_PaymentStatus.SUPPORTED.includes(status)) {
+      throw new InternalError(`Payment status <${status}> is not supported`);
+    }
+  }
+  get isDone() {
+    return this.value === "DONE";
+  }
+  get isPending() {
+    return this.value === "PENDING";
+  }
+  get isInProgress() {
+    return this.value === "IN_PROGRESS";
+  }
+  get isFailed() {
+    return this.value === "FAILED";
+  }
+  get isCanceled() {
+    return this.value === "CANCELED";
+  }
+  get isHold() {
+    return this.value === "HOLD";
+  }
+  get isPendingRefund() {
+    return this.value === "PENDING_REFUND";
+  }
+  get isRefunded() {
+    return this.value === "REFUNDED";
+  }
+  toPrimitives() {
+    return { value: this.value };
+  }
+  static create(gateway) {
+    return new _PaymentStatus(gateway.trim().toUpperCase());
+  }
+};
+_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 {
+  static parse(str, ob) {
+    const regex = /{{(.*?)}}/g;
+    return str.replace(regex, (match, variable) => {
+      if (ob.hasOwnProperty(variable.trim())) {
+        return ob[variable.trim()];
+      } else {
+        return match;
+      }
+    });
+  }
+};
+
+// src/infrastructure/errors/ErrorManager.ts
+var _ErrorManager = class _ErrorManager {
+  constructor(logger = null) {
+    this.logger = logger;
+  }
+  getDefaultMessage(lang) {
+    return _ErrorManager.DEFAULT_MESSAGES[lang.value] || _ErrorManager.DEFAULT_MESSAGES[lang.base()] || "error";
+  }
+  onFatal(err, lang) {
+    this.logger?.fatal(err.type, err.message);
+    return { status: "ERROR", message: this.getDefaultMessage(lang) };
+  }
+  onInternal(err, lang) {
+    this.logger?.error(err.type, err.message);
+    return { status: "ERROR", message: this.getDefaultMessage(lang) };
+  }
+  onUsage(err, lang) {
+    const tmpl = _ErrorManager.TEMPLATES.get(err.type);
+    if (!tmpl) {
+      this.logger?.error("TEMPLATE_NOT_FOUND", `${err.type}`);
+      return { status: "ERROR", message: this.getDefaultMessage(lang) };
+    }
+    const code = lang.value;
+    const base = lang.base();
+    const rawMsg = tmpl.languages[code] ?? tmpl.languages[base] ?? this.getDefaultMessage(lang);
+    return {
+      status: 400,
+      message: StringVars.parse(rawMsg, err.vars)
+    };
+  }
+  onUnknown(err, lang) {
+    this.logger?.error("UNKNOWN_ERROR", err.message);
+    return { status: "ERROR", message: this.getDefaultMessage(lang) };
+  }
+  handle(err, lang) {
+    if (["local", "dev"].includes(process.env.ENVIRONMENT ?? "")) {
+      console.log(err);
+    }
+    if (err instanceof FatalError) {
+      return this.onFatal(err, lang);
+    }
+    if (err instanceof InternalError) {
+      return this.onInternal(err, lang);
+    }
+    if (err instanceof UsageError) {
+      return this.onUsage(err, lang);
+    }
+    return this.onUnknown(err, lang);
+  }
+  static addTemplate(template) {
+    _ErrorManager.TEMPLATES.set(template.type, template);
+  }
+};
+_ErrorManager.DEFAULT_MESSAGES = {
+  "es": "Ups, hemos encontrado un error. Nuestro equipo ya est\xE1 trabajando para solucionarlo",
+  "en": "Ups, we found an error. Our team is working on it.",
+  "pt": "Ops, encontramos um bug. Nossa equipe j\xE1 est\xE1 trabalhando para resolver isso."
+};
+_ErrorManager.APP_ERRORS = {
+  UNDEFINED: "UNDEFINED_ERROR",
+  PROCESS: "PROCESS_ERROR",
+  DATABASE: "DATABASE_ERROR"
+};
+_ErrorManager.TEMPLATES = /* @__PURE__ */ new Map();
+var ErrorManager = _ErrorManager;
+
+// src/domain/value-objects/Country.ts
+ErrorManager.addTemplate({
+  type: "INVALID_COUNTRY",
+  languages: {
+    "es": "El pa\xEDs <{{country}}> no es v\xE1lido o no est\xE1 soportado",
+    "en": "Country <{{country}}> is not valid or not supported"
+  }
+});
+ErrorManager.addTemplate({
+  type: "COUNTRY_NOT_FOUND_BY_ALPHA2",
+  languages: {
+    "es": "No se encontr\xF3 pa\xEDs con c\xF3digo alpha2 <{{alpha2}}>",
+    "en": "Country not found with alpha2 code <{{alpha2}}>"
+  }
+});
+ErrorManager.addTemplate({
+  type: "COUNTRY_NOT_FOUND_BY_UUID",
+  languages: {
+    "es": "No se encontr\xF3 pa\xEDs con UUID <{{uuid}}>",
+    "en": "Country not found with UUID <{{uuid}}>"
+  }
+});
+var _Country = class _Country extends ValueObject {
+  constructor(country) {
+    const normalizedCountry = country.toUpperCase().trim();
+    super(normalizedCountry);
+    this._name = normalizedCountry;
+    this._alpha2 = _Country.COUNTRIES[normalizedCountry].alpha2;
+    this._alpha3 = _Country.COUNTRIES[normalizedCountry].alpha3;
+    this._numeric = _Country.COUNTRIES[normalizedCountry].numeric;
+    this._uuid = _Country.COUNTRIES[normalizedCountry].uuid;
+    this._phoneCode = _Country.COUNTRIES[normalizedCountry].phoneCode;
+    this._url = _Country.COUNTRIES[normalizedCountry].url;
+  }
+  validate(country) {
+    if (!_Country.NAMES.includes(country)) {
+      throw new UsageError("INVALID_COUNTRY", { country });
+    }
+  }
+  name() {
+    return this._name;
+  }
+  alpha2() {
+    return this._alpha2;
+  }
+  alpha3() {
+    return this._alpha3;
+  }
+  numeric() {
+    return this._numeric;
+  }
+  uuid() {
+    return this._uuid;
+  }
+  phoneCode() {
+    return this._phoneCode;
+  }
+  url() {
+    return this._url;
+  }
+  static findCountryByAlpha2(alpha2) {
+    for (const [country, codes] of Object.entries(_Country.COUNTRIES)) {
+      if (codes.alpha2 === alpha2.toUpperCase()) {
+        return new _Country(country);
+      }
+    }
+    throw new UsageError("COUNTRY_NOT_FOUND_BY_ALPHA2", { alpha2 });
+  }
+  static findCountryByUUID(uuid) {
+    for (const [country, codes] of Object.entries(_Country.COUNTRIES)) {
+      if (codes.uuid === uuid) {
+        return new _Country(country);
+      }
+    }
+    throw new UsageError("COUNTRY_NOT_FOUND_BY_UUID", { uuid });
+  }
+  static create(country) {
+    return new _Country(country);
+  }
+  static createOrDefault(country) {
+    try {
+      return new _Country(country);
+    } catch (error) {
+      return _Country.DEFAULT;
+    }
+  }
+  toPrimitives() {
+    return {
+      value: this.value,
+      name: this._name,
+      alpha2: this._alpha2,
+      alpha3: this._alpha3,
+      numeric: this._numeric,
+      uuid: this._uuid,
+      phoneCode: this._phoneCode,
+      url: this._url
+    };
+  }
+  static isValid(country) {
+    try {
+      _Country.create(country);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+_Country.COUNTRIES = {
+  URUGUAY: {
+    alpha2: "UY",
+    alpha3: "URY",
+    numeric: "858",
+    phoneCode: "+598",
+    uuid: "5739ecc0-d12b-4db5-8897-e03a04a95c72",
+    url: "https://dev-wonasports.s3.us-east-2.amazonaws.com/assets/uruguay.png"
+  },
+  ARGENTINA: {
+    alpha2: "AR",
+    alpha3: "ARG",
+    numeric: "032",
+    phoneCode: "+54",
+    uuid: "66663efe-ab7a-4166-b971-9f36fd0ea6b2",
+    url: "https://dev-wonasports.s3.us-east-2.amazonaws.com/assets/argentina.png"
+  },
+  ECUADOR: {
+    alpha2: "EC",
+    alpha3: "ECU",
+    numeric: "218",
+    phoneCode: "+593",
+    uuid: "ee109239-0150-4e5f-9ff2-a85f270092b1",
+    url: "https://dev-wonasports.s3.us-east-2.amazonaws.com/assets/ecuador.png"
+  },
+  PERU: {
+    alpha2: "PE",
+    alpha3: "PER",
+    numeric: "604",
+    phoneCode: "+51",
+    uuid: "e4d61ef5-b92d-4f9c-8ec1-23f4beb50abd",
+    url: "https://dev-wonasports.s3.us-east-2.amazonaws.com/assets/peru.png"
+  },
+  BRASIL: {
+    alpha2: "BR",
+    alpha3: "BRA",
+    numeric: "076",
+    phoneCode: "+55",
+    uuid: "b7b91d72-deaf-4641-957c-a65003e33104",
+    url: "https://dev-wonasports.s3.us-east-2.amazonaws.com/assets/brasil.png"
+  },
+  CHILE: {
+    alpha2: "CL",
+    alpha3: "CHL",
+    numeric: "152",
+    phoneCode: "+56",
+    uuid: "f69b35f4-d734-4c76-866c-29a18bf000fb",
+    url: "https://dev-wonasports.s3.us-east-2.amazonaws.com/assets/chile.png"
+  },
+  VENEZUELA: {
+    alpha2: "VE",
+    alpha3: "VEN",
+    numeric: "862",
+    phoneCode: "+58",
+    uuid: "31b6c591-63f6-43db-8ea9-829bb03746c5",
+    url: "https://dev-wonasports.s3.us-east-2.amazonaws.com/assets/venezuela.png"
+  },
+  COLOMBIA: {
+    alpha2: "CO",
+    alpha3: "COL",
+    numeric: "170",
+    phoneCode: "+57",
+    uuid: "6fdfe34b-6726-4604-96af-665ea5fc9239",
+    url: "https://dev-wonasports.s3.us-east-2.amazonaws.com/assets/colombia.png"
+  },
+  BOLIVIA: {
+    alpha2: "BO",
+    alpha3: "BOL",
+    numeric: "068",
+    phoneCode: "+591",
+    uuid: "948886db-c280-4ba7-a777-a76c180b295b",
+    url: "https://dev-wonasports.s3.us-east-2.amazonaws.com/assets/bolivia.png"
+  },
+  PARAGUAY: {
+    alpha2: "PY",
+    alpha3: "PRY",
+    numeric: "600",
+    phoneCode: "+595",
+    uuid: "d67b3472-e38d-4900-8ae3-02d99cd1d884",
+    url: "https://dev-wonasports.s3.us-east-2.amazonaws.com/assets/paraguay.png"
+  },
+  USA: {
+    alpha2: "US",
+    alpha3: "USA",
+    numeric: "840",
+    phoneCode: "+1",
+    uuid: "16ac3b9b-8f7b-4c54-91d5-d62c7cd74ad4",
+    url: "https://dev-wonasports.s3.us-east-2.amazonaws.com/assets/usa.png"
+  }
+};
+_Country.NAMES = Object.keys(_Country.COUNTRIES);
+_Country.DEFAULT = new _Country("URUGUAY");
+_Country.ARGENTINA = new _Country("ARGENTINA");
+_Country.ECUADOR = new _Country("ECUADOR");
+_Country.PERU = new _Country("PERU");
+_Country.BRASIL = new _Country("BRASIL");
+_Country.CHILE = new _Country("CHILE");
+_Country.VENEZUELA = new _Country("VENEZUELA");
+_Country.COLOMBIA = new _Country("COLOMBIA");
+_Country.BOLIVIA = new _Country("BOLIVIA");
+_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) {
@@ -210,6 +699,11 @@ var _Currency = class _Currency extends ValueObject {
       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);
@@ -263,6 +757,11 @@ var _Email = class _Email extends ValueObject {
       throw new Error(`Email <${value}> is not a valid address`);
     }
   }
+  toPrimitives() {
+    return {
+      value: this.value
+    };
+  }
   static create(raw) {
     return new _Email(raw);
   }
@@ -280,12 +779,18 @@ var _Language = class _Language extends ValueObject {
   }
   validate(value) {
     if (!_Language.SUPPORTED.includes(value)) {
-      throw new Error(`Language <${value}> is not supported`);
+      throw new InternalError(`Language <${value}> is not supported`);
     }
   }
   base() {
     return this.value.split("-")[0];
   }
+  toPrimitives() {
+    return {
+      base: this.base(),
+      value: this.value
+    };
+  }
   static create(raw) {
     const normalized = raw.trim().toLowerCase().replace("_", "-");
     try {
@@ -366,25 +871,43 @@ _Language.SPANISH_PUERTO_RICO = new _Language("es-pr");
 var Language = _Language;
 
 // src/domain/value-objects/Price.ts
+ErrorManager.addTemplate({
+  type: "INVALID_PRICE_AMOUNT",
+  languages: {
+    "es": "El precio <{{amount}}> no es v\xE1lido",
+    "en": "Price amount <{{amount}}> is not a valid number"
+  }
+});
+ErrorManager.addTemplate({
+  type: "INVALID_PRICE_RANGE",
+  languages: {
+    "es": "El precio <{{amount}}> debe ser \u2265 {{min}} y \u2264 {{max}}",
+    "en": "Price amount <{{amount}}> must be \u2265 {{min}} and \u2264 {{max}}"
+  }
+});
 var _Price = class _Price extends ValueObject {
   constructor(amount, currency) {
     super({ amount, currency });
-    this.amount = amount;
-    this.currency = currency;
   }
   validate(props) {
     const { amount, currency } = props;
     if (typeof amount !== "number" || Number.isNaN(amount) || !Number.isFinite(amount)) {
-      throw new Error(`Price amount <${amount}> is not a valid number`);
+      throw new UsageError("INVALID_PRICE_AMOUNT", { amount });
     }
-    if (amount < _Price.MIN_AMOUNT) {
-      throw new Error(`Price amount <${amount}> must be \u2265 ${_Price.MIN_AMOUNT}`);
+    if (amount < _Price.MIN_AMOUNT || amount > _Price.MAX_AMOUNT) {
+      throw new UsageError("INVALID_PRICE_RANGE", { amount, min: _Price.MIN_AMOUNT, max: _Price.MAX_AMOUNT });
     }
   }
+  get amount() {
+    return this._value.amount;
+  }
+  get currency() {
+    return this._value.currency;
+  }
   equals(other) {
     if (!other)
       return false;
-    return this.amount === other.amount && this.currency.equals(other.currency);
+    return this._value.amount === other.amount && this.currency.equals(other.currency);
   }
   assertSameCurrency(other) {
     if (!this.currency.equals(other.currency)) {
@@ -399,190 +922,537 @@ var _Price = class _Price extends ValueObject {
     this.assertSameCurrency(other);
     return _Price.create(this.amount - other.amount, this.currency);
   }
+  toPrimitives() {
+    return {
+      amount: this.amount,
+      currency: this.currency.value
+    };
+  }
   static create(amount, currency) {
     const cur = currency instanceof Currency ? currency : Currency.create(currency);
     return new _Price(amount, cur);
   }
+  static createFromPrimitives(data) {
+    return new _Price(Number(data.amount), Currency.create(String(data.currency)));
+  }
 };
 _Price.MIN_AMOUNT = -1e6;
+_Price.MAX_AMOUNT = 1e9;
 var Price = _Price;
 
+// src/domain/value-objects/ProcessStatus.ts
+var _ProcessStatus = class _ProcessStatus extends ValueObject {
+  constructor(status) {
+    super(status.trim().toUpperCase());
+  }
+  validate(value) {
+    if (!_ProcessStatus.SUPPORTED.includes(value)) {
+      throw new InternalError(`Domain event status <${value}> is not supported`);
+    }
+  }
+  toPrimitives() {
+    return void 0;
+  }
+  static create(status) {
+    return new _ProcessStatus(status);
+  }
+};
+_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/UUID.ts
-var UUID = class _UUID extends ValueObject {
+import * as crypto from "crypto";
+var _UUID = class _UUID extends ValueObject {
   constructor(value) {
     super(value);
   }
   validate(uuid) {
     if (!_UUID.isValid(uuid)) {
-      throw new Error(`Invalid uuid ${uuid}`);
+      throw new InternalError(`Invalid uuid <${uuid}>`);
     }
   }
+  toPrimitives() {
+    return { value: this.value };
+  }
   static create(uuid) {
     return new _UUID(uuid ?? crypto.randomUUID());
   }
-  static isValid(uuid) {
-    return /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(uuid);
+  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);
   }
 };
+_UUID.NIL = "00000000-0000-0000-0000-000000000000";
+var UUID = _UUID;
 
-// src/utils/StringVars.ts
-var StringVars = class {
-  static parse(str, ob) {
-    const regex = /{{(.*?)}}/g;
-    return str.replace(regex, (match, variable) => {
-      if (ob.hasOwnProperty(variable.trim())) {
-        return ob[variable.trim()];
-      } else {
-        return match;
-      }
-    });
+// 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;
+  }
+  get aggregateUuid() {
+    return this._aggregateUuid;
+  }
+  get aggregateType() {
+    return this._aggregateType;
   }
 };
 
-// src/infrastructure/errors/ErrorManager.ts
-var _ErrorManager = class _ErrorManager {
-  constructor(logger = null) {
-    this.logger = logger;
+// src/application/event-bus/EventBus.ts
+var _EventBus = class _EventBus {
+  constructor(repository) {
+    this.repository = repository;
+  }
+  async publish(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));
   }
-  getDefaultMessage(lang) {
-    return _ErrorManager.DEFAULT_MESSAGES[lang.value] || _ErrorManager.DEFAULT_MESSAGES[lang.base()] || "error";
+  async publishMany(events) {
+    for (let event of events) {
+      await this.publish(event);
+    }
   }
-  onFatal(err, lang) {
-    this.logger?.fatal(err.type, err.message);
-    return { status: "ERROR", message: this.getDefaultMessage(lang) };
+  static addMapper(eventType, mapper) {
+    _EventBus.MAPPERS.set(eventType, mapper);
   }
-  onInternal(err, lang) {
-    this.logger?.error(err.type, err.message);
-    return { status: "ERROR", message: this.getDefaultMessage(lang) };
+};
+_EventBus.MAPPERS = /* @__PURE__ */ new Map();
+var EventBus = _EventBus;
+
+// src/application/unit-of-work/BasicUnitOfWork.ts
+var BasicUnitOfWork = class {
+  constructor(conn) {
+    this.connection = conn;
   }
-  onUsage(err, lang) {
-    const tmpl = _ErrorManager.TEMPLATES.get(err.type);
-    if (!tmpl) {
-      this.logger?.error("TEMPLATE_NOT_FOUND", `${err.type}`);
-      return { status: "ERROR", message: this.getDefaultMessage(lang) };
+  async execute(fn) {
+    await this.connection.begin();
+    try {
+      const result = await fn();
+      await this.connection.commit();
+      return result;
+    } catch (err) {
+      await this.connection.rollback();
+      throw err;
+    } finally {
+      await this.connection.close();
     }
-    const code = lang.value;
-    const base = lang.base();
-    const rawMsg = tmpl.languages[code] ?? tmpl.languages[base] ?? this.getDefaultMessage(lang);
-    return {
-      status: "ERROR",
-      message: StringVars.parse(rawMsg, err.vars)
-    };
   }
-  onUnknown(err, lang) {
-    this.logger?.error("UNKNOWN_ERROR", err.message);
-    return { status: "ERROR", message: this.getDefaultMessage(lang) };
+};
+
+// src/application/unit-of-work/BasicUnitOfWorkFactory.ts
+var BasicUnitOfWorkFactory = class {
+  constructor(connector) {
+    this.connector = connector;
   }
-  handle(err, lang) {
-    if (["local", "dev"].includes(process.env.ENVIRONMENT ?? "")) {
-      console.log(err);
-    }
-    if (err instanceof FatalError) {
-      return this.onFatal(err, lang);
-    }
-    if (err instanceof InternalError) {
-      return this.onInternal(err, lang);
+  async create() {
+    const conn = await this.connector.getConnection();
+    return new BasicUnitOfWork(conn);
+  }
+};
+
+// src/infrastructure/contracts/EventManager.ts
+var EventManager = class {
+  constructor(connection) {
+    this._connection = connection;
+    this._topics = [];
+    this._callbackList = {};
+    this._onStart = null;
+    this._onConnected = null;
+    this._onSubscribe = null;
+    this._onMessage = null;
+    this._onError = null;
+    this._onCrash = null;
+    this._onReconnect = null;
+  }
+  async execRoute(topic, event) {
+    if (this._callbackList[topic]) {
+      await this._callbackList[topic](event);
     }
-    if (err instanceof UsageError) {
-      return this.onUsage(err, lang);
+  }
+  async execCallback(callback, data) {
+    if (callback) {
+      await callback(data);
     }
-    return this.onUnknown(err, lang);
   }
-  static addTemplate(template) {
-    _ErrorManager.TEMPLATES.set(template.type, template);
+  route(topic, callback) {
+    this._topics.push(topic);
+    this._callbackList[topic] = callback;
+  }
+  onStart(callback) {
+    this._onStart = callback;
+  }
+  onConnected(callback) {
+    this._onConnected = callback;
+  }
+  onSubscribe(callback) {
+    this._onSubscribe = callback;
+  }
+  onMessage(callback) {
+    this._onMessage = callback;
+  }
+  onError(callback) {
+    this._onError = callback;
+  }
+  onCrash(callback) {
+    this._onCrash = callback;
+  }
+  onReconnect(callback) {
+    this._onReconnect = callback;
+  }
+  get topics() {
+    return this._topics;
+  }
+  get callbackList() {
+    return this._callbackList;
   }
 };
-_ErrorManager.DEFAULT_MESSAGES = {
-  "es": "Ups, hemos encontrado un error. Nuestro equipo ya est\xE1 trabajando para solucionarlo",
-  "en": "Ups, we found an error. Our team is working on it.",
-  "pt": "Ops, encontramos um bug. Nossa equipe j\xE1 est\xE1 trabalhando para resolver isso."
-};
-_ErrorManager.APP_ERRORS = {
-  UNDEFINED: "UNDEFINED_ERROR",
-  PROCESS: "PROCESS_ERROR",
-  DATABASE: "DATABASE_ERROR"
-};
-_ErrorManager.TEMPLATES = /* @__PURE__ */ new Map();
-var ErrorManager = _ErrorManager;
 
-// src/infrastructure/mysql/MysqlConnector.ts
-import { createPool } from "mysql2/promise";
-
-// src/infrastructure/mysql/MysqlConnection.ts
-var MysqlConnection = class {
-  constructor(conn) {
-    this._conn = conn;
+// 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 ?? DateTime.now();
   }
-  async query(statement, params = []) {
-    const [rows] = await this._conn.query(statement, params);
-    return rows;
+  get eventUuid() {
+    return this._eventUuid;
   }
-  async begin() {
-    await this._conn.beginTransaction();
+  get tenantUuid() {
+    return this._tenantUuid;
   }
-  async commit() {
-    await this._conn.commit();
+  get aggregateUuid() {
+    return this._aggregateUuid;
   }
-  async rollback() {
-    await this._conn.rollback();
+  get aggregateType() {
+    return this._aggregateType;
   }
-  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 eventType() {
+    return this._eventType;
   }
-  async close() {
-    this._conn.release();
+  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;
+  }
+  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
+    };
+  }
+  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/mysql/MysqlConnector.ts
-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_NAME,
-      connectionLimit: Number(process.env.DB_POOL_SIZE) || _MysqlConnector.DEFAULT_POOL_SIZE,
-      decimalNumbers: true
-    });
+// src/infrastructure/contracts/InboxRecord.ts
+var InboxRecord = class _InboxRecord {
+  constructor(eventUuid, tenantUuid, topic, producer, payload, status, attempts, errorMessage, lastAttempt, processedAt, createdAt) {
+    this._eventUuid = eventUuid;
+    this._tenantUuid = tenantUuid;
+    this._topic = topic;
+    this._producer = producer;
+    this._payload = payload;
+    this._status = status;
+    this._attempts = attempts ?? 0;
+    this._errorMessage = errorMessage ?? void 0;
+    this._lastAttempt = lastAttempt ?? void 0;
+    this._processedAt = processedAt ?? void 0;
+    this._createdAt = createdAt ?? DateTime.now();
   }
-  async wrap(conn) {
-    return new MysqlConnection(conn);
+  get eventUuid() {
+    return this._eventUuid;
   }
-  async getConnection() {
-    const conn = await this._pool.getConnection();
-    return this.wrap(conn);
+  get tenantUuid() {
+    return this._tenantUuid;
   }
-  async closePool() {
-    await this._pool.end();
+  get topic() {
+    return this._topic;
   }
-  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 producer() {
+    return this._producer;
+  }
+  get payload() {
+    return this._payload;
+  }
+  get status() {
+    return this._status;
+  }
+  get attempts() {
+    return this._attempts;
+  }
+  get errorMessage() {
+    return this._errorMessage;
+  }
+  get lastAttempt() {
+    return this._lastAttempt;
+  }
+  get processedAt() {
+    return this._processedAt;
+  }
+  get createdAt() {
+    return this._createdAt;
+  }
+  incrementAttempts() {
+    this._attempts++;
+    this._lastAttempt = DateTime.now();
+  }
+  markProcessed() {
+    this._status = ProcessStatus.PROCESSED;
+    this._processedAt = 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,
+      tenantUuid: this.tenantUuid.value,
+      topic: this.topic,
+      producer: this.producer,
+      payload: this.payload,
+      status: this.status.value,
+      attempts: this.attempts,
+      errorMessage: this.errorMessage ?? void 0,
+      lastAttempt: this.lastAttempt?.value ?? void 0,
+      processedAt: this.processedAt?.value ?? void 0,
+      createdAt: this.createdAt.value
+    };
+  }
+  static reconstitute(data) {
+    return new _InboxRecord(
+      UUID.create(data.event_uuid),
+      UUID.create(data.tenant_uuid),
+      String(data.topic),
+      String(data.producer),
+      String(data.payload),
+      ProcessStatus.create(data.status),
+      Number(data.attempts),
+      data.error_message ?? void 0,
+      data.last_attempt ? DateTime.create(data.last_attempt) : void 0,
+      data.processed_at ? DateTime.create(data.processed_at) : void 0,
+      data.created_at ? DateTime.create(data.created_at) : void 0
+    );
+  }
+};
+
+// src/infrastructure/event-bus/EventBusMysqlRepository.ts
+var EventBusMysqlRepository = class {
+  constructor(connection) {
+    this.connection = connection;
+  }
+  recordToRowValues(record) {
+    return [
+      record.eventUuid.value,
+      record.eventType,
+      record.tenantUuid.value,
+      record.aggregateUuid.value,
+      record.aggregateType,
+      record.topic,
+      record.payload,
+      record.status.value,
+      record.attempts,
+      record.errorMessage,
+      record.publishedAt?.value,
+      record.lastAttempt?.value,
+      record.createdAt.value
+    ];
+  }
+  async create(record) {
+    const values = this.recordToRowValues(record);
+    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(record) {
+    const values = [record.status.value, record.attempts, record.errorMessage, record.publishedAt?.value, record.lastAttempt?.value, record.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 ${limit}`,
+      []
+    );
+    return result.length > 0 ? result.map((r) => OutboxRecord.reconstitute(r)) : [];
   }
 };
-_MysqlConnector.DEFAULT_POOL_SIZE = 10;
-var MysqlConnector = _MysqlConnector;
 
 // src/infrastructure/express/ExpressAdapters.ts
+var BOOL_TRUE = /* @__PURE__ */ new Set(["1", "true", "yes", "y", "on"]);
+var BOOL_FALSE = /* @__PURE__ */ new Set(["0", "false", "no", "n", "off"]);
+var NUMERIC_KEY_RE = /^(?:page|qty|limit|offset|total|amount|price|count|rounding|min[A-Z_].*|max[A-Z_].*)$/i;
+var DATE_KEY_RE = /(At|Date|_at|_date)$/i;
+function toUtcDateTimeString(raw) {
+  const s = raw.trim();
+  if (/^\d{4}-\d{2}-\d{2}$/.test(s))
+    return `${s} 00:00:00`;
+  if (/^\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2}:\d{2}$/.test(s))
+    return s;
+  const d = new Date(s);
+  if (Number.isNaN(d.getTime()))
+    return void 0;
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${d.getUTCFullYear()}-${pad(d.getUTCMonth() + 1)}-${pad(d.getUTCDate())} ${pad(d.getUTCHours())}:${pad(d.getUTCMinutes())}:${pad(d.getUTCSeconds())}`;
+}
+function coerceScalar(key, v) {
+  if (v == null)
+    return void 0;
+  if (typeof v !== "string")
+    return v;
+  const s = v.trim();
+  if (s === "")
+    return void 0;
+  if (s.toLowerCase() === "null")
+    return null;
+  const low = s.toLowerCase();
+  if (BOOL_TRUE.has(low))
+    return true;
+  if (BOOL_FALSE.has(low))
+    return false;
+  if (NUMERIC_KEY_RE.test(key) && /^-?\d+(\.\d+)?$/.test(s)) {
+    const n = Number(s);
+    if (Number.isFinite(n))
+      return n;
+  }
+  if (DATE_KEY_RE.test(key)) {
+    return toUtcDateTimeString(s) ?? s;
+  }
+  return s;
+}
+function normalizeQuery(q) {
+  const out = {};
+  for (const [key, raw] of Object.entries(q)) {
+    const values = Array.isArray(raw) ? raw : typeof raw === "string" && raw.includes(",") ? raw.split(",").map((s) => s.trim()).filter(Boolean) : [raw];
+    const coerced = values.map((v) => coerceScalar(key, v)).filter((v) => v !== void 0);
+    if (coerced.length === 1)
+      out[key] = coerced[0];
+    else if (coerced.length > 1)
+      out[key] = coerced;
+  }
+  return out;
+}
+function isReadableStream(x) {
+  return x && typeof x.pipe === "function";
+}
+function hasHeader(headers, name) {
+  if (!headers)
+    return false;
+  const lname = name.toLowerCase();
+  return Object.keys(headers).some((h) => h.toLowerCase() === lname);
+}
 function adaptExpressRoute(Controller) {
   return async (req, res, next) => {
     const rawLangHeader = req.headers["accept-language"] ?? req.headers["Accept-Language"] ?? "es";
@@ -591,14 +1461,49 @@ function adaptExpressRoute(Controller) {
     const httpRequest = {
       headers: req.headers,
       params: req.params,
-      query: Object.fromEntries(Object.entries(req.query).map(([k, v]) => [k, String(v)])),
+      query: normalizeQuery(req.query),
       lang,
       body: req.body
     };
     try {
       const controller = new Controller();
-      const { statusCode, body } = await controller.handle(httpRequest);
-      res.status(statusCode).json(body);
+      const { statusCode, body, headers } = await controller.handle(httpRequest);
+      if (headers)
+        res.set(headers);
+      if (isReadableStream(body)) {
+        if (!hasHeader(headers, "Content-Type"))
+          res.set("Content-Type", "application/octet-stream");
+        res.status(statusCode);
+        body.on("error", next);
+        body.pipe(res);
+        return;
+      }
+      const isArrayBuffer = typeof body === "object" && body instanceof ArrayBuffer;
+      const isArrayBufferView = typeof body === "object" && body != null && ArrayBuffer.isView(body);
+      if (Buffer.isBuffer(body) || isArrayBuffer || isArrayBufferView) {
+        let buf;
+        if (Buffer.isBuffer(body)) {
+          buf = body;
+        } else if (isArrayBuffer) {
+          buf = Buffer.from(body);
+        } else {
+          const view = body;
+          buf = Buffer.from(view.buffer, view.byteOffset, view.byteLength);
+        }
+        if (!hasHeader(headers, "Content-Type"))
+          res.set("Content-Type", "application/octet-stream");
+        if (!res.getHeader("Content-Length"))
+          res.set("Content-Length", String(buf.length));
+        res.status(statusCode);
+        res.end(buf);
+        return;
+      }
+      const hasCT = hasHeader(headers, "Content-Type");
+      if (typeof body === "string" || hasCT) {
+        res.status(statusCode).send(body);
+        return;
+      }
+      res.status(statusCode).json(body ?? {});
     } catch (err) {
       next(err);
     }
@@ -615,48 +1520,460 @@ function adaptExpressErrorHandler(errorManager) {
   };
 }
 
-// src/infrastructure/http/HttpNotFoundController.ts
+// src/infrastructure/http/DefaultController.ts
+var HttpHealthCheckController = class {
+  async handle(request) {
+    return {
+      statusCode: 200,
+      body: {
+        date: DateTime.create().value,
+        code: 200
+      }
+    };
+  }
+};
 var HttpNotFoundController = class {
   async handle(request) {
     return {
       statusCode: 404,
       body: {
-        status: "NOT_FOUND",
         message: `Route ${request.headers.location} not found`
       }
     };
   }
 };
 
-// src/infrastructure/http/HttpHealthCheckController.ts
-var HttpHealthCheckController = class {
-  async handle(request) {
-    return {
-      statusCode: 200,
-      body: {
-        date: DateTime.create().value,
-        code: 200,
-        status: "OK"
+// src/infrastructure/kafka/KafkaManager.ts
+import { Kafka, logLevel } from "kafkajs";
+var KafkaManager = class extends EventManager {
+  constructor(connection) {
+    super(connection);
+    this.kafka = new Kafka({
+      brokers: this._connection.brokers,
+      ssl: true,
+      sasl: {
+        mechanism: "scram-sha-256",
+        username: this._connection.userName,
+        password: this._connection.password
+      },
+      logLevel: logLevel.ERROR
+    });
+    this.consumer = this.kafka.consumer({ groupId: process.env.KAFKA_GROUP || "default" });
+    this.producer = this.kafka.producer();
+  }
+  async run(autocommit) {
+    const __run = async () => {
+      await this.execCallback(this._onStart, { message: `--- ${this.constructor.name} started ---` });
+      await this.consumer.connect();
+      await this.execCallback(this._onConnected, { message: `--- ${this.constructor.name} connected to ${this._connection.brokers} ---` });
+      for (let topic of this._topics) {
+        try {
+          await this.consumer.subscribe({ topic, fromBeginning: true });
+          await this.execCallback(this._onSubscribe, { message: `--- ${this.constructor.name} subscribed to ${topic} ---` });
+        } catch (error) {
+          await this.execCallback(this._onConnected, { message: `Error on subscribe to kafka topic: ${topic}` });
+        }
+      }
+      await this.consumer.run({
+        autoCommit: autocommit,
+        // @ts-ignore
+        eachMessage: async ({ topic, partition, message, heartbeat }) => {
+          try {
+            await this.execCallback(this._onMessage, `[New message detected for ${topic}]: ${message.value?.toString()}`);
+            const json = JSON.parse(String(message.value?.toString()));
+            await this.execRoute(topic, {
+              topic: String(json.topic),
+              producer: String(json.producer),
+              tenant: UUID.create(String(json.tenant)),
+              message: json.message
+            });
+            const next = (BigInt(message.offset) + 1n).toString();
+            await this.consumer.commitOffsets([{ topic, partition, offset: next }]);
+            await heartbeat();
+          } catch (error) {
+            await this.execCallback(this._onError, error);
+          }
+        }
+      });
+    };
+    try {
+      await __run();
+    } catch (error) {
+      await this.execCallback(this._onError, new InternalError(ErrorManager.APP_ERRORS.PROCESS, error.toString()));
+    }
+  }
+  async send(e) {
+    const evt = {
+      date: DateTime.now().value,
+      tenant: e.tenant.value,
+      producer: e.producer,
+      data: JSON.parse(e.message)
+    };
+    try {
+      if (!this.producer) {
+        throw new InternalError(ErrorManager.APP_ERRORS.PROCESS, "Producer not initialized");
+      }
+      await this.producer.connect();
+      await this.producer.send({
+        topic: e.topic,
+        messages: [{ value: JSON.stringify(evt) }]
+      });
+      await this.producer.disconnect();
+    } catch (error) {
+      throw new InternalError(error.toString());
+    }
+  }
+  async start(autocommit = false) {
+    this.consumer.on(this.consumer.events.CRASH, async (error) => {
+      await this.execCallback(this._onError, new InternalError(ErrorManager.APP_ERRORS.PROCESS, error.payload.error.stack));
+    });
+    await this.run(autocommit);
+  }
+  async pause() {
+  }
+  async restart() {
+    await this.consumer.stop();
+    await this.start();
+  }
+  async stop() {
+    await this.consumer.stop();
+  }
+};
+
+// 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/infrastructure/runners/default-mysql-outbox-runner.ts
+var DefaultMysqlOutboxRunner = class {
+  constructor(uowFactory, eventManager) {
+    this.errors = [];
+    this.uowFactory = uowFactory;
+    this.eventManager = eventManager;
+    this.interval = Number(process.env.OUTBOX_RUNNER_INTERVAL_MS || 5e3);
+    this.maxEvents = Number(process.env.OUTBOX_RUNNER_MAX_EVENTS || 20);
+  }
+  addError(error) {
+    this.errors.push(error);
+  }
+  logErrors() {
+    if (this.errors.length > 0) {
+      console.error(this.errors);
+      this.errors = [];
+    }
+  }
+  async sleep() {
+    return new Promise((r) => setTimeout(r, this.maxEvents));
+  }
+  async processOutboxRecord(e, eventBusRepository) {
+    try {
+      e.markProcessing();
+      await eventBusRepository.update(e);
+      await this.eventManager.send({
+        topic: e.topic,
+        producer: process.env.NAME && process.env.ENVIRONMENT ? `${process.env.NAME}-${process.env.ENVIRONMENT}` : "unknown",
+        tenant: e.tenantUuid,
+        message: e.payload
+      });
+      e.markProcessed();
+    } catch (error) {
+      const type = String(error.type);
+      e.markWithError(type);
+      throw new Error(type);
+    } finally {
+      await eventBusRepository.update(e);
+    }
+  }
+  async process() {
+    const uow = await this.uowFactory.create();
+    const eventBusRepository = new EventBusMysqlRepository(uow.connection);
+    await uow.execute(async () => {
+      const records = await eventBusRepository.listPending(this.maxEvents);
+      for (let record of records) {
+        try {
+          await this.processOutboxRecord(record, eventBusRepository);
+        } catch (error) {
+          this.addError({ eventUuid: record.eventUuid.value, error: error.toString() });
+        }
+      }
+      this.logErrors();
+    });
+  }
+  async start() {
+    console.log("[outbox-runner]: start");
+    for (; ; ) {
+      await this.process();
+      await this.sleep();
+    }
+  }
+};
+
+// src/infrastructure/inbox/InboxMysqlRepository.ts
+var InboxMysqlRepository = class {
+  constructor(connection) {
+    this.connection = connection;
+  }
+  recordToRowValues(record) {
+    return [
+      record.eventUuid.value,
+      record.tenantUuid.value,
+      record.topic,
+      record.producer,
+      record.payload,
+      record.status.value,
+      record.attempts,
+      record.errorMessage,
+      record.lastAttempt?.value ?? null,
+      record.processedAt?.value ?? null,
+      record.createdAt.value
+    ];
+  }
+  async create(record) {
+    const values = this.recordToRowValues(record);
+    await this.connection.query(
+      `INSERT INTO events_inbox (event_uuid, tenant_uuid, topic, producer,
+                                       payload, status, attempts, error_message, last_attempt, processed_at, created_at)
+             VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      values
+    );
+  }
+  async update(record) {
+    const values = [record.status.value, record.attempts, record.errorMessage, record.processedAt?.value, record.lastAttempt?.value, record.eventUuid.value];
+    await this.connection.query(
+      `UPDATE events_inbox
+             SET status          = ?,
+                 attempts        = ?,
+                 error_message   = ?,
+                 processed_at    = ?,
+                 last_attempt    = ?
+             WHERE event_uuid = ?`,
+      values
+    );
+  }
+  async listPending(limit) {
+    const result = await this.connection.query(
+      `SELECT * FROM events_inbox WHERE status IN ('PENDING','FAILED') AND events_inbox.processed_at IS NULL LIMIT ${limit}`,
+      []
+    );
+    return result.length > 0 ? result.map((r) => InboxRecord.reconstitute(r)) : [];
+  }
+};
+
+// src/infrastructure/runners/default-mysql-inbox-runner.ts
+var DefaultMysqlInboxRunner = class {
+  constructor(uowFactory, eventManager) {
+    this.topics = [];
+    this.uowFactory = uowFactory;
+    this.eventManager = eventManager;
+    this.interval = Number(process.env.OUTBOX_RUNNER_INTERVAL_MS || 5e3);
+    this.maxEvents = Number(process.env.OUTBOX_RUNNER_MAX_EVENTS || 20);
+  }
+  async saveEvent(e, repository) {
+    let record = new InboxRecord(
+      UUID.create(),
+      e.tenant,
+      e.topic,
+      e.producer,
+      JSON.stringify(e.message),
+      ProcessStatus.PENDING
+    );
+    try {
+      await repository.create(record);
+    } catch (error) {
+      const type = String(error.type);
+      record.markWithError(type);
+      throw new Error(type);
+    } finally {
+      await repository.update(record);
+    }
+  }
+  subscribeTo(topic) {
+    this.topics.push(topic);
+  }
+  async process() {
+    const uow = await this.uowFactory.create();
+    const inboxRepository = new InboxMysqlRepository(uow.connection);
+    return await uow.execute(async () => {
+      for (let topic of this.topics) {
+        try {
+          this.eventManager.route(topic, async (e) => {
+            await this.saveEvent(e, inboxRepository);
+          });
+        } catch (error) {
+          console.log(error.toString());
+        }
       }
+      await this.eventManager.start();
+    });
+  }
+  async start() {
+    console.log("[inbox-runner]: start");
+    for (; ; ) {
+      await this.process();
+    }
+  }
+};
+
+// src/utils/ExchangeRates.ts
+var ExchangeRates = class _ExchangeRates extends BaseObject {
+  constructor(props) {
+    super(props);
+  }
+  getRate(currency) {
+    if (Object.keys(this.props.rates).includes(currency.value)) {
+      return this.props.rates[currency.value];
+    }
+    return null;
+  }
+  get base() {
+    return this.props.base;
+  }
+  get rates() {
+    return this.props.rates;
+  }
+  get date() {
+    return this.props.date;
+  }
+  toProps() {
+    return this.props;
+  }
+  toPrimitives() {
+    return {
+      base: this.props.base.value,
+      rates: this.props.rates,
+      date: this.props.date.value
     };
   }
+  exchangeToBase(price) {
+    const rate = this.getRate(price.currency);
+    if (!rate) {
+      throw new InternalError("INVALID_EXCHANGE_RATE_CURRENCY", `Avaiable rates: ${this.props.rates} - Base Currency:${this.props.base.value} - Price Currency: ${price.currency.value}`);
+    }
+    if (price.currency.value === this.props.base.value) {
+      return price;
+    }
+    return Price.create(parseFloat((price.amount / rate).toFixed(2)), this.props.base.value);
+  }
+  static create(props) {
+    return new _ExchangeRates(props);
+  }
+  static createFromPrimitives(data) {
+    return _ExchangeRates.create({
+      base: Currency.create(data.base),
+      rates: data.rates ?? [],
+      date: DateTime.create(data.date ?? "")
+    });
+  }
 };
 export {
+  BaseEvent,
+  BaseObject,
+  BasicUnitOfWork,
+  BasicUnitOfWorkFactory,
+  Country,
   Currency,
   DateTime,
+  DefaultMysqlInboxRunner,
+  DefaultMysqlOutboxRunner,
   DomainEntity,
   DomainError,
   DomainEvent,
   Email,
   ErrorManager,
+  EventBus,
+  EventBusMysqlRepository,
+  EventManager,
+  ExchangeRates,
   FatalError,
   HttpHealthCheckController,
   HttpNotFoundController,
+  InboxRecord,
+  IntegrationEvent,
   InternalError,
+  KafkaManager,
   Language,
   MysqlConnection,
   MysqlConnector,
+  OutboxRecord,
+  PaymentGateway,
+  PaymentStatus,
   Price,
+  ProcessStatus,
+  StringVars,
   UUID,
   UsageError,
   ValueObject,