@saasicat/nest 1.0.0-rc.2 → 1.0.0-rc.21

package/dist/chunk-5CKC7O52.js

@@ -0,0 +1,140 @@
+import {
+  BILLING_PERMISSION_GUARDS_TOKEN,
+  TENANT_AUTH_GUARDS_TOKEN
+} from "./chunk-GPQWGA6B.js";
+import {
+  codedError
+} from "./chunk-J7NJRK3K.js";
+import {
+  __name
+} from "./chunk-SHUYVCID.js";
+
+// src/billing/composed-tenant-auth.guard.ts
+import { ForbiddenException, Inject, Injectable, Optional } from "@nestjs/common";
+import { AUTH_ERROR_CODES } from "@saasicat/core";
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+function _ts_metadata(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata, "_ts_metadata");
+function _ts_param(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param, "_ts_param");
+var ComposedTenantAuthGuard = class {
+  static {
+    __name(this, "ComposedTenantAuthGuard");
+  }
+  guards;
+  constructor(guards = null) {
+    this.guards = guards;
+  }
+  async canActivate(context) {
+    if (!this.guards || this.guards.length === 0) {
+      throw new ForbiddenException({
+        code: AUTH_ERROR_CODES.AUTH_GUARDS_NOT_CONFIGURED,
+        message: "TenantBillingModule.forRoot.authGuards is not configured."
+      });
+    }
+    for (const guard of this.guards) {
+      const result = await Promise.resolve(guard.canActivate(context));
+      if (!result) return false;
+    }
+    return true;
+  }
+};
+ComposedTenantAuthGuard = _ts_decorate([
+  Injectable(),
+  _ts_param(0, Optional()),
+  _ts_param(0, Inject(TENANT_AUTH_GUARDS_TOKEN)),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    Object
+  ])
+], ComposedTenantAuthGuard);
+
+// src/billing/billing-permission.guard.ts
+import { ForbiddenException as ForbiddenException3, Inject as Inject2, Injectable as Injectable2, Optional as Optional2 } from "@nestjs/common";
+import { AUTH_ERROR_CODES as AUTH_ERROR_CODES3 } from "@saasicat/core";
+
+// src/billing/tenant-roles.ts
+import { ForbiddenException as ForbiddenException2 } from "@nestjs/common";
+import { AUTH_ERROR_CODES as AUTH_ERROR_CODES2 } from "@saasicat/core";
+var ADMIN_ROLES = /* @__PURE__ */ new Set([
+  "TENANT_ADMIN",
+  "SUPER_ADMIN"
+]);
+function holdsTenantAdminRole(context) {
+  const request = context.switchToHttp().getRequest();
+  if (!request.user) {
+    throw new ForbiddenException2({
+      code: AUTH_ERROR_CODES2.NOT_AUTHENTICATED,
+      message: "Not authenticated"
+    });
+  }
+  const role = request.user.platformRole ?? request.user.role;
+  return Boolean(role && ADMIN_ROLES.has(role));
+}
+__name(holdsTenantAdminRole, "holdsTenantAdminRole");
+
+// src/billing/billing-permission.guard.ts
+function _ts_decorate2(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate2, "_ts_decorate");
+function _ts_metadata2(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata2, "_ts_metadata");
+function _ts_param2(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param2, "_ts_param");
+var BillingPermissionGuard = class {
+  static {
+    __name(this, "BillingPermissionGuard");
+  }
+  guards;
+  constructor(guards = null) {
+    this.guards = guards;
+  }
+  async canActivate(context) {
+    if (await this.holdsPermission(context)) return true;
+    throw new ForbiddenException3(codedError(AUTH_ERROR_CODES3.BILLING_PERMISSION_REQUIRED));
+  }
+  async holdsPermission(context) {
+    if (!this.guards || this.guards.length === 0) return holdsTenantAdminRole(context);
+    for (const guard of this.guards) {
+      if (!await Promise.resolve(guard.canActivate(context))) return false;
+    }
+    return true;
+  }
+};
+BillingPermissionGuard = _ts_decorate2([
+  Injectable2(),
+  _ts_param2(0, Optional2()),
+  _ts_param2(0, Inject2(BILLING_PERMISSION_GUARDS_TOKEN)),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    Object
+  ])
+], BillingPermissionGuard);
+
+export {
+  ComposedTenantAuthGuard,
+  holdsTenantAdminRole,
+  BillingPermissionGuard
+};

