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

package/dist/{chunk-NA6O63B7.js → chunk-F5X66HF5.js}

@@ -1,12 +1,12 @@
-import {
-  DiscoverySnapshotNotFoundError,
-  loadDiscoverySnapshotFromFile
-} from "./chunk-74SCJ4HF.js";
 import {
   ADVISORY_STRICT_MODE_CODES,
   validateBundleDraft,
   validatePlanDraft
-} from "./chunk-WOVQPXV4.js";
+} from "./chunk-CQ2ZZMTD.js";
+import {
+  DiscoverySnapshotNotFoundError,
+  loadDiscoverySnapshotFromFile
+} from "./chunk-74SCJ4HF.js";
 import {
   __name
 } from "./chunk-SHUYVCID.js";

package/dist/chunk-FEQZCWUL.js

@@ -0,0 +1,174 @@
+import {
+  asProvider
+} from "./chunk-J7NJRK3K.js";
+import {
+  __name
+} from "./chunk-SHUYVCID.js";
+
+// src/billing/plan-catalog-from-snapshot.ts
+function buildPlanCatalogFromSnapshot(settings, snapshot) {
+  const liveByPlanKey = new Map(snapshot.livePlanVersions.map((v) => [
+    v.planId,
+    v
+  ]));
+  const plans = snapshot.plans.filter((p) => p.deletedAt === null).sort((a, b) => a.sortOrder - b.sortOrder || byKey(a.planKey, b.planKey)).map((stem) => {
+    const live = liveByPlanKey.get(stem.planKey);
+    if (!live) {
+      return {
+        id: stem.planKey,
+        name: stem.label,
+        tagline: stem.description ?? void 0,
+        marketed: false,
+        monthlyNet: null,
+        yearlyNet: null,
+        features: [],
+        quotas: {}
+      };
+    }
+    return planDefFromVersion({
+      id: stem.planKey,
+      name: stem.label,
+      tagline: stem.description ?? void 0
+    }, live);
+  });
+  const features = snapshot.featureEntries.filter((f) => f.deletedAt === null).sort((a, b) => a.sortOrder - b.sortOrder || byKey(a.featureKey, b.featureKey)).map((row) => ({
+    key: row.featureKey,
+    label: row.label,
+    icon: row.icon ?? void 0,
+    tier: row.tier ?? void 0,
+    plannedOnly: row.plannedOnly
+  }));
+  const given = Object.fromEntries(Object.entries(settings).filter(([, value]) => value !== void 0));
+  return {
+    schemaVersion: 1,
+    ...given,
+    features,
+    plans
+  };
+}
+__name(buildPlanCatalogFromSnapshot, "buildPlanCatalogFromSnapshot");
+function planDefFromVersion(identity, version) {
+  return {
+    ...identity,
+    marketed: version.marketed,
+    monthlyNet: priceOf(version.monthlyNet),
+    yearlyNet: priceOf(version.yearlyNet),
+    features: version.features,
+    quotas: version.quotas ?? {}
+  };
+}
+__name(planDefFromVersion, "planDefFromVersion");
+function priceOf(value) {
+  const price = Number.parseFloat(String(value));
+  return Number.isFinite(price) ? price : null;
+}
+__name(priceOf, "priceOf");
+function byKey(a, b) {
+  if (a === b) return 0;
+  return a < b ? -1 : 1;
+}
+__name(byKey, "byKey");
+
+// src/billing/plan-catalog-source.ts
+function databasePlanCatalogSource(settings, sink) {
+  return {
+    origin: "database",
+    current: /* @__PURE__ */ __name(async () => buildPlanCatalogFromSnapshot(settings, await sink.loadSnapshot()), "current")
+  };
+}
+__name(databasePlanCatalogSource, "databasePlanCatalogSource");
+function givenPlanCatalogSource(catalog) {
+  return {
+    origin: "given",
+    current: /* @__PURE__ */ __name(() => Promise.resolve(catalog), "current")
+  };
+}
+__name(givenPlanCatalogSource, "givenPlanCatalogSource");
+
+// src/billing/plan-catalog.module.ts
+import { Module } from "@nestjs/common";
+import { planCatalogSettingsOf } 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");
+var PLAN_CATALOG_SETTINGS_TOKEN = /* @__PURE__ */ Symbol.for("saasicat/nest/PlanCatalogSettings");
+var PLAN_CATALOG_SOURCE_TOKEN = /* @__PURE__ */ Symbol.for("saasicat/nest/PlanCatalogSource");
+var PLAN_CATALOG_READ_SINK_TOKEN = /* @__PURE__ */ Symbol.for("saasicat/nest/PLAN_CATALOG_READ_SINK");
+var PlanCatalogModule = class _PlanCatalogModule {
+  static {
+    __name(this, "PlanCatalogModule");
+  }
+  static forRoot(options) {
+    const { sink: sinkSpec, imports, extraProviders, global, ...settings } = options;
+    return {
+      module: _PlanCatalogModule,
+      global: global ?? true,
+      imports: imports ?? [],
+      providers: [
+        ...extraProviders ?? [],
+        asProvider(PLAN_CATALOG_READ_SINK_TOKEN, sinkSpec),
+        {
+          provide: PLAN_CATALOG_SETTINGS_TOKEN,
+          useValue: settings
+        },
+        {
+          provide: PLAN_CATALOG_SOURCE_TOKEN,
+          useFactory: /* @__PURE__ */ __name(async (sink) => {
+            const source = databasePlanCatalogSource(settings, sink);
+            await source.current();
+            return source;
+          }, "useFactory"),
+          inject: [
+            PLAN_CATALOG_READ_SINK_TOKEN
+          ]
+        }
+      ],
+      exports: [
+        PLAN_CATALOG_SETTINGS_TOKEN,
+        PLAN_CATALOG_SOURCE_TOKEN,
+        PLAN_CATALOG_READ_SINK_TOKEN
+      ]
+    };
+  }
+  /**
+   * Tests / in-memory setup: takes the catalog object directly, without a
+   * sink/DB lookup. For unit tests + test bootstraps.
+   */
+  static forRootWithCatalog(catalog, opts = {}) {
+    return {
+      module: _PlanCatalogModule,
+      providers: [
+        {
+          provide: PLAN_CATALOG_SETTINGS_TOKEN,
+          useValue: planCatalogSettingsOf(catalog)
+        },
+        {
+          provide: PLAN_CATALOG_SOURCE_TOKEN,
+          useValue: givenPlanCatalogSource(catalog)
+        }
+      ],
+      exports: [
+        PLAN_CATALOG_SETTINGS_TOKEN,
+        PLAN_CATALOG_SOURCE_TOKEN
+      ],
+      global: opts.global ?? true
+    };
+  }
+};
+PlanCatalogModule = _ts_decorate([
+  Module({})
+], PlanCatalogModule);
+
+export {
+  buildPlanCatalogFromSnapshot,
+  planDefFromVersion,
+  givenPlanCatalogSource,
+  PLAN_CATALOG_SETTINGS_TOKEN,
+  PLAN_CATALOG_SOURCE_TOKEN,
+  PLAN_CATALOG_READ_SINK_TOKEN,
+  PlanCatalogModule
+};

