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

package/dist/chunk-VXEYLNIB.js

@@ -1,632 +0,0 @@
-import {
-  PLAN_CATALOG_TOKEN,
-  computeIncludedVat,
-  getPlanPriceGross,
-  round2
-} from "./chunk-DQKCK7DX.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");
-var LEGACY_LABEL_LOCALE = "de-DE";
-var LEGACY_LABEL_CURRENCY = "EUR";
-var ICU_NON_BREAKING_SPACES = /[\u00A0\u202F]/g;
-function requireSupportedLocale(locale) {
-  if (Intl.NumberFormat.supportedLocalesOf([
-    locale
-  ]).length === 0) {
-    throw new RangeError(`buildLabel: locale "${locale}" names a language this runtime cannot serve. It would be formatted as "${new Intl.NumberFormat(locale).resolvedOptions().locale}" instead \u2014 a language nobody chose. Pass a tag the runtime serves.`);
-  }
-}
-__name(requireSupportedLocale, "requireSupportedLocale");
-function formatPromoValue(value, valueType, { locale = LEGACY_LABEL_LOCALE, currency = LEGACY_LABEL_CURRENCY }) {
-  requireSupportedLocale(locale);
-  const numberFormat = valueType === "PERCENT" ? {
-    style: "unit",
-    unit: "percent"
-  } : {
-    style: "currency",
-    currency
-  };
-  return new Intl.NumberFormat(locale, numberFormat).format(value).replace(ICU_NON_BREAKING_SPACES, " ");
-}
-__name(formatPromoValue, "formatPromoValue");
-function buildLabel(code, cycle, options = {}) {
-  const value = Number(code.value);
-  const valueStr = formatPromoValue(value, code.valueType, options);
-  if (code.durationType === "ONCE") {
-    return `${valueStr} once`;
-  }
-  if (code.durationType === "MONTHS") {
-    const m = code.durationValue ?? 0;
-    return m === 1 ? `${valueStr} for the first month` : `${valueStr} for ${m} months`;
-  }
-  const n = code.durationValue ?? 0;
-  if (n === 1) return cycle === "YEARLY" ? `${valueStr} for the first year` : `${valueStr} for the first month`;
-  return cycle === "YEARLY" ? `${valueStr} for the first ${n} years` : `${valueStr} for the first ${n} months`;
-}
-__name(buildLabel, "buildLabel");
-
-// src/promo/promo.tokens.ts
-var PROMO_CODE_REPOSITORY_TOKEN = /* @__PURE__ */ Symbol.for("saasicat/nest/PromoCodeRepository");
-var PROMO_CODE_REDEMPTION_REPOSITORY_TOKEN = /* @__PURE__ */ Symbol.for("saasicat/nest/PromoCodeRedemptionRepository");
-var PROMO_CODE_VALIDATION_LOG_REPOSITORY_TOKEN = /* @__PURE__ */ Symbol.for("saasicat/nest/PromoCodeValidationLogRepository");
-var PROMO_FIRST_TIME_CUSTOMER_CHECK_TOKEN = /* @__PURE__ */ Symbol.for("saasicat/nest/PromoFirstTimeCustomerCheck");
-var PROMO_SUBSCRIPTION_LOOKUP_TOKEN = /* @__PURE__ */ Symbol.for("saasicat/nest/PromoSubscriptionLookup");
-var PROMO_REVENUE_DEDUCTION_AGGREGATOR_TOKEN = /* @__PURE__ */ Symbol.for("saasicat/nest/PromoRevenueDeductionAggregator");
-var PROMO_TRANSACTION_RUNNER_TOKEN = /* @__PURE__ */ Symbol.for("saasicat/nest/PromoTransactionRunner");
-var PROMO_SERVICE_CONFIG_TOKEN = /* @__PURE__ */ Symbol.for("saasicat/nest/PromoServiceConfig");
-
-// src/promo/promo.service.ts
-import { BadRequestException, Inject, Injectable, NotFoundException } from "@nestjs/common";
-import { BILLING_ERROR_CODES, PROMO_ERROR_CODES } from "@saasicat/core";
-function _ts_decorate(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-__name(_ts_decorate, "_ts_decorate");
-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_MIN_LENGTH = 4;
-var CODE_MAX_LENGTH = 32;
-var CODE_PATTERN = /^[A-Z0-9_-]{4,32}$/;
-var PERCENT_MIN_EXCLUSIVE = 0;
-var PERCENT_MAX = 100;
-var DURATION_MIN = 1;
-var DURATION_MAX = 24;
-function notRedeemable(reason) {
-  return new BadRequestException({
-    code: PROMO_ERROR_CODES.PROMO_CODE_NOT_REDEEMABLE,
-    message: `Code cannot be redeemed: ${reason}`,
-    params: {
-      reason
-    }
-  });
-}
-__name(notRedeemable, "notRedeemable");
-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: PROMO_ERROR_CODES.PROMO_CODE_FORMAT_INVALID,
-        message: 'The code may only contain upper-case letters, digits, "-" and "_" (4\u201332 characters).',
-        params: {
-          promoCode: code,
-          minLength: CODE_MIN_LENGTH,
-          maxLength: CODE_MAX_LENGTH
-        }
-      });
-    }
-    if (input.valueType === "PERCENT") {
-      if (!(input.value > PERCENT_MIN_EXCLUSIVE && input.value <= PERCENT_MAX)) {
-        throw new BadRequestException({
-          code: PROMO_ERROR_CODES.PROMO_PERCENT_OUT_OF_RANGE,
-          message: "The percentage must be between 0 and 100.",
-          params: {
-            value: input.value,
-            min: PERCENT_MIN_EXCLUSIVE,
-            max: PERCENT_MAX
-          }
-        });
-      }
-    } else if (!(input.value > 0)) {
-      throw new BadRequestException({
-        code: PROMO_ERROR_CODES.PROMO_AMOUNT_NOT_POSITIVE,
-        message: "The amount must be positive.",
-        params: {
-          value: input.value,
-          min: 0
-        }
-      });
-    }
-    if (input.durationType === "ONCE") {
-      if (input.durationValue != null) {
-        throw new BadRequestException({
-          code: PROMO_ERROR_CODES.PROMO_ONE_OFF_WITH_DURATION,
-          message: "A one-off discount must not set a duration.",
-          params: {
-            durationValue: input.durationValue
-          }
-        });
-      }
-    } else {
-      const v = input.durationValue;
-      if (v == null || v < DURATION_MIN || v > DURATION_MAX) {
-        throw new BadRequestException({
-          code: PROMO_ERROR_CODES.PROMO_DURATION_INVALID,
-          message: "Invalid duration (at most 24 months or billing periods).",
-          params: {
-            durationValue: v ?? null,
-            min: DURATION_MIN,
-            max: DURATION_MAX
-          }
-        });
-      }
-    }
-    if (input.validFrom && input.validUntil && input.validFrom >= input.validUntil) {
-      throw new BadRequestException({
-        code: PROMO_ERROR_CODES.PROMO_VALIDITY_WINDOW_INVALID,
-        message: "Invalid validity window.",
-        params: {
-          validFrom: input.validFrom.toISOString(),
-          validUntil: input.validUntil.toISOString()
-        }
-      });
-    }
-    const plans = input.appliesToPlans ?? [];
-    const blocked = this.config.nonRedeemablePlans ?? [];
-    for (const p of plans) {
-      if (blocked.includes(p)) {
-        throw new BadRequestException({
-          code: PROMO_ERROR_CODES.PROMO_PLAN_NOT_DISCOUNTABLE,
-          message: `${p}-Plan cannot be discounted.`,
-          params: {
-            plan: p
-          }
-        });
-      }
-    }
-    if (input.minimumPlanAmountGross != null && input.minimumPlanAmountGross <= 0) {
-      throw new BadRequestException({
-        code: PROMO_ERROR_CODES.PROMO_MIN_AMOUNT_NOT_POSITIVE,
-        message: "The minimum plan gross amount must be positive.",
-        params: {
-          value: input.minimumPlanAmountGross,
-          min: 0
-        }
-      });
-    }
-    if (input.valueType === "ABSOLUTE" && !input.allowZeroInvoice) {
-      const lowestApplicableGross = this.lowestApplicablePlanGross(plans);
-      if (lowestApplicableGross != null && input.value >= lowestApplicableGross) {
-        throw new BadRequestException({
-          code: PROMO_ERROR_CODES.PROMO_WOULD_PRODUCE_ZERO_INVOICE,
-          message: "For absolute amounts the discount must stay below the lowest applicable plan price, or allowZeroInvoice must be enabled.",
-          params: {
-            value: input.value,
-            lowestApplicablePlanGross: lowestApplicableGross
-          }
-        });
-      }
-    }
-    const exists = await this.promoRepo.findByCode(code);
-    if (exists) {
-      throw new BadRequestException({
-        code: PROMO_ERROR_CODES.PROMO_CODE_ALREADY_EXISTS,
-        message: "The code already exists.",
-        params: {
-          promoCode: code
-        }
-      });
-    }
-    return this.promoRepo.create({
-      ...input,
-      code
-    });
-  }
-  async update(id, input) {
-    const existing = await this.promoRepo.findById(id);
-    if (!existing) {
-      throw new NotFoundException({
-        code: PROMO_ERROR_CODES.PROMO_CODE_NOT_FOUND,
-        message: "Code not found",
-        params: {
-          promoCodeId: id,
-          promoCode: null
-        }
-      });
-    }
-    if (input.maxRedemptions != null && existing.maxRedemptions != null) {
-      if (input.maxRedemptions < existing.maxRedemptions) {
-        throw new BadRequestException({
-          code: PROMO_ERROR_CODES.PROMO_MAX_REDEMPTIONS_LOWERED,
-          message: "maxRedemptions cannot be lowered.",
-          params: {
-            current: existing.maxRedemptions,
-            requested: input.maxRedemptions
-          }
-        });
-      }
-    }
-    return this.promoRepo.update(id, input);
-  }
-  async softDelete(id) {
-    const redemptions = await this.redemptionRepo.countByPromoCode(id);
-    if (redemptions > 0) {
-      throw new BadRequestException({
-        code: PROMO_ERROR_CODES.PROMO_CODE_HAS_REDEMPTIONS,
-        message: "The code already has redemptions \u2014 it cannot be soft-deleted. Pause it instead.",
-        params: {
-          promoCodeId: id,
-          redemptions
-        }
-      });
-    }
-    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: PROMO_ERROR_CODES.PROMO_CODE_NOT_FOUND,
-        message: "Code not found",
-        params: {
-          promoCodeId: id,
-          promoCode: null
-        }
-      });
-    }
-    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: PROMO_ERROR_CODES.PROMO_CODE_NOT_FOUND,
-        // The lookup runs on the code string, so there is no id to report.
-        message: "Code not found",
-        params: {
-          promoCodeId: null,
-          promoCode: code
-        }
-      });
-    }
-    const sub = await this.subscriptionLookup.findById(input.subscriptionId, tx);
-    if (!sub) {
-      throw new NotFoundException({
-        code: BILLING_ERROR_CODES.SUBSCRIPTION_NOT_FOUND,
-        message: "Subscription not found",
-        params: {
-          tenantId: input.tenantId
-        }
-      });
-    }
-    if (sub.tenantId !== input.tenantId) {
-      throw new BadRequestException({
-        code: BILLING_ERROR_CODES.SUBSCRIPTION_TENANT_MISMATCH,
-        message: "Subscription does not belong to the tenant",
-        params: {
-          subscriptionId: sub.id,
-          tenantId: input.tenantId
-        }
-      });
-    }
-    const reason = this.checkEligibility(promo, {
-      code,
-      planId: sub.plan,
-      billingCycle: sub.billingCycle
-    });
-    if (reason) throw notRedeemable(reason);
-    const firstTimeReason = await this.checkFirstTimeCustomer(promo, input.email, {
-      requireEmail: true
-    });
-    if (firstTimeReason) {
-      throw notRedeemable(firstTimeReason);
-    }
-    const claimed = await this.promoRepo.claimSlot(promo.id, tx);
-    if (!claimed) {
-      throw notRedeemable("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,
-  CODE_MIN_LENGTH,
-  CODE_MAX_LENGTH,
-  CODE_PATTERN,
-  PromoCodesService
-};