@saasicat/nest 0.2.0

package/dist/promo/index.cjs

@@ -0,0 +1,995 @@
+"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/promo/index.ts
+var promo_exports = {};
+__export(promo_exports, {
+  PROMO_CODE_REDEMPTION_REPOSITORY_TOKEN: () => PROMO_CODE_REDEMPTION_REPOSITORY_TOKEN,
+  PROMO_CODE_REPOSITORY_TOKEN: () => PROMO_CODE_REPOSITORY_TOKEN,
+  PROMO_CODE_VALIDATION_LOG_REPOSITORY_TOKEN: () => PROMO_CODE_VALIDATION_LOG_REPOSITORY_TOKEN,
+  PROMO_FIRST_TIME_CUSTOMER_CHECK_TOKEN: () => PROMO_FIRST_TIME_CUSTOMER_CHECK_TOKEN,
+  PROMO_REVENUE_DEDUCTION_AGGREGATOR_TOKEN: () => PROMO_REVENUE_DEDUCTION_AGGREGATOR_TOKEN,
+  PROMO_SERVICE_CONFIG_TOKEN: () => PROMO_SERVICE_CONFIG_TOKEN,
+  PROMO_SUBSCRIPTION_LOOKUP_TOKEN: () => PROMO_SUBSCRIPTION_LOOKUP_TOKEN,
+  PROMO_TRANSACTION_RUNNER_TOKEN: () => PROMO_TRANSACTION_RUNNER_TOKEN,
+  PreviewPromoCodeDto: () => PreviewPromoCodeDto,
+  PromoCodeExpirer: () => PromoCodeExpirer,
+  PromoCodePublicController: () => PromoCodePublicController,
+  PromoCodeRateLimitGuard: () => PromoCodeRateLimitGuard,
+  PromoCodesModule: () => PromoCodesModule,
+  PromoCodesService: () => PromoCodesService,
+  addCycles: () => addCycles,
+  buildLabel: () => buildLabel,
+  computeDiscountGross: () => computeDiscountGross,
+  computeDiscountedGross: () => computeDiscountedGross,
+  computeIncludedVat: () => computeIncludedVat,
+  computeRegularStartsAt: () => computeRegularStartsAt,
+  grossFromNet: () => grossFromNet,
+  hashIp: () => hashIp,
+  ipFingerprint: () => ipFingerprint,
+  round2: () => round2
+});
+module.exports = __toCommonJS(promo_exports);
+
+// src/promo/math.ts
+function round2(n) {
+  return Math.round(n * 100) / 100;
+}
+__name(round2, "round2");
+function grossFromNet(net, vatRate) {
+  return round2(net * (1 + vatRate / 100));
+}
+__name(grossFromNet, "grossFromNet");
+function computeIncludedVat(grossAmount, vatRate) {
+  return round2(grossAmount * vatRate / (100 + vatRate));
+}
+__name(computeIncludedVat, "computeIncludedVat");
+
+// src/promo/calculator.ts
+function computeDiscountGross(plan, code) {
+  const v = Number(code.value);
+  if (code.valueType === "PERCENT") {
+    return round2(plan.gross * v / 100);
+  }
+  return round2(v);
+}
+__name(computeDiscountGross, "computeDiscountGross");
+function computeDiscountedGross(planGross, discountGross) {
+  return round2(planGross - discountGross);
+}
+__name(computeDiscountedGross, "computeDiscountedGross");
+function computeRegularStartsAt(startsAt, cycle, durationType, durationValue) {
+  const result = new Date(startsAt);
+  if (durationType === "ONCE") {
+    return addCycles(result, cycle, 1);
+  }
+  if (durationType === "MONTHS") {
+    result.setMonth(result.getMonth() + (durationValue ?? 0));
+    return result;
+  }
+  return addCycles(result, cycle, durationValue ?? 0);
+}
+__name(computeRegularStartsAt, "computeRegularStartsAt");
+function addCycles(date, cycle, n) {
+  const r = new Date(date);
+  if (cycle === "YEARLY") {
+    r.setFullYear(r.getFullYear() + n);
+  } else {
+    r.setMonth(r.getMonth() + n);
+  }
+  return r;
+}
+__name(addCycles, "addCycles");
+function buildLabel(code, cycle) {
+  const value = Number(code.value);
+  const valueStr = code.valueType === "PERCENT" ? `${value.toLocaleString("de-DE")} %` : `${value.toLocaleString("de-DE", {
+    minimumFractionDigits: 2,
+    maximumFractionDigits: 2
+  })} \u20AC`;
+  if (code.durationType === "ONCE") {
+    return `${valueStr} einmalig`;
+  }
+  if (code.durationType === "MONTHS") {
+    const m = code.durationValue ?? 0;
+    return m === 1 ? `${valueStr} im ersten Monat` : `${valueStr} f\xFCr ${m} Monate`;
+  }
+  const n = code.durationValue ?? 0;
+  if (n === 1) return cycle === "YEARLY" ? `${valueStr} im ersten Jahr` : `${valueStr} im ersten Monat`;
+  return cycle === "YEARLY" ? `${valueStr} in den ersten ${n} Jahren` : `${valueStr} in den ersten ${n} Monaten`;
+}
+__name(buildLabel, "buildLabel");
+
+// src/promo/service.ts
+var import_common2 = require("@nestjs/common");
+
+// 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/plan-helpers.ts
+function findPlan(catalog, planId) {
+  return (catalog.plans ?? []).find((p) => p.id === planId);
+}
+__name(findPlan, "findPlan");
+function getPlanPriceNet(catalog, planId, cycle) {
+  const plan = findPlan(catalog, planId);
+  if (!plan) return null;
+  if (plan.marketed === false) return null;
+  const net = cycle === "YEARLY" ? plan.yearlyNet : plan.monthlyNet;
+  return net ?? null;
+}
+__name(getPlanPriceNet, "getPlanPriceNet");
+function getPlanPriceGross(catalog, planId, cycle, vatRate) {
+  const net = getPlanPriceNet(catalog, planId, cycle);
+  if (net === null) return null;
+  const rate = vatRate ?? catalog.vatRate;
+  return round2(net * (1 + rate / 100));
+}
+__name(getPlanPriceGross, "getPlanPriceGross");
+
+// src/promo/tokens.ts
+var PROMO_CODE_REPOSITORY_TOKEN = /* @__PURE__ */ Symbol("PROMO_CODE_REPOSITORY");
+var PROMO_CODE_REDEMPTION_REPOSITORY_TOKEN = /* @__PURE__ */ Symbol("PROMO_CODE_REDEMPTION_REPOSITORY");
+var PROMO_CODE_VALIDATION_LOG_REPOSITORY_TOKEN = /* @__PURE__ */ Symbol("PROMO_CODE_VALIDATION_LOG_REPOSITORY");
+var PROMO_FIRST_TIME_CUSTOMER_CHECK_TOKEN = /* @__PURE__ */ Symbol("PROMO_FIRST_TIME_CUSTOMER_CHECK");
+var PROMO_SUBSCRIPTION_LOOKUP_TOKEN = /* @__PURE__ */ Symbol("PROMO_SUBSCRIPTION_LOOKUP");
+var PROMO_REVENUE_DEDUCTION_AGGREGATOR_TOKEN = /* @__PURE__ */ Symbol("PROMO_REVENUE_DEDUCTION_AGGREGATOR");
+var PROMO_TRANSACTION_RUNNER_TOKEN = /* @__PURE__ */ Symbol("PROMO_TRANSACTION_RUNNER");
+var PROMO_SERVICE_CONFIG_TOKEN = /* @__PURE__ */ Symbol("PROMO_SERVICE_CONFIG");
+
+// src/promo/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 CODE_PATTERN = /^[A-Z0-9_-]{4,32}$/;
+var PromoCodesService = class {
+  static {
+    __name(this, "PromoCodesService");
+  }
+  promoRepo;
+  redemptionRepo;
+  validationLogRepo;
+  firstTimeCheck;
+  subscriptionLookup;
+  revenueAggregator;
+  transactionRunner;
+  planCatalog;
+  config;
+  constructor(promoRepo, redemptionRepo, validationLogRepo, firstTimeCheck, subscriptionLookup, revenueAggregator, transactionRunner, planCatalog, config) {
+    this.promoRepo = promoRepo;
+    this.redemptionRepo = redemptionRepo;
+    this.validationLogRepo = validationLogRepo;
+    this.firstTimeCheck = firstTimeCheck;
+    this.subscriptionLookup = subscriptionLookup;
+    this.revenueAggregator = revenueAggregator;
+    this.transactionRunner = transactionRunner;
+    this.planCatalog = planCatalog;
+    this.config = config;
+  }
+  // ─── ADMIN: Creation / Editing ─────────────────────────────────────────
+  async create(input) {
+    const code = input.code.trim().toUpperCase();
+    if (!CODE_PATTERN.test(code)) {
+      throw new import_common2.BadRequestException('Code darf nur Gro\xDFbuchstaben, Ziffern, \u201E-" und \u201E_" enthalten (4\u201332 Zeichen).');
+    }
+    if (input.valueType === "PERCENT") {
+      if (!(input.value > 0 && input.value <= 100)) {
+        throw new import_common2.BadRequestException("Prozentsatz muss zwischen 0 und 100 liegen.");
+      }
+    } else if (!(input.value > 0)) {
+      throw new import_common2.BadRequestException("Betrag muss positiv sein.");
+    }
+    if (input.durationType === "ONCE") {
+      if (input.durationValue != null) {
+        throw new import_common2.BadRequestException("Bei einmaligem Rabatt darf keine Laufzeit gesetzt sein.");
+      }
+    } else {
+      const v = input.durationValue;
+      if (v == null || v < 1 || v > 24) {
+        throw new import_common2.BadRequestException("Laufzeit ung\xFCltig (max. 24 Monate bzw. Abrechnungsperioden).");
+      }
+    }
+    if (input.validFrom && input.validUntil && input.validFrom >= input.validUntil) {
+      throw new import_common2.BadRequestException("G\xFCltigkeits-Fenster ung\xFCltig.");
+    }
+    const plans = input.appliesToPlans ?? [];
+    const blocked = this.config.nonRedeemablePlans ?? [];
+    for (const p of plans) {
+      if (blocked.includes(p)) {
+        throw new import_common2.BadRequestException(`${p}-Plan kann nicht rabattiert werden.`);
+      }
+    }
+    if (input.minimumPlanAmountGross != null && input.minimumPlanAmountGross <= 0) {
+      throw new import_common2.BadRequestException("Mindest-Plan-Brutto muss positiv sein.");
+    }
+    if (input.valueType === "ABSOLUTE" && !input.allowZeroInvoice) {
+      const lowestApplicableGross = this.lowestApplicablePlanGross(plans);
+      if (lowestApplicableGross != null && input.value >= lowestApplicableGross) {
+        throw new import_common2.BadRequestException("Bei Absolutbetr\xE4gen muss der Rabatt unter dem niedrigsten anwendbaren Plan-Preis liegen oder allowZeroInvoice aktiviert sein.");
+      }
+    }
+    const exists = await this.promoRepo.findByCode(code);
+    if (exists) throw new import_common2.BadRequestException("Code existiert bereits.");
+    return this.promoRepo.create({
+      ...input,
+      code
+    });
+  }
+  async update(id, input) {
+    const existing = await this.promoRepo.findById(id);
+    if (!existing) throw new import_common2.NotFoundException("Code nicht gefunden");
+    if (input.maxRedemptions != null && existing.maxRedemptions != null) {
+      if (input.maxRedemptions < existing.maxRedemptions) {
+        throw new import_common2.BadRequestException("maxRedemptions kann nicht gesenkt werden.");
+      }
+    }
+    return this.promoRepo.update(id, input);
+  }
+  async softDelete(id) {
+    const redemptions = await this.redemptionRepo.countByPromoCode(id);
+    if (redemptions > 0) {
+      throw new import_common2.BadRequestException("Code hat bereits Einl\xF6sungen \u2014 Soft-Delete nicht m\xF6glich. Stattdessen pausieren.");
+    }
+    await this.promoRepo.softDelete(id);
+  }
+  async findAll(filter = {}) {
+    await this.lazyExpire();
+    return this.promoRepo.findMany(filter);
+  }
+  async findOne(id) {
+    await this.lazyExpire();
+    const code = await this.promoRepo.findById(id);
+    if (!code || code.deletedAt) throw new import_common2.NotFoundException("Code nicht gefunden");
+    return code;
+  }
+  async stats(id) {
+    const code = await this.findOne(id);
+    const [active, total, reversed, expired, validations, revenueDeductionGross] = await Promise.all([
+      this.redemptionRepo.countByPromoCode(id, "ACTIVE"),
+      this.redemptionRepo.countByPromoCode(id),
+      this.redemptionRepo.countByPromoCode(id, "REVERSED"),
+      this.redemptionRepo.countByPromoCode(id, "EXPIRED"),
+      this.validationLogRepo.countValid(id),
+      this.revenueAggregator.sumGrossForPromoCode(id)
+    ]);
+    return {
+      code,
+      validations,
+      redemptions: {
+        active,
+        total,
+        reversed,
+        expired
+      },
+      revenueDeductionGross
+    };
+  }
+  async listRedemptions(promoCodeId) {
+    return this.redemptionRepo.listByPromoCode(promoCodeId);
+  }
+  // ─── PUBLIC: Preview / Validation ──────────────────────────────────────
+  async preview(input) {
+    const code = input.code.trim().toUpperCase();
+    if (!CODE_PATTERN.test(code)) {
+      await this.validationLogRepo.log({
+        promoCodeId: null,
+        codeAttempt: code,
+        result: "NOT_FOUND",
+        ipHash: input.ipHash,
+        sessionId: input.sessionId
+      });
+      return {
+        valid: false,
+        reason: "NOT_FOUND"
+      };
+    }
+    await this.lazyExpire();
+    const promo = await this.promoRepo.findByCode(code);
+    const reason = this.checkEligibility(promo, input) ?? await this.checkFirstTimeCustomer(promo, input.email);
+    if (reason) {
+      await this.validationLogRepo.log({
+        promoCodeId: promo?.id ?? null,
+        codeAttempt: code,
+        result: reason,
+        ipHash: input.ipHash,
+        sessionId: input.sessionId
+      });
+      return {
+        valid: false,
+        reason
+      };
+    }
+    const planGross = getPlanPriceGross(this.planCatalog, input.planId, input.billingCycle);
+    const discountGross = Math.min(computeDiscountGross({
+      gross: planGross
+    }, promo), planGross);
+    const discountedGross = computeDiscountedGross(planGross, discountGross);
+    const includedVat = computeIncludedVat(discountedGross, this.planCatalog.vatRate);
+    if (!promo.allowZeroInvoice && discountedGross <= 0) {
+      await this.validationLogRepo.log({
+        promoCodeId: promo.id,
+        codeAttempt: code,
+        result: "WOULD_PRODUCE_ZERO_INVOICE",
+        ipHash: input.ipHash,
+        sessionId: input.sessionId
+      });
+      return {
+        valid: false,
+        reason: "WOULD_PRODUCE_ZERO_INVOICE"
+      };
+    }
+    const startsAt = /* @__PURE__ */ new Date();
+    const regularStartsAt = computeRegularStartsAt(startsAt, input.billingCycle, promo.durationType, promo.durationValue);
+    await this.validationLogRepo.log({
+      promoCodeId: promo.id,
+      codeAttempt: code,
+      result: "VALID",
+      ipHash: input.ipHash,
+      sessionId: input.sessionId
+    });
+    return {
+      valid: true,
+      code: promo.code,
+      label: buildLabel(promo, input.billingCycle),
+      discount: {
+        valueType: promo.valueType,
+        value: Number(promo.value).toFixed(2),
+        durationType: promo.durationType,
+        durationValue: promo.durationValue
+      },
+      price: {
+        originalGross: planGross.toFixed(2),
+        discountGross: discountGross.toFixed(2),
+        discountedGross: discountedGross.toFixed(2),
+        includedVat: includedVat.toFixed(2),
+        nextRegularAmountGross: planGross.toFixed(2),
+        regularStartsAt: regularStartsAt ? regularStartsAt.toISOString() : null
+      }
+    };
+  }
+  // ─── Onboarding path: atomic redemption ────────────────────────────────
+  /**
+   * Wraps `redeemInTransaction` in its own transaction-runner call —
+   * the default path when the caller has no external tx context
+   * (e.g. POST /billing/promo/redeem as a stand-alone endpoint).
+   */
+  async redeem(input) {
+    return this.transactionRunner.run((tx) => this.redeemInTransaction(input, tx));
+  }
+  /**
+   * Redeems a promo code within an EXTERNAL transaction — the caller
+   * (typically `TenantSubscriptionWritePort.applyOnboardingSelection`)
+   * already has `prisma.$transaction(...)` open and passes the `tx`
+   * context through. This lands plan change, add-on insert, and redemption
+   * insert in a single DB transaction (P10.1.1).
+   */
+  async redeemInTransaction(input, tx) {
+    const code = input.code.trim().toUpperCase();
+    const promo = await this.promoRepo.findByCode(code, tx);
+    if (!promo || promo.deletedAt) {
+      throw new import_common2.BadRequestException("Code nicht gefunden");
+    }
+    const sub = await this.subscriptionLookup.findById(input.subscriptionId, tx);
+    if (!sub) throw new import_common2.NotFoundException("Subscription nicht gefunden");
+    if (sub.tenantId !== input.tenantId) {
+      throw new import_common2.BadRequestException("Subscription geh\xF6rt nicht zum Tenant");
+    }
+    const reason = this.checkEligibility(promo, {
+      code,
+      planId: sub.plan,
+      billingCycle: sub.billingCycle
+    });
+    if (reason) throw new import_common2.BadRequestException(`Code nicht einl\xF6sbar: ${reason}`);
+    const firstTimeReason = await this.checkFirstTimeCustomer(promo, input.email, {
+      requireEmail: true
+    });
+    if (firstTimeReason) {
+      throw new import_common2.BadRequestException(`Code nicht einl\xF6sbar: ${firstTimeReason}`);
+    }
+    const claimed = await this.promoRepo.claimSlot(promo.id, tx);
+    if (!claimed) {
+      throw new import_common2.BadRequestException("Code nicht einl\xF6sbar: EXHAUSTED");
+    }
+    await this.promoRepo.markExhaustedIfFull(promo.id, tx);
+    const startsAt = sub.startedAt ?? /* @__PURE__ */ new Date();
+    const endsAt = promo.durationType === "ONCE" ? null : computeRegularStartsAt(startsAt, sub.billingCycle, promo.durationType, promo.durationValue);
+    return this.redemptionRepo.create({
+      promoCodeId: promo.id,
+      subscriptionId: sub.id,
+      tenantId: sub.tenantId,
+      appliedValueType: promo.valueType,
+      appliedValue: promo.value,
+      appliedDurationType: promo.durationType,
+      appliedDurationValue: promo.durationValue,
+      startsAt,
+      endsAt
+    }, tx);
+  }
+  async reverse(subscriptionId) {
+    return this.transactionRunner.run(async (tx) => {
+      const redemption = await this.redemptionRepo.findBySubscription(subscriptionId, tx);
+      if (!redemption || redemption.status !== "ACTIVE") return redemption;
+      const updated = await this.redemptionRepo.setReversed(redemption.id, tx);
+      await this.promoRepo.releaseSlot(redemption.promoCodeId, tx);
+      return updated;
+    });
+  }
+  // ─── Helpers ───────────────────────────────────────────────────────────
+  checkEligibility(promo, input) {
+    if (!promo || promo.deletedAt) return "NOT_FOUND";
+    if (promo.status === "EXPIRED") return "EXPIRED";
+    if (promo.status === "EXHAUSTED") return "EXHAUSTED";
+    if (promo.status === "PAUSED") return "PAUSED";
+    const now = /* @__PURE__ */ new Date();
+    if (promo.validFrom && promo.validFrom > now) return "EXPIRED";
+    if (promo.validUntil && promo.validUntil < now) return "EXPIRED";
+    const blocked = this.config.nonRedeemablePlans ?? [];
+    if (blocked.includes(input.planId)) {
+      return "PLAN_MISMATCH";
+    }
+    if (promo.appliesToPlans.length > 0 && !promo.appliesToPlans.includes(input.planId)) {
+      return "PLAN_MISMATCH";
+    }
+    if (promo.appliesToBilling && promo.appliesToBilling !== input.billingCycle) {
+      return "BILLING_MISMATCH";
+    }
+    const planGross = getPlanPriceGross(this.planCatalog, input.planId, input.billingCycle);
+    if (planGross == null) return "PLAN_MISMATCH";
+    if (promo.minimumPlanAmountGross && planGross < Number(promo.minimumPlanAmountGross)) {
+      return "BELOW_MINIMUM_AMOUNT";
+    }
+    return null;
+  }
+  async checkFirstTimeCustomer(promo, email, options = {}) {
+    if (!promo || !promo.firstTimeCustomersOnly) return null;
+    if (!email) return options.requireEmail ? "NOT_FIRST_TIME_CUSTOMER" : null;
+    const existing = await this.firstTimeCheck.hasExistingCustomerForEmail(email);
+    return existing ? "NOT_FIRST_TIME_CUSTOMER" : null;
+  }
+  /**
+   * Lazy expiry: sets codes whose validUntil has passed to EXPIRED.
+   * Called before every find/preview — defense-in-depth alongside the cron.
+   */
+  async lazyExpire() {
+    const now = /* @__PURE__ */ new Date();
+    await this.promoRepo.expireDueCodes(now);
+    await this.redemptionRepo.expireDueRedemptions(now);
+  }
+  /**
+   * Lowest applicable plan price. With a whitelist it takes the minimum
+   * from the whitelist, otherwise across all marketed plans of the catalog
+   * (except non-redeemable).
+   */
+  lowestApplicablePlanGross(plans) {
+    const blocked = new Set(this.config.nonRedeemablePlans ?? []);
+    const candidates = plans.length > 0 ? plans : (this.planCatalog.plans ?? []).filter((p) => p.marketed !== false && !blocked.has(p.id)).map((p) => p.id);
+    let min = null;
+    for (const p of candidates) {
+      const g = getPlanPriceGross(this.planCatalog, p, "MONTHLY");
+      if (g == null) continue;
+      if (min == null || g < min) min = g;
+    }
+    return min;
+  }
+};
+PromoCodesService = _ts_decorate2([
+  (0, import_common2.Injectable)(),
+  _ts_param(0, (0, import_common2.Inject)(PROMO_CODE_REPOSITORY_TOKEN)),
+  _ts_param(1, (0, import_common2.Inject)(PROMO_CODE_REDEMPTION_REPOSITORY_TOKEN)),
+  _ts_param(2, (0, import_common2.Inject)(PROMO_CODE_VALIDATION_LOG_REPOSITORY_TOKEN)),
+  _ts_param(3, (0, import_common2.Inject)(PROMO_FIRST_TIME_CUSTOMER_CHECK_TOKEN)),
+  _ts_param(4, (0, import_common2.Inject)(PROMO_SUBSCRIPTION_LOOKUP_TOKEN)),
+  _ts_param(5, (0, import_common2.Inject)(PROMO_REVENUE_DEDUCTION_AGGREGATOR_TOKEN)),
+  _ts_param(6, (0, import_common2.Inject)(PROMO_TRANSACTION_RUNNER_TOKEN)),
+  _ts_param(7, (0, import_common2.Inject)(PLAN_CATALOG_TOKEN)),
+  _ts_param(8, (0, import_common2.Inject)(PROMO_SERVICE_CONFIG_TOKEN)),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof PromoCodeRepository === "undefined" ? Object : PromoCodeRepository,
+    typeof PromoCodeRedemptionRepository === "undefined" ? Object : PromoCodeRedemptionRepository,
+    typeof PromoCodeValidationLogRepository === "undefined" ? Object : PromoCodeValidationLogRepository,
+    typeof FirstTimeCustomerCheck === "undefined" ? Object : FirstTimeCustomerCheck,
+    typeof PromoSubscriptionLookup === "undefined" ? Object : PromoSubscriptionLookup,
+    typeof PromoRevenueDeductionAggregator === "undefined" ? Object : PromoRevenueDeductionAggregator,
+    typeof TransactionRunner === "undefined" ? Object : TransactionRunner,
+    typeof PlanCatalog === "undefined" ? Object : PlanCatalog,
+    typeof PromoServiceConfig === "undefined" ? Object : PromoServiceConfig
+  ])
+], PromoCodesService);
+
+// src/promo/expirer.ts
+var import_common3 = require("@nestjs/common");
+var import_schedule = require("@nestjs/schedule");
+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");
+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 PromoCodeExpirer = class _PromoCodeExpirer {
+  static {
+    __name(this, "PromoCodeExpirer");
+  }
+  promoRepo;
+  redemptionRepo;
+  logger = new import_common3.Logger(_PromoCodeExpirer.name);
+  constructor(promoRepo, redemptionRepo) {
+    this.promoRepo = promoRepo;
+    this.redemptionRepo = redemptionRepo;
+  }
+  async expirePromoCodes() {
+    const now = /* @__PURE__ */ new Date();
+    const codes = await this.promoRepo.expireDueCodes(now);
+    const redemptions = await this.redemptionRepo.expireDueRedemptions(now);
+    if (codes > 0 || redemptions > 0) {
+      this.logger.log(`PromoCodeExpirer: ${codes} Codes, ${redemptions} Redemptions abgelaufen.`);
+    }
+  }
+};
+_ts_decorate3([
+  (0, import_schedule.Cron)(import_schedule.CronExpression.EVERY_DAY_AT_3AM, {
+    name: "promoCodeExpirer",
+    timeZone: "Europe/Berlin"
+  }),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", []),
+  _ts_metadata2("design:returntype", Promise)
+], PromoCodeExpirer.prototype, "expirePromoCodes", null);
+PromoCodeExpirer = _ts_decorate3([
+  (0, import_common3.Injectable)(),
+  _ts_param2(0, (0, import_common3.Inject)(PROMO_CODE_REPOSITORY_TOKEN)),
+  _ts_param2(1, (0, import_common3.Inject)(PROMO_CODE_REDEMPTION_REPOSITORY_TOKEN)),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    typeof PromoCodeRepository === "undefined" ? Object : PromoCodeRepository,
+    typeof PromoCodeRedemptionRepository === "undefined" ? Object : PromoCodeRedemptionRepository
+  ])
+], PromoCodeExpirer);
+
+// src/promo/rate-limit.guard.ts
+var import_common4 = require("@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");
+var IP_WINDOW_MS = 6e4;
+var IP_LIMIT = 20;
+var SESSION_WINDOW_MS = 60 * 6e4;
+var SESSION_LIMIT = 50;
+var PromoCodeRateLimitGuard = class {
+  static {
+    __name(this, "PromoCodeRateLimitGuard");
+  }
+  ipBuckets = /* @__PURE__ */ new Map();
+  sessionBuckets = /* @__PURE__ */ new Map();
+  canActivate(context) {
+    const req = context.switchToHttp().getRequest();
+    const ipKey = ipFingerprint(req);
+    const sessionKey = req.user?.id ?? null;
+    if (this.exceeded(this.ipBuckets, ipKey, IP_WINDOW_MS, IP_LIMIT)) {
+      throw new import_common4.HttpException({
+        valid: false,
+        reason: "RATE_LIMITED"
+      }, import_common4.HttpStatus.TOO_MANY_REQUESTS);
+    }
+    if (sessionKey && this.exceeded(this.sessionBuckets, sessionKey, SESSION_WINDOW_MS, SESSION_LIMIT)) {
+      throw new import_common4.HttpException({
+        valid: false,
+        reason: "RATE_LIMITED"
+      }, import_common4.HttpStatus.TOO_MANY_REQUESTS);
+    }
+    return true;
+  }
+  exceeded(map, key, windowMs, limit) {
+    const now = Date.now();
+    const b = map.get(key);
+    if (!b || now - b.windowStart > windowMs) {
+      map.set(key, {
+        count: 1,
+        windowStart: now
+      });
+      return false;
+    }
+    b.count += 1;
+    return b.count > limit;
+  }
+};
+PromoCodeRateLimitGuard = _ts_decorate4([
+  (0, import_common4.Injectable)()
+], PromoCodeRateLimitGuard);
+function ipFingerprint(req) {
+  const fwd = req.headers["x-forwarded-for"];
+  const first = Array.isArray(fwd) ? fwd[0] : fwd?.split(",")[0]?.trim();
+  return first || req.ip || "unknown";
+}
+__name(ipFingerprint, "ipFingerprint");
+function hashIp(req) {
+  const fp = ipFingerprint(req);
+  let h = 0;
+  for (let i = 0; i < fp.length; i++) {
+    h = h * 31 + fp.charCodeAt(i) | 0;
+  }
+  return `ip${(h >>> 0).toString(16)}`;
+}
+__name(hashIp, "hashIp");
+
+// src/promo/controller.ts
+var import_common5 = require("@nestjs/common");
+
+// src/promo/dto/promo-public.dto.ts
+var import_class_validator = require("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_metadata3(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata3, "_ts_metadata");
+var PLAN_OR_CYCLE_PATTERN = /^[A-Z][A-Z0-9_]*$/;
+var CODE_PATTERN2 = /^[A-Z0-9_-]{4,32}$/i;
+var PreviewPromoCodeDto = class {
+  static {
+    __name(this, "PreviewPromoCodeDto");
+  }
+  code;
+  plan;
+  billingCycle;
+  email;
+};
+_ts_decorate5([
+  (0, import_class_validator.IsString)(),
+  (0, import_class_validator.Matches)(CODE_PATTERN2, {
+    message: 'code muss aus A\u2013Z, 0\u20139, "-" und "_" bestehen (4\u201332 Zeichen)'
+  }),
+  _ts_metadata3("design:type", String)
+], PreviewPromoCodeDto.prototype, "code", void 0);
+_ts_decorate5([
+  (0, import_class_validator.IsString)(),
+  (0, import_class_validator.Matches)(PLAN_OR_CYCLE_PATTERN, {
+    message: "plan muss SCREAMING_SNAKE_CASE sein"
+  }),
+  _ts_metadata3("design:type", String)
+], PreviewPromoCodeDto.prototype, "plan", void 0);
+_ts_decorate5([
+  (0, import_class_validator.IsString)(),
+  (0, import_class_validator.Matches)(PLAN_OR_CYCLE_PATTERN, {
+    message: "billingCycle muss SCREAMING_SNAKE_CASE sein (z. B. MONTHLY, YEARLY)"
+  }),
+  _ts_metadata3("design:type", String)
+], PreviewPromoCodeDto.prototype, "billingCycle", void 0);
+_ts_decorate5([
+  (0, import_class_validator.IsOptional)(),
+  (0, import_class_validator.IsEmail)(),
+  (0, import_class_validator.MaxLength)(254),
+  _ts_metadata3("design:type", String)
+], PreviewPromoCodeDto.prototype, "email", void 0);
+
+// src/promo/controller.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");
+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_param3(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param3, "_ts_param");
+var PromoCodePublicController = class {
+  static {
+    __name(this, "PromoCodePublicController");
+  }
+  promo;
+  constructor(promo) {
+    this.promo = promo;
+  }
+  async preview(dto, req) {
+    return this.promo.preview({
+      code: dto.code,
+      planId: dto.plan,
+      billingCycle: dto.billingCycle,
+      email: dto.email,
+      ipHash: hashIp(req),
+      sessionId: req.user?.id ?? req.user?.sub
+    });
+  }
+};
+_ts_decorate6([
+  (0, import_common5.Post)("preview"),
+  (0, import_common5.HttpCode)(import_common5.HttpStatus.OK),
+  (0, import_common5.UseGuards)(PromoCodeRateLimitGuard),
+  _ts_param3(0, (0, import_common5.Body)()),
+  _ts_param3(1, (0, import_common5.Req)()),
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", [
+    typeof PreviewPromoCodeDto === "undefined" ? Object : PreviewPromoCodeDto,
+    typeof RequestLike === "undefined" ? Object : RequestLike
+  ]),
+  _ts_metadata4("design:returntype", Promise)
+], PromoCodePublicController.prototype, "preview", null);
+PromoCodePublicController = _ts_decorate6([
+  (0, import_common5.Controller)("billing/promo"),
+  _ts_param3(0, (0, import_common5.Inject)(PromoCodesService)),
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", [
+    typeof PromoCodesService === "undefined" ? Object : PromoCodesService
+  ])
+], PromoCodePublicController);
+
+// src/promo/module.ts
+var import_common6 = require("@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 PromoCodesModule = class _PromoCodesModule {
+  static {
+    __name(this, "PromoCodesModule");
+  }
+  static forRoot(options) {
+    const includeCron = options.includeExpirerCron ?? true;
+    const includePublic = options.includePublicController ?? true;
+    const providers = [
+      asProvider(PROMO_CODE_REPOSITORY_TOKEN, options.promoCodeRepository),
+      asProvider(PROMO_CODE_REDEMPTION_REPOSITORY_TOKEN, options.redemptionRepository),
+      asProvider(PROMO_CODE_VALIDATION_LOG_REPOSITORY_TOKEN, options.validationLogRepository),
+      asProvider(PROMO_FIRST_TIME_CUSTOMER_CHECK_TOKEN, options.firstTimeCustomerCheck),
+      asProvider(PROMO_SUBSCRIPTION_LOOKUP_TOKEN, options.subscriptionLookup),
+      asProvider(PROMO_REVENUE_DEDUCTION_AGGREGATOR_TOKEN, options.revenueAggregator),
+      asProvider(PROMO_TRANSACTION_RUNNER_TOKEN, options.transactionRunner),
+      {
+        provide: PROMO_SERVICE_CONFIG_TOKEN,
+        useValue: options.config ?? {}
+      },
+      PromoCodesService,
+      PromoCodeRateLimitGuard
+    ];
+    if (includeCron) {
+      providers.push(PromoCodeExpirer);
+    }
+    return {
+      module: _PromoCodesModule,
+      global: options.global ?? false,
+      controllers: includePublic ? [
+        PromoCodePublicController
+      ] : [],
+      providers,
+      exports: [
+        PromoCodesService,
+        PromoCodeRateLimitGuard,
+        PROMO_CODE_REPOSITORY_TOKEN,
+        PROMO_CODE_REDEMPTION_REPOSITORY_TOKEN,
+        PROMO_CODE_VALIDATION_LOG_REPOSITORY_TOKEN
+      ]
+    };
+  }
+};
+PromoCodesModule = _ts_decorate7([
+  (0, import_common6.Module)({})
+], PromoCodesModule);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PROMO_CODE_REDEMPTION_REPOSITORY_TOKEN,
+  PROMO_CODE_REPOSITORY_TOKEN,
+  PROMO_CODE_VALIDATION_LOG_REPOSITORY_TOKEN,
+  PROMO_FIRST_TIME_CUSTOMER_CHECK_TOKEN,
+  PROMO_REVENUE_DEDUCTION_AGGREGATOR_TOKEN,
+  PROMO_SERVICE_CONFIG_TOKEN,
+  PROMO_SUBSCRIPTION_LOOKUP_TOKEN,
+  PROMO_TRANSACTION_RUNNER_TOKEN,
+  PreviewPromoCodeDto,
+  PromoCodeExpirer,
+  PromoCodePublicController,
+  PromoCodeRateLimitGuard,
+  PromoCodesModule,
+  PromoCodesService,
+  addCycles,
+  buildLabel,
+  computeDiscountGross,
+  computeDiscountedGross,
+  computeIncludedVat,
+  computeRegularStartsAt,
+  grossFromNet,
+  hashIp,
+  ipFingerprint,
+  round2
+});