package/dist/{chunk-VIJ5NJWC.js → chunk-G6EZWECL.js}

@@ -1,25 +1,27 @@
-import {
-  PLAN_CATALOG_TOKEN,
-  isFeaturePlannedOnly
-} from "./chunk-DQKCK7DX.js";
-import {
-  SUBSCRIPTION_CONTRACT_REPOSITORY_TOKEN
-} from "./chunk-VBRYPU7V.js";
-import {
-  codedError
-} from "./chunk-57V6ZTI6.js";
 import {
   ENTITLEMENT_RESOLUTION_CONFIG_TOKEN,
   PLAN_VERSION_REPOSITORY_TOKEN,
   SUBSCRIPTION_REPOSITORY_TOKEN,
   TRANSACTION_RUNNER_TOKEN
 } from "./chunk-OUDSQ3PU.js";
+import {
+  isFeaturePlannedOnly
+} from "./chunk-TBBZWZQT.js";
+import {
+  SUBSCRIPTION_CONTRACT_REPOSITORY_TOKEN
+} from "./chunk-VBRYPU7V.js";
 import {
   BUNDLE_REPOSITORY_TOKEN
-} from "./chunk-AOQJEYOL.js";
+} from "./chunk-3QVGA6JX.js";
 import {
   DISCOVERY_SNAPSHOT_TOKEN
 } from "./chunk-QUZU2M33.js";
