@saasicat/nest 0.2.0

package/dist/chunk-ZL4LLE2Z.js

@@ -0,0 +1,465 @@
+import {
+  PLAN_CATALOG_TOKEN,
+  computeIncludedVat,
+  getPlanPriceGross,
+  round2
+} from "./chunk-MV6LW5UB.js";
+import {
+  __name
+} from "./chunk-SHUYVCID.js";
+
+// 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/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
+import { BadRequestException, Inject, Injectable, NotFoundException } from "@nestjs/common";
+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 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 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 BadRequestException("Prozentsatz muss zwischen 0 und 100 liegen.");
+      }
+    } else if (!(input.value > 0)) {
+      throw new BadRequestException("Betrag muss positiv sein.");
+    }
+    if (input.durationType === "ONCE") {
+      if (input.durationValue != null) {
+        throw new BadRequestException("Bei einmaligem Rabatt darf keine Laufzeit gesetzt sein.");
+      }
+    } else {
+      const v = input.durationValue;
+      if (v == null || v < 1 || v > 24) {
+        throw new BadRequestException("Laufzeit ung\xFCltig (max. 24 Monate bzw. Abrechnungsperioden).");
+      }
+    }
+    if (input.validFrom && input.validUntil && input.validFrom >= input.validUntil) {
+      throw new 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 BadRequestException(`${p}-Plan kann nicht rabattiert werden.`);
+      }
+    }
+    if (input.minimumPlanAmountGross != null && input.minimumPlanAmountGross <= 0) {
+      throw new 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 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 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 NotFoundException("Code nicht gefunden");
+    if (input.maxRedemptions != null && existing.maxRedemptions != null) {
+      if (input.maxRedemptions < existing.maxRedemptions) {
+        throw new 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 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 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 BadRequestException("Code nicht gefunden");
+    }
+    const sub = await this.subscriptionLookup.findById(input.subscriptionId, tx);
+    if (!sub) throw new NotFoundException("Subscription nicht gefunden");
+    if (sub.tenantId !== input.tenantId) {
+      throw new BadRequestException("Subscription geh\xF6rt nicht zum Tenant");
+    }
+    const reason = this.checkEligibility(promo, {
+      code,
+      planId: sub.plan,
+      billingCycle: sub.billingCycle
+    });
+    if (reason) throw new BadRequestException(`Code nicht einl\xF6sbar: ${reason}`);
+    const firstTimeReason = await this.checkFirstTimeCustomer(promo, input.email, {
+      requireEmail: true
+    });
+    if (firstTimeReason) {
+      throw new BadRequestException(`Code nicht einl\xF6sbar: ${firstTimeReason}`);
+    }
+    const claimed = await this.promoRepo.claimSlot(promo.id, tx);
+    if (!claimed) {
+      throw new 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_decorate([
+  Injectable(),
+  _ts_param(0, Inject(PROMO_CODE_REPOSITORY_TOKEN)),
+  _ts_param(1, Inject(PROMO_CODE_REDEMPTION_REPOSITORY_TOKEN)),
+  _ts_param(2, Inject(PROMO_CODE_VALIDATION_LOG_REPOSITORY_TOKEN)),
+  _ts_param(3, Inject(PROMO_FIRST_TIME_CUSTOMER_CHECK_TOKEN)),
+  _ts_param(4, Inject(PROMO_SUBSCRIPTION_LOOKUP_TOKEN)),
+  _ts_param(5, Inject(PROMO_REVENUE_DEDUCTION_AGGREGATOR_TOKEN)),
+  _ts_param(6, Inject(PROMO_TRANSACTION_RUNNER_TOKEN)),
+  _ts_param(7, Inject(PLAN_CATALOG_TOKEN)),
+  _ts_param(8, 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);
+
+export {
+  computeDiscountGross,
+  computeDiscountedGross,
+  computeRegularStartsAt,
+  addCycles,
+  buildLabel,
+  PROMO_CODE_REPOSITORY_TOKEN,
+  PROMO_CODE_REDEMPTION_REPOSITORY_TOKEN,
+  PROMO_CODE_VALIDATION_LOG_REPOSITORY_TOKEN,
+  PROMO_FIRST_TIME_CUSTOMER_CHECK_TOKEN,
+  PROMO_SUBSCRIPTION_LOOKUP_TOKEN,
+  PROMO_REVENUE_DEDUCTION_AGGREGATOR_TOKEN,
+  PROMO_TRANSACTION_RUNNER_TOKEN,
+  PROMO_SERVICE_CONFIG_TOKEN,
+  PromoCodesService
+};

package/dist/di-CcNeq9v-.d.cts

@@ -0,0 +1,16 @@
+import { FactoryProvider, Provider } from '@nestjs/common';
+
+/**
+ * A port implementation can be passed as a ready-made value OR as a factory
+ * (`{ useFactory, inject }`) — this way consumers supply their adapters
+ * without needing to know the instantiation themselves.
+ */
+type ProviderSpec<T> = T | Pick<FactoryProvider, 'useFactory' | 'inject'>;
+/**
+ * Normalizes a `ProviderSpec<T>` into a Nest `Provider` for `token`:
+ * a `{ useFactory, inject }` form becomes a factory provider, everything else
+ * a `useValue` provider.
+ */
+declare function asProvider<T>(token: symbol, impl: ProviderSpec<T>): Provider;
+
+export { type ProviderSpec as P, asProvider as a };

package/dist/di-CcNeq9v-.d.ts

@@ -0,0 +1,16 @@
+import { FactoryProvider, Provider } from '@nestjs/common';
+
+/**
+ * A port implementation can be passed as a ready-made value OR as a factory
+ * (`{ useFactory, inject }`) — this way consumers supply their adapters
+ * without needing to know the instantiation themselves.
+ */
+type ProviderSpec<T> = T | Pick<FactoryProvider, 'useFactory' | 'inject'>;
+/**
+ * Normalizes a `ProviderSpec<T>` into a Nest `Provider` for `token`:
+ * a `{ useFactory, inject }` form becomes a factory provider, everything else
+ * a `useValue` provider.
+ */
+declare function asProvider<T>(token: symbol, impl: ProviderSpec<T>): Provider;
+
+export { type ProviderSpec as P, asProvider as a };