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

package/dist/{checkout-offer.service-CCVxG9b2.d.cts → checkout-offer.service-HKoTZ3JH.d.cts}

@@ -1,7 +1,7 @@
 import { PlanCatalogSettings, PlanRepository, BundleRepository, PromotionRepository, CheckoutOfferPriceBreakdown, CheckoutOfferLineItem, CheckoutOfferPromotionSnapshot, CheckoutOfferPromoCodeSnapshot, CheckoutOfferRow, CheckoutOfferRepository, CatalogEntryRepository, TransactionRunner, CheckoutOfferFilter, CheckoutOfferSelection, CheckoutOfferSelectionUpdate, NewSubscriberDetails, TransactionContext, SubscriptionContractRecord } from '@saasicat/core';
-import { S as SubscriptionContractService, C as CreateContractFromOfferOptions } from './subscription-contract.service-CfNApLuP.cjs';
+import { S as SubscriptionContractService, C as CreateContractFromOfferOptions } from './subscription-contract.service-CH2TKw-j.cjs';
 import { S as SubscriberService } from './subscriber.service-5W6Gi-1B.cjs';
-import { a as PromoCodesService } from './promo.service-BYBu6dy3.cjs';
+import { a as PromoCodesService } from './promo.service-BextPvx5.cjs';
 
 type Cycle = 'monthly' | 'yearly';
 /** What pricing needs to know about a selection. */
@@ -239,4 +239,4 @@ declare class CheckoutOfferService {
     private isExpired;
 }
 
-export { CheckoutOfferPricing as C, type PricedCheckoutOffer as P, type CheckoutOfferPricingInput as a, CheckoutOfferService as b, type ConcludeCheckoutOfferOptions as c, type ConcludeCheckoutOfferWithin as d, type ConcludedCheckoutOffer as e };
+export { CheckoutOfferPricing as C, type PricedCheckoutOffer as P, CheckoutOfferService as a, type CheckoutOfferPricingInput as b, type ConcludeCheckoutOfferOptions as c, type ConcludeCheckoutOfferWithin as d, type ConcludedCheckoutOffer as e };

package/dist/{chunk-F5X66HF5.js → chunk-2ECX7BST.js}

@@ -2,7 +2,7 @@ import {
   ADVISORY_STRICT_MODE_CODES,
   validateBundleDraft,
   validatePlanDraft
-} from "./chunk-CQ2ZZMTD.js";
+} from "./chunk-MU4O4EKX.js";
 import {
   DiscoverySnapshotNotFoundError,
   loadDiscoverySnapshotFromFile

package/dist/{chunk-G6EZWECL.js → chunk-2XBWYMOL.js}

@@ -9,7 +9,7 @@ import {
 } from "./chunk-TBBZWZQT.js";
 import {
   SUBSCRIPTION_CONTRACT_REPOSITORY_TOKEN
-} from "./chunk-VBRYPU7V.js";
+} from "./chunk-E224LKO2.js";
 import {
   BUNDLE_REPOSITORY_TOKEN
 } from "./chunk-3QVGA6JX.js";
@@ -46,6 +46,10 @@ function filterActiveSubscriptionBundles(bundles, now) {
   return bundles.filter((b) => b.canceledEffectiveAt === null || b.canceledEffectiveAt > now);
 }
 __name(filterActiveSubscriptionBundles, "filterActiveSubscriptionBundles");
+function isCancellationDeclared(booking) {
+  return booking.canceledEffectiveAt !== null;
+}
+__name(isCancellationDeclared, "isCancellationDeclared");
 function aggregateSubscriptionBundleQuotas(bundles) {
   const sums = {};
   for (const bundle of bundles) {
@@ -112,6 +116,10 @@ function contractBundleVersionIds(contract) {
       ids.add(item.sourceVersionId);
     }
   }
+  const leftOut = contract.entitlementSnapshot?.leftOutBundleVersionIds;
+  if (Array.isArray(leftOut)) {
+    for (const id of leftOut) ids.delete(id);
+  }
   return ids;
 }
 __name(contractBundleVersionIds, "contractBundleVersionIds");