+import {
+  PLAN_CATALOG_SOURCE_TOKEN
+} from "./chunk-FEQZCWUL.js";
+import {
+  codedError
+} from "./chunk-J7NJRK3K.js";
 import {
   __name
 } from "./chunk-SHUYVCID.js";
@@ -28,6 +30,17 @@ import {
 var SUBSCRIPTION_BUNDLE_REPOSITORY_TOKEN = /* @__PURE__ */ Symbol.for("saasicat/nest/SubscriptionBundleRepository");
 var SUBSCRIPTION_BUNDLE_CONFIG_TOKEN = /* @__PURE__ */ Symbol.for("saasicat/nest/SubscriptionBundleConfig");
 
+// src/entitlement/landed-cancellation.ts
+function cancellationHasLanded(sub, now) {
+  const landsAt = cancellationLandsAt(sub);
+  return landsAt !== null && landsAt <= now;
+}
+__name(cancellationHasLanded, "cancellationHasLanded");
+function cancellationLandsAt(sub) {
+  return sub.canceledEffectiveAt ?? sub.canceledAt;
+}
+__name(cancellationLandsAt, "cancellationLandsAt");
+
 // src/entitlement/aggregation.ts
 function filterActiveSubscriptionBundles(bundles, now) {
   return bundles.filter((b) => b.canceledEffectiveAt === null || b.canceledEffectiveAt > now);
@@ -332,7 +345,7 @@ var EntitlementService = class {
   static {
     __name(this, "EntitlementService");
   }
-  catalog;
+  catalogs;
   subscriptions;
   planVersions;
   tx;
@@ -350,8 +363,8 @@ var EntitlementService = class {
   // #39 — replaces alias index, built lazily from the boot-static snapshot;
   // throws on replaces cycles (a clear error instead of an infinite loop).
   replacedByIndex = null;
-  constructor(catalog, subscriptions, planVersions, tx, resolutionConfig = null, subscriptionBundles = null, bundles = null, subscriptionContracts = null, discoverySnapshot = null) {
-    this.catalog = catalog;
+  constructor(catalogs, subscriptions, planVersions, tx, resolutionConfig = null, subscriptionBundles = null, bundles = null, subscriptionContracts = null, discoverySnapshot = null) {
+    this.catalogs = catalogs;
     this.subscriptions = subscriptions;
     this.planVersions = planVersions;
     this.tx = tx;
@@ -364,9 +377,19 @@ var EntitlementService = class {
   // ---------------------------------------------------------------------
   // Read path — for FeatureGuard, sidebar hooks, GET /billing/entitlement
   // ---------------------------------------------------------------------
-  async computeLimits(tenantId, now = /* @__PURE__ */ new Date()) {
-    const cached = this.readCache(tenantId, now.getTime());
-    if (cached) return cached;
+  /**
+   * The tenant's effective limits, answered from the cache for up to
+   * `CACHE_TTL_MS`. A caller that has already read the catalogue for its own
+   * operation passes it as `catalog`: the answer is then computed against
+   * that reading and kept out of the cache in both directions — not taken
+   * from it, and not written to it, since a reading the caller holds may be
+   * older than the one everybody else should be answered from.
+   */
+  async computeLimits(tenantId, now = /* @__PURE__ */ new Date(), catalog) {
+    if (!catalog) {
+      const cached = this.readCache(tenantId, now.getTime());
+      if (cached) return cached;
+    }
     const sub = await this.subscriptions.findByTenantId(tenantId);
     if (!sub) {
       throw new NotFoundException({
@@ -377,8 +400,9 @@ var EntitlementService = class {
         }
       });
     }
-    const limits = await this.deriveLimits(sub, now);
-    this.writeCache(tenantId, limits, now.getTime());
+    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;
   }
   /**
@@ -399,27 +423,75 @@ 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);
+  }
+  /**
+   * `deriveLimits` against a catalogue already read. The catalogue decides
+   * which features are `plannedOnly`, and it is read outside any transaction
+   * 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) {
+    if (cancellationHasLanded(sub, now)) {
+      const floor = this.resolutionConfig?.canceledEntitlementPlan;
+      if (floor === void 0) {
+        return {
+          plan: sub.plan,
+          quotas: {},
+          features: /* @__PURE__ */ new Set()
+        };
+      }
+      const floorVersion = await this.findActivePlanVersionOrFallback(floor, now, tx);
+      return this.asGrantable(catalog, aggregateLimits({
+        plan: floor,
+        planVersion: floorVersion,
+        subscriptionBundles: [],
+        customLimits: null
+      }, catalog, now));
+    }
     const contract = await this.findActiveContract(sub.tenantId, now, tx);
     if (contract) {
       const bundles = await this.loadSubscriptionBundleSnapshots(sub.id, now, tx);
-      return this.withReplacedFeatureAliases(mergeSubscriptionBundlesIntoLimits(contractLimits(contract), bundles, contractBundleVersionIds(contract), this.catalog, now));
+      return this.asGrantable(catalog, mergeSubscriptionBundlesIntoLimits(contractLimits(contract), bundles, contractBundleVersionIds(contract), catalog, now));
     }
     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.withReplacedFeatureAliases(aggregateLimits({
+    return this.asGrantable(catalog, aggregateLimits({
       plan: effectivePlan,
       planVersion,
       subscriptionBundles,
       customLimits: sub.customLimits ?? null
-    }, this.catalog, now));
+    }, catalog, now));
+  }
+  /**
+   * The last thing every path does, so that no path can skip it.
+   *
+   * Two steps, in this order. Grandfathering (#39): granted old feature keys
+   * transitively grant their successors from the `replaces` chains of the
+   * discovery snapshot — a no-op without a snapshot or without replaces
+   * declarations. Then `plannedOnly` features come out.
+   *
+   * The filter sits here rather than in each branch because it used to sit
+   * in each branch and one of them did not have it: limits read from a
+   * frozen contract were handed over as they stood, so a feature the
+   * catalogue says has no code behind it was granted to whoever had signed
+   * before it was marked. A successor pulled in by an alias could arrive the
+   * same way. `SC-ENTL-003` says "never … wherever it comes from", and one
+   * place is what makes that answerable.
+   */
+  asGrantable(catalog, limits) {
+    return {
+      ...limits,
+      features: filterPlannedOnlyFeatures(this.replaceFeatureAliases(limits).features, catalog)
+    };
   }
   /**
    * Grandfathering (#39): granted old feature keys transitively grant
    * their successors from the `replaces` chains of the discovery snapshot.
    * A no-op without a snapshot or without replaces declarations.
    */
-  withReplacedFeatureAliases(limits) {
+  replaceFeatureAliases(limits) {
     if (!this.discoverySnapshot) return limits;
     if (!this.replacedByIndex) {
       this.replacedByIndex = buildReplacedByIndex(this.discoverySnapshot.features);
@@ -467,6 +539,7 @@ var EntitlementService = class {
   async enforceLimit(input) {
     const now = input.now ?? /* @__PURE__ */ new Date();
     const delta = input.delta ?? 1;
+    const catalog = await this.catalogs.current();
     return this.tx.run(async (tx) => {
       const sub = await this.subscriptions.findByTenantIdLocked(input.tenantId, tx);
       if (!sub) {
@@ -478,12 +551,11 @@ var EntitlementService = class {
           }
         });
       }
-      const limits = await this.deriveLimits(sub, now, tx);
+      const limits = await this.limitsFor(sub, now, catalog, tx);
       const max = limits.quotas[input.dimension];
       if (max === void 0) {
         throw new InternalServerErrorException(codedError(BILLING_ERROR_CODES.QUOTA_DIMENSION_UNKNOWN, {
-          dimension: input.dimension,
-          projectKey: this.catalog.projectKey
+          dimension: input.dimension
         }));
       }
       const used = await input.currentUsage(tx, input.tenantId);
@@ -520,7 +592,7 @@ var EntitlementService = class {
   readCache(tenantId, nowMs) {
     const entry = this.cache.get(tenantId);
     if (!entry) return null;
-    if (entry.expiresAt < nowMs) {
+    if (entry.expiresAt <= nowMs) {
       this.cache.delete(tenantId);
       return null;
     }
@@ -528,11 +600,13 @@ var EntitlementService = class {
     this.cache.set(tenantId, entry);
     return entry.value;
   }
-  writeCache(tenantId, value, nowMs) {
+  writeCache(tenantId, value, nowMs, expiresNotAfter = null) {
     if (this.cache.has(tenantId)) this.cache.delete(tenantId);
+    const ttlExpiry = nowMs + CACHE_TTL_MS;
+    const boundary = expiresNotAfter?.getTime() ?? Infinity;
     this.cache.set(tenantId, {
       value,
-      expiresAt: nowMs + CACHE_TTL_MS
+      expiresAt: boundary > nowMs ? Math.min(ttlExpiry, boundary) : ttlExpiry
     });
     while (this.cache.size > CACHE_MAX_ENTRIES) {
       const oldest = this.cache.keys().next().value;
@@ -543,7 +617,7 @@ var EntitlementService = class {
 };
 EntitlementService = _ts_decorate([
   Injectable(),
-  _ts_param(0, Inject(PLAN_CATALOG_TOKEN)),
+  _ts_param(0, Inject(PLAN_CATALOG_SOURCE_TOKEN)),
   _ts_param(1, Inject(SUBSCRIPTION_REPOSITORY_TOKEN)),
   _ts_param(2, Inject(PLAN_VERSION_REPOSITORY_TOKEN)),
   _ts_param(3, Inject(TRANSACTION_RUNNER_TOKEN)),
@@ -559,7 +633,7 @@ EntitlementService = _ts_decorate([
   _ts_param(8, Inject(DISCOVERY_SNAPSHOT_TOKEN)),
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
-    typeof PlanCatalog === "undefined" ? Object : PlanCatalog,
+    typeof PlanCatalogSource === "undefined" ? Object : PlanCatalogSource,
     typeof SubscriptionRepository === "undefined" ? Object : SubscriptionRepository,
     typeof PlanVersionRepository === "undefined" ? Object : PlanVersionRepository,
     typeof TransactionRunner === "undefined" ? Object : TransactionRunner,
@@ -574,6 +648,8 @@ EntitlementService = _ts_decorate([
 export {
   SUBSCRIPTION_BUNDLE_REPOSITORY_TOKEN,
   SUBSCRIPTION_BUNDLE_CONFIG_TOKEN,
+  cancellationHasLanded,
+  cancellationLandsAt,
   filterActiveSubscriptionBundles,
   aggregateSubscriptionBundleQuotas,
   collectSubscriptionBundleFeatures,

package/dist/{chunk-N3L3AICU.js → chunk-GPQWGA6B.js}

@@ -1,8 +1,6 @@
-// src/billing/version-diff.ts
-import { classifyBundleVersionDiff, classifyPlanDiff } from "@saasicat/core";
-
 // src/billing/tenant-billing.tokens.ts
 var TENANT_AUTH_GUARDS_TOKEN = /* @__PURE__ */ Symbol.for("saasicat/nest/TenantAuthGuards");
+var BILLING_PERMISSION_GUARDS_TOKEN = /* @__PURE__ */ Symbol.for("saasicat/nest/BillingPermissionGuards");
 var TENANT_ID_RESOLVER_TOKEN = /* @__PURE__ */ Symbol.for("saasicat/nest/TenantIdResolver");
 var USER_ID_RESOLVER_TOKEN = /* @__PURE__ */ Symbol.for("saasicat/nest/UserIdResolver");
 var USER_EMAIL_RESOLVER_TOKEN = /* @__PURE__ */ Symbol.for("saasicat/nest/UserEmailResolver");
@@ -12,11 +10,11 @@ var USAGE_SNAPSHOT_PORT_TOKEN = /* @__PURE__ */ Symbol.for("saasicat/nest/UsageS
 var SUBSCRIPTION_WRITE_PORT_TOKEN = /* @__PURE__ */ Symbol.for("saasicat/nest/TenantSubscriptionWritePort");
 var TRIAL_PROJECTION_PORT_TOKEN = /* @__PURE__ */ Symbol.for("saasicat/nest/TrialProjectionPort");
 var PENDING_PLAN_QUERY_PORT_TOKEN = /* @__PURE__ */ Symbol.for("saasicat/nest/PendingPlanQueryPort");
+var CANCELLATION_NOTICE_DAYS_TOKEN = /* @__PURE__ */ Symbol.for("saasicat/nest/CancellationNoticeDays");
 
 export {
-  classifyBundleVersionDiff,
-  classifyPlanDiff,
   TENANT_AUTH_GUARDS_TOKEN,
+  BILLING_PERMISSION_GUARDS_TOKEN,
   TENANT_ID_RESOLVER_TOKEN,
   USER_ID_RESOLVER_TOKEN,
   USER_EMAIL_RESOLVER_TOKEN,
@@ -25,5 +23,6 @@ export {
   USAGE_SNAPSHOT_PORT_TOKEN,
   SUBSCRIPTION_WRITE_PORT_TOKEN,
   TRIAL_PROJECTION_PORT_TOKEN,
-  PENDING_PLAN_QUERY_PORT_TOKEN
+  PENDING_PLAN_QUERY_PORT_TOKEN,
+  CANCELLATION_NOTICE_DAYS_TOKEN
 };

package/dist/chunk-GZTL64QK.js

@@ -0,0 +1,7 @@
+// src/billing/version-diff.ts
+import { classifyBundleVersionDiff, classifyPlanDiff } from "@saasicat/core";
+
+export {
+  classifyBundleVersionDiff,
+  classifyPlanDiff
+};

package/dist/{chunk-SABTXESR.js → chunk-J7NJRK3K.js}

@@ -19,6 +19,22 @@ function asProvider(token, impl) {
 }
 __name(asProvider, "asProvider");
 
+// src/errors/coded-error.ts
+import { ERROR_MESSAGES_EN, formatErrorMessage } from "@saasicat/core";
+function codedError(code, params) {
+  const message = formatErrorMessage(ERROR_MESSAGES_EN[code], params ?? {});
+  return params ? {
+    code,
+    message,
+    params
+  } : {
+    code,
+    message
+  };
+}
+__name(codedError, "codedError");
+
 export {
-  asProvider
+  asProvider,
+  codedError
 };