wsp-ms-core 1.0.0 → 1.0.2

package/dist/index.cjs

@@ -0,0 +1,639 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Currency: () => Currency,
+  DateTime: () => DateTime,
+  DomainEntity: () => DomainEntity,
+  DomainError: () => DomainError,
+  DomainEvent: () => DomainEvent,
+  Email: () => Email,
+  ErrorManager: () => ErrorManager,
+  FatalError: () => FatalError,
+  InternalError: () => InternalError,
+  Language: () => Language,
+  MysqlConnection: () => MysqlConnection,
+  MysqlConnector: () => MysqlConnector,
+  Price: () => Price,
+  UUID: () => UUID,
+  UsageError: () => UsageError,
+  ValueObject: () => ValueObject
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/domain/value-objects/DateTime.ts
+var import_luxon = require("luxon");
+
+// src/domain/contracts/ValueObject.ts
+var ValueObject = class {
+  constructor(value) {
+    this.validate(value);
+    this._value = Object.freeze(value);
+  }
+  get value() {
+    return this._value;
+  }
+  toString() {
+    return String(this._value);
+  }
+  equals(vo) {
+    if (vo === null || vo === void 0)
+      return false;
+    if (vo.constructor !== this.constructor)
+      return false;
+    return vo.value === this._value;
+  }
+};
+
+// src/domain/value-objects/DateTime.ts
+var _DateTime = class _DateTime extends ValueObject {
+  constructor(value) {
+    super(value);
+    this._dt = import_luxon.DateTime.fromFormat(value, _DateTime.DEFAULT_FORMAT, { zone: "utc" });
+  }
+  static fromLuxon(dt) {
+    return new _DateTime(_DateTime.toUtcFormat(dt));
+  }
+  static toUtcFormat(dt) {
+    return dt.setZone("utc").toFormat(_DateTime.DEFAULT_FORMAT);
+  }
+  validate(value) {
+    const q = import_luxon.DateTime.fromFormat(value, _DateTime.DEFAULT_FORMAT, { zone: "utc" });
+    if (!q.isValid) {
+      throw new Error(`Invalid DateTime: ${q.invalidExplanation}`);
+    }
+  }
+  plusYears(years) {
+    return _DateTime.fromLuxon(this._dt.plus({ years }));
+  }
+  plusMonths(months) {
+    return _DateTime.fromLuxon(this._dt.plus({ months }));
+  }
+  plusDays(days) {
+    return _DateTime.fromLuxon(this._dt.plus({ days }));
+  }
+  plusHours(hours) {
+    return _DateTime.fromLuxon(this._dt.plus({ hours }));
+  }
+  plusMinutes(minutes) {
+    return _DateTime.fromLuxon(this._dt.plus({ minutes }));
+  }
+  plusSeconds(seconds) {
+    return _DateTime.fromLuxon(this._dt.plus({ seconds }));
+  }
+  minusYears(years) {
+    return _DateTime.fromLuxon(this._dt.minus({ years }));
+  }
+  minusMonths(months) {
+    return _DateTime.fromLuxon(this._dt.minus({ months }));
+  }
+  minusDays(days) {
+    return _DateTime.fromLuxon(this._dt.minus({ days }));
+  }
+  minusHours(hours) {
+    return _DateTime.fromLuxon(this._dt.minus({ hours }));
+  }
+  minusMinutes(minutes) {
+    return _DateTime.fromLuxon(this._dt.minus({ minutes }));
+  }
+  minusSeconds(seconds) {
+    return _DateTime.fromLuxon(this._dt.minus({ seconds }));
+  }
+  get year() {
+    return this._dt.year;
+  }
+  get month() {
+    return this._dt.month;
+  }
+  get day() {
+    return this._dt.day;
+  }
+  get hour() {
+    return this._dt.hour;
+  }
+  get minute() {
+    return this._dt.minute;
+  }
+  get second() {
+    return this._dt.second;
+  }
+  getMonthName(locale = "en") {
+    return this._dt.setLocale(locale).toFormat("LLLL");
+  }
+  getWeekdayName(locale = "en") {
+    return this._dt.setLocale(locale).toFormat("cccc");
+  }
+  static create(input) {
+    if (input === void 0) {
+      return new _DateTime(_DateTime.toUtcFormat(import_luxon.DateTime.now()));
+    }
+    if (typeof input === "number") {
+      return new _DateTime(
+        _DateTime.toUtcFormat(import_luxon.DateTime.fromMillis(input, { zone: "utc" }))
+      );
+    }
+    const iso = import_luxon.DateTime.fromISO(input, { zone: "utc" });
+    if (iso.isValid) {
+      return new _DateTime(_DateTime.toUtcFormat(iso));
+    }
+    return new _DateTime(input);
+  }
+};
+_DateTime.DEFAULT_FORMAT = "yyyy-MM-dd HH:mm:ss";
+var DateTime = _DateTime;
+
+// src/domain/contracts/DomainEntity.ts
+var DomainEntity = class {
+  constructor(uuid, props, audit) {
+    this.uuid = uuid;
+    this.props = props;
+    this._createdAt = audit?.createdAt ?? DateTime.create();
+    this._updatedAt = audit?.updatedAt ?? this.createdAt;
+    this._deletedAt = audit?.deletedAt;
+  }
+  touch() {
+    this._updatedAt = DateTime.create();
+  }
+  get createdAt() {
+    return this._createdAt;
+  }
+  get updatedAt() {
+    return this._updatedAt;
+  }
+  get deletedAt() {
+    return this._deletedAt;
+  }
+  get isDeleted() {
+    return Boolean(this._deletedAt);
+  }
+  softDelete() {
+    if (!this._deletedAt) {
+      this._deletedAt = DateTime.create();
+      this.touch();
+    }
+  }
+};
+
+// src/domain/contracts/DomainError.ts
+var DomainError = class extends Error {
+  constructor(type, message = "") {
+    super(message);
+    this.type = type;
+  }
+};
+
+// 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 = "") {
+    super(type, message);
+  }
+};
+
+// src/domain/errors/InternalError.ts
+var InternalError = class extends DomainError {
+  constructor(type, message = "") {
+    super(type, message);
+  }
+};
+
+// src/domain/errors/UsageError.ts
+var UsageError = class extends DomainError {
+  constructor(type, vars = {}) {
+    super(type);
+    this.vars = vars;
+  }
+};
+
+// 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`);
+    }
+  }
+  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) {
+    super(email.trim());
+  }
+  validate(value) {
+    if (!_Email.REGEX.test(value)) {
+      throw new Error(`Email <${value}> is not a valid address`);
+    }
+  }
+  static create(raw) {
+    return new _Email(raw);
+  }
+  static isValid(raw) {
+    return _Email.REGEX.test(raw.trim());
+  }
+};
+_Email.REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/u;
+var Email = _Email;
+
+// src/domain/value-objects/Language.ts
+var _Language = class _Language extends ValueObject {
+  constructor(code) {
+    super(code.trim().toLowerCase());
+  }
+  validate(value) {
+    if (!_Language.SUPPORTED.includes(value)) {
+      throw new Error(`Language <${value}> is not supported`);
+    }
+  }
+  base() {
+    return this.value.split("-")[0];
+  }
+  static create(raw) {
+    const normalized = raw.trim().toLowerCase().replace("_", "-");
+    return new _Language(normalized);
+  }
+};
+_Language.SUPPORTED = [
+  "es",
+  "en",
+  "en-us",
+  "en-gb",
+  "en-au",
+  "en-ca",
+  "en-nz",
+  "en-ie",
+  "en-za",
+  "en-jm",
+  "en-bz",
+  "en-tt",
+  "pt-br",
+  "pt",
+  "es",
+  "es-ar",
+  "es-gt",
+  "es-cr",
+  "es-pa",
+  "es-do",
+  "es-mx",
+  "es-ve",
+  "es-co",
+  "es-pe",
+  "es-ec",
+  "es-cl",
+  "es-uy",
+  "es-py",
+  "es-bo",
+  "es-sv",
+  "es-hn",
+  "es-ni",
+  "es-pr"
+];
+_Language.DEFAULT = new _Language("es");
+_Language.ENGLISH = new _Language("en");
+_Language.ENGLISH_UNITED_STATES = new _Language("en-us");
+_Language.ENGLISH_UNITED_KINGDOM = new _Language("en-gb");
+_Language.ENGLISH_AUSTRALIA = new _Language("en-au");
+_Language.ENGLISH_CANADA = new _Language("en-ca");
+_Language.ENGLISH_NEW_ZEALAND = new _Language("en-nz");
+_Language.ENGLISH_IRELAND = new _Language("en-ie");
+_Language.ENGLISH_SOUTH_AFRICA = new _Language("en-za");
+_Language.ENGLISH_JAMAICA = new _Language("en-jm");
+_Language.ENGLISH_BELIZE = new _Language("en-bz");
+_Language.ENGLISH_TRINIDAD = new _Language("en-tt");
+_Language.PORTUGUESE_BRAZIL = new _Language("pt-br");
+_Language.PORTUGUESE_PORTUGAL = new _Language("pt");
+_Language.SPANISH = new _Language("es");
+_Language.SPANISH_ARGENTINA = new _Language("es-ar");
+_Language.SPANISH_GUATEMALA = new _Language("es-gt");
+_Language.SPANISH_COSTA_RICA = new _Language("es-cr");
+_Language.SPANISH_PANAMA = new _Language("es-pa");
+_Language.SPANISH_REPUBLICA_DOMINICANA = new _Language("es-do");
+_Language.SPANISH_MEXICO = new _Language("es-mx");
+_Language.SPANISH_VENEZUELA = new _Language("es-ve");
+_Language.SPANISH_COLOMBIA = new _Language("es-co");
+_Language.SPANISH_PERU = new _Language("es-pe");
+_Language.SPANISH_ECUADOR = new _Language("es-ec");
+_Language.SPANISH_CHILE = new _Language("es-cl");
+_Language.SPANISH_URUGUAY = new _Language("es-uy");
+_Language.SPANISH_PARAGUAY = new _Language("es-py");
+_Language.SPANISH_BOLIVIA = new _Language("es-bo");
+_Language.SPANISH_EL_SALVADOR = new _Language("es-sv");
+_Language.SPANISH_HONDURAS = new _Language("es-hn");
+_Language.SPANISH_NICARAGUA = new _Language("es-ni");
+_Language.SPANISH_PUERTO_RICO = new _Language("es-pr");
+var Language = _Language;
+
+// src/domain/value-objects/Price.ts
+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`);
+    }
+    if (amount < _Price.MIN_AMOUNT) {
+      throw new Error(`Price amount <${amount}> must be \u2265 ${_Price.MIN_AMOUNT}`);
+    }
+  }
+  equals(other) {
+    if (!other)
+      return false;
+    return this.amount === other.amount && this.currency.equals(other.currency);
+  }
+  assertSameCurrency(other) {
+    if (!this.currency.equals(other.currency)) {
+      throw new Error("Cannot operate on Price objects with different currencies");
+    }
+  }
+  add(other) {
+    this.assertSameCurrency(other);
+    return _Price.create(this.amount + other.amount, this.currency);
+  }
+  subtract(other) {
+    this.assertSameCurrency(other);
+    return _Price.create(this.amount - other.amount, this.currency);
+  }
+  static create(amount, currency) {
+    const cur = currency instanceof Currency ? currency : Currency.create(currency);
+    return new _Price(amount, cur);
+  }
+};
+_Price.MIN_AMOUNT = -1e6;
+var Price = _Price;
+
+// src/domain/value-objects/UUID.ts
+var UUID = class _UUID extends ValueObject {
+  constructor(value) {
+    super(value);
+  }
+  validate(uuid) {
+    if (!_UUID.isValid(uuid)) {
+      throw new Error(`Invalid uuid ${uuid}`);
+    }
+  }
+  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);
+  }
+};
+
+// 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: "ERROR",
+      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/infrastructure/mysql/MysqlConnector.ts
+var import_promise = require("mysql2/promise");
+
+// src/infrastructure/mysql/MysqlConnection.ts
+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() {
+    this._conn.release();
+  }
+};
+
+// src/infrastructure/mysql/MysqlConnector.ts
+var _MysqlConnector = class _MysqlConnector {
+  constructor(pool) {
+    this._pool = pool ?? (0, import_promise.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
+    });
+  }
+  async wrap(conn) {
+    return new MysqlConnection(conn);
+  }
+  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 = 10;
+var MysqlConnector = _MysqlConnector;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Currency,
+  DateTime,
+  DomainEntity,
+  DomainError,
+  DomainEvent,
+  Email,
+  ErrorManager,
+  FatalError,
+  InternalError,
+  Language,
+  MysqlConnection,
+  MysqlConnector,
+  Price,
+  UUID,
+  UsageError,
+  ValueObject
+});
+//# sourceMappingURL=index.cjs.map