@saasicat/nest 0.26.0 → 0.27.0

package/dist/chunk-2JTISFUZ.js

@@ -0,0 +1,792 @@
+import {
+  FEATURE_GUARD_MARKER,
+  PUBLIC_CATALOG_BUNDLE_REPOSITORY_TOKEN,
+  PUBLIC_CATALOG_CATALOG_ENTRY_REPOSITORY_TOKEN,
+  PUBLIC_CATALOG_PROJECT_KEY_TOKEN,
+  REQUIRE_FEATURE_KEY,
+  periodEndAfter
+} from "./chunk-UHD6FJBQ.js";
+import {
+  EntitlementService,
+  isLimitExceededError
+} from "./chunk-F4B2NJUZ.js";
+import {
+  ENTITLEMENT_SERVICE_TOKEN
+} from "./chunk-WKVBNTYC.js";
+import {
+  asProvider
+} from "./chunk-SABTXESR.js";
+import {
+  __name
+} from "./chunk-SHUYVCID.js";
+
+// src/billing/version-publish.ts
+var PublishValidationError = class extends Error {
+  static {
+    __name(this, "PublishValidationError");
+  }
+  code;
+  constructor(code, message) {
+    super(message), this.code = code;
+    this.name = "PublishValidationError";
+  }
+};
+function assertChangeNote(changeNote) {
+  const trimmed = (changeNote ?? "").trim();
+  if (trimmed.length === 0) {
+    throw new PublishValidationError("CHANGE_NOTE_REQUIRED", "changeNote is required when publishing a version.");
+  }
+  return trimmed;
+}
+__name(assertChangeNote, "assertChangeNote");
+function assertDraftPublishable(draft, draftId) {
+  if (!draft) {
+    throw new PublishValidationError("NOT_FOUND", `PlanVersion ${draftId} not found`);
+  }
+  if (draft.publishedAt !== null) {
+    throw new PublishValidationError("ALREADY_PUBLISHED", `PlanVersion ${draftId} has already been published.`);
+  }
+  if (!draft.baseVersionId) {
+    throw new PublishValidationError("NO_BASE_VERSION", `Draft ${draftId} has no baseVersion \u2014 probably a manually created v1 that may only be published via a migration.`);
+  }
+}
+__name(assertDraftPublishable, "assertDraftPublishable");
+function assertBaseVersionFresh(base, baseId, planContext) {
+  if (!base) {
+    throw new PublishValidationError("BASE_NOT_FOUND", `baseVersion ${baseId} no longer exists.`);
+  }
+  if (base.supersededAt !== null) {
+    throw new PublishValidationError("BASE_SUPERSEDED", `The draft is based on a superseded version (${planContext}). Rebase the draft onto the current live version, or create a new one.`);
+  }
+}
+__name(assertBaseVersionFresh, "assertBaseVersionFresh");
+function assertOptimisticLockHeld(updateCount, draftId) {
+  if (updateCount !== 1) {
+    throw new PublishValidationError("OPTIMISTIC_LOCK_CONFLICT", `Draft ${draftId} has meanwhile been published by another admin.`);
+  }
+}
+__name(assertOptimisticLockHeld, "assertOptimisticLockHeld");
+
+// src/billing/version-renewal.ts
+function decideRenewal(sub, now) {
+  if (!sub.pendingPlanVersionId || !sub.pendingPlanVersionEffectiveAt) return "SKIP";
+  if (sub.pendingPlanVersionEffectiveAt > now) return "SKIP";
+  if (sub.pendingPlanVersionNonRegressive || sub.pendingPlanVersionAccepted) {
+    return "ROLL_FORWARD";
+  }
+  return "CLEAR_PENDING";
+}
+__name(decideRenewal, "decideRenewal");
+function clearPendingPlanVersionFields() {
+  return {
+    pendingPlanVersionId: null,
+    pendingPlanVersionEffectiveAt: null,
+    pendingPlanVersionAccepted: false,
+    pendingPlanVersionAcceptedAt: null,
+    pendingPlanVersionAcceptedByUserId: null,
+    pendingPlanVersionNotifiedAt: null,
+    pendingPlanVersionReminderSentAt: null
+  };
+}
+__name(clearPendingPlanVersionFields, "clearPendingPlanVersionFields");
+function computeNextPeriod(sub, now) {
+  if (sub.canceledAt !== null) return null;
+  if (sub.currentPeriodEnd === null) return null;
+  if (sub.currentPeriodEnd > now) return null;
+  const newStart = sub.currentPeriodEnd;
+  const newEnd = periodEndAfter(newStart, sub.billingCycle, now);
+  return {
+    currentPeriodStart: newStart,
+    currentPeriodEnd: newEnd
+  };
+}
+__name(computeNextPeriod, "computeNextPeriod");
+
+// src/billing/feature-guard.tokens.ts
+var FEATURE_GUARD_CONFIG_TOKEN = /* @__PURE__ */ Symbol.for("saas-platform/FeatureGuardConfig");
+
+// src/billing/feature.guard.ts
+import { ForbiddenException, Inject, Injectable, Logger, Optional } from "@nestjs/common";
+import { Reflector } from "@nestjs/core";
+import { AUTH_ERROR_CODES, FEATURE_NOT_LICENSED } from "@saasicat/types";
+
+// src/billing/upsell.tokens.ts
+var UPSELL_OFFER_RESOLVER_TOKEN = /* @__PURE__ */ Symbol.for("saas-platform/UpsellOfferResolver");
+var UPSELL_OFFER_CURRENCY_TOKEN = /* @__PURE__ */ Symbol.for("saas-platform/UpsellOfferCurrency");
+
+// src/billing/feature.guard.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");
+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 FeatureGuard = class _FeatureGuard {
+  static {
+    __name(this, "FeatureGuard");
+  }
+  reflector;
+  entitlements;
+  config;
+  upsellResolver;
+  /** Lets `EnforcementChainCheck` recognise this guard across CJS entries. */
+  static [FEATURE_GUARD_MARKER] = true;
+  logger = new Logger(_FeatureGuard.name);
+  constructor(reflector, entitlements, config = null, upsellResolver = null) {
+    this.reflector = reflector;
+    this.entitlements = entitlements;
+    this.config = config;
+    this.upsellResolver = upsellResolver;
+  }
+  async canActivate(context) {
+    const required = this.reflector.getAllAndOverride(REQUIRE_FEATURE_KEY, [
+      context.getHandler(),
+      context.getClass()
+    ]);
+    if (!required || required.length === 0) return true;
+    const request = context.switchToHttp().getRequest();
+    const user = request.user;
+    if (!user) {
+      throw new ForbiddenException({
+        code: AUTH_ERROR_CODES.NOT_AUTHENTICATED,
+        message: "Not authenticated"
+      });
+    }
+    const role = this.config?.userRoleResolver ? this.config.userRoleResolver(user) : user.role ?? user.platformRole;
+    if (role === "SUPER_ADMIN") return true;
+    const tenantId = this.config?.tenantIdResolver ? this.config.tenantIdResolver(request) : request.tenantId ?? user.tenantId;
+    if (!tenantId) {
+      throw new ForbiddenException({
+        code: AUTH_ERROR_CODES.NO_TENANT_ASSIGNED,
+        message: "No tenant assigned"
+      });
+    }
+    const compute = /* @__PURE__ */ __name(() => this.entitlements.computeLimits(tenantId), "compute");
+    const limits = this.config?.tenantContextRunner ? await this.config.tenantContextRunner(tenantId, compute) : await compute();
+    const allowed = required.some((f) => limits.features.has(f));
+    if (!allowed) {
+      throw await this.buildNotLicensedException(required, tenantId);
+    }
+    return true;
+  }
+  /**
+   * Upsell response (#36): the 403 body is always the full
+   * `FeatureNotLicensedBody`, so a consumer that matches on `code` can read
+   * `featureKey`/`offers` unconditionally. Without a registered
+   * `UpsellOfferResolver` there is simply nothing to offer — `offers` is
+   * empty, the same degradation a failing resolver produces.
+   *
+   * Deliberately 403 + `code` field instead of 402 — rationale in
+   * `@saasicat/types` upsell.types.ts (402 is reserved / inconsistently
+   * supported; SPA interceptors must not treat the 403 as an auth error, the
+   * distinction runs through `code`).
+   *
+   * The message must keep starting with the word `Feature` — consumers
+   * classify the response by that prefix.
+   */
+  async buildNotLicensedException(required, tenantId) {
+    const body = {
+      code: FEATURE_NOT_LICENSED,
+      featureKey: required[0],
+      featureKeys: required,
+      offers: this.upsellResolver ? await this.resolveOffersSafe(required, tenantId) : [],
+      message: `Feature ${required.join(" / ")} is not included in the current plan.`
+    };
+    return new ForbiddenException(body);
+  }
+  /**
+   * A resolver error must not turn the semantically correct 403 into a 500 —
+   * degrade to empty offers and log.
+   */
+  async resolveOffersSafe(required, tenantId) {
+    try {
+      return await this.upsellResolver.resolveOffers(required, tenantId);
+    } catch (error) {
+      this.logger.warn(`UpsellOfferResolver failed for [${required.join(", ")}]: ${String(error)}`);
+      return [];
+    }
+  }
+};
+FeatureGuard = _ts_decorate([
+  Injectable(),
+  _ts_param(0, Inject(Reflector)),
+  _ts_param(1, Inject(ENTITLEMENT_SERVICE_TOKEN)),
+  _ts_param(2, Optional()),
+  _ts_param(2, Inject(FEATURE_GUARD_CONFIG_TOKEN)),
+  _ts_param(3, Optional()),
+  _ts_param(3, Inject(UPSELL_OFFER_RESOLVER_TOKEN)),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof Reflector === "undefined" ? Object : Reflector,
+    typeof EntitlementService === "undefined" ? Object : EntitlementService,
+    Object,
+    Object
+  ])
+], FeatureGuard);
+
+// src/billing/catalog-bundle-upsell-resolver.ts
+import { Inject as Inject2, Injectable as Injectable2, Optional as Optional2 } from "@nestjs/common";
+import { buildFeatureRequiresIndex, collectUnsatisfiedRequires } from "@saasicat/types";
+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_metadata2(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata2, "_ts_metadata");
+function _ts_param2(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param2, "_ts_param");
+var DEFAULT_CURRENCY = "EUR";
+var CatalogBundleUpsellResolver = class {
+  static {
+    __name(this, "CatalogBundleUpsellResolver");
+  }
+  bundleRepo;
+  projectKey;
+  catalogEntryRepo;
+  currency;
+  constructor(bundleRepo, projectKey, catalogEntryRepo = null, currency = null) {
+    this.bundleRepo = bundleRepo;
+    this.projectKey = projectKey;
+    this.catalogEntryRepo = catalogEntryRepo;
+    this.currency = currency;
+  }
+  async resolveOffers(featureKeys, tenantId) {
+    void tenantId;
+    if (featureKeys.length === 0) return [];
+    const missing = new Set(featureKeys);
+    const wanted = /* @__PURE__ */ new Set([
+      ...featureKeys,
+      ...await this.lookupUnmetRequires(featureKeys)
+    ]);
+    const ranked = [];
+    for (const live of await this.listLiveMarketedBundles()) {
+      const features = live.features;
+      if (!features.some((key) => missing.has(key))) continue;
+      ranked.push({
+        offer: this.toOffer(live),
+        coverage: features.filter((key) => wanted.has(key)).length
+      });
+    }
+    return ranked.sort(compareRankedOffers).map((r) => r.offer);
+  }
+  /**
+   * Uncovered dependencies of the missing features (#35) — feed into the
+   * coverage ranking. Without a CatalogEntryRepository: empty (ranking
+   * degrades to price).
+   */
+  async lookupUnmetRequires(featureKeys) {
+    if (!this.catalogEntryRepo) return [];
+    const rows = await this.catalogEntryRepo.listFeatures({
+      projectKey: this.projectKey
+    });
+    return collectUnsatisfiedRequires(featureKeys, buildFeatureRequiresIndex(rows));
+  }
+  /** Only published-and-live AND marketed — non-marketed bundles are not an offer. */
+  async listLiveMarketedBundles() {
+    const stems = await this.bundleRepo.list({
+      projectKey: this.projectKey,
+      excludeDeleted: true
+    });
+    const out = [];
+    for (const stem of stems) {
+      const live = await this.bundleRepo.findLatestLive(stem.id);
+      if (live?.marketed) out.push(live);
+    }
+    return out;
+  }
+  toOffer(live) {
+    return {
+      bundleKey: live.bundleKey,
+      bundleVersionId: live.id,
+      priceMonthlyNet: parsePrice(live.monthlyNet),
+      currency: this.currency ?? DEFAULT_CURRENCY,
+      label: live.label
+    };
+  }
+};
+CatalogBundleUpsellResolver = _ts_decorate2([
+  Injectable2(),
+  _ts_param2(0, Inject2(PUBLIC_CATALOG_BUNDLE_REPOSITORY_TOKEN)),
+  _ts_param2(1, Inject2(PUBLIC_CATALOG_PROJECT_KEY_TOKEN)),
+  _ts_param2(2, Optional2()),
+  _ts_param2(2, Inject2(PUBLIC_CATALOG_CATALOG_ENTRY_REPOSITORY_TOKEN)),
+  _ts_param2(3, Optional2()),
+  _ts_param2(3, Inject2(UPSELL_OFFER_CURRENCY_TOKEN)),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    typeof BundleRepository === "undefined" ? Object : BundleRepository,
+    String,
+    Object,
+    Object
+  ])
+], CatalogBundleUpsellResolver);
+function parsePrice(decimal) {
+  if (decimal === null) return null;
+  const n = Number.parseFloat(decimal);
+  return Number.isFinite(n) ? n : null;
+}
+__name(parsePrice, "parsePrice");
+function compareRankedOffers(a, b) {
+  if (a.coverage !== b.coverage) return b.coverage - a.coverage;
+  const priceA = a.offer.priceMonthlyNet ?? Number.POSITIVE_INFINITY;
+  const priceB = b.offer.priceMonthlyNet ?? Number.POSITIVE_INFINITY;
+  if (priceA !== priceB) return priceA - priceB;
+  return a.offer.bundleKey.localeCompare(b.offer.bundleKey);
+}
+__name(compareRankedOffers, "compareRankedOffers");
+
+// src/billing/limit-exceeded.filter.ts
+import { Catch, HttpStatus, Logger as Logger2 } from "@nestjs/common";
+import { BaseExceptionFilter } from "@nestjs/core";
+import { BILLING_ERROR_CODES } from "@saasicat/types";
+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 LimitExceededFilter = class _LimitExceededFilter extends BaseExceptionFilter {
+  static {
+    __name(this, "LimitExceededFilter");
+  }
+  logger = new Logger2(_LimitExceededFilter.name);
+  catch(exception, host) {
+    if (!isLimitExceededError(exception)) {
+      super.catch(exception, host);
+      return;
+    }
+    const ctx = host.switchToHttp();
+    const response = ctx.getResponse();
+    const request = ctx.getRequest();
+    this.logger.warn(`Limit ${exception.dimension} exceeded: ${exception.used}/${exception.max} on ${request.method ?? "?"} ${request.url ?? ""}`);
+    response.status(HttpStatus.PAYMENT_REQUIRED).send({
+      statusCode: HttpStatus.PAYMENT_REQUIRED,
+      error: "PaymentRequired",
+      code: BILLING_ERROR_CODES.LIMIT_EXCEEDED,
+      // Deprecated: superseded by `code`, kept until consumers have
+      // migrated. Same value, only under the older field name.
+      reason: BILLING_ERROR_CODES.LIMIT_EXCEEDED,
+      dimension: exception.dimension,
+      used: exception.used,
+      max: exception.max,
+      message: exception.message
+    });
+  }
+};
+LimitExceededFilter = _ts_decorate3([
+  Catch()
+], LimitExceededFilter);
+
+// src/billing/plan-catalog-loader.ts
+import { readFileSync } from "fs";
+import { resolve as resolvePath } from "path";
+import yaml from "js-yaml";
+import Ajv2020 from "ajv/dist/2020.js";
+import addFormats from "ajv-formats";
+import { planCatalogSchema } from "@saasicat/spec";
+var PlanCatalogValidationError = class extends Error {
+  static {
+    __name(this, "PlanCatalogValidationError");
+  }
+  source;
+  errors;
+  constructor(source, errors) {
+    const messages = errors.map((e) => `${e.instancePath || "/"}: ${e.message ?? "unknown"}`).join("\n  ");
+    super(`Plan catalog validation failed for ${source}:
+  ${messages}`), this.source = source, this.errors = errors;
+    this.name = "PlanCatalogValidationError";
+  }
+};
+function loadPlanCatalogFromFile(opts) {
+  const absolutePath = resolvePath(opts.path);
+  const raw = readFileSync(absolutePath, "utf-8");
+  return loadPlanCatalogFromString(raw, {
+    source: absolutePath,
+    crossFieldChecks: opts.crossFieldChecks ?? true
+  });
+}
+__name(loadPlanCatalogFromFile, "loadPlanCatalogFromFile");
+function loadPlanCatalogFromString(yamlContent, opts) {
+  const parsed = yaml.load(yamlContent);
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`The YAML content of ${opts.source} is not an object`);
+  }
+  const ajv = new Ajv2020({
+    strict: false,
+    allErrors: true
+  });
+  addFormats.default(ajv);
+  const validate = ajv.compile(planCatalogSchema);
+  if (!validate(parsed)) {
+    throw new PlanCatalogValidationError(opts.source, validate.errors ?? []);
+  }
+  const catalog = parsed;
+  if (opts.crossFieldChecks ?? true) {
+    validateConsistency(catalog, opts.source);
+  }
+  return catalog;
+}
+__name(loadPlanCatalogFromString, "loadPlanCatalogFromString");
+function validateConsistency(catalog, source) {
+  const errors = [];
+  const declaredFeatureKeys = new Set((catalog.features ?? []).map((f) => f.key));
+  const planIds = /* @__PURE__ */ new Set();
+  for (const plan of catalog.plans ?? []) {
+    if (planIds.has(plan.id)) {
+      errors.push(`plans[].id: duplicate plan id "${plan.id}"`);
+    }
+    planIds.add(plan.id);
+    if (catalog.features) {
+      for (const fk of plan.features) {
+        if (!declaredFeatureKeys.has(fk)) {
+          errors.push(`plans[id=${plan.id}].features: Unknown featureKey "${fk}" \u2014 not declared in catalog.features`);
+        }
+      }
+    }
+  }
+  if (errors.length > 0) {
+    const err = new Error(`Plan catalog consistency error in ${source}:
+  ${errors.join("\n  ")}`);
+    err.name = "PlanCatalogConsistencyError";
+    throw err;
+  }
+}
+__name(validateConsistency, "validateConsistency");
+
+// src/billing/plan-catalog-importer.service.ts
+import { Inject as Inject3, Injectable as Injectable3 } from "@nestjs/common";
+function _ts_decorate4(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_decorate4, "_ts_decorate");
+function _ts_metadata3(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata3, "_ts_metadata");
+function _ts_param3(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param3, "_ts_param");
+var PLAN_CATALOG_IMPORT_SINK_TOKEN = /* @__PURE__ */ Symbol.for("saas-platform/PlanCatalogImportSink");
+var IMPORT_CHANGE_NOTE = "Initial import from saas.yaml";
+var PlanCatalogImporterService = class {
+  static {
+    __name(this, "PlanCatalogImporterService");
+  }
+  sink;
+  constructor(sink) {
+    this.sink = sink;
+  }
+  /**
+   * Import directly from a YAML string. Apps pass the contents of the
+   * `saas.yaml` through via the HTTP body; CLI tools can read the file
+   * contents themselves beforehand.
+   *
+   * @throws on a schema failure of the YAML (validated first via the loader).
+   */
+  async importFromYaml(yamlContent, opts = {}) {
+    const catalog = loadPlanCatalogFromString(yamlContent, {
+      source: opts.source ?? "http-import",
+      crossFieldChecks: opts.crossFieldChecks ?? true
+    });
+    return this.importCatalog(catalog);
+  }
+  async importCatalog(catalog) {
+    const report = {
+      plansCreated: 0,
+      plansSkipped: 0,
+      planVersionsCreated: 0,
+      planVersionsSkipped: 0,
+      featureEntriesCreated: 0,
+      featureEntriesSkipped: 0,
+      warnings: []
+    };
+    for (const feature of catalog.features ?? []) {
+      const result = await this.sink.upsertFeatureCatalogEntry({
+        projectKey: catalog.projectKey,
+        featureKey: feature.key,
+        label: feature.label,
+        icon: feature.icon,
+        tier: feature.tier,
+        plannedOnly: feature.plannedOnly
+      });
+      if (result.created) report.featureEntriesCreated++;
+      else report.featureEntriesSkipped++;
+    }
+    for (const plan of catalog.plans ?? []) {
+      const planResult = await this.sink.upsertPlan({
+        projectKey: catalog.projectKey,
+        planKey: plan.id,
+        label: plan.name ?? plan.id,
+        description: plan.tagline ?? null
+      });
+      if (planResult.created) report.plansCreated++;
+      else report.plansSkipped++;
+      if (plan.monthlyNet === null || plan.monthlyNet === void 0) {
+        report.warnings.push(`Plan '${plan.id}' has no monthlyNet \u2014 skipped (on-request plans need a manual plan version).`);
+        continue;
+      }
+      const versionResult = await this.sink.upsertPlanVersion({
+        planKey: plan.id,
+        version: 1,
+        features: plan.features,
+        quotas: plan.quotas,
+        monthlyNet: plan.monthlyNet.toFixed(2),
+        yearlyNet: (plan.yearlyNet ?? plan.monthlyNet * 10).toFixed(2),
+        marketed: plan.marketed ?? true,
+        publish: true,
+        changeNote: IMPORT_CHANGE_NOTE
+      });
+      if (versionResult.created) report.planVersionsCreated++;
+      else report.planVersionsSkipped++;
+    }
+    return report;
+  }
+};
+PlanCatalogImporterService = _ts_decorate4([
+  Injectable3(),
+  _ts_param3(0, Inject3(PLAN_CATALOG_IMPORT_SINK_TOKEN)),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof PlanCatalogImportSink === "undefined" ? Object : PlanCatalogImportSink
+  ])
+], PlanCatalogImporterService);
+
+// src/billing/plan-catalog-importer.module.ts
+import { Module } from "@nestjs/common";
+
+// src/billing/plan-catalog-importer.controller.ts
+import { Body, Controller, Inject as Inject4, Post, UseGuards } from "@nestjs/common";
+import { IsBoolean, IsOptional, IsString, MinLength } from "class-validator";
+function _ts_decorate5(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_decorate5, "_ts_decorate");
+function _ts_metadata4(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata4, "_ts_metadata");
+function _ts_param4(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param4, "_ts_param");
+var PlanCatalogImportDto = class {
+  static {
+    __name(this, "PlanCatalogImportDto");
+  }
+  yamlContent;
+  crossFieldChecks;
+};
+_ts_decorate5([
+  IsString(),
+  MinLength(1),
+  _ts_metadata4("design:type", String)
+], PlanCatalogImportDto.prototype, "yamlContent", void 0);
+_ts_decorate5([
+  IsOptional(),
+  IsBoolean(),
+  _ts_metadata4("design:type", Boolean)
+], PlanCatalogImportDto.prototype, "crossFieldChecks", void 0);
+function buildPlanCatalogImporterController(guards) {
+  let GeneratedPlanCatalogImporterController = class GeneratedPlanCatalogImporterController {
+    static {
+      __name(this, "GeneratedPlanCatalogImporterController");
+    }
+    service;
+    constructor(service) {
+      this.service = service;
+    }
+    async import(dto) {
+      return this.service.importFromYaml(dto.yamlContent, {
+        crossFieldChecks: dto.crossFieldChecks
+      });
+    }
+  };
+  _ts_decorate5([
+    Post("import"),
+    _ts_param4(0, Body()),
+    _ts_metadata4("design:type", Function),
+    _ts_metadata4("design:paramtypes", [
+      typeof PlanCatalogImportDto === "undefined" ? Object : PlanCatalogImportDto
+    ]),
+    _ts_metadata4("design:returntype", Promise)
+  ], GeneratedPlanCatalogImporterController.prototype, "import", null);
+  GeneratedPlanCatalogImporterController = _ts_decorate5([
+    Controller("admin/billing/plan-catalog"),
+    UseGuards(...guards),
+    _ts_param4(0, Inject4(PlanCatalogImporterService)),
+    _ts_metadata4("design:type", Function),
+    _ts_metadata4("design:paramtypes", [
+      typeof PlanCatalogImporterService === "undefined" ? Object : PlanCatalogImporterService
+    ])
+  ], GeneratedPlanCatalogImporterController);
+  return GeneratedPlanCatalogImporterController;
+}
+__name(buildPlanCatalogImporterController, "buildPlanCatalogImporterController");
+
+// src/billing/plan-catalog-importer.module.ts
+function _ts_decorate6(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_decorate6, "_ts_decorate");
+var PlanCatalogImporterModule = class _PlanCatalogImporterModule {
+  static {
+    __name(this, "PlanCatalogImporterModule");
+  }
+  static forRoot(options) {
+    const providers = [
+      ...options.extraProviders ?? [],
+      asProvider(PLAN_CATALOG_IMPORT_SINK_TOKEN, options.sink),
+      PlanCatalogImporterService
+    ];
+    const controllers = [];
+    if (options.controller) {
+      controllers.push(buildPlanCatalogImporterController(options.controller.guards));
+    }
+    return {
+      module: _PlanCatalogImporterModule,
+      global: options.global ?? false,
+      imports: options.imports ?? [],
+      controllers,
+      providers,
+      exports: [
+        PlanCatalogImporterService
+      ]
+    };
+  }
+};
+PlanCatalogImporterModule = _ts_decorate6([
+  Module({})
+], PlanCatalogImporterModule);
+
+// src/billing/trial-carryover.ts
+var MS_PER_DAY = 864e5;
+function computeCarriedTrialEndsAt(currentTrialDays, newTrialDays, currentTrialEndsAt, now) {
+  const daysRemaining = Math.max(0, Math.ceil((currentTrialEndsAt.getTime() - now.getTime()) / MS_PER_DAY));
+  const usedDays = Math.max(0, currentTrialDays - daysRemaining);
+  const newDays = Math.max(0, newTrialDays - usedDays);
+  return new Date(now.getTime() + newDays * MS_PER_DAY);
+}
+__name(computeCarriedTrialEndsAt, "computeCarriedTrialEndsAt");
+
+// src/billing/configurator-catalog-builder.ts
+import { Injectable as Injectable4 } from "@nestjs/common";
+function _ts_decorate7(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_decorate7, "_ts_decorate");
+var ConfiguratorCatalogBuilder = class {
+  static {
+    __name(this, "ConfiguratorCatalogBuilder");
+  }
+  async build(input) {
+    const { sources, marketing } = input;
+    const planRows = await sources.listLivePlans();
+    const planMarketingByPlanId = new Map(marketing.listPlanMarketing().map((m) => [
+      m.planId,
+      m
+    ]));
+    return {
+      cycleDiscount: marketing.getCycleDiscount(),
+      currency: marketing.getCurrency(),
+      vatRate: marketing.getVatRate(),
+      models: planRows.filter((row) => row.marketed).map((row) => buildModel(row, planMarketingByPlanId)).filter((m) => m !== null)
+    };
+  }
+};
+ConfiguratorCatalogBuilder = _ts_decorate7([
+  Injectable4()
+], ConfiguratorCatalogBuilder);
+function buildModel(row, marketing) {
+  const m = marketing.get(row.planId);
+  if (!m) return null;
+  return {
+    id: row.planId.toLowerCase(),
+    code: m.code,
+    name: m.name,
+    glyph: m.glyph,
+    tagline: m.tagline,
+    planId: row.planId,
+    monthlyNet: row.monthlyNet,
+    yearlyNet: row.yearlyNet,
+    tags: m.tags,
+    includedFeatureKeys: row.features,
+    quotaBase: normalizeQuotas(row.quotas),
+    ...m.popular ? {
+      popular: true
+    } : {}
+  };
+}
+__name(buildModel, "buildModel");
+function normalizeQuotas(quotas) {
+  const out = {};
+  for (const [k, v] of Object.entries(quotas)) {
+    out[k] = v === -1 ? Number.MAX_SAFE_INTEGER : v;
+  }
+  return out;
+}
+__name(normalizeQuotas, "normalizeQuotas");
+
+export {
+  PublishValidationError,
+  assertChangeNote,
+  assertDraftPublishable,
+  assertBaseVersionFresh,
+  assertOptimisticLockHeld,
+  decideRenewal,
+  clearPendingPlanVersionFields,
+  computeNextPeriod,
+  FEATURE_GUARD_CONFIG_TOKEN,
+  UPSELL_OFFER_RESOLVER_TOKEN,
+  UPSELL_OFFER_CURRENCY_TOKEN,
+  FeatureGuard,
+  CatalogBundleUpsellResolver,
+  LimitExceededFilter,
+  PlanCatalogValidationError,
+  loadPlanCatalogFromFile,
+  loadPlanCatalogFromString,
+  PLAN_CATALOG_IMPORT_SINK_TOKEN,
+  PlanCatalogImporterService,
+  PlanCatalogImportDto,
+  buildPlanCatalogImporterController,
+  PlanCatalogImporterModule,
+  computeCarriedTrialEndsAt,
+  ConfiguratorCatalogBuilder
+};