@saasicat/nest 0.2.0

package/dist/checkout-offer/index.d.cts

@@ -0,0 +1,120 @@
+import { CheckoutOfferRepository, BundleRepository, PlanRepository, CatalogEntryRepository, CheckoutOfferFilter, CheckoutOfferRow, CreateCheckoutOfferData, UpdateCheckoutOfferData, CheckoutOfferPriceBreakdown, CheckoutOfferLineItem, CheckoutOfferPromotionSnapshot, CheckoutOfferPromoCodeSnapshot } from '@saasicat/types';
+import { Type, CanActivate, DynamicModule, ForwardReference, Provider } from '@nestjs/common';
+import { P as ProviderSpec } from '../di-CcNeq9v-.cjs';
+
+declare class CheckoutOfferService {
+    private readonly repo;
+    private readonly bundles;
+    private readonly plans;
+    private readonly catalogEntries;
+    constructor(repo: CheckoutOfferRepository, bundles?: BundleRepository | null, plans?: PlanRepository | null, catalogEntries?: CatalogEntryRepository | null);
+    list(filter: CheckoutOfferFilter): Promise<CheckoutOfferRow[]>;
+    getById(id: string): Promise<CheckoutOfferRow>;
+    create(data: CreateCheckoutOfferData): Promise<CheckoutOfferRow>;
+    /** Customization in onboarding — only while the offer is `open`. */
+    update(id: string, data: UpdateCheckoutOfferData): Promise<CheckoutOfferRow>;
+    /**
+     * Freezes the offer (`status = 'consumed'`). Returns the final
+     * snapshot — the caller (registration/billing) writes it
+     * as `Subscription.packageSnapshot`.
+     */
+    consume(id: string): Promise<CheckoutOfferRow>;
+    /**
+     * #35 P6 — server-side requires validation: the dependencies of all
+     * features (plan ∪ selected bundles) must be covered within the
+     * selection, otherwise an offer would be created whose features cannot
+     * work at the tenant (an app-specific validateModuleDependencies check is
+     * thereby replaced on the platform side). The requires source are the
+     * curated FeatureCatalogEntries; without CatalogEntryRepository it is
+     * skipped (graceful — no requires data available).
+     */
+    private assertFeatureRequiresSatisfied;
+    /**
+     * Plan features preferably from the server SSOT (PlanRepository); fallback
+     * is the frozen featuresSnapshot of the plan LineItem (adapter without
+     * PlanRepository wiring).
+     */
+    private resolvePlanFeatures;
+    /** Bundle features from the BundleVersions; fallback featuresSnapshot. */
+    private resolveBundleFeatures;
+    private assertBundleVersionsStillBookable;
+    private normalizeCreateData;
+    private normalizeUpdateData;
+    private resolveLineItems;
+    private defaultPlanLineItem;
+    private assertOpen;
+    private isExpired;
+    private dateIsAfterNow;
+    private isValidUntilExpired;
+}
+
+declare function buildCheckoutOfferController(guards: Array<Type<CanActivate>>): Type;
+
+interface CheckoutOfferControllerConfig {
+    /** Class-level guards; `[]` for auth-free public endpoints. */
+    guards: Array<Type<CanActivate>>;
+}
+interface CheckoutOfferModuleOptions {
+    checkoutOfferRepository: ProviderSpec<CheckoutOfferRepository>;
+    /**
+     * Optional for V3 revalidation on consume: if set, the service checks
+     * whether referenced bundle versions are still bookable. Also provides
+     * the bundle features for the requires validation (#35 P6).
+     */
+    bundleRepository?: ProviderSpec<BundleRepository>;
+    /**
+     * Optional for the requires validation (#35 P6): plan features of the
+     * chosen plan version. Without wiring, falls back to the featuresSnapshot
+     * of the plan line item.
+     */
+    planRepository?: ProviderSpec<PlanRepository>;
+    /**
+     * Optional for the requires validation (#35 P6): requires source =
+     * curated FeatureCatalogEntries. Without wiring, the validation is
+     * skipped (graceful).
+     */
+    catalogEntryRepository?: ProviderSpec<CatalogEntryRepository>;
+    /** Controller mount for `/public/checkout-offer`. Omitted = service only. */
+    controller?: CheckoutOfferControllerConfig;
+    imports?: Array<Type<unknown> | DynamicModule | Promise<DynamicModule> | ForwardReference>;
+    extraProviders?: Provider[];
+    global?: boolean;
+}
+declare class CheckoutOfferModule {
+    static forRoot(options: CheckoutOfferModuleOptions): DynamicModule;
+}
+
+/** Repository for `checkout_offers`. */
+declare const CHECKOUT_OFFER_REPOSITORY_TOKEN: unique symbol;
+
+declare class CreateCheckoutOfferDto {
+    projectKey: string;
+    planKey: string;
+    planVersionId?: string | null;
+    billingCycle: 'monthly' | 'yearly';
+    promotionId?: string | null;
+    promoCode?: string | null;
+    bundles?: string[];
+    bundleVersionIds?: string[];
+    priceBreakdown: CheckoutOfferPriceBreakdown;
+    lineItems?: CheckoutOfferLineItem[];
+    promotionSnapshots?: CheckoutOfferPromotionSnapshot[];
+    promoCodeSnapshot?: CheckoutOfferPromoCodeSnapshot | null;
+    locale?: string;
+    validUntil?: string | null;
+}
+declare class UpdateCheckoutOfferDto {
+    billingCycle?: 'monthly' | 'yearly';
+    promotionId?: string | null;
+    promoCode?: string | null;
+    bundles?: string[];
+    bundleVersionIds?: string[];
+    priceBreakdown?: CheckoutOfferPriceBreakdown;
+    lineItems?: CheckoutOfferLineItem[];
+    promotionSnapshots?: CheckoutOfferPromotionSnapshot[];
+    promoCodeSnapshot?: CheckoutOfferPromoCodeSnapshot | null;
+    locale?: string;
+    validUntil?: string | null;
+}
+
+export { CHECKOUT_OFFER_REPOSITORY_TOKEN, type CheckoutOfferControllerConfig, CheckoutOfferModule, type CheckoutOfferModuleOptions, CheckoutOfferService, CreateCheckoutOfferDto, UpdateCheckoutOfferDto, buildCheckoutOfferController };

