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

package/dist/{chunk-KFT5AIIH.js → chunk-NDLC5GYK.js}

@@ -1,15 +1,127 @@
-import {
-  appendImplicitDiscountLineItem
-} from "./chunk-BSK6YBLI.js";
 import {
   SUBSCRIPTION_CONTRACT_REPOSITORY_TOKEN
 } from "./chunk-VBRYPU7V.js";
+import {
+  assertContractWindow,
+  assertLinesAddUp,
+  assertNoNegativeDiscount,
+  assertOnePlanLine,
+  assertTaxRatePercent,
+  grossSharesOf,
+  recordContractLinesMoney,
+  round2
+} from "./chunk-6PJE7EWO.js";
+import {
+  SubscriberService
+} from "./chunk-LF6J4YYN.js";
 import {
   __name
 } from "./chunk-SHUYVCID.js";
 
 // src/subscription-contract/subscription-contract.service.ts
 import { ConflictException, Inject, Injectable, NotFoundException, UnprocessableEntityException } from "@nestjs/common";
+
+// src/checkout-offer/discount-line-items.ts
+function appendImplicitDiscountLineItem(input) {
+  return withGrossShares(linesWithDiscount(input), input.priceBreakdown.vatRate);
+}
+__name(appendImplicitDiscountLineItem, "appendImplicitDiscountLineItem");
+function linesWithDiscount(input) {
+  const lineItems = input.lineItems.map((item) => cloneCheckoutOfferLineItem(item));
+  const discountNet = roundMoney(input.priceBreakdown.regularNet - input.priceBreakdown.effectiveNet);
+  if (lineItems.some((item) => item.kind === "discount" && !isGeneratedDiscount(item))) {
+    return lineItems;
+  }
+  const lineItemsWithoutGeneratedDiscount = lineItems.filter((item) => !isGeneratedDiscount(item));
+  if (discountNet <= 0) {
+    return lineItemsWithoutGeneratedDiscount;
+  }
+  return [
+    ...lineItemsWithoutGeneratedDiscount,
+    createDiscountLineItem(input, discountNet)
+  ];
+}
+__name(linesWithDiscount, "linesWithDiscount");
+function cloneCheckoutOfferLineItem(item) {
+  return {
+    ...item,
+    featuresSnapshot: [
+      ...item.featuresSnapshot ?? []
+    ],
+    quotaEffectsSnapshot: {
+      ...item.quotaEffectsSnapshot ?? {}
+    },
+    metadata: cloneRecord(item.metadata)
+  };
+}
+__name(cloneCheckoutOfferLineItem, "cloneCheckoutOfferLineItem");
+function withGrossShares(lines, vatRate) {
+  const shares = grossSharesOf(lines, vatRate);
+  return lines.map((line, index) => {
+    const priceGross = shares[index];
+    if (!isGeneratedDiscount(line)) return {
+      ...line,
+      priceGross
+    };
+    return {
+      ...line,
+      priceGross,
+      metadata: {
+        ...line.metadata,
+        discountGross: -priceGross
+      }
+    };
+  });
+}
+__name(withGrossShares, "withGrossShares");
+function createDiscountLineItem(input, discountNet) {
+  const promoCode = input.promoCodeSnapshot ?? null;
+  const firstPromotion = input.promotionSnapshots?.[0] ?? null;
+  return {
+    kind: "discount",
+    sourceKey: promoCode?.code ?? firstPromotion?.id ?? "price-discount",
+    sourceVersionId: null,
+    titleSnapshot: promoCode?.label ?? firstPromotion?.label ?? "Discount",
+    descriptionSnapshot: promoCode ? `Promo-Code ${promoCode.code}` : null,
+    quantity: 1,
+    unit: null,
+    priceNet: -discountNet,
+    billingCycle: input.billingCycle,
+    featuresSnapshot: [],
+    quotaEffectsSnapshot: {},
+    metadata: {
+      generated: true,
+      source: promoCode ? "promo_code" : firstPromotion ? "promotion" : "price_breakdown",
+      discountNet,
+      promotionSnapshots: cloneArray(input.promotionSnapshots ?? []),
+      promoCodeSnapshot: cloneJsonValue(promoCode)
+    }
+  };
+}
+__name(createDiscountLineItem, "createDiscountLineItem");
+function roundMoney(value) {
+  return Math.round((value + Number.EPSILON) * 100) / 100;
+}
+__name(roundMoney, "roundMoney");
+function isGeneratedDiscount(item) {
+  return item.kind === "discount" && item.metadata?.generated === true;
+}
+__name(isGeneratedDiscount, "isGeneratedDiscount");
+function cloneRecord(value) {
+  if (!value) return null;
+  return cloneJsonValue(value);
+}
+__name(cloneRecord, "cloneRecord");
+function cloneArray(value) {
+  return cloneJsonValue(value);
+}
+__name(cloneArray, "cloneArray");
+function cloneJsonValue(value) {
+  return value == null ? value : JSON.parse(JSON.stringify(value));
+}
+__name(cloneJsonValue, "cloneJsonValue");
+
+// src/subscription-contract/subscription-contract.service.ts
 import { CONTRACT_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;
@@ -33,8 +145,10 @@ var SubscriptionContractService = class {
     __name(this, "SubscriptionContractService");
   }
   repo;
-  constructor(repo) {
+  subscribers;
+  constructor(repo, subscribers) {
     this.repo = repo;
+    this.subscribers = subscribers;
   }
   list(filter) {
     return this.repo.list(filter);
@@ -69,9 +183,36 @@ var SubscriptionContractService = class {
     }
     return subscriptionContractToInvoiceSnapshot(contract);
   }
-  async create(data) {
+  /**
+   * Writes the contract between the tenant's subscriber and the issuer
+   * `config/saas.yaml` names, copying both as they stand. With `tx`, the
+   * contract is written on that transaction and undone with it, and the
+   * subscriber is read there too — so one created earlier on the same
+   * transaction is found.
+   *
+   * Refused with `SUBSCRIBER_REQUIRED` for a tenant without a subscriber:
+   * nothing is agreed without the party to it.
+   */
+  async create(data, tx) {
     this.assertCreateData(data);
-    return this.repo.create(this.cloneCreateData(data));
+    const parties = await this.subscribers.contractPartiesFor(data.tenantId, tx);
+    return this.repo.create({
+      ...this.cloneCreateData(data),
+      parties
+    }, tx);
+  }
+  /**
+   * Refuses, with `SUBSCRIBER_REQUIRED`, a contract this tenant could not
+   * have. For callers that change something before the contract is written —
+   * closing the one in force, changing a plan — and must refuse before that
+   * rather than after.
+   */
+  async assertPartyFor(tenantId, tx) {
+    await this.subscribers.requireForTenant(tenantId, tx);
+  }
+  /** The contract concluded from a checkout offer, or `null` when none was. */
+  findByOriginalOfferId(offerId, tx) {
+    return this.repo.findByOriginalOfferId(offerId, tx);
   }
   async terminate(contractId, data) {
     const existing = await this.getById(contractId);
@@ -79,6 +220,13 @@ var SubscriptionContractService = class {
     return this.repo.terminate(contractId, data);
   }
   async replaceActiveContract(tenantId, data, terminateAt) {
+    const nextData = {
+      ...data,
+      tenantId,
+      effectiveFrom: data.effectiveFrom ?? terminateAt
+    };
+    this.assertCreateData(nextData);
+    await this.assertPartyFor(tenantId);
     const previous = await this.repo.findActiveByTenantId(tenantId, terminateAt);
     if (previous) {
       await this.terminate(previous.id, {
@@ -86,11 +234,7 @@ var SubscriptionContractService = class {
         status: "superseded"
       });
     }
-    const next = await this.create({
-      ...data,
-      tenantId,
-      effectiveFrom: data.effectiveFrom ?? terminateAt
-    });
+    const next = await this.create(nextData);
     return {
       previous,
       next
@@ -107,9 +251,22 @@ var SubscriptionContractService = class {
         }
       });
     }
+    return this.dataFromOffer(offer, options);
+  }
+  /**
+   * The contract an offer becomes, checked the way `create` checks it, before
+   * anything is written. Unlike `createDataFromOffer` it takes an offer that
+   * is still open: concluding an offer refuses a contract it could not create
+   * before the offer is consumed, rather than after.
+   */
+  prepareFromOffer(offer, options) {
+    const data = this.dataFromOffer(offer, options);
+    this.assertCreateData(data);
+    return data;
+  }
+  dataFromOffer(offer, options) {
     const lineItems = this.lineItemsFromOffer(offer);
     return {
-      projectKey: offer.projectKey,
       tenantId: options.tenantId,
       status: options.status ?? "active",
       effectiveFrom: options.effectiveFrom,
@@ -142,13 +299,17 @@ var SubscriptionContractService = class {
         message: "A checkout offer can yield only one contract, and only once its line items are frozen."
       });
     }
-    return appendImplicitDiscountLineItem({
+    const lines = appendImplicitDiscountLineItem({
       billingCycle: offer.billingCycle,
       priceBreakdown: offer.priceBreakdown,
       lineItems: source,
       promotionSnapshots: offer.promotionSnapshots ?? [],
       promoCodeSnapshot: offer.promoCodeSnapshot ?? null
     }).map((item) => this.offerLineItemToContractLineItem(item));
+    return recordContractLinesMoney(lines, {
+      currency: offer.priceBreakdown.currency,
+      taxRate: offer.priceBreakdown.vatRate
+    });
   }
   offerLineItemToContractLineItem(item) {
     return {
@@ -160,7 +321,6 @@ var SubscriptionContractService = class {
       quantity: item.quantity,
       unit: item.unit ?? null,
       priceNet: item.priceNet,
-      priceGross: item.priceGross,
       billingCycle: item.billingCycle,
       minimumTermUntil: this.parseOptionalDate(item.minimumTermUntil, "lineItems.minimumTermUntil"),
       featuresSnapshot: [
@@ -192,7 +352,7 @@ var SubscriptionContractService = class {
       currency: breakdown.currency,
       billingCycle: breakdown.billingCycle,
       subtotalNet: breakdown.regularNet,
-      discountNet: Math.max(0, breakdown.regularNet - breakdown.effectiveNet),
+      discountNet: Math.max(0, round2(breakdown.regularNet - breakdown.effectiveNet)),
       totalNet: breakdown.effectiveNet,
       vatRate: breakdown.vatRate,
       totalGross: breakdown.effectiveGross
@@ -205,19 +365,36 @@ var SubscriptionContractService = class {
         message: "A subscription contract requires at least one line item."
       });
     }
-    if (data.effectiveUntil && data.effectiveUntil <= data.effectiveFrom) {
+    assertContractWindow(data.effectiveFrom, data.effectiveUntil ?? null);
+    assertOnePlanLine(data.lineItems);
+    assertTaxRatePercent("priceSnapshot.vatRate", data.priceSnapshot.vatRate);
+    data.lineItems.forEach((item, index) => assertTaxRatePercent(`lineItems[${index}].taxRate`, item.taxRate));
+    const foreign = data.lineItems.find((item) => item.currency !== data.priceSnapshot.currency);
+    if (foreign) {
       throw new UnprocessableEntityException({
-        code: CONTRACT_ERROR_CODES.SUBSCRIPTION_CONTRACT_INVALID_WINDOW,
-        message: "effectiveUntil must be after effectiveFrom."
+        code: CONTRACT_ERROR_CODES.SUBSCRIPTION_CONTRACT_LINE_ITEM_CURRENCY_MISMATCH,
+        message: "A line item must be booked in the currency its contract was priced in.",
+        params: {
+          sourceKey: foreign.sourceKey,
+          currency: foreign.currency,
+          expected: data.priceSnapshot.currency
+        }
       });
     }
-    const planLineItems = data.lineItems.filter((item) => item.kind === "plan");
-    if (planLineItems.length !== 1) {
+    const contradictory = data.lineItems.find((item) => round2(item.priceGross - item.priceNet) !== round2(item.taxAmount));
+    if (contradictory) {
       throw new UnprocessableEntityException({
-        code: CONTRACT_ERROR_CODES.SUBSCRIPTION_CONTRACT_PLAN_LINE_ITEM_REQUIRED,
-        message: "A subscription contract requires exactly one plan base item."
+        code: CONTRACT_ERROR_CODES.SUBSCRIPTION_CONTRACT_LINE_ITEM_TAX_MISMATCH,
+        message: "A line item's taxAmount must be exactly priceGross minus priceNet.",
+        params: {
+          sourceKey: contradictory.sourceKey,
+          taxAmount: contradictory.taxAmount,
+          expected: round2(contradictory.priceGross - contradictory.priceNet)
+        }
       });
     }
+    assertLinesAddUp(data.lineItems, data.priceSnapshot);
+    assertNoNegativeDiscount(data);
   }
   assertTerminable(existing, data) {
     if (existing.status === "terminated" || existing.status === "superseded") {
@@ -273,9 +450,11 @@ var SubscriptionContractService = class {
 SubscriptionContractService = _ts_decorate([
   Injectable(),
   _ts_param(0, Inject(SUBSCRIPTION_CONTRACT_REPOSITORY_TOKEN)),
+  _ts_param(1, Inject(SubscriberService)),
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
-    typeof SubscriptionContractRepository === "undefined" ? Object : SubscriptionContractRepository
+    typeof SubscriptionContractRepository === "undefined" ? Object : SubscriptionContractRepository,
+    typeof SubscriberService === "undefined" ? Object : SubscriberService
   ])
 ], SubscriptionContractService);
 function contractLineItemToInvoiceLineItem(item) {
@@ -291,6 +470,9 @@ function contractLineItemToInvoiceLineItem(item) {
     priceNet: item.priceNet,
     priceGross: item.priceGross,
     billingCycle: item.billingCycle,
+    currency: item.currency,
+    taxRate: item.taxRate,
+    taxAmount: item.taxAmount,
     minimumTermUntil: item.minimumTermUntil,
     metadata: item.metadata
   };
@@ -299,7 +481,6 @@ __name(contractLineItemToInvoiceLineItem, "contractLineItemToInvoiceLineItem");
 function subscriptionContractToInvoiceSnapshot(contract) {
   return {
     contractId: contract.id,
-    projectKey: contract.projectKey,
     tenantId: contract.tenantId,
     originalOfferId: contract.originalOfferId,
     currency: contract.priceSnapshot.currency,
@@ -334,6 +515,7 @@ function lineItemKindPriority(kind) {
 __name(lineItemKindPriority, "lineItemKindPriority");
 
 export {
+  appendImplicitDiscountLineItem,
   SubscriptionContractService,
   contractLineItemToInvoiceLineItem,
   subscriptionContractToInvoiceSnapshot,

package/dist/{chunk-O2J2HDXA.js → chunk-OOTEXP47.js}

@@ -1,12 +1,10 @@
+import {
+  AUDIT_PORT_TOKEN
+} from "./chunk-SZ7RFPXA.js";
 import {
   __name
 } from "./chunk-SHUYVCID.js";
 
-// src/admin/admin.tokens.ts
-var MFA_PORT_TOKEN = /* @__PURE__ */ Symbol.for("saasicat/nest/MfaPort");
-var AUDIT_PORT_TOKEN = /* @__PURE__ */ Symbol.for("saasicat/nest/AuditPort");
-var RLS_BYPASS_PORT_TOKEN = /* @__PURE__ */ Symbol.for("saasicat/nest/RlsBypassPort");
-
 // src/admin/admin-audit.service.ts
 import * as os from "os";
 import { Inject, Injectable } from "@nestjs/common";
@@ -83,8 +81,5 @@ AdminAuditService = _ts_decorate([
 ], AdminAuditService);
 
 export {
-  MFA_PORT_TOKEN,
-  AUDIT_PORT_TOKEN,
-  RLS_BYPASS_PORT_TOKEN,
   AdminAuditService
 };