@saasicat/nest 0.2.0

package/dist/entitlement/index.cjs

@@ -0,0 +1,805 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/entitlement/index.ts
+var entitlement_exports = {};
+__export(entitlement_exports, {
+  ENTITLEMENT_RESOLUTION_CONFIG_TOKEN: () => ENTITLEMENT_RESOLUTION_CONFIG_TOKEN,
+  EntitlementModule: () => EntitlementModule,
+  EntitlementService: () => EntitlementService,
+  LimitExceededError: () => LimitExceededError,
+  PLAN_VERSION_REPOSITORY_TOKEN: () => PLAN_VERSION_REPOSITORY_TOKEN,
+  SUBSCRIPTION_REPOSITORY_TOKEN: () => SUBSCRIPTION_REPOSITORY_TOKEN,
+  TRANSACTION_RUNNER_TOKEN: () => TRANSACTION_RUNNER_TOKEN,
+  aggregateBusinessTypeQuotas: () => aggregateBusinessTypeQuotas,
+  aggregateContractLineItemEntitlements: () => aggregateContractLineItemEntitlements,
+  aggregateLimits: () => aggregateLimits,
+  aggregateSubscriptionBundleQuotas: () => aggregateSubscriptionBundleQuotas,
+  applyCustomLimits: () => applyCustomLimits,
+  buildReplacedByIndex: () => buildReplacedByIndex,
+  collectBusinessTypeFeatures: () => collectBusinessTypeFeatures,
+  collectSubscriptionBundleFeatures: () => collectSubscriptionBundleFeatures,
+  expandReplacedFeatures: () => expandReplacedFeatures,
+  filterActiveSubscriptionBundles: () => filterActiveSubscriptionBundles,
+  filterPlannedOnlyFeatures: () => filterPlannedOnlyFeatures,
+  hasAnyFeature: () => hasAnyFeature,
+  hasFeature: () => hasFeature,
+  resolveEntitlementPlan: () => resolveEntitlementPlan,
+  toEffectiveLimitsSnapshot: () => toEffectiveLimitsSnapshot
+});
+module.exports = __toCommonJS(entitlement_exports);
+
+// src/billing/plan-helpers.ts
+function isFeaturePlannedOnly(catalog, featureKey) {
+  const def = (catalog.features ?? []).find((f) => f.key === featureKey);
+  return def?.plannedOnly === true;
+}
+__name(isFeaturePlannedOnly, "isFeaturePlannedOnly");
+
+// src/entitlement/aggregation.ts
+function aggregateBusinessTypeQuotas(snapshot) {
+  const sums = {};
+  for (const bundle of snapshot.bundles) {
+    for (const [key, value] of Object.entries(bundle.quotas)) {
+      if (sums[key] === -1 || value === -1) {
+        sums[key] = -1;
+      } else {
+        sums[key] = (sums[key] ?? 0) + value;
+      }
+    }
+  }
+  for (const [key, value] of Object.entries(snapshot.quotaOverrides)) {
+    if (value !== void 0) {
+      sums[key] = value;
+    }
+  }
+  return sums;
+}
+__name(aggregateBusinessTypeQuotas, "aggregateBusinessTypeQuotas");
+function filterActiveSubscriptionBundles(bundles, now) {
+  return bundles.filter((b) => b.canceledEffectiveAt === null || b.canceledEffectiveAt > now);
+}
+__name(filterActiveSubscriptionBundles, "filterActiveSubscriptionBundles");
+function aggregateSubscriptionBundleQuotas(bundles) {
+  const sums = {};
+  for (const bundle of bundles) {
+    for (const [key, value] of Object.entries(bundle.quotas)) {
+      if (sums[key] === -1 || value === -1) {
+        sums[key] = -1;
+      } else {
+        sums[key] = (sums[key] ?? 0) + value;
+      }
+    }
+  }
+  return sums;
+}
+__name(aggregateSubscriptionBundleQuotas, "aggregateSubscriptionBundleQuotas");
+function collectSubscriptionBundleFeatures(bundles) {
+  const set = /* @__PURE__ */ new Set();
+  for (const bundle of bundles) {
+    for (const f of bundle.features) set.add(f);
+  }
+  return Array.from(set);
+}
+__name(collectSubscriptionBundleFeatures, "collectSubscriptionBundleFeatures");
+function aggregateContractLineItemEntitlements(lineItems, fallbackPlan = "UNKNOWN") {
+  const planItem = lineItems.find((item) => item.kind === "plan");
+  const plan = planItem?.sourceKey ?? fallbackPlan;
+  const quotas = {};
+  const features = /* @__PURE__ */ new Set();
+  for (const item of lineItems) {
+    for (const feature of item.featuresSnapshot) {
+      features.add(feature);
+    }
+    for (const [key, value] of Object.entries(item.quotaEffectsSnapshot)) {
+      if (quotas[key] === -1 || value === -1) {
+        quotas[key] = -1;
+      } else {
+        quotas[key] = (quotas[key] ?? 0) + value;
+      }
+    }
+  }
+  return {
+    plan,
+    quotas,
+    features
+  };
+}
+__name(aggregateContractLineItemEntitlements, "aggregateContractLineItemEntitlements");
+function collectBusinessTypeFeatures(snapshot) {
+  const set = /* @__PURE__ */ new Set();
+  for (const bundle of snapshot.bundles) {
+    for (const f of bundle.features) {
+      set.add(f);
+    }
+  }
+  return Array.from(set);
+}
+__name(collectBusinessTypeFeatures, "collectBusinessTypeFeatures");
+function filterPlannedOnlyFeatures(features, catalog) {
+  const out = /* @__PURE__ */ new Set();
+  for (const f of features) {
+    if (!isFeaturePlannedOnly(catalog, f)) {
+      out.add(f);
+    }
+  }
+  return out;
+}
+__name(filterPlannedOnlyFeatures, "filterPlannedOnlyFeatures");
+function applyCustomLimits(base, custom) {
+  if (!custom) return base;
+  const quotas = {
+    ...base.quotas
+  };
+  if (custom.quotas) {
+    for (const [k, v] of Object.entries(custom.quotas)) {
+      quotas[k] = v;
+    }
+  }
+  const features = new Set(base.features);
+  if (custom.features) {
+    for (const f of custom.features) features.add(f);
+  }
+  return {
+    plan: base.plan,
+    quotas,
+    features
+  };
+}
+__name(applyCustomLimits, "applyCustomLimits");
+function aggregateLimits(input, catalog, now) {
+  const businessTypeQuotas = input.businessTypeVersion ? aggregateBusinessTypeQuotas(input.businessTypeVersion) : {};
+  const businessTypeFeatures = input.businessTypeVersion ? collectBusinessTypeFeatures(input.businessTypeVersion) : [];
+  const activeBundles = filterActiveSubscriptionBundles(input.subscriptionBundles ?? [], now);
+  const subBundleQuotas = aggregateSubscriptionBundleQuotas(activeBundles);
+  const subBundleFeatures = collectSubscriptionBundleFeatures(activeBundles);
+  const quotas = {};
+  for (const [k, v] of Object.entries(input.planVersion.quotas)) {
+    quotas[k] = v;
+  }
+  for (const [k, v] of Object.entries(businessTypeQuotas)) {
+    if (quotas[k] === -1 || v === -1) {
+      quotas[k] = -1;
+    } else {
+      quotas[k] = (quotas[k] ?? 0) + v;
+    }
+  }
+  for (const [k, v] of Object.entries(subBundleQuotas)) {
+    if (quotas[k] === -1 || v === -1) {
+      quotas[k] = -1;
+    } else {
+      quotas[k] = (quotas[k] ?? 0) + v;
+    }
+  }
+  const features = /* @__PURE__ */ new Set([
+    ...input.planVersion.features,
+    ...businessTypeFeatures,
+    ...subBundleFeatures
+  ]);
+  const withCustom = applyCustomLimits({
+    plan: input.plan,
+    quotas,
+    features
+  }, input.customLimits);
+  const filteredFeatures = filterPlannedOnlyFeatures(withCustom.features, catalog);
+  return {
+    plan: withCustom.plan,
+    quotas: withCustom.quotas,
+    features: filteredFeatures
+  };
+}
+__name(aggregateLimits, "aggregateLimits");
+function hasFeature(limits, feature) {
+  return limits.features.has(feature);
+}
+__name(hasFeature, "hasFeature");
+function hasAnyFeature(limits, features) {
+  return features.some((f) => limits.features.has(f));
+}
+__name(hasAnyFeature, "hasAnyFeature");
+function toEffectiveLimitsSnapshot(limits) {
+  return {
+    plan: limits.plan,
+    quotas: {
+      ...limits.quotas
+    },
+    features: Array.from(limits.features).sort()
+  };
+}
+__name(toEffectiveLimitsSnapshot, "toEffectiveLimitsSnapshot");
+
+// src/entitlement/feature-aliases.ts
+function buildReplacedByIndex(features) {
+  const index = /* @__PURE__ */ new Map();
+  for (const feature of features) {
+    for (const oldKey of feature.replaces ?? []) {
+      if (oldKey === feature.featureKey) continue;
+      const list = index.get(oldKey) ?? [];
+      list.push(feature.featureKey);
+      index.set(oldKey, list);
+    }
+  }
+  for (const list of index.values()) list.sort((a, b) => a.localeCompare(b));
+  assertNoReplacesCycle(index);
+  return index;
+}
+__name(buildReplacedByIndex, "buildReplacedByIndex");
+function expandReplacedFeatures(granted, index) {
+  const expanded = new Set(granted);
+  const worklist = [
+    ...granted
+  ];
+  while (worklist.length > 0) {
+    const key = worklist.pop();
+    for (const successor of index.get(key) ?? []) {
+      if (expanded.has(successor)) continue;
+      expanded.add(successor);
+      worklist.push(successor);
+    }
+  }
+  return expanded;
+}
+__name(expandReplacedFeatures, "expandReplacedFeatures");
+function assertNoReplacesCycle(index) {
+  const DONE = 2;
+  const IN_PROGRESS = 1;
+  const state = /* @__PURE__ */ new Map();
+  const visit = /* @__PURE__ */ __name((key, path) => {
+    const s = state.get(key);
+    if (s === DONE) return;
+    if (s === IN_PROGRESS) {
+      const cycleStart = path.indexOf(key);
+      const cycle = [
+        ...path.slice(cycleStart),
+        key
+      ].join(" \u2192 ");
+      throw new Error(`replaces-Zyklus in den Discovery-Metadaten: ${cycle}. Feature-Ersetzungen m\xFCssen azyklisch sein \u2014 replaces-Deklarationen im Code korrigieren (#39).`);
+    }
+    state.set(key, IN_PROGRESS);
+    for (const successor of index.get(key) ?? []) {
+      visit(successor, [
+        ...path,
+        key
+      ]);
+    }
+    state.set(key, DONE);
+  }, "visit");
+  for (const key of index.keys()) visit(key, []);
+}
+__name(assertNoReplacesCycle, "assertNoReplacesCycle");
+
+// src/entitlement/plan-resolution.ts
+function resolveEntitlementPlan(input, config, now) {
+  if (input.isPilot && config.pilotEntitlementPlan !== void 0) {
+    return config.pilotEntitlementPlan;
+  }
+  if (input.status === "TRIAL") {
+    return input.trialEntitlementPlan ?? config.defaultTrialEntitlementPlan ?? input.plan;
+  }
+  if (input.status === "PENDING_SALES" && config.pendingSalesEntitlementPlan !== void 0) {
+    return config.pendingSalesEntitlementPlan;
+  }
+  if (input.pendingPlan && input.pendingEffectiveAt && input.pendingEffectiveAt <= now) {
+    return input.pendingPlan;
+  }
+  return input.plan;
+}
+__name(resolveEntitlementPlan, "resolveEntitlementPlan");
+
+// src/entitlement/limit-exceeded-error.ts
+var LimitExceededError = class extends Error {
+  static {
+    __name(this, "LimitExceededError");
+  }
+  dimension;
+  max;
+  used;
+  constructor(dimension, max, used) {
+    super(`Limit f\xFCr ${dimension} erreicht: ${used}/${max}.`), this.dimension = dimension, this.max = max, this.used = used;
+    this.name = "LimitExceededError";
+  }
+};
+
+// src/entitlement/service.ts
+var import_common2 = require("@nestjs/common");
+
+// src/catalog/tokens.ts
+var BUNDLE_REPOSITORY_TOKEN = /* @__PURE__ */ Symbol("BUNDLE_REPOSITORY");
+
+// src/billing/plan-catalog.module.ts
+var import_common = require("@nestjs/common");
+
+// src/core/di.ts
+function asProvider(token, impl) {
+  if (typeof impl === "object" && impl !== null && "useFactory" in impl && typeof impl.useFactory === "function") {
+    const factory = impl;
+    return {
+      provide: token,
+      useFactory: factory.useFactory,
+      inject: factory.inject
+    };
+  }
+  return {
+    provide: token,
+    useValue: impl
+  };
+}
+__name(asProvider, "asProvider");
+
+// 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).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 {
+      id: stem.planKey,
+      name: stem.label,
+      tagline: stem.description ?? void 0,
+      marketed: live.marketed,
+      monthlyNet: parseFloat(live.monthlyNet),
+      yearlyNet: parseFloat(live.yearlyNet),
+      features: live.features,
+      quotas: live.quotas ?? {}
+    };
+  });
+  const features = snapshot.featureEntries.filter((f) => f.deletedAt === null).sort((a, b) => a.sortOrder - b.sortOrder).map((row) => ({
+    key: row.featureKey,
+    label: row.label,
+    icon: row.icon ?? void 0,
+    tier: row.tier ?? void 0,
+    plannedOnly: row.plannedOnly
+  }));
+  return {
+    schemaVersion: 1,
+    projectKey: settings.projectKey,
+    ...settings.app ? {
+      app: settings.app
+    } : {},
+    currency: settings.currency,
+    vatRate: settings.vatRate,
+    ...settings.marketing ? {
+      marketing: settings.marketing
+    } : {},
+    features,
+    plans
+  };
+}
+__name(buildPlanCatalogFromSnapshot, "buildPlanCatalogFromSnapshot");
+
+// src/billing/plan-catalog.module.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");
+var PLAN_CATALOG_TOKEN = /* @__PURE__ */ Symbol("PLAN_CATALOG");
+var PLAN_CATALOG_READ_SINK_TOKEN = /* @__PURE__ */ Symbol("PLAN_CATALOG_READ_SINK");
+var PlanCatalogModule = class _PlanCatalogModule {
+  static {
+    __name(this, "PlanCatalogModule");
+  }
+  static forRoot(options) {
+    return {
+      module: _PlanCatalogModule,
+      global: options.global ?? true,
+      imports: options.imports ?? [],
+      providers: [
+        ...options.extraProviders ?? [],
+        asProvider(PLAN_CATALOG_READ_SINK_TOKEN, options.sink),
+        {
+          provide: PLAN_CATALOG_TOKEN,
+          useFactory: /* @__PURE__ */ __name(async (sink) => {
+            const snapshot = await sink.loadSnapshot(options.projectKey);
+            return buildPlanCatalogFromSnapshot({
+              projectKey: options.projectKey,
+              app: options.app,
+              currency: options.currency,
+              vatRate: options.vatRate,
+              marketing: options.marketing
+            }, snapshot);
+          }, "useFactory"),
+          inject: [
+            PLAN_CATALOG_READ_SINK_TOKEN
+          ]
+        }
+      ],
+      exports: [
+        PLAN_CATALOG_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_TOKEN,
+          useValue: catalog
+        }
+      ],
+      exports: [
+        PLAN_CATALOG_TOKEN
+      ],
+      global: opts.global ?? true
+    };
+  }
+};
+PlanCatalogModule = _ts_decorate([
+  (0, import_common.Module)({})
+], PlanCatalogModule);
+
+// src/billing/subscription-bundles.tokens.ts
+var SUBSCRIPTION_BUNDLE_REPOSITORY_TOKEN = /* @__PURE__ */ Symbol.for("saas-platform/SubscriptionBundleRepository");
+
+// src/subscription-contract/tokens.ts
+var SUBSCRIPTION_CONTRACT_REPOSITORY_TOKEN = /* @__PURE__ */ Symbol.for("saas-platform/SubscriptionContractRepository");
+
+// src/discovery/tokens.ts
+var DISCOVERY_SNAPSHOT_TOKEN = /* @__PURE__ */ Symbol.for("saas-platform/DiscoverySnapshot");
+
+// src/entitlement/tokens.ts
+var SUBSCRIPTION_REPOSITORY_TOKEN = /* @__PURE__ */ Symbol.for("saas-platform/SubscriptionRepository");
+var PLAN_VERSION_REPOSITORY_TOKEN = /* @__PURE__ */ Symbol.for("saas-platform/PlanVersionRepository");
+var TRANSACTION_RUNNER_TOKEN = /* @__PURE__ */ Symbol.for("saas-platform/TransactionRunner");
+var ENTITLEMENT_RESOLUTION_CONFIG_TOKEN = /* @__PURE__ */ Symbol.for("saas-platform/EntitlementResolutionConfig");
+
+// src/entitlement/service.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_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 CACHE_TTL_MS = 6e4;
+var CACHE_MAX_ENTRIES = 1e3;
+var EntitlementService = class {
+  static {
+    __name(this, "EntitlementService");
+  }
+  catalog;
+  subscriptions;
+  planVersions;
+  tx;
+  resolutionConfig;
+  subscriptionBundles;
+  bundles;
+  subscriptionContracts;
+  discoverySnapshot;
+  // Map preserves insert order — on a hit the entry is removed and
+  // re-inserted (LRU). The TTL is a safety net for forgotten
+  // invalidations — 60s is enough, because limits generally only change
+  // through mutations, not through time (a pending plan's effective date
+  // is day-granular).
+  cache = /* @__PURE__ */ new Map();
+  // #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;
+    this.subscriptions = subscriptions;
+    this.planVersions = planVersions;
+    this.tx = tx;
+    this.resolutionConfig = resolutionConfig;
+    this.subscriptionBundles = subscriptionBundles;
+    this.bundles = bundles;
+    this.subscriptionContracts = subscriptionContracts;
+    this.discoverySnapshot = discoverySnapshot;
+  }
+  // ---------------------------------------------------------------------
+  // 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;
+    const sub = await this.subscriptions.findByTenantId(tenantId);
+    if (!sub) {
+      throw new import_common2.NotFoundException(`Keine Subscription f\xFCr Tenant ${tenantId}`);
+    }
+    const limits = await this.deriveLimits(sub, now);
+    this.writeCache(tenantId, limits, now.getTime());
+    return limits;
+  }
+  /**
+   * Clears a tenant's cache entry. MUST be called as soon as a mutation
+   * changes the subscription, a bundle booking, or a PlanVersion binding —
+   * otherwise FeatureGuard and the sidebar stay on stale state for up to
+   * 60s.
+   */
+  invalidateTenant(tenantId) {
+    this.cache.delete(tenantId);
+  }
+  /** Clears the entire cache. Only for tests / bootstrap. */
+  invalidateAll() {
+    this.cache.clear();
+  }
+  /**
+   * Aggregator path — also callable directly by consumers that already
+   * have a `SubscriptionRecord` (e.g. within a transaction).
+   */
+  async deriveLimits(sub, now, tx) {
+    const contractLimits = await this.deriveLimitsFromContract(sub.tenantId, now);
+    if (contractLimits) return this.withReplacedFeatureAliases(contractLimits);
+    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);
+    return this.withReplacedFeatureAliases(aggregateLimits({
+      plan: effectivePlan,
+      planVersion,
+      subscriptionBundles,
+      customLimits: sub.customLimits ?? null
+    }, this.catalog, now));
+  }
+  /**
+   * 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) {
+    if (!this.discoverySnapshot) return limits;
+    if (!this.replacedByIndex) {
+      this.replacedByIndex = buildReplacedByIndex(this.discoverySnapshot.features);
+    }
+    if (this.replacedByIndex.size === 0) return limits;
+    return {
+      ...limits,
+      features: expandReplacedFeatures(limits.features, this.replacedByIndex)
+    };
+  }
+  async deriveLimitsFromContract(tenantId, now) {
+    if (!this.subscriptionContracts) return null;
+    const contract = await this.subscriptionContracts.findActiveByTenantId(tenantId, now);
+    if (!contract) return null;
+    if (contract.entitlementSnapshot) {
+      return {
+        plan: contract.entitlementSnapshot.plan,
+        quotas: {
+          ...contract.entitlementSnapshot.quotas
+        },
+        features: new Set(contract.entitlementSnapshot.features)
+      };
+    }
+    return aggregateContractLineItemEntitlements(contract.lineItems);
+  }
+  /**
+   * Loads a subscription's active bundle bookings and resolves the
+   * `BundleVersion` features/quotas per entry. Without a registered
+   * `SubscriptionBundleRepository` or `BundleRepository` the method
+   * returns an empty list — apps without a bundle schema stay unchanged
+   * (plan-only aggregation).
+   */
+  async loadSubscriptionBundleSnapshots(subscriptionId, now) {
+    if (!this.subscriptionBundles || !this.bundles) return [];
+    const active = await this.subscriptionBundles.listActiveBySubscription(subscriptionId, now);
+    if (active.length === 0) return [];
+    return Promise.all(active.map(async (booking) => {
+      const bv = await this.bundles.findVersionById(booking.bundleVersionId);
+      if (!bv) {
+        throw new Error(`BundleVersion '${booking.bundleVersionId}' aus aktiver SubscriptionBundle nicht gefunden`);
+      }
+      return {
+        bundleKey: bv.bundleKey,
+        features: bv.features,
+        quotas: bv.quotas,
+        canceledEffectiveAt: booking.canceledEffectiveAt
+      };
+    }));
+  }
+  // ---------------------------------------------------------------------
+  // Write/consumption path — row lock + count + insert in the same
+  // transaction. Protects against race conditions on concurrent creations
+  // for the same tenant.
+  // ---------------------------------------------------------------------
+  async enforceLimit(input) {
+    const now = input.now ?? /* @__PURE__ */ new Date();
+    const delta = input.delta ?? 1;
+    return this.tx.run(async (tx) => {
+      const sub = await this.subscriptions.findByTenantIdLocked(input.tenantId, tx);
+      if (!sub) {
+        throw new import_common2.NotFoundException(`Keine Subscription f\xFCr Tenant ${input.tenantId}`);
+      }
+      const limits = await this.deriveLimits(sub, now, tx);
+      const max = limits.quotas[input.dimension];
+      if (max === void 0) {
+        throw new Error(`Quota-Dimension "${input.dimension}" nicht im PlanCatalog (${this.catalog.projectKey}).`);
+      }
+      const used = await input.currentUsage(tx, input.tenantId);
+      if (max !== -1 && used + delta > max) {
+        throw new LimitExceededError(input.dimension, max, used);
+      }
+      return input.insert(tx);
+    });
+  }
+  // ---------------------------------------------------------------------
+  // Helpers
+  // ---------------------------------------------------------------------
+  /**
+   * Plan fallback for TRIAL/PENDING_SALES: returns the PlanVersion active
+   * as of `asOf` (SPEC_V2 §4.2). If the repo does not implement
+   * `findActive`, we fall back to `findLatestLive` (backward compat for
+   * adapters without `validFrom` columns).
+   */
+  async findActivePlanVersionOrFallback(planId, asOf, tx) {
+    const v = this.planVersions.findActive ? await this.planVersions.findActive(planId, asOf, tx) : await this.planVersions.findLatestLive(planId, tx);
+    if (!v) {
+      throw new import_common2.NotFoundException(`Keine zu ${asOf.toISOString().slice(0, 10)} aktive PlanVersion f\xFCr ${planId} \u2014 weder validFrom-window erf\xFCllt noch latest-live verf\xFCgbar.`);
+    }
+    return v;
+  }
+  readCache(tenantId, nowMs) {
+    const entry = this.cache.get(tenantId);
+    if (!entry) return null;
+    if (entry.expiresAt < nowMs) {
+      this.cache.delete(tenantId);
+      return null;
+    }
+    this.cache.delete(tenantId);
+    this.cache.set(tenantId, entry);
+    return entry.value;
+  }
+  writeCache(tenantId, value, nowMs) {
+    if (this.cache.has(tenantId)) this.cache.delete(tenantId);
+    this.cache.set(tenantId, {
+      value,
+      expiresAt: nowMs + CACHE_TTL_MS
+    });
+    while (this.cache.size > CACHE_MAX_ENTRIES) {
+      const oldest = this.cache.keys().next().value;
+      if (oldest === void 0) break;
+      this.cache.delete(oldest);
+    }
+  }
+};
+EntitlementService = _ts_decorate2([
+  (0, import_common2.Injectable)(),
+  _ts_param(0, (0, import_common2.Inject)(PLAN_CATALOG_TOKEN)),
+  _ts_param(1, (0, import_common2.Inject)(SUBSCRIPTION_REPOSITORY_TOKEN)),
+  _ts_param(2, (0, import_common2.Inject)(PLAN_VERSION_REPOSITORY_TOKEN)),
+  _ts_param(3, (0, import_common2.Inject)(TRANSACTION_RUNNER_TOKEN)),
+  _ts_param(4, (0, import_common2.Optional)()),
+  _ts_param(4, (0, import_common2.Inject)(ENTITLEMENT_RESOLUTION_CONFIG_TOKEN)),
+  _ts_param(5, (0, import_common2.Optional)()),
+  _ts_param(5, (0, import_common2.Inject)(SUBSCRIPTION_BUNDLE_REPOSITORY_TOKEN)),
+  _ts_param(6, (0, import_common2.Optional)()),
+  _ts_param(6, (0, import_common2.Inject)(BUNDLE_REPOSITORY_TOKEN)),
+  _ts_param(7, (0, import_common2.Optional)()),
+  _ts_param(7, (0, import_common2.Inject)(SUBSCRIPTION_CONTRACT_REPOSITORY_TOKEN)),
+  _ts_param(8, (0, import_common2.Optional)()),
+  _ts_param(8, (0, import_common2.Inject)(DISCOVERY_SNAPSHOT_TOKEN)),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof PlanCatalog === "undefined" ? Object : PlanCatalog,
+    typeof SubscriptionRepository === "undefined" ? Object : SubscriptionRepository,
+    typeof PlanVersionRepository === "undefined" ? Object : PlanVersionRepository,
+    typeof TransactionRunner === "undefined" ? Object : TransactionRunner,
+    Object,
+    Object,
+    Object,
+    Object,
+    Object
+  ])
+], EntitlementService);
+
+// src/entitlement/module.ts
+var import_common3 = require("@nestjs/common");
+function _ts_decorate3(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_decorate3, "_ts_decorate");
+var EntitlementModule = class _EntitlementModule {
+  static {
+    __name(this, "EntitlementModule");
+  }
+  static forRoot(options) {
+    const providers = [
+      asProvider(SUBSCRIPTION_REPOSITORY_TOKEN, options.subscriptionRepository),
+      asProvider(PLAN_VERSION_REPOSITORY_TOKEN, options.planVersionRepository),
+      asProvider(TRANSACTION_RUNNER_TOKEN, options.transactionRunner),
+      EntitlementService
+    ];
+    if (options.resolutionConfig) {
+      providers.push({
+        provide: ENTITLEMENT_RESOLUTION_CONFIG_TOKEN,
+        useValue: options.resolutionConfig
+      });
+    }
+    if (options.subscriptionContractRepository) {
+      providers.push(asProvider(SUBSCRIPTION_CONTRACT_REPOSITORY_TOKEN, options.subscriptionContractRepository));
+    }
+    if (options.subscriptionBundleRepository) {
+      providers.push(asProvider(SUBSCRIPTION_BUNDLE_REPOSITORY_TOKEN, options.subscriptionBundleRepository));
+    }
+    if (options.bundleRepository) {
+      providers.push(asProvider(BUNDLE_REPOSITORY_TOKEN, options.bundleRepository));
+    }
+    return {
+      module: _EntitlementModule,
+      global: options.global ?? false,
+      providers,
+      exports: [
+        EntitlementService,
+        SUBSCRIPTION_REPOSITORY_TOKEN
+      ]
+    };
+  }
+};
+EntitlementModule = _ts_decorate3([
+  (0, import_common3.Module)({})
+], EntitlementModule);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ENTITLEMENT_RESOLUTION_CONFIG_TOKEN,
+  EntitlementModule,
+  EntitlementService,
+  LimitExceededError,
+  PLAN_VERSION_REPOSITORY_TOKEN,
+  SUBSCRIPTION_REPOSITORY_TOKEN,
+  TRANSACTION_RUNNER_TOKEN,
+  aggregateBusinessTypeQuotas,
+  aggregateContractLineItemEntitlements,
+  aggregateLimits,
+  aggregateSubscriptionBundleQuotas,
+  applyCustomLimits,
+  buildReplacedByIndex,
+  collectBusinessTypeFeatures,
+  collectSubscriptionBundleFeatures,
+  expandReplacedFeatures,
+  filterActiveSubscriptionBundles,
+  filterPlannedOnlyFeatures,
+  hasAnyFeature,
+  hasFeature,
+  resolveEntitlementPlan,
+  toEffectiveLimitsSnapshot
+});