package/dist/chunk-6PJE7EWO.js

@@ -0,0 +1,185 @@
+import {
+  __name
+} from "./chunk-SHUYVCID.js";
+
+// src/promo/math.ts
+function round2(n) {
+  return Math.round(n * 100) / 100;
+}
+__name(round2, "round2");
+function isTaxRatePercent(rate) {
+  return Number.isFinite(rate) && rate >= 0 && rate <= 100 && !(rate > 0 && rate < 1);
+}
+__name(isTaxRatePercent, "isTaxRatePercent");
+function grossFromNet(net, vatRate) {
+  return round2(net * (1 + vatRate / 100));
+}
+__name(grossFromNet, "grossFromNet");
+function netFromGross(gross, vatRate) {
+  return round2(gross * 100 / (100 + vatRate));
+}
+__name(netFromGross, "netFromGross");
+function computeIncludedVat(grossAmount, vatRate) {
+  return round2(grossAmount * vatRate / (100 + vatRate));
+}
+__name(computeIncludedVat, "computeIncludedVat");
+
+// src/subscription-contract/contract-line-item-money.ts
+var MONTHS_PER_YEAR = 12;
+function recordContractLinesMoney(lines, money) {
+  const shares = grossSharesOf(lines, money.taxRate);
+  return lines.map((line, index) => {
+    const priceGross = shares[index];
+    return {
+      ...line,
+      priceGross,
+      currency: money.currency,
+      taxRate: money.taxRate,
+      taxAmount: fromCents(toCents(priceGross) - toCents(line.priceNet))
+    };
+  });
+}
+__name(recordContractLinesMoney, "recordContractLinesMoney");
+function grossSharesOf(lines, taxRate) {
+  const netSoFar = /* @__PURE__ */ new Map();
+  return lines.map((line) => {
+    const before = netSoFar.get(line.billingCycle) ?? 0;
+    const after = before + toCents(line.priceNet);
+    netSoFar.set(line.billingCycle, after);
+    return fromCents(grossCents(after, taxRate) - grossCents(before, taxRate));
+  });
+}
+__name(grossSharesOf, "grossSharesOf");
+function contractTotalsOf(lines, contractCycle) {
+  let subtotalNet = 0;
+  let discountNet = 0;
+  let totalGross = 0;
+  for (const line of lines) {
+    const times = timesDueInOnePeriod(contractCycle, line.billingCycle);
+    const net = times * toCents(line.priceNet);
+    if (line.kind === "discount") discountNet -= net;
+    else subtotalNet += net;
+    totalGross += times * toCents(line.priceGross);
+  }
+  return {
+    subtotalNet: fromCents(subtotalNet),
+    discountNet: fromCents(discountNet),
+    totalNet: fromCents(subtotalNet - discountNet),
+    totalGross: fromCents(totalGross)
+  };
+}
+__name(contractTotalsOf, "contractTotalsOf");
+function timesDueInOnePeriod(contractCycle, lineCycle) {
+  return contractCycle === "yearly" && lineCycle === "monthly" ? MONTHS_PER_YEAR : 1;
+}
+__name(timesDueInOnePeriod, "timesDueInOnePeriod");
+function grossCents(netCents, taxRate) {
+  return toCents(grossFromNet(fromCents(netCents), taxRate));
+}
+__name(grossCents, "grossCents");
+function toCents(amount) {
+  return Math.round(amount * 100);
+}
+__name(toCents, "toCents");
+function fromCents(cents) {
+  return cents === 0 ? 0 : cents / 100;
+}
+__name(fromCents, "fromCents");
+
+// src/subscription-contract/contract-refusals.ts
+import { UnprocessableEntityException } from "@nestjs/common";
+import { CONTRACT_ERROR_CODES } from "@saasicat/core";
+function assertTaxRatePercent(field, taxRate) {
+  if (isTaxRatePercent(taxRate)) return;
+  throw new UnprocessableEntityException({
+    code: CONTRACT_ERROR_CODES.SUBSCRIPTION_CONTRACT_TAX_RATE_NOT_PERCENT,
+    message: `A subscription contract states a tax rate of ${taxRate} at ${field}, which is not a percentage: a rate lies from 0 to 100, and a value between 0 and 1 is refused as a fraction.`,
+    params: {
+      field,
+      taxRate
+    }
+  });
+}
+__name(assertTaxRatePercent, "assertTaxRatePercent");
+function assertContractWindow(effectiveFrom, effectiveUntil) {
+  if (!effectiveUntil || effectiveUntil > effectiveFrom) return;
+  throw new UnprocessableEntityException({
+    code: CONTRACT_ERROR_CODES.SUBSCRIPTION_CONTRACT_INVALID_WINDOW,
+    message: "effectiveUntil must be after effectiveFrom."
+  });
+}
+__name(assertContractWindow, "assertContractWindow");
+function assertOnePlanLine(lineItems) {
+  if (lineItems.filter((item) => item.kind === "plan").length === 1) return;
+  throw new UnprocessableEntityException({
+    code: CONTRACT_ERROR_CODES.SUBSCRIPTION_CONTRACT_PLAN_LINE_ITEM_REQUIRED,
+    message: "A subscription contract requires exactly one plan base item."
+  });
+}
+__name(assertOnePlanLine, "assertOnePlanLine");
+var ADDED_UP_TOTALS = [
+  "subtotalNet",
+  "discountNet",
+  "totalNet",
+  "totalGross"
+];
+function assertLinesAddUp(lineItems, priceSnapshot) {
+  const lines = contractTotalsOf(lineItems, priceSnapshot.billingCycle);
+  const field = ADDED_UP_TOTALS.find((total) => Math.round(lines[total] * 100) !== Math.round(priceSnapshot[total] * 100));
+  if (!field) return;
+  throw new UnprocessableEntityException({
+    code: CONTRACT_ERROR_CODES.SUBSCRIPTION_CONTRACT_LINES_DO_NOT_ADD_UP,
+    message: `The line items of a subscription contract add up to ${lines[field]} for priceSnapshot.${field}, but the contract states ${priceSnapshot[field]}.`,
+    params: {
+      field: `priceSnapshot.${field}`,
+      lines: lines[field],
+      stated: priceSnapshot[field]
+    }
+  });
+}
+__name(assertLinesAddUp, "assertLinesAddUp");
+function assertNoNegativeDiscount(data) {
+  const negative = (data.priceSnapshot.discountNet < 0 ? {
+    field: "priceSnapshot.discountNet",
+    amount: data.priceSnapshot.discountNet
+  } : null) ?? negativeResolvedAmount("promotionSnapshots", data.promotionSnapshots) ?? negativeResolvedAmount("promoCodeSnapshots", data.promoCodeSnapshots);
+  if (!negative) return;
+  throw new UnprocessableEntityException({
+    code: CONTRACT_ERROR_CODES.SUBSCRIPTION_CONTRACT_DISCOUNT_NEGATIVE,
+    message: `A subscription contract states a discount of ${negative.amount} at ${negative.field}; a discount takes money off and is never negative.`,
+    params: {
+      field: negative.field,
+      amount: negative.amount
+    }
+  });
+}
+__name(assertNoNegativeDiscount, "assertNoNegativeDiscount");
+function negativeResolvedAmount(list, snapshots) {
+  for (const [index, snapshot] of (snapshots ?? []).entries()) {
+    const amount = snapshot?.resolvedAmountNet;
+    if (typeof amount === "number" && amount < 0) {
+      return {
+        field: `${list}[${index}].resolvedAmountNet`,
+        amount
+      };
+    }
+  }
+  return null;
+}
+__name(negativeResolvedAmount, "negativeResolvedAmount");
+
+export {
+  round2,
+  isTaxRatePercent,
+  grossFromNet,
+  netFromGross,
+  computeIncludedVat,
+  recordContractLinesMoney,
+  grossSharesOf,
+  contractTotalsOf,
+  assertTaxRatePercent,
+  assertContractWindow,
+  assertOnePlanLine,
+  assertLinesAddUp,
+  assertNoNegativeDiscount
+};