@@ -390,20 +398,81 @@ var EntitlementService = class {
       const cached = this.readCache(tenantId, now.getTime());
       if (cached) return cached;
     }
+    const sub = await this.requireSubscription(tenantId);
+    if (catalog) return (await this.answerFor(sub, now, catalog)).limits;
+    const answer = await this.answerFor(sub, now, await this.catalogs.current());
+    this.writeCache(tenantId, answer.limits, now.getTime(), firstAfter(now, [
+      cancellationLandsAt(sub),
+      answer.nextBookingEnd
+    ]));
+    return answer.limits;
+  }
+  /**
+   * What a contract frozen at `now` records as its entitlements: what
+   * `computeLimits` would grant with no contract in force, less the add-ons
+   * whose cancellation is declared. The contract in force is not read, so a
+   * successor can be composed — and shown — before the one it replaces ends.
+   *
+   * Those are granted until their effective date by the booking rather than
+   * by the contract (`mergeSubscriptionBundlesIntoLimits`), so their end
+   * needs nobody to write the contract again. Frozen into the snapshot, they
+   * would be granted for as long as the contract runs. Never cached, like
+   * `computeLimits` with a catalogue.
+   */
+  async computeContractLimits(tenantId, now, catalog) {
+    const sub = await this.requireSubscription(tenantId);
+    const { limits, leftOutBundleVersionIds } = await this.answerFor(sub, now, catalog, void 0, {
+      freezing: true
+    });
+    return {
+      limits,
+      leftOutBundleVersionIds
+    };
+  }
+  /**
+   * The features a contract of the tenant covering exactly `bundleVersionIds`
+   * records when frozen now, and the plan version they are read from — or
+   * `null` where the tenant has no subscription. They are the plan version
+   * the subscription is bound to and those add-on versions, each as its row
+   * reads today, with the subscription's own arrangement — aliased and
+   * filtered the way every grant is.
+   *
+   * The add-ons are the ones the caller names, not the bookings running now:
+   * a vocabulary carried into a contract changes what the add-ons it already
+   * covers are called, not which add-ons it covers. Quotas are not asked
+   * for, for the same reason.
+   */
+  async contractFeaturesFor(tenantId, bundleVersionIds, catalog) {
     const sub = await this.subscriptions.findByTenantId(tenantId);
-    if (!sub) {
-      throw new NotFoundException({
-        code: BILLING_ERROR_CODES.SUBSCRIPTION_NOT_FOUND,
-        message: `No subscription for tenant ${tenantId}`,
-        params: {
-          tenantId
-        }
-      });
+    if (!sub) return null;
+    const features = new Set(sub.planVersion.features);
+    for (const id of bundleVersionIds) {
+      const version = this.bundles ? await this.bundles.findVersionById(id) : null;
+      if (!version) {
+        throw new Error(`The contract covers add-on version '${id}', which cannot be read` + (this.bundles ? "." : ": no BundleRepository is configured."));
+      }
+      for (const feature of version.features) features.add(feature);
     }
-    if (catalog) return this.limitsFor(sub, now, catalog);
-    const limits = await this.limitsFor(sub, now, await this.catalogs.current());
-    this.writeCache(tenantId, limits, now.getTime(), cancellationLandsAt(sub));
-    return limits;
+    for (const feature of sub.customLimits?.features ?? []) features.add(feature);
+    return {
+      planVersionId: sub.planVersionId,
+      features: this.asGrantable(catalog, {
+        plan: sub.plan,
+        quotas: {},
+        features
+      }).features
+    };
+  }
+  /**
+   * `features` with every successor a `replaces` declaration carries them to —
+   * what a contract holding them is granted beyond its own keys.
+   */
+  withReplacements(features) {
+    return new Set(this.replaceFeatureAliases({
+      plan: "",
+      quotas: {},
+      features: new Set(features)
+    }).features);
   }
   /**
    * Clears a tenant's cache entry. MUST be called as soon as a mutation
@@ -423,7 +492,20 @@ var EntitlementService = class {
    * have a `SubscriptionRecord` (e.g. within a transaction).
    */
   async deriveLimits(sub, now, tx) {
-    return this.limitsFor(sub, now, await this.catalogs.current(), tx);
+    return (await this.answerFor(sub, now, await this.catalogs.current(), tx)).limits;
+  }
+  async requireSubscription(tenantId) {
+    const sub = await this.subscriptions.findByTenantId(tenantId);
+    if (!sub) {
+      throw new NotFoundException({
+        code: BILLING_ERROR_CODES.SUBSCRIPTION_NOT_FOUND,
+        message: `No subscription for tenant ${tenantId}`,
+        params: {
+          tenantId
+        }
+      });
+    }
+    return sub;
   }
   /**
    * `deriveLimits` against a catalogue already read. The catalogue decides
@@ -431,38 +513,61 @@ var EntitlementService = class {
    * a caller holds, so that checking a limit does not wait for a second
    * connection while the subscription row is locked.
    */
-  async limitsFor(sub, now, catalog, tx) {
+  async answerFor(sub, now, catalog, tx, options = {}) {
     if (cancellationHasLanded(sub, now)) {
       const floor = this.resolutionConfig?.canceledEntitlementPlan;
       if (floor === void 0) {
         return {
-          plan: sub.plan,
-          quotas: {},
-          features: /* @__PURE__ */ new Set()
+          limits: {
+            plan: sub.plan,
+            quotas: {},
+            features: /* @__PURE__ */ new Set()
+          },
+          nextBookingEnd: null,
+          leftOutBundleVersionIds: []
         };
       }
       const floorVersion = await this.findActivePlanVersionOrFallback(floor, now, tx);
-      return this.asGrantable(catalog, aggregateLimits({
+      const limits2 = this.asGrantable(catalog, aggregateLimits({
         plan: floor,
         planVersion: floorVersion,
         subscriptionBundles: [],
         customLimits: null
       }, catalog, now));
+      return {
+        limits: limits2,
+        nextBookingEnd: null,
+        leftOutBundleVersionIds: []
+      };
     }
-    const contract = await this.findActiveContract(sub.tenantId, now, tx);
+    const bundles = await this.loadSubscriptionBundleSnapshots(sub.id, now, tx);
+    const leftOut = options.freezing ? bundles.filter(isCancellationDeclared) : [];
+    const counted = bundles.filter((booking) => !leftOut.includes(booking));
+    const leftOutBundleVersionIds = leftOut.map((booking) => booking.bundleVersionId);
+    const nextBookingEnd = firstAfter(now, counted.map((booking) => booking.canceledEffectiveAt));
+    const contract = options.freezing ? null : await this.findActiveContract(sub.tenantId, now, tx);
     if (contract) {
-      const bundles = await this.loadSubscriptionBundleSnapshots(sub.id, now, tx);
-      return this.asGrantable(catalog, mergeSubscriptionBundlesIntoLimits(contractLimits(contract), bundles, contractBundleVersionIds(contract), catalog, now));
+      const covered = contractBundleVersionIds(contract);
+      const limits2 = this.asGrantable(catalog, mergeSubscriptionBundlesIntoLimits(contractLimits(contract), counted, covered, catalog, now));
+      return {
+        limits: limits2,
+        nextBookingEnd,
+        leftOutBundleVersionIds: []
+      };
     }
     const effectivePlan = resolveEntitlementPlan(sub, this.resolutionConfig ?? {}, now);
     const planVersion = effectivePlan === sub.plan ? sub.planVersion : await this.findActivePlanVersionOrFallback(effectivePlan, now, tx);
-    const subscriptionBundles = await this.loadSubscriptionBundleSnapshots(sub.id, now, tx);
-    return this.asGrantable(catalog, aggregateLimits({
+    const limits = this.asGrantable(catalog, aggregateLimits({
       plan: effectivePlan,
       planVersion,
-      subscriptionBundles,
+      subscriptionBundles: counted,
       customLimits: sub.customLimits ?? null
     }, catalog, now));
+    return {
+      limits,
+      nextBookingEnd,
+      leftOutBundleVersionIds
+    };
   }
   /**
    * The last thing every path does, so that no path can skip it.
@@ -551,7 +656,7 @@ var EntitlementService = class {
           }
         });
       }
-      const limits = await this.limitsFor(sub, now, catalog, tx);
+      const { limits } = await this.answerFor(sub, now, catalog, tx);
       const max = limits.quotas[input.dimension];
       if (max === void 0) {
         throw new InternalServerErrorException(codedError(BILLING_ERROR_CODES.QUOTA_DIMENSION_UNKNOWN, {
@@ -644,6 +749,15 @@ EntitlementService = _ts_decorate([
     Object
   ])
 ], EntitlementService);
+function firstAfter(now, dates) {
+  let first = null;
+  for (const date of dates) {
+    if (date === null || date <= now) continue;
+    if (first === null || date < first) first = date;
+  }
+  return first;
+}
+__name(firstAfter, "firstAfter");
 
 export {
   SUBSCRIPTION_BUNDLE_REPOSITORY_TOKEN,
@@ -651,6 +765,7 @@ export {
   cancellationHasLanded,
   cancellationLandsAt,
   filterActiveSubscriptionBundles,
+  isCancellationDeclared,
   aggregateSubscriptionBundleQuotas,
   collectSubscriptionBundleFeatures,
   aggregateContractLineItemEntitlements,

package/dist/{chunk-R5YCJBHY.js → chunk-3HBP2HK3.js}

@@ -7,14 +7,17 @@ import {
   REQUIRE_FEATURE_KEY,
   loadPlanCatalogFromString,
   periodEndAfter
-} from "./chunk-M47BNEY2.js";
+} from "./chunk-7MLB6T5B.js";
 import {
   EnforceMfa
 } from "./chunk-34XVPR6P.js";
+import {
+  AllowDuringMaintenance
+} from "./chunk-TSLGMPGZ.js";
 import {
   EntitlementService,
   isLimitExceededError
-} from "./chunk-G6EZWECL.js";
+} from "./chunk-2XBWYMOL.js";
 import {
   ENTITLEMENT_SERVICE_TOKEN
 } from "./chunk-OUDSQ3PU.js";
@@ -613,6 +616,7 @@ function buildPlanCatalogImporterController(guards) {
   ], GeneratedPlanCatalogImporterController.prototype, "import", null);
   GeneratedPlanCatalogImporterController = _ts_decorate5([
     Controller("admin/billing/plan-catalog"),
+    AllowDuringMaintenance(),
     UseGuards(...guards),
     _ts_param4(0, Inject4(PlanCatalogImporterService)),
     _ts_metadata4("design:type", Function),

package/dist/{chunk-S33SO5XX.js → chunk-4OFJLVVH.js}

@@ -3,6 +3,9 @@ import {
   DISCOVERY_SNAPSHOT_PATH_TOKEN,
   DiscoveryScanner
 } from "./chunk-JVAEKTJ4.js";
+import {
+  AllowDuringMaintenance
+} from "./chunk-TSLGMPGZ.js";
 import {
   DISCOVERY_SNAPSHOT_TOKEN
 } from "./chunk-QUZU2M33.js";
@@ -82,6 +85,7 @@ function buildDiscoveryController(guards) {
   ], GeneratedDiscoveryController.prototype, "rescanDiscovery", null);
   GeneratedDiscoveryController = _ts_decorate([
     Controller("admin"),
+    AllowDuringMaintenance(),
     UseGuards(...guards),
     _ts_param(0, Inject(DiscoveryScanner)),
     _ts_metadata("design:type", Function),