@olympio/payment-gateway 0.1.0

package/dist/index.js

@@ -0,0 +1,1019 @@
+// src/adapters/stripe/StripeGateway.ts
+import Stripe from "stripe";
+
+// src/domain/capabilities/Capability.ts
+var Capability = {
+  PIX: "pix",
+  BOLETO: "boleto",
+  CARD: "card",
+  REFUND: "refund",
+  SUBSCRIPTIONS: "subscriptions"
+};
+function hasCapability(caps, capability) {
+  return caps.has(capability);
+}
+
+// src/domain/errors/index.ts
+var GatewayError = class extends Error {
+  constructor(provider, message, options = {}) {
+    super(message, { cause: options.cause });
+    this.provider = provider;
+    this.name = new.target.name;
+    this.raw = options.raw;
+  }
+  provider;
+  raw;
+};
+var CardDeclinedError = class extends GatewayError {
+  code = "card_declined";
+  constructor(provider, options) {
+    super(provider, "Cart\xE3o recusado.", options);
+  }
+};
+var AuthenticationError = class extends GatewayError {
+  code = "authentication";
+  constructor(provider, options) {
+    super(provider, "Falha de autentica\xE7\xE3o com o gateway.", options);
+  }
+};
+var RateLimitError = class extends GatewayError {
+  code = "rate_limit";
+  constructor(provider, options) {
+    super(provider, "Limite de requisi\xE7\xF5es do gateway excedido.", options);
+  }
+};
+var ValidationError = class extends GatewayError {
+  code = "validation";
+  constructor(provider, message, options) {
+    super(provider, message, options);
+  }
+};
+var GatewayUnavailableError = class extends GatewayError {
+  code = "gateway_unavailable";
+  constructor(provider, options) {
+    super(provider, "Gateway indispon\xEDvel.", options);
+  }
+};
+var UnknownGatewayError = class extends GatewayError {
+  code = "unknown";
+  constructor(provider, message, options) {
+    super(provider, message, options);
+  }
+};
+var UnsupportedCapabilityError = class extends GatewayError {
+  constructor(provider, capability, options) {
+    super(
+      provider,
+      `O gateway "${provider}" n\xE3o suporta a capability "${capability}".`,
+      options
+    );
+    this.capability = capability;
+  }
+  capability;
+  code = "unsupported_capability";
+};
+
+// src/domain/models/Money.ts
+var Money = class _Money {
+  constructor(cents, currency) {
+    this.cents = cents;
+    this.currency = currency;
+  }
+  cents;
+  currency;
+  static fromCents(cents, currency) {
+    if (!Number.isInteger(cents)) {
+      throw new RangeError(`Money.cents deve ser inteiro, recebido: ${cents}`);
+    }
+    return new _Money(cents, currency.toUpperCase());
+  }
+  static fromDecimal(amount, currency) {
+    return _Money.fromCents(Math.round(amount * 100), currency);
+  }
+  toDecimal() {
+    return this.cents / 100;
+  }
+  equals(other) {
+    return this.cents === other.cents && this.currency === other.currency;
+  }
+};
+
+// src/adapters/stripe/mappers.ts
+var PROVIDER = "stripe";
+function toChargeStatus(pi) {
+  switch (pi.status) {
+    case "succeeded":
+      return "paid";
+    case "canceled":
+      return "canceled";
+    case "requires_payment_method":
+      return pi.last_payment_error ? "failed" : "pending";
+    default:
+      return "pending";
+  }
+}
+function toPaymentMethod(types) {
+  if (types?.includes("pix")) return "pix";
+  if (types?.includes("boleto")) return "boleto";
+  return "card";
+}
+function customerId(customer) {
+  if (!customer) return void 0;
+  return typeof customer === "string" ? customer : customer.id;
+}
+function toCharge(pi) {
+  return {
+    id: pi.id,
+    status: toChargeStatus(pi),
+    amount: Money.fromCents(pi.amount, pi.currency),
+    paymentMethod: toPaymentMethod(pi.payment_method_types),
+    customerId: customerId(pi.customer),
+    description: pi.description ?? void 0,
+    createdAt: new Date(pi.created * 1e3),
+    metadata: pi.metadata ?? void 0
+  };
+}
+function toCustomer(c) {
+  return {
+    id: c.id,
+    name: c.name ?? "",
+    email: c.email ?? void 0,
+    phone: c.phone ?? void 0,
+    metadata: c.metadata ?? void 0
+  };
+}
+function toSubscriptionStatus(status) {
+  switch (status) {
+    case "active":
+    case "trialing":
+      return "active";
+    case "canceled":
+      return "canceled";
+    default:
+      return "past_due";
+  }
+}
+function toInterval(interval) {
+  switch (interval) {
+    case "week":
+      return "weekly";
+    case "year":
+      return "yearly";
+    default:
+      return "monthly";
+  }
+}
+function toSubscription(sub) {
+  const price = sub.items.data[0]?.price;
+  return {
+    id: sub.id,
+    status: toSubscriptionStatus(sub.status),
+    customerId: customerId(sub.customer) ?? "",
+    amount: Money.fromCents(price?.unit_amount ?? 0, price?.currency ?? "brl"),
+    interval: toInterval(price?.recurring?.interval),
+    createdAt: new Date(sub.created * 1e3),
+    metadata: sub.metadata ?? void 0
+  };
+}
+function mapStripeError(err) {
+  const e = err;
+  const opts = { cause: err, raw: err };
+  switch (e.type) {
+    case "StripeCardError":
+      return new CardDeclinedError(PROVIDER, opts);
+    case "StripeAuthenticationError":
+      return new AuthenticationError(PROVIDER, opts);
+    case "StripeRateLimitError":
+      return new RateLimitError(PROVIDER, opts);
+    case "StripeInvalidRequestError":
+      return new ValidationError(PROVIDER, e.message ?? "Requisi\xE7\xE3o inv\xE1lida.", opts);
+    default:
+      return new UnknownGatewayError(PROVIDER, e.message ?? "Erro do Stripe.", opts);
+  }
+}
+function toWebhookEvent(event) {
+  switch (event.type) {
+    case "payment_intent.succeeded":
+      return {
+        type: "charge.paid",
+        data: toCharge(event.data.object),
+        raw: event
+      };
+    case "payment_intent.payment_failed":
+      return {
+        type: "charge.failed",
+        data: toCharge(event.data.object),
+        raw: event
+      };
+    case "customer.subscription.deleted":
+      return {
+        type: "subscription.canceled",
+        data: toSubscription(event.data.object),
+        raw: event
+      };
+    default:
+      return { type: "unknown", data: null, raw: event };
+  }
+}
+
+// src/adapters/stripe/StripeGateway.ts
+var PROVIDER2 = "stripe";
+var CAPABILITY_BY_METHOD = {
+  card: Capability.CARD,
+  pix: Capability.PIX,
+  boleto: Capability.BOLETO
+};
+var STRIPE_INTERVAL = {
+  weekly: "week",
+  monthly: "month",
+  yearly: "year"
+};
+async function normalizeErrors(fn) {
+  try {
+    return await fn();
+  } catch (err) {
+    throw mapStripeError(err);
+  }
+}
+function isResourceMissing(err) {
+  return err.code === "resource_missing";
+}
+var StripeGateway = class {
+  constructor(config, client) {
+    this.config = config;
+    this.client = client ?? new Stripe(config.apiKey);
+    this.customers = this.buildCustomerPort();
+    this.charges = this.buildChargePort();
+    this.subscriptions = this.buildSubscriptionPort();
+    this.webhooks = this.buildWebhookPort();
+  }
+  config;
+  provider = PROVIDER2;
+  capabilities = /* @__PURE__ */ new Set([
+    Capability.CARD,
+    Capability.REFUND,
+    Capability.SUBSCRIPTIONS
+  ]);
+  client;
+  customers;
+  charges;
+  subscriptions;
+  webhooks;
+  supports(capability) {
+    return this.capabilities.has(capability);
+  }
+  raw() {
+    return this.client;
+  }
+  requireMethod(method) {
+    const cap = CAPABILITY_BY_METHOD[method];
+    if (!this.capabilities.has(cap)) {
+      throw new UnsupportedCapabilityError(PROVIDER2, cap);
+    }
+  }
+  buildCustomerPort() {
+    const client = this.client;
+    return {
+      create: (input) => normalizeErrors(
+        async () => toCustomer(
+          await client.customers.create(
+            {
+              name: input.name,
+              email: input.email,
+              phone: input.phone,
+              metadata: input.metadata
+            },
+            input.idempotencyKey ? { idempotencyKey: input.idempotencyKey } : void 0
+          )
+        )
+      ),
+      get: async (id) => {
+        try {
+          const c = await client.customers.retrieve(id);
+          if (c.deleted) return null;
+          return toCustomer(c);
+        } catch (err) {
+          if (isResourceMissing(err)) return null;
+          throw mapStripeError(err);
+        }
+      },
+      update: (id, input) => normalizeErrors(
+        async () => toCustomer(
+          await client.customers.update(id, {
+            name: input.name,
+            email: input.email,
+            phone: input.phone,
+            metadata: input.metadata
+          })
+        )
+      ),
+      delete: (id) => normalizeErrors(async () => {
+        await client.customers.del(id);
+      })
+    };
+  }
+  buildChargePort() {
+    const client = this.client;
+    return {
+      create: async (input) => {
+        this.requireMethod(input.paymentMethod);
+        return normalizeErrors(
+          async () => toCharge(
+            await client.paymentIntents.create(
+              {
+                amount: input.amount.cents,
+                currency: input.amount.currency.toLowerCase(),
+                customer: input.customerId,
+                description: input.description,
+                payment_method: input.cardToken,
+                payment_method_types: ["card"],
+                confirm: input.cardToken !== void 0,
+                metadata: input.metadata
+              },
+              input.idempotencyKey ? { idempotencyKey: input.idempotencyKey } : void 0
+            )
+          )
+        );
+      },
+      get: async (id) => {
+        try {
+          return toCharge(await client.paymentIntents.retrieve(id));
+        } catch (err) {
+          if (isResourceMissing(err)) return null;
+          throw mapStripeError(err);
+        }
+      },
+      cancel: (id) => normalizeErrors(async () => toCharge(await client.paymentIntents.cancel(id))),
+      refund: (input) => normalizeErrors(async () => {
+        await client.refunds.create({
+          payment_intent: input.chargeId,
+          amount: input.amount?.cents
+        });
+        const pi = await client.paymentIntents.retrieve(input.chargeId);
+        return { ...toCharge(pi), status: "refunded" };
+      })
+    };
+  }
+  buildSubscriptionPort() {
+    const client = this.client;
+    return {
+      create: (input) => normalizeErrors(async () => {
+        const price = await client.prices.create({
+          unit_amount: input.amount.cents,
+          currency: input.amount.currency.toLowerCase(),
+          recurring: { interval: STRIPE_INTERVAL[input.interval] },
+          product_data: { name: `subscription-${input.customerId}` }
+        });
+        const sub = await client.subscriptions.create(
+          {
+            customer: input.customerId,
+            items: [{ price: price.id }],
+            metadata: input.metadata
+          },
+          input.idempotencyKey ? { idempotencyKey: input.idempotencyKey } : void 0
+        );
+        return toSubscription(sub);
+      }),
+      get: async (id) => {
+        try {
+          return toSubscription(await client.subscriptions.retrieve(id));
+        } catch (err) {
+          if (isResourceMissing(err)) return null;
+          throw mapStripeError(err);
+        }
+      },
+      cancel: (id) => normalizeErrors(async () => toSubscription(await client.subscriptions.cancel(id)))
+    };
+  }
+  buildWebhookPort() {
+    const client = this.client;
+    const secret = this.config.webhookSecret;
+    return {
+      verifyAndParse: (input) => {
+        if (!secret) {
+          throw new ValidationError(PROVIDER2, "webhookSecret n\xE3o configurado.");
+        }
+        const signature = input.headers["stripe-signature"];
+        try {
+          const event = client.webhooks.constructEvent(input.payload, signature ?? "", secret);
+          return toWebhookEvent(event);
+        } catch (err) {
+          throw new ValidationError(PROVIDER2, "Assinatura de webhook inv\xE1lida.", {
+            cause: err
+          });
+        }
+      }
+    };
+  }
+};
+
+// src/adapters/asaas/AsaasHttpClient.ts
+var AsaasApiError = class extends Error {
+  constructor(status, body) {
+    super(`Asaas API respondeu ${status}`);
+    this.status = status;
+    this.body = body;
+    this.name = "AsaasApiError";
+  }
+  status;
+  body;
+};
+var DEFAULT_BASE_URL = "https://api.asaas.com/v3";
+function createAsaasHttpClient(config) {
+  const baseUrl = (config.baseUrl ?? DEFAULT_BASE_URL).replace(/\/$/, "");
+  async function request(method, path, body) {
+    const res = await fetch(`${baseUrl}${path}`, {
+      method,
+      headers: {
+        access_token: config.apiKey,
+        "Content-Type": "application/json"
+      },
+      body: body === void 0 ? void 0 : JSON.stringify(body)
+    });
+    const text = await res.text();
+    const json = text ? JSON.parse(text) : {};
+    if (!res.ok) {
+      throw new AsaasApiError(res.status, json);
+    }
+    return json;
+  }
+  return {
+    get: (path) => request("GET", path),
+    post: (path, body) => request("POST", path, body),
+    delete: (path) => request("DELETE", path)
+  };
+}
+
+// src/adapters/asaas/mappers.ts
+var PROVIDER3 = "asaas";
+var CURRENCY = "BRL";
+function toChargeStatus2(status) {
+  switch (status) {
+    case "RECEIVED":
+    case "CONFIRMED":
+    case "RECEIVED_IN_CASH":
+      return "paid";
+    case "OVERDUE":
+      return "failed";
+    case "REFUNDED":
+    case "REFUND_REQUESTED":
+      return "refunded";
+    default:
+      return "pending";
+  }
+}
+function toPaymentMethod2(billingType) {
+  switch (billingType) {
+    case "PIX":
+      return "pix";
+    case "BOLETO":
+      return "boleto";
+    default:
+      return "card";
+  }
+}
+function toCharge2(p) {
+  return {
+    id: p.id,
+    status: toChargeStatus2(p.status),
+    amount: Money.fromDecimal(p.value, CURRENCY),
+    paymentMethod: toPaymentMethod2(p.billingType),
+    customerId: p.customer,
+    description: p.description ?? void 0,
+    boleto: p.bankSlipUrl ? { url: p.bankSlipUrl } : void 0,
+    createdAt: new Date(p.dateCreated)
+  };
+}
+function toCustomer2(c) {
+  return {
+    id: c.id,
+    name: c.name,
+    email: c.email ?? void 0,
+    taxId: c.cpfCnpj ?? void 0,
+    phone: c.phone ?? c.mobilePhone ?? void 0
+  };
+}
+function toSubscriptionStatus2(status) {
+  switch (status) {
+    case "ACTIVE":
+      return "active";
+    case "EXPIRED":
+      return "past_due";
+    default:
+      return "canceled";
+  }
+}
+function toInterval2(cycle) {
+  switch (cycle) {
+    case "WEEKLY":
+      return "weekly";
+    case "YEARLY":
+      return "yearly";
+    default:
+      return "monthly";
+  }
+}
+function toSubscription2(s) {
+  return {
+    id: s.id,
+    status: toSubscriptionStatus2(s.status),
+    customerId: s.customer,
+    amount: Money.fromDecimal(s.value, CURRENCY),
+    interval: toInterval2(s.cycle),
+    createdAt: new Date(s.dateCreated)
+  };
+}
+function mapAsaasError(status, body) {
+  const description = body.errors?.[0]?.description;
+  const opts = { raw: body };
+  if (status === 401 || status === 403) return new AuthenticationError(PROVIDER3, opts);
+  if (status === 429) return new RateLimitError(PROVIDER3, opts);
+  if (status >= 500) return new GatewayUnavailableError(PROVIDER3, opts);
+  if (status === 400) {
+    return new ValidationError(PROVIDER3, description ?? "Requisi\xE7\xE3o inv\xE1lida.", opts);
+  }
+  return new UnknownGatewayError(PROVIDER3, description ?? "Erro do Asaas.", opts);
+}
+function toWebhookEvent2(body) {
+  const payment = body.payment;
+  switch (body.event) {
+    case "PAYMENT_RECEIVED":
+    case "PAYMENT_CONFIRMED":
+      return { type: "charge.paid", data: toCharge2(payment), raw: body };
+    case "PAYMENT_OVERDUE":
+      return { type: "charge.failed", data: toCharge2(payment), raw: body };
+    case "PAYMENT_REFUNDED":
+      return { type: "charge.refunded", data: toCharge2(payment), raw: body };
+    default:
+      return { type: "unknown", data: null, raw: body };
+  }
+}
+
+// src/adapters/asaas/AsaasGateway.ts
+var PROVIDER4 = "asaas";
+var BILLING_TYPE = {
+  pix: "PIX",
+  boleto: "BOLETO",
+  card: "CREDIT_CARD"
+};
+var ASAAS_CYCLE = {
+  weekly: "WEEKLY",
+  monthly: "MONTHLY",
+  yearly: "YEARLY"
+};
+function today() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+}
+async function normalizeErrors2(fn) {
+  try {
+    return await fn();
+  } catch (err) {
+    if (err instanceof GatewayError) throw err;
+    if (err instanceof AsaasApiError) throw mapAsaasError(err.status, err.body);
+    throw new UnknownGatewayError(PROVIDER4, "Erro inesperado no Asaas.", { cause: err });
+  }
+}
+function isNotFound(err) {
+  return err instanceof AsaasApiError && err.status === 404;
+}
+var AsaasGateway = class {
+  constructor(config, http) {
+    this.config = config;
+    this.http = http ?? createAsaasHttpClient(config);
+    this.customers = this.buildCustomerPort();
+    this.charges = this.buildChargePort();
+    this.subscriptions = this.buildSubscriptionPort();
+    this.webhooks = this.buildWebhookPort();
+  }
+  config;
+  provider = PROVIDER4;
+  capabilities = /* @__PURE__ */ new Set([
+    Capability.PIX,
+    Capability.BOLETO,
+    Capability.CARD,
+    Capability.REFUND,
+    Capability.SUBSCRIPTIONS
+  ]);
+  http;
+  customers;
+  charges;
+  subscriptions;
+  webhooks;
+  supports(capability) {
+    return this.capabilities.has(capability);
+  }
+  raw() {
+    return this.http;
+  }
+  buildCustomerPort() {
+    const http = this.http;
+    return {
+      create: (input) => normalizeErrors2(
+        async () => toCustomer2(
+          await http.post("/customers", {
+            name: input.name,
+            email: input.email,
+            cpfCnpj: input.taxId,
+            mobilePhone: input.phone,
+            externalReference: input.idempotencyKey
+          })
+        )
+      ),
+      get: async (id) => {
+        try {
+          return toCustomer2(await http.get(`/customers/${id}`));
+        } catch (err) {
+          if (isNotFound(err)) return null;
+          throw mapAsaasError(err.status, err.body);
+        }
+      },
+      update: (id, input) => normalizeErrors2(
+        async () => toCustomer2(
+          await http.post(`/customers/${id}`, {
+            name: input.name,
+            email: input.email,
+            cpfCnpj: input.taxId,
+            mobilePhone: input.phone
+          })
+        )
+      ),
+      delete: (id) => normalizeErrors2(async () => {
+        await http.delete(`/customers/${id}`);
+      })
+    };
+  }
+  buildChargePort() {
+    const http = this.http;
+    return {
+      create: (input) => normalizeErrors2(
+        async () => toCharge2(
+          await http.post("/payments", {
+            customer: input.customerId,
+            billingType: BILLING_TYPE[input.paymentMethod],
+            value: input.amount.toDecimal(),
+            dueDate: (input.dueDate ?? /* @__PURE__ */ new Date()).toISOString().slice(0, 10),
+            description: input.description,
+            creditCardToken: input.cardToken,
+            remoteIp: input.remoteIp,
+            externalReference: input.idempotencyKey
+          })
+        )
+      ),
+      get: async (id) => {
+        try {
+          return toCharge2(await http.get(`/payments/${id}`));
+        } catch (err) {
+          if (isNotFound(err)) return null;
+          throw mapAsaasError(err.status, err.body);
+        }
+      },
+      cancel: (id) => normalizeErrors2(async () => {
+        const payment = await http.get(`/payments/${id}`);
+        await http.delete(`/payments/${id}`);
+        return { ...toCharge2(payment), status: "canceled" };
+      }),
+      refund: (input) => normalizeErrors2(
+        async () => toCharge2(
+          await http.post(`/payments/${input.chargeId}/refund`, {
+            value: input.amount?.toDecimal()
+          })
+        )
+      )
+    };
+  }
+  buildSubscriptionPort() {
+    const http = this.http;
+    return {
+      create: (input) => normalizeErrors2(
+        async () => toSubscription2(
+          await http.post("/subscriptions", {
+            customer: input.customerId,
+            billingType: BILLING_TYPE[input.paymentMethod],
+            value: input.amount.toDecimal(),
+            cycle: ASAAS_CYCLE[input.interval],
+            nextDueDate: today(),
+            creditCardToken: input.cardToken,
+            externalReference: input.idempotencyKey
+          })
+        )
+      ),
+      get: async (id) => {
+        try {
+          return toSubscription2(await http.get(`/subscriptions/${id}`));
+        } catch (err) {
+          if (isNotFound(err)) return null;
+          throw mapAsaasError(err.status, err.body);
+        }
+      },
+      cancel: (id) => normalizeErrors2(async () => {
+        const sub = await http.get(`/subscriptions/${id}`);
+        await http.delete(`/subscriptions/${id}`);
+        return { ...toSubscription2(sub), status: "canceled" };
+      })
+    };
+  }
+  buildWebhookPort() {
+    const expectedToken = this.config.webhookToken;
+    return {
+      verifyAndParse: (input) => {
+        const received = input.headers["asaas-access-token"];
+        if (!expectedToken || received !== expectedToken) {
+          throw new ValidationError(PROVIDER4, "Token de webhook do Asaas inv\xE1lido.");
+        }
+        const body = JSON.parse(input.payload.toString());
+        return toWebhookEvent2(body);
+      }
+    };
+  }
+};
+
+// src/adapters/dom/DomHttpClient.ts
+var DomHttpClient = class {
+  baseUrl;
+  apiKey;
+  constructor(config) {
+    this.baseUrl = config.baseUrl ?? "https://apiv3.dompagamentos.com.br/checkout/production";
+    this.apiKey = config.apiKey;
+  }
+  async request(path, options) {
+    const url = `${this.baseUrl}${path}`;
+    const response = await fetch(url, {
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.apiKey}`,
+        ...options.headers
+      }
+    });
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(`DOM API Error: ${response.status} ${response.statusText} - ${body}`);
+    }
+    if (response.status === 204) {
+      return {};
+    }
+    return await response.json();
+  }
+  async get(path) {
+    return this.request(path, { method: "GET" });
+  }
+  async post(path, body) {
+    return this.request(path, {
+      method: "POST",
+      body: body ? JSON.stringify(body) : void 0
+    });
+  }
+  async put(path, body) {
+    return this.request(path, {
+      method: "PUT",
+      body: body ? JSON.stringify(body) : void 0
+    });
+  }
+  async delete(path) {
+    return this.request(path, { method: "DELETE" });
+  }
+};
+
+// src/adapters/dom/mappers.ts
+function toDomCustomer(input) {
+  const data = {
+    name: input.name,
+    email: input.email,
+    mobile_phone: input.phone || "00000000000",
+    code_external: input.metadata?.code_external
+  };
+  if (input.taxId) {
+    data.document = input.taxId;
+    data.document_type = input.taxId.length === 11 ? "CPF" : "CNPJ";
+  }
+  return data;
+}
+function toDomainCustomer(domCustomer) {
+  return {
+    id: domCustomer.id,
+    name: domCustomer.name,
+    email: domCustomer.email,
+    taxId: domCustomer.document,
+    phone: domCustomer.mobile_phone,
+    metadata: domCustomer.code_external ? { code_external: domCustomer.code_external } : void 0
+  };
+}
+function mapDomStatus(domStatus) {
+  switch (domStatus) {
+    case "pending":
+      return "pending";
+    case "paid":
+      return "paid";
+    case "canceled":
+      return "canceled";
+    case "failed":
+      return "failed";
+    case "refunded":
+      return "refunded";
+    default:
+      return "pending";
+  }
+}
+function toDomainCharge(domTransaction) {
+  return {
+    id: domTransaction.id,
+    status: mapDomStatus(domTransaction.status),
+    amount: Money.fromCents(domTransaction.amount, domTransaction.currency || "BRL"),
+    paymentMethod: domTransaction.payment_method === "credit_card" ? "card" : domTransaction.payment_method,
+    customerId: domTransaction.customer?.id,
+    description: domTransaction.items?.[0]?.description,
+    createdAt: new Date(domTransaction.created_at),
+    boleto: domTransaction.payment_method === "boleto" ? {
+      url: domTransaction.boleto_url,
+      barcode: domTransaction.boleto_digitable_line
+    } : void 0,
+    pix: domTransaction.payment_method === "pix" ? {
+      copyPaste: domTransaction.pix_content,
+      qrCode: domTransaction.pix_qrcode
+    } : void 0
+  };
+}
+function toWebhookEvent3(payload) {
+  const transaction = payload.data?.transaction;
+  if (!transaction) return { type: "unknown", data: null, raw: payload };
+  const charge = toDomainCharge(transaction);
+  switch (payload.event) {
+    case "transaction.paid":
+      return { type: "charge.paid", data: charge, raw: payload };
+    case "transaction.failed":
+      return { type: "charge.failed", data: charge, raw: payload };
+    case "transaction.refunded":
+      return { type: "charge.refunded", data: charge, raw: payload };
+    default:
+      return { type: "unknown", data: null, raw: payload };
+  }
+}
+
+// src/adapters/dom/ports.ts
+var PROVIDER5 = "dom";
+function buildDomCustomerPort(http) {
+  return {
+    create: async (input) => {
+      const response = await http.post("/customers", toDomCustomer(input));
+      return toDomainCustomer(response);
+    },
+    get: async (id) => {
+      try {
+        const response = await http.get(`/customers/${id}`);
+        return toDomainCustomer(response);
+      } catch (err) {
+        if (err.message.includes("404")) return null;
+        throw err;
+      }
+    },
+    update: async (id, input) => {
+      const response = await http.post(`/customers/${id}`, toDomCustomer(input));
+      return toDomainCustomer(response);
+    },
+    delete: async (id) => {
+      await http.delete(`/customers/${id}`);
+    }
+  };
+}
+function buildDomChargePort(http, customerPort) {
+  return {
+    create: async (input) => {
+      let customerData;
+      if (!input.cardToken) {
+        const c = await customerPort.get(input.customerId);
+        if (!c) throw new Error("Cliente n\xE3o encontrado para criar transa\xE7\xE3o (DOM Pagamentos exige customer para Pix/Boleto)");
+        customerData = toDomCustomer({ ...c, phone: c.phone || "00000000000", taxId: c.taxId });
+      }
+      const isBoleto = input.paymentMethod === "boleto";
+      const isPix = input.paymentMethod === "pix";
+      const isCard = input.paymentMethod === "card";
+      const payload = {
+        cod_external: input.metadata?.cod_external || input.idempotencyKey,
+        items: [{ description: input.description || "Cobran\xE7a", price: input.amount.toDecimal(), quantity: 1 }],
+        payment: {
+          total: input.amount.toDecimal(),
+          payment_method: isCard ? "credit_card" : input.paymentMethod
+        }
+      };
+      if (customerData) payload.customer = customerData;
+      if (isCard && input.cardToken) payload.payment.credit_card = { token: input.cardToken, installments: 1 };
+      if (isBoleto) payload.payment.boleto = { boleto_due_days: 3 };
+      if (isPix) payload.payment.pix = {};
+      const response = await http.post("/transactions", payload);
+      return toDomainCharge(response);
+    },
+    get: async (id) => {
+      try {
+        const response = await http.get(`/transactions/${id}`);
+        return toDomainCharge(response);
+      } catch (err) {
+        if (err.message.includes("404")) return null;
+        throw err;
+      }
+    },
+    cancel: async (id) => {
+      const response = await http.post(`/transactions/${id}/cancel`);
+      return toDomainCharge(response);
+    },
+    refund: async (input) => {
+      const payload = {};
+      if (input.amount) {
+        payload.amount = input.amount.toDecimal();
+      }
+      const response = await http.post(`/transactions/${input.chargeId}/refund`, payload);
+      return toDomainCharge(response);
+    }
+  };
+}
+function buildDomSubscriptionPort(http) {
+  return {
+    create: async (input) => {
+      throw new UnknownGatewayError(PROVIDER5, "DOM SubscriptionPort.create n\xE3o implementado.", { cause: null });
+    },
+    get: async (id) => {
+      throw new UnknownGatewayError(PROVIDER5, "DOM SubscriptionPort.get n\xE3o implementado.", { cause: null });
+    },
+    cancel: async (id) => {
+      throw new UnknownGatewayError(PROVIDER5, "DOM SubscriptionPort.cancel n\xE3o implementado.", { cause: null });
+    }
+  };
+}
+function buildDomWebhookPort(webhookSecret) {
+  return {
+    verifyAndParse: (input) => {
+      const receivedToken = input.headers["authorization"] || input.headers["x-dom-token"];
+      if (webhookSecret && receivedToken !== webhookSecret) {
+        throw new ValidationError(PROVIDER5, "Token de webhook inv\xE1lido.");
+      }
+      const payload = typeof input.payload === "string" ? JSON.parse(input.payload) : JSON.parse(input.payload.toString());
+      return toWebhookEvent3(payload);
+    }
+  };
+}
+
+// src/adapters/dom/DomGateway.ts
+var PROVIDER6 = "dom";
+var DomGateway = class {
+  constructor(config, http) {
+    this.config = config;
+    this.http = http ?? new DomHttpClient(config);
+    this.customers = buildDomCustomerPort(this.http);
+    this.charges = buildDomChargePort(this.http, this.customers);
+    this.subscriptions = buildDomSubscriptionPort(this.http);
+    this.webhooks = buildDomWebhookPort(config.webhookToken);
+  }
+  config;
+  provider = PROVIDER6;
+  capabilities = /* @__PURE__ */ new Set([
+    Capability.PIX,
+    Capability.CARD,
+    Capability.BOLETO,
+    Capability.REFUND
+  ]);
+  http;
+  customers;
+  charges;
+  subscriptions;
+  webhooks;
+  supports(capability) {
+    return this.capabilities.has(capability);
+  }
+  raw() {
+    return this.http;
+  }
+};
+
+// src/createGateway.ts
+function createGateway(config) {
+  switch (config.provider) {
+    case "stripe":
+      return new StripeGateway(config);
+    case "asaas":
+      return new AsaasGateway(config);
+    case "dom":
+      return new DomGateway(config);
+    default: {
+      const exhaustive = config;
+      throw new Error(`Provider n\xE3o suportado: ${JSON.stringify(exhaustive)}`);
+    }
+  }
+}
+export {
+  AsaasApiError,
+  AsaasGateway,
+  AuthenticationError,
+  Capability,
+  CardDeclinedError,
+  GatewayError,
+  GatewayUnavailableError,
+  Money,
+  RateLimitError,
+  StripeGateway,
+  UnknownGatewayError,
+  UnsupportedCapabilityError,
+  ValidationError,
+  createAsaasHttpClient,
+  createGateway,
+  hasCapability
+};
+//# sourceMappingURL=index.js.map