package/dist/chunk-7NJKVC5X.js

@@ -0,0 +1,353 @@
+import {
+  PLAN_CATALOG_SETTINGS_TOKEN
+} from "./chunk-FEQZCWUL.js";
+import {
+  codedError
+} from "./chunk-J7NJRK3K.js";
+import {
+  __name
+} from "./chunk-SHUYVCID.js";
+
+// src/payments/payments.tokens.ts
+var PAYMENT_GATEWAYS_TOKEN = /* @__PURE__ */ Symbol.for("saasicat/nest/PaymentGateways");
+var PAYMENT_EVENT_LOG_TOKEN = /* @__PURE__ */ Symbol.for("saasicat/nest/PaymentEventLog");
+var SUBSCRIBER_PAYMENT_METHOD_REPOSITORY_TOKEN = /* @__PURE__ */ Symbol.for("saasicat/nest/SubscriberPaymentMethodRepository");
+var PAYMENT_TRANSACTION_RUNNER_TOKEN = /* @__PURE__ */ Symbol.for("saasicat/nest/PaymentTransactionRunner");
+
+// src/payments/payment-gateway-registry.ts
+import { Inject, Injectable } from "@nestjs/common";
+
+// src/payments/payment-accounts.ts
+function paymentAccountProblems(payments, gateways) {
+  const bound = Object.keys(gateways);
+  if (!payments) {
+    return [
+      `Payment gateways are bound for ${bound.join(", ") || "no account"}, but config/saas.yaml has no \`payments\` block naming the accounts.`
+    ];
+  }
+  const named = Object.keys(payments.accounts);
+  const problems = [];
+  for (const account of named) {
+    const gateway = gateways[account];
+    if (!gateway) {
+      problems.push(`config/saas.yaml names the payment account '${account}', and no gateway is bound for it: bind its adapter, or remove the account once it holds nothing.`);
+      continue;
+    }
+    const provider = payments.accounts[account].provider;
+    if (gateway.provider !== provider) {
+      problems.push(`The payment account '${account}' is at '${provider}' in config/saas.yaml, but the gateway bound for it is '${gateway.provider}'.`);
+    }
+  }
+  for (const account of bound) {
+    if (!named.includes(account)) {
+      problems.push(`A gateway is bound for the payment account '${account}', which config/saas.yaml#payments.accounts does not name.`);
+    }
+  }
+  const takesNew = payments.newPaymentMethods;
+  if (takesNew !== void 0) {
+    const account = payments.accounts[takesNew];
+    if (!account) {
+      problems.push(`config/saas.yaml#payments.newPaymentMethods names '${takesNew}', which is not one of its accounts.`);
+    } else if (!account.methods?.length) {
+      problems.push(`The payment account '${takesNew}' takes new payment methods, and lists no \`methods\` to offer.`);
+    }
+  }
+  return problems;
+}
+__name(paymentAccountProblems, "paymentAccountProblems");
+
+// src/payments/payment-gateway-registry.ts
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+function _ts_metadata(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata, "_ts_metadata");
+function _ts_param(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param, "_ts_param");
+var PaymentGatewayRegistry = class {
+  static {
+    __name(this, "PaymentGatewayRegistry");
+  }
+  settings;
+  accounts = /* @__PURE__ */ new Map();
+  takesNew;
+  constructor(settings, gateways) {
+    this.settings = settings;
+    const problems = paymentAccountProblems(settings.payments, gateways);
+    if (problems.length > 0) {
+      throw new Error(`Payments cannot start:
+- ${problems.join("\n- ")}`);
+    }
+    for (const [name, account] of Object.entries(settings.payments.accounts)) {
+      this.accounts.set(name, {
+        name,
+        provider: account.provider,
+        gateway: gateways[name]
+      });
+    }
+    this.takesNew = settings.payments.newPaymentMethods;
+  }
+  /** The account a callback names, or `null` when none is configured under it. */
+  account(name) {
+    return this.accounts.get(name) ?? null;
+  }
+  /** The accounts among `held` that are not configured, each once — references nothing can reach any more. */
+  unconfigured(held) {
+    return [
+      ...new Set(held)
+    ].filter((name) => !this.accounts.has(name));
+  }
+  /** The origins a gateway's form may send a person back to. */
+  returnUrlOrigins() {
+    return this.settings.payments.returnUrlOrigins;
+  }
+  /** The account a new payment method is taken at, or `null` when none takes new ones. */
+  forNewPaymentMethods() {
+    if (this.takesNew === void 0) return null;
+    const account = this.accounts.get(this.takesNew);
+    return {
+      ...account,
+      methods: this.settings.payments.accounts[this.takesNew].methods
+    };
+  }
+};
+PaymentGatewayRegistry = _ts_decorate([
+  Injectable(),
+  _ts_param(0, Inject(PLAN_CATALOG_SETTINGS_TOKEN)),
+  _ts_param(1, Inject(PAYMENT_GATEWAYS_TOKEN)),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof PlanCatalogSettings === "undefined" ? Object : PlanCatalogSettings,
+    typeof Readonly === "undefined" ? Object : Readonly
+  ])
+], PaymentGatewayRegistry);
+
+// src/payments/payment-callback.service.ts
+import { BadRequestException, Inject as Inject2, Injectable as Injectable2, Logger, NotFoundException } from "@nestjs/common";
+import { PAYMENT_ERROR_CODES, isForeignPaymentMethodReferenceError, isPaymentCallbackRejectedError } from "@saasicat/core";
+function _ts_decorate2(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate2, "_ts_decorate");
+function _ts_metadata2(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata2, "_ts_metadata");
+function _ts_param2(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param2, "_ts_param");
+var PaymentCallbackService = class _PaymentCallbackService {
+  static {
+    __name(this, "PaymentCallbackService");
+  }
+  registry;
+  log;
+  transactions;
+  logger = new Logger(_PaymentCallbackService.name);
+  handlers = /* @__PURE__ */ new Map();
+  constructor(registry, log, transactions) {
+    this.registry = registry;
+    this.log = log;
+    this.transactions = transactions;
+  }
+  /**
+   * Names who handles the setups of one kind of subject. Each kind has one
+   * handler; a second is a wiring error, not a replacement.
+   */
+  handleSetupsOf(kind, handler) {
+    if (this.handlers.has(kind)) {
+      throw new Error(`A handler for payment method setups of '${kind}' is registered twice.`);
+    }
+    this.handlers.set(kind, handler);
+  }
+  async handle(account, callback) {
+    const entry = this.registry.account(account);
+    if (!entry) {
+      throw new NotFoundException(codedError(PAYMENT_ERROR_CODES.PAYMENT_GATEWAY_ACCOUNT_UNKNOWN, {
+        account
+      }));
+    }
+    const event = await this.read(entry.gateway.readCallback.bind(entry.gateway), callback, account);
+    if (event.kind === "unhandled") {
+      this.logger.debug(`Payment event ${event.eventId} (${event.type}) at '${account}' needs no action.`);
+      return "unhandled";
+    }
+    const handler = this.handlerFor(event);
+    const afterCommit = [];
+    const claimed = await this.transactions.run(async (tx) => {
+      const fresh = await this.log.claim({
+        gatewayAccount: account,
+        eventId: event.eventId,
+        provider: entry.provider,
+        sessionId: event.sessionRef,
+        kind: event.kind,
+        summary: summaryOf(event)
+      }, tx);
+      if (!fresh) return false;
+      const context = {
+        tx,
+        gatewayAccount: account,
+        provider: entry.provider,
+        afterCommit: /* @__PURE__ */ __name((step) => afterCommit.push(step), "afterCommit")
+      };
+      if (event.kind === "payment-method-confirmed") {
+        const effect = await this.confirm(handler, event, context);
+        if (effect === "nothing-to-do") {
+          await this.log.releaseSession(account, event.eventId, tx);
+        }
+      } else {
+        await handler.failed(event, context);
+      }
+      return true;
+    });
+    if (!claimed) {
+      this.logger.log(`Payment event ${event.eventId} at '${account}' was handled before; duplicate ignored.`);
+      return "duplicate";
+    }
+    for (const step of afterCommit) {
+      try {
+        await step();
+      } catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        this.logger.error(`Payment event ${event.eventId} at '${account}' is handled, and a step after it failed: ${reason}`);
+      }
+    }
+    return "handled";
+  }
+  /**
+   * Hands the confirmation to its handler, and names the one refusal that
+   * will never come out differently.
+   *
+   * A reference belongs to one subscriber for good (`SC-SEC-014`), so a
+   * confirmation refused for that reason is refused on every delivery. It
+   * still leaves by throwing, which rolls this transaction back: by the time
+   * it is raised a handler has written something that must not stand on its
+   * own — the setup marked complete on the tenant's path, the whole
+   * activation on the sign-up's. Answering the gateway anything else would
+   * commit one of those without the payment method that justifies it.
+   *
+   * The gateway therefore retries until it gives up, and the claim rolls back
+   * with everything else, so nothing durable is left to say why. This line is
+   * what says it.
+   *
+   * There is no terminal state for it, and that is worth knowing before an
+   * operator waits for one: the webhook route has no filter for this, so every
+   * redelivery is answered `500`, for as long as the provider keeps trying. A
+   * provider that disables an endpoint after sustained failures would take the
+   * account's other callbacks with it. Giving the event an end would mean
+   * keeping the claim while undoing what the handler wrote, which needs a
+   * savepoint the port does not have — so it is named here rather than
+   * implied. It names the account, the reference and the subject the
+   * event was about — never the subscriber the reference belongs to, which is
+   * on the other side of the boundary being refused.
+   */
+  async confirm(handler, event, context) {
+    try {
+      return await handler.confirmed(event, context);
+    } catch (error) {
+      if (!isForeignPaymentMethodReferenceError(error)) throw error;
+      this.logger.error(`Payment event ${event.eventId} at '${context.gatewayAccount}' confirms payment method '${error.paymentMethodRef}' for ${subjectOf(event)}, and that reference belongs to another subscriber; nothing was recorded, and every delivery of this event is refused the same way.`);
+      throw error;
+    }
+  }
+  async read(readCallback, callback, account) {
+    try {
+      return await readCallback(callback);
+    } catch (error) {
+      if (!isPaymentCallbackRejectedError(error)) throw error;
+      this.logger.warn(`A payment callback for '${account}' was rejected: ${error.message}`);
+      throw new BadRequestException(codedError(PAYMENT_ERROR_CODES.PAYMENT_CALLBACK_REJECTED));
+    }
+  }
+  handlerFor(event) {
+    const handler = this.handlers.get(event.subject.kind);
+    if (handler) return handler;
+    throw new Error(`A payment method setup for a ${event.subject.kind} was reported, and nothing handles ` + (event.subject.kind === "registration" ? "sign-ups: wire RegistrationModule." : "subscriber payment methods."));
+  }
+};
+PaymentCallbackService = _ts_decorate2([
+  Injectable2(),
+  _ts_param2(1, Inject2(PAYMENT_EVENT_LOG_TOKEN)),
+  _ts_param2(2, Inject2(PAYMENT_TRANSACTION_RUNNER_TOKEN)),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    typeof PaymentGatewayRegistry === "undefined" ? Object : PaymentGatewayRegistry,
+    typeof PaymentEventLog === "undefined" ? Object : PaymentEventLog,
+    typeof TransactionRunner === "undefined" ? Object : TransactionRunner
+  ])
+], PaymentCallbackService);
+function subjectOf(event) {
+  return event.subject.kind === "registration" ? `sign-up ${event.subject.pendingRegistrationId}` : `subscriber ${event.subject.subscriberId}`;
+}
+__name(subjectOf, "subjectOf");
+function summaryOf(event) {
+  const subject = event.subject.kind === "registration" ? {
+    registration: event.subject.pendingRegistrationId
+  } : {
+    subscriber: event.subject.subscriberId
+  };
+  if (event.kind === "payment-method-setup-failed") return {
+    ...subject
+  };
+  const { type, brand, last4 } = event.paymentMethod;
+  return {
+    ...subject,
+    type,
+    brand,
+    last4
+  };
+}
+__name(summaryOf, "summaryOf");
+
+// src/payments/return-urls.ts
+import { BadRequestException as BadRequestException2 } from "@nestjs/common";
+import { PAYMENT_ERROR_CODES as PAYMENT_ERROR_CODES2 } from "@saasicat/core";
+function refuseForeignReturnUrls(urls, allowedOrigins) {
+  const allowed = new Set(allowedOrigins.map(originOf));
+  for (const field of [
+    "successUrl",
+    "cancelUrl"
+  ]) {
+    const origin = originOf(urls[field]);
+    if (origin === null || !allowed.has(origin)) {
+      throw new BadRequestException2(codedError(PAYMENT_ERROR_CODES2.PAYMENT_RETURN_URL_NOT_ALLOWED, {
+        field
+      }));
+    }
+  }
+}
+__name(refuseForeignReturnUrls, "refuseForeignReturnUrls");
+function originOf(url) {
+  try {
+    return new URL(url).origin;
+  } catch {
+    return null;
+  }
+}
+__name(originOf, "originOf");
+
+export {
+  PAYMENT_GATEWAYS_TOKEN,
+  PAYMENT_EVENT_LOG_TOKEN,
+  SUBSCRIBER_PAYMENT_METHOD_REPOSITORY_TOKEN,
+  PAYMENT_TRANSACTION_RUNNER_TOKEN,
+  PaymentGatewayRegistry,
+  PaymentCallbackService,
+  refuseForeignReturnUrls
+};