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

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-CRCNY3U6.js → chunk-7NJKVC5X.js}

@@ -1,6 +1,6 @@
 import {
-  PLAN_CATALOG_TOKEN
-} from "./chunk-323FB6TD.js";
+  PLAN_CATALOG_SETTINGS_TOKEN
+} from "./chunk-FEQZCWUL.js";
 import {
   codedError
 } from "./chunk-J7NJRK3K.js";
@@ -78,24 +78,24 @@ var PaymentGatewayRegistry = class {
   static {
     __name(this, "PaymentGatewayRegistry");
   }
-  catalog;
+  settings;
   accounts = /* @__PURE__ */ new Map();
   takesNew;
-  constructor(catalog, gateways) {
-    this.catalog = catalog;
-    const problems = paymentAccountProblems(catalog.payments, gateways);
+  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(catalog.payments.accounts)) {
+    for (const [name, account] of Object.entries(settings.payments.accounts)) {
       this.accounts.set(name, {
         name,
         provider: account.provider,
         gateway: gateways[name]
       });
     }
-    this.takesNew = catalog.payments.newPaymentMethods;
+    this.takesNew = settings.payments.newPaymentMethods;
   }
   /** The account a callback names, or `null` when none is configured under it. */
   account(name) {
@@ -109,7 +109,7 @@ var PaymentGatewayRegistry = class {
   }
   /** The origins a gateway's form may send a person back to. */
   returnUrlOrigins() {
-    return this.catalog.payments.returnUrlOrigins;
+    return this.settings.payments.returnUrlOrigins;
   }
   /** The account a new payment method is taken at, or `null` when none takes new ones. */
   forNewPaymentMethods() {
@@ -117,24 +117,24 @@ var PaymentGatewayRegistry = class {
     const account = this.accounts.get(this.takesNew);
     return {
       ...account,
-      methods: this.catalog.payments.accounts[this.takesNew].methods
+      methods: this.settings.payments.accounts[this.takesNew].methods
     };
   }
 };
 PaymentGatewayRegistry = _ts_decorate([
   Injectable(),
-  _ts_param(0, Inject(PLAN_CATALOG_TOKEN)),
+  _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 PlanCatalog === "undefined" ? Object : PlanCatalog,
+    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, isPaymentCallbackRejectedError } from "@saasicat/core";
+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);
@@ -207,7 +207,7 @@ var PaymentCallbackService = class _PaymentCallbackService {
         afterCommit: /* @__PURE__ */ __name((step) => afterCommit.push(step), "afterCommit")
       };
       if (event.kind === "payment-method-confirmed") {
-        const effect = await handler.confirmed(event, context);
+        const effect = await this.confirm(handler, event, context);
         if (effect === "nothing-to-do") {
           await this.log.releaseSession(account, event.eventId, tx);
         }
@@ -230,6 +230,42 @@ var PaymentCallbackService = class _PaymentCallbackService {
     }
     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);
@@ -256,6 +292,10 @@ PaymentCallbackService = _ts_decorate2([
     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