package/dist/checkout-offer/index.d.ts

@@ -0,0 +1,120 @@
+import { CheckoutOfferRepository, BundleRepository, PlanRepository, CatalogEntryRepository, CheckoutOfferFilter, CheckoutOfferRow, CreateCheckoutOfferData, UpdateCheckoutOfferData, CheckoutOfferPriceBreakdown, CheckoutOfferLineItem, CheckoutOfferPromotionSnapshot, CheckoutOfferPromoCodeSnapshot } from '@saasicat/types';
+import { Type, CanActivate, DynamicModule, ForwardReference, Provider } from '@nestjs/common';
+import { P as ProviderSpec } from '../di-CcNeq9v-.js';
+
+declare class CheckoutOfferService {
+    private readonly repo;
+    private readonly bundles;
+    private readonly plans;
+    private readonly catalogEntries;
+    constructor(repo: CheckoutOfferRepository, bundles?: BundleRepository | null, plans?: PlanRepository | null, catalogEntries?: CatalogEntryRepository | null);
+    list(filter: CheckoutOfferFilter): Promise<CheckoutOfferRow[]>;
+    getById(id: string): Promise<CheckoutOfferRow>;
+    create(data: CreateCheckoutOfferData): Promise<CheckoutOfferRow>;
+    /** Customization in onboarding — only while the offer is `open`. */
+    update(id: string, data: UpdateCheckoutOfferData): Promise<CheckoutOfferRow>;
+    /**
+     * Freezes the offer (`status = 'consumed'`). Returns the final
+     * snapshot — the caller (registration/billing) writes it
+     * as `Subscription.packageSnapshot`.
+     */
+    consume(id: string): Promise<CheckoutOfferRow>;
+    /**
+     * #35 P6 — server-side requires validation: the dependencies of all
+     * features (plan ∪ selected bundles) must be covered within the
+     * selection, otherwise an offer would be created whose features cannot
+     * work at the tenant (an app-specific validateModuleDependencies check is
+     * thereby replaced on the platform side). The requires source are the
+     * curated FeatureCatalogEntries; without CatalogEntryRepository it is
+     * skipped (graceful — no requires data available).
+     */
+    private assertFeatureRequiresSatisfied;
+    /**
+     * Plan features preferably from the server SSOT (PlanRepository); fallback
+     * is the frozen featuresSnapshot of the plan LineItem (adapter without
+     * PlanRepository wiring).
+     */
+    private resolvePlanFeatures;
+    /** Bundle features from the BundleVersions; fallback featuresSnapshot. */
+    private resolveBundleFeatures;
+    private assertBundleVersionsStillBookable;
+    private normalizeCreateData;
+    private normalizeUpdateData;
+    private resolveLineItems;
+    private defaultPlanLineItem;
+    private assertOpen;
+    private isExpired;
+    private dateIsAfterNow;
+    private isValidUntilExpired;
+}
+
+declare function buildCheckoutOfferController(guards: Array<Type<CanActivate>>): Type;
+
+interface CheckoutOfferControllerConfig {
+    /** Class-level guards; `[]` for auth-free public endpoints. */
+    guards: Array<Type<CanActivate>>;
+}
+interface CheckoutOfferModuleOptions {
+    checkoutOfferRepository: ProviderSpec<CheckoutOfferRepository>;
+    /**
+     * Optional for V3 revalidation on consume: if set, the service checks
+     * whether referenced bundle versions are still bookable. Also provides
+     * the bundle features for the requires validation (#35 P6).
+     */
+    bundleRepository?: ProviderSpec<BundleRepository>;
+    /**
+     * Optional for the requires validation (#35 P6): plan features of the
+     * chosen plan version. Without wiring, falls back to the featuresSnapshot
+     * of the plan line item.
+     */
+    planRepository?: ProviderSpec<PlanRepository>;
+    /**
+     * Optional for the requires validation (#35 P6): requires source =
+     * curated FeatureCatalogEntries. Without wiring, the validation is
+     * skipped (graceful).
+     */
+    catalogEntryRepository?: ProviderSpec<CatalogEntryRepository>;
+    /** Controller mount for `/public/checkout-offer`. Omitted = service only. */
+    controller?: CheckoutOfferControllerConfig;
+    imports?: Array<Type<unknown> | DynamicModule | Promise<DynamicModule> | ForwardReference>;
+    extraProviders?: Provider[];
+    global?: boolean;
+}
+declare class CheckoutOfferModule {
+    static forRoot(options: CheckoutOfferModuleOptions): DynamicModule;
+}
+
+/** Repository for `checkout_offers`. */
+declare const CHECKOUT_OFFER_REPOSITORY_TOKEN: unique symbol;
+
+declare class CreateCheckoutOfferDto {
+    projectKey: string;
+    planKey: string;
+    planVersionId?: string | null;
+    billingCycle: 'monthly' | 'yearly';
+    promotionId?: string | null;
+    promoCode?: string | null;
+    bundles?: string[];
+    bundleVersionIds?: string[];
+    priceBreakdown: CheckoutOfferPriceBreakdown;
+    lineItems?: CheckoutOfferLineItem[];
+    promotionSnapshots?: CheckoutOfferPromotionSnapshot[];
+    promoCodeSnapshot?: CheckoutOfferPromoCodeSnapshot | null;
+    locale?: string;
+    validUntil?: string | null;
+}
+declare class UpdateCheckoutOfferDto {
+    billingCycle?: 'monthly' | 'yearly';
+    promotionId?: string | null;
+    promoCode?: string | null;
+    bundles?: string[];
+    bundleVersionIds?: string[];
+    priceBreakdown?: CheckoutOfferPriceBreakdown;
+    lineItems?: CheckoutOfferLineItem[];
+    promotionSnapshots?: CheckoutOfferPromotionSnapshot[];
+    promoCodeSnapshot?: CheckoutOfferPromoCodeSnapshot | null;
+    locale?: string;
+    validUntil?: string | null;
+}
+
+export { CHECKOUT_OFFER_REPOSITORY_TOKEN, type CheckoutOfferControllerConfig, CheckoutOfferModule, type CheckoutOfferModuleOptions, CheckoutOfferService, CreateCheckoutOfferDto, UpdateCheckoutOfferDto, buildCheckoutOfferController };

package/dist/checkout-offer/index.js

@@ -0,0 +1,20 @@
+import {
+  CHECKOUT_OFFER_REPOSITORY_TOKEN,
+  CheckoutOfferModule,
+  CheckoutOfferService,
+  CreateCheckoutOfferDto,
+  UpdateCheckoutOfferDto,
+  buildCheckoutOfferController
+} from "../chunk-SYEVGPFC.js";
+import "../chunk-MDIZUVIK.js";
+import "../chunk-XCZ3TTFK.js";
+import "../chunk-SABTXESR.js";
+import "../chunk-SHUYVCID.js";
+export {
+  CHECKOUT_OFFER_REPOSITORY_TOKEN,
+  CheckoutOfferModule,
+  CheckoutOfferService,
+  CreateCheckoutOfferDto,
+  UpdateCheckoutOfferDto,
+  buildCheckoutOfferController
+};

package/dist/chunk-2PNX2QL2.js

@@ -0,0 +1,347 @@
+import {
+  appendImplicitDiscountLineItem
+} from "./chunk-MDIZUVIK.js";
+import {
+  SUBSCRIPTION_CONTRACT_REPOSITORY_TOKEN
+} from "./chunk-NYLON2VC.js";
+import {
+  asProvider
+} from "./chunk-SABTXESR.js";
+import {
+  __name
+} from "./chunk-SHUYVCID.js";
+
+// src/subscription-contract/subscription-contract.service.ts
+import { ConflictException, Inject, Injectable, NotFoundException, UnprocessableEntityException } 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 SubscriptionContractService = class {
+  static {
+    __name(this, "SubscriptionContractService");
+  }
+  repo;
+  constructor(repo) {
+    this.repo = repo;
+  }
+  list(filter) {
+    return this.repo.list(filter);
+  }
+  async getById(contractId) {
+    const row = await this.repo.findById(contractId);
+    if (!row) {
+      throw new NotFoundException(`SubscriptionContract '${contractId}' nicht gefunden`);
+    }
+    return row;
+  }
+  async findActiveByTenantId(tenantId, asOf = /* @__PURE__ */ new Date()) {
+    return this.repo.findActiveByTenantId(tenantId, asOf);
+  }
+  async getActiveInvoiceSnapshotForTenant(tenantId, asOf = /* @__PURE__ */ new Date()) {
+    const contract = await this.repo.findActiveByTenantId(tenantId, asOf);
+    if (!contract) {
+      throw new NotFoundException(`Kein aktiver SubscriptionContract f\xFCr Tenant ${tenantId}`);
+    }
+    return subscriptionContractToInvoiceSnapshot(contract);
+  }
+  async create(data) {
+    this.assertCreateData(data);
+    return this.repo.create(this.cloneCreateData(data));
+  }
+  async terminate(contractId, data) {
+    const existing = await this.getById(contractId);
+    this.assertTerminable(existing, data);
+    return this.repo.terminate(contractId, data);
+  }
+  async replaceActiveContract(tenantId, data, terminateAt) {
+    const previous = await this.repo.findActiveByTenantId(tenantId, terminateAt);
+    if (previous) {
+      await this.terminate(previous.id, {
+        effectiveUntil: terminateAt,
+        status: "superseded"
+      });
+    }
+    const next = await this.create({
+      ...data,
+      tenantId,
+      effectiveFrom: data.effectiveFrom ?? terminateAt
+    });
+    return {
+      previous,
+      next
+    };
+  }
+  createDataFromOffer(offer, options) {
+    if (offer.status !== "consumed") {
+      throw new ConflictException(`CheckoutOffer '${offer.id}' muss vor Contract-Erstellung consumed sein`);
+    }
+    const lineItems = this.lineItemsFromOffer(offer);
+    return {
+      projectKey: offer.projectKey,
+      tenantId: options.tenantId,
+      status: options.status ?? "active",
+      effectiveFrom: options.effectiveFrom,
+      effectiveUntil: options.effectiveUntil ?? null,
+      originalOfferId: offer.id,
+      originalPlanVersionId: offer.planVersionId,
+      originalBundleVersionIds: [
+        ...offer.bundleVersionIds ?? []
+      ],
+      entitlementSnapshot: options.entitlementSnapshot ?? null,
+      priceSnapshot: this.priceSnapshotFromOffer(offer),
+      promotionSnapshots: [
+        ...offer.promotionSnapshots ?? []
+      ],
+      promoCodeSnapshots: offer.promoCodeSnapshot ? [
+        offer.promoCodeSnapshot
+      ] : [],
+      termsSnapshot: options.termsSnapshot ?? null,
+      lineItems
+    };
+  }
+  async createFromOffer(offer, options) {
+    return this.create(this.createDataFromOffer(offer, options));
+  }
+  lineItemsFromOffer(offer) {
+    const source = offer.lineItems ?? [];
+    if (source.length === 0) {
+      throw new UnprocessableEntityException({
+        code: "CHECKOUT_OFFER_LINE_ITEMS_REQUIRED",
+        message: "Aus einem CheckoutOffer kann nur ein Contract entstehen, wenn LineItems eingefroren sind."
+      });
+    }
+    return appendImplicitDiscountLineItem({
+      billingCycle: offer.billingCycle,
+      priceBreakdown: offer.priceBreakdown,
+      lineItems: source,
+      promotionSnapshots: offer.promotionSnapshots ?? [],
+      promoCodeSnapshot: offer.promoCodeSnapshot ?? null
+    }).map((item) => this.offerLineItemToContractLineItem(item));
+  }
+  offerLineItemToContractLineItem(item) {
+    return {
+      kind: item.kind,
+      sourceKey: item.sourceKey,
+      sourceVersionId: item.sourceVersionId ?? null,
+      titleSnapshot: item.titleSnapshot,
+      descriptionSnapshot: item.descriptionSnapshot ?? null,
+      quantity: item.quantity,
+      unit: item.unit ?? null,
+      priceNet: item.priceNet,
+      priceGross: item.priceGross,
+      billingCycle: item.billingCycle,
+      minimumTermUntil: this.parseOptionalDate(item.minimumTermUntil, "lineItems.minimumTermUntil"),
+      featuresSnapshot: [
+        ...item.featuresSnapshot ?? []
+      ],
+      quotaEffectsSnapshot: {
+        ...item.quotaEffectsSnapshot ?? {}
+      },
+      metadata: item.metadata ?? null
+    };
+  }
+  parseOptionalDate(value, field) {
+    if (value === null || value === void 0) return null;
+    const date = value instanceof Date ? new Date(value) : new Date(value);
+    if (Number.isNaN(date.getTime())) {
+      throw new UnprocessableEntityException({
+        code: "SUBSCRIPTION_CONTRACT_INVALID_DATE",
+        message: `${field} muss ein g\xFCltiges Datum sein.`
+      });
+    }
+    return date;
+  }
+  priceSnapshotFromOffer(offer) {
+    const breakdown = offer.priceBreakdown;
+    return {
+      currency: breakdown.currency,
+      billingCycle: breakdown.billingCycle,
+      subtotalNet: breakdown.regularNet,
+      discountNet: Math.max(0, breakdown.regularNet - breakdown.effectiveNet),
+      totalNet: breakdown.effectiveNet,
+      vatRate: breakdown.vatRate,
+      totalGross: breakdown.effectiveGross
+    };
+  }
+  assertCreateData(data) {
+    if (data.lineItems.length === 0) {
+      throw new UnprocessableEntityException({
+        code: "SUBSCRIPTION_CONTRACT_LINE_ITEMS_REQUIRED",
+        message: "SubscriptionContract ben\xF6tigt mindestens eine LineItem."
+      });
+    }
+    if (data.effectiveUntil && data.effectiveUntil <= data.effectiveFrom) {
+      throw new UnprocessableEntityException({
+        code: "SUBSCRIPTION_CONTRACT_INVALID_WINDOW",
+        message: "effectiveUntil muss nach effectiveFrom liegen."
+      });
+    }
+    const planLineItems = data.lineItems.filter((item) => item.kind === "plan");
+    if (planLineItems.length !== 1) {
+      throw new UnprocessableEntityException({
+        code: "SUBSCRIPTION_CONTRACT_PLAN_LINE_ITEM_REQUIRED",
+        message: "SubscriptionContract ben\xF6tigt genau eine Plan-Grundposition."
+      });
+    }
+  }
+  assertTerminable(existing, data) {
+    if (existing.status === "terminated" || existing.status === "superseded") {
+      throw new ConflictException(`SubscriptionContract '${existing.id}' ist bereits geschlossen`);
+    }
+    if (data.effectiveUntil <= existing.effectiveFrom) {
+      throw new UnprocessableEntityException({
+        code: "SUBSCRIPTION_CONTRACT_TERMINATION_BEFORE_START",
+        message: "effectiveUntil muss nach effectiveFrom des Contracts liegen."
+      });
+    }
+  }
+  cloneCreateData(data) {
+    return {
+      ...data,
+      originalBundleVersionIds: [
+        ...data.originalBundleVersionIds ?? []
+      ],
+      promotionSnapshots: [
+        ...data.promotionSnapshots ?? []
+      ],
+      promoCodeSnapshots: [
+        ...data.promoCodeSnapshots ?? []
+      ],
+      termsSnapshot: data.termsSnapshot ? {
+        ...data.termsSnapshot
+      } : null,
+      lineItems: data.lineItems.map((item) => this.cloneLineItemData(item))
+    };
+  }
+  cloneLineItemData(item) {
+    return {
+      ...item,
+      featuresSnapshot: [
+        ...item.featuresSnapshot
+      ],
+      quotaEffectsSnapshot: {
+        ...item.quotaEffectsSnapshot
+      },
+      metadata: item.metadata ? {
+        ...item.metadata
+      } : null
+    };
+  }
+};
+SubscriptionContractService = _ts_decorate([
+  Injectable(),
+  _ts_param(0, Inject(SUBSCRIPTION_CONTRACT_REPOSITORY_TOKEN)),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof SubscriptionContractRepository === "undefined" ? Object : SubscriptionContractRepository
+  ])
+], SubscriptionContractService);
+function contractLineItemToInvoiceLineItem(item) {
+  return {
+    sourceContractLineItemId: item.id,
+    sourceKey: item.sourceKey,
+    sourceVersionId: item.sourceVersionId,
+    kind: item.kind,
+    title: item.titleSnapshot,
+    description: item.descriptionSnapshot,
+    quantity: item.quantity,
+    unit: item.unit,
+    priceNet: item.priceNet,
+    priceGross: item.priceGross,
+    billingCycle: item.billingCycle,
+    minimumTermUntil: item.minimumTermUntil,
+    metadata: item.metadata
+  };
+}
+__name(contractLineItemToInvoiceLineItem, "contractLineItemToInvoiceLineItem");
+function subscriptionContractToInvoiceSnapshot(contract) {
+  return {
+    contractId: contract.id,
+    projectKey: contract.projectKey,
+    tenantId: contract.tenantId,
+    originalOfferId: contract.originalOfferId,
+    currency: contract.priceSnapshot.currency,
+    billingCycle: contract.priceSnapshot.billingCycle,
+    effectiveFrom: contract.effectiveFrom,
+    effectiveUntil: contract.effectiveUntil,
+    subtotalNet: contract.priceSnapshot.subtotalNet,
+    discountNet: contract.priceSnapshot.discountNet,
+    totalNet: contract.priceSnapshot.totalNet,
+    vatRate: contract.priceSnapshot.vatRate,
+    totalGross: contract.priceSnapshot.totalGross,
+    lineItems: sortContractLineItemsForInvoice(contract.lineItems).map(contractLineItemToInvoiceLineItem)
+  };
+}
+__name(subscriptionContractToInvoiceSnapshot, "subscriptionContractToInvoiceSnapshot");
+function sortContractLineItemsForInvoice(lineItems) {
+  return [
+    ...lineItems
+  ].sort((a, b) => lineItemKindPriority(a.kind) - lineItemKindPriority(b.kind) || a.createdAt.getTime() - b.createdAt.getTime() || a.id.localeCompare(b.id));
+}
+__name(sortContractLineItemsForInvoice, "sortContractLineItemsForInvoice");
+function lineItemKindPriority(kind) {
+  switch (kind) {
+    case "plan":
+      return 10;
+    case "bundle":
+      return 20;
+    case "discount":
+      return 90;
+  }
+}
+__name(lineItemKindPriority, "lineItemKindPriority");
+
+// src/subscription-contract/subscription-contract.module.ts
+import { Module } from "@nestjs/common";
+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");
+var SubscriptionContractModule = class _SubscriptionContractModule {
+  static {
+    __name(this, "SubscriptionContractModule");
+  }
+  static forRoot(options) {
+    return {
+      module: _SubscriptionContractModule,
+      global: options.global ?? false,
+      providers: [
+        asProvider(SUBSCRIPTION_CONTRACT_REPOSITORY_TOKEN, options.subscriptionContractRepository),
+        SubscriptionContractService,
+        ...options.extraProviders ?? []
+      ],
+      exports: [
+        SubscriptionContractService,
+        SUBSCRIPTION_CONTRACT_REPOSITORY_TOKEN
+      ]
+    };
+  }
+};
+SubscriptionContractModule = _ts_decorate2([
+  Module({})
+], SubscriptionContractModule);
+
+export {
+  SubscriptionContractService,
+  contractLineItemToInvoiceLineItem,
+  subscriptionContractToInvoiceSnapshot,
+  sortContractLineItemsForInvoice,
+  SubscriptionContractModule
+};