@saasicat/nest 0.2.0

package/dist/subscription-contract/index.cjs

@@ -0,0 +1,471 @@
+"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/subscription-contract/index.ts
+var subscription_contract_exports = {};
+__export(subscription_contract_exports, {
+  SUBSCRIPTION_CONTRACT_REPOSITORY_TOKEN: () => SUBSCRIPTION_CONTRACT_REPOSITORY_TOKEN,
+  SubscriptionContractModule: () => SubscriptionContractModule,
+  SubscriptionContractService: () => SubscriptionContractService,
+  contractLineItemToInvoiceLineItem: () => contractLineItemToInvoiceLineItem,
+  sortContractLineItemsForInvoice: () => sortContractLineItemsForInvoice,
+  subscriptionContractToInvoiceSnapshot: () => subscriptionContractToInvoiceSnapshot
+});
+module.exports = __toCommonJS(subscription_contract_exports);
+
+// src/subscription-contract/subscription-contract.service.ts
+var import_common = require("@nestjs/common");
+
+// src/checkout-offer/discount-line-items.ts
+function appendImplicitDiscountLineItem(input) {
+  const lineItems = input.lineItems.map((item) => cloneCheckoutOfferLineItem(item));
+  const discountNet = roundMoney(input.priceBreakdown.regularNet - input.priceBreakdown.effectiveNet);
+  if (lineItems.some((item) => item.kind === "discount" && !isGeneratedDiscount(item))) {
+    return lineItems;
+  }
+  const lineItemsWithoutGeneratedDiscount = lineItems.filter((item) => !isGeneratedDiscount(item));
+  if (discountNet <= 0) {
+    return lineItemsWithoutGeneratedDiscount;
+  }
+  return [
+    ...lineItemsWithoutGeneratedDiscount,
+    createDiscountLineItem(input, discountNet)
+  ];
+}
+__name(appendImplicitDiscountLineItem, "appendImplicitDiscountLineItem");
+function cloneCheckoutOfferLineItem(item) {
+  return {
+    ...item,
+    featuresSnapshot: [
+      ...item.featuresSnapshot ?? []
+    ],
+    quotaEffectsSnapshot: {
+      ...item.quotaEffectsSnapshot ?? {}
+    },
+    metadata: cloneRecord(item.metadata)
+  };
+}
+__name(cloneCheckoutOfferLineItem, "cloneCheckoutOfferLineItem");
+function createDiscountLineItem(input, discountNet) {
+  const promoCode = input.promoCodeSnapshot ?? null;
+  const firstPromotion = input.promotionSnapshots?.[0] ?? null;
+  const discountGross = roundMoney(discountNet * (1 + input.priceBreakdown.vatRate));
+  return {
+    kind: "discount",
+    sourceKey: promoCode?.code ?? firstPromotion?.id ?? "price-discount",
+    sourceVersionId: null,
+    titleSnapshot: promoCode?.label ?? firstPromotion?.label ?? "Rabatt",
+    descriptionSnapshot: promoCode ? `Promo-Code ${promoCode.code}` : null,
+    quantity: 1,
+    unit: null,
+    priceNet: -discountNet,
+    priceGross: -discountGross,
+    billingCycle: input.billingCycle,
+    featuresSnapshot: [],
+    quotaEffectsSnapshot: {},
+    metadata: {
+      generated: true,
+      source: promoCode ? "promo_code" : firstPromotion ? "promotion" : "price_breakdown",
+      discountNet,
+      discountGross,
+      promotionSnapshots: cloneArray(input.promotionSnapshots ?? []),
+      promoCodeSnapshot: cloneJsonValue(promoCode)
+    }
+  };
+}
+__name(createDiscountLineItem, "createDiscountLineItem");
+function roundMoney(value) {
+  return Math.round((value + Number.EPSILON) * 100) / 100;
+}
+__name(roundMoney, "roundMoney");
+function isGeneratedDiscount(item) {
+  return item.kind === "discount" && item.metadata?.generated === true;
+}
+__name(isGeneratedDiscount, "isGeneratedDiscount");
+function cloneRecord(value) {
+  if (!value) return null;
+  return cloneJsonValue(value);
+}
+__name(cloneRecord, "cloneRecord");
+function cloneArray(value) {
+  return cloneJsonValue(value);
+}
+__name(cloneArray, "cloneArray");
+function cloneJsonValue(value) {
+  return value == null ? value : JSON.parse(JSON.stringify(value));
+}
+__name(cloneJsonValue, "cloneJsonValue");
+
+// src/subscription-contract/tokens.ts
+var SUBSCRIPTION_CONTRACT_REPOSITORY_TOKEN = /* @__PURE__ */ Symbol.for("saas-platform/SubscriptionContractRepository");
+
+// src/subscription-contract/subscription-contract.service.ts
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+function _ts_metadata(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata, "_ts_metadata");
+function _ts_param(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param, "_ts_param");
+var 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 import_common.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 import_common.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 import_common.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 import_common.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 import_common.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 import_common.UnprocessableEntityException({
+        code: "SUBSCRIPTION_CONTRACT_LINE_ITEMS_REQUIRED",
+        message: "SubscriptionContract ben\xF6tigt mindestens eine LineItem."
+      });
+    }
+    if (data.effectiveUntil && data.effectiveUntil <= data.effectiveFrom) {
+      throw new import_common.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 import_common.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 import_common.ConflictException(`SubscriptionContract '${existing.id}' ist bereits geschlossen`);
+    }
+    if (data.effectiveUntil <= existing.effectiveFrom) {
+      throw new import_common.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([
+  (0, import_common.Injectable)(),
+  _ts_param(0, (0, import_common.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
+var import_common2 = 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/subscription-contract/subscription-contract.module.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");
+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([
+  (0, import_common2.Module)({})
+], SubscriptionContractModule);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SUBSCRIPTION_CONTRACT_REPOSITORY_TOKEN,
+  SubscriptionContractModule,
+  SubscriptionContractService,
+  contractLineItemToInvoiceLineItem,
+  sortContractLineItemsForInvoice,
+  subscriptionContractToInvoiceSnapshot
+});

package/dist/subscription-contract/index.d.cts

@@ -0,0 +1,17 @@
+export { C as CreateContractFromOfferOptions, S as SubscriptionContractService, c as contractLineItemToInvoiceLineItem, s as sortContractLineItemsForInvoice, a as subscriptionContractToInvoiceSnapshot } from '../subscription-contract.service--cm47ZJJ.cjs';
+import { Provider, DynamicModule } from '@nestjs/common';
+import { SubscriptionContractRepository } from '@saasicat/types';
+import { P as ProviderSpec } from '../di-CcNeq9v-.cjs';
+
+interface SubscriptionContractModuleOptions {
+    subscriptionContractRepository: ProviderSpec<SubscriptionContractRepository>;
+    extraProviders?: Provider[];
+    global?: boolean;
+}
+declare class SubscriptionContractModule {
+    static forRoot(options: SubscriptionContractModuleOptions): DynamicModule;
+}
+
+declare const SUBSCRIPTION_CONTRACT_REPOSITORY_TOKEN: unique symbol;
+
+export { SUBSCRIPTION_CONTRACT_REPOSITORY_TOKEN, SubscriptionContractModule, type SubscriptionContractModuleOptions };

package/dist/subscription-contract/index.d.ts

@@ -0,0 +1,17 @@
+export { C as CreateContractFromOfferOptions, S as SubscriptionContractService, c as contractLineItemToInvoiceLineItem, s as sortContractLineItemsForInvoice, a as subscriptionContractToInvoiceSnapshot } from '../subscription-contract.service--cm47ZJJ.js';
+import { Provider, DynamicModule } from '@nestjs/common';
+import { SubscriptionContractRepository } from '@saasicat/types';
+import { P as ProviderSpec } from '../di-CcNeq9v-.js';
+
+interface SubscriptionContractModuleOptions {
+    subscriptionContractRepository: ProviderSpec<SubscriptionContractRepository>;
+    extraProviders?: Provider[];
+    global?: boolean;
+}
+declare class SubscriptionContractModule {
+    static forRoot(options: SubscriptionContractModuleOptions): DynamicModule;
+}
+
+declare const SUBSCRIPTION_CONTRACT_REPOSITORY_TOKEN: unique symbol;
+
+export { SUBSCRIPTION_CONTRACT_REPOSITORY_TOKEN, SubscriptionContractModule, type SubscriptionContractModuleOptions };

package/dist/subscription-contract/index.js

@@ -0,0 +1,21 @@
+import {
+  SubscriptionContractModule,
+  SubscriptionContractService,
+  contractLineItemToInvoiceLineItem,
+  sortContractLineItemsForInvoice,
+  subscriptionContractToInvoiceSnapshot
+} from "../chunk-2PNX2QL2.js";
+import "../chunk-MDIZUVIK.js";
+import {
+  SUBSCRIPTION_CONTRACT_REPOSITORY_TOKEN
+} from "../chunk-NYLON2VC.js";
+import "../chunk-SABTXESR.js";
+import "../chunk-SHUYVCID.js";
+export {
+  SUBSCRIPTION_CONTRACT_REPOSITORY_TOKEN,
+  SubscriptionContractModule,
+  SubscriptionContractService,
+  contractLineItemToInvoiceLineItem,
+  sortContractLineItemsForInvoice,
+  subscriptionContractToInvoiceSnapshot
+};

package/dist/subscription-contract.service--cm47ZJJ.d.cts

@@ -0,0 +1,39 @@
+import { SubscriptionContractRepository, SubscriptionContractRecord, SubscriptionContractInvoiceSnapshot, CreateSubscriptionContractData, TerminateSubscriptionContractData, CheckoutOfferRow, ContractLineItemRecord, InvoiceLineItemSnapshot } from '@saasicat/types';
+
+interface CreateContractFromOfferOptions {
+    tenantId: string;
+    effectiveFrom: Date;
+    effectiveUntil?: Date | null;
+    status?: CreateSubscriptionContractData['status'];
+    entitlementSnapshot?: CreateSubscriptionContractData['entitlementSnapshot'];
+    termsSnapshot?: Record<string, unknown> | null;
+}
+declare class SubscriptionContractService {
+    private readonly repo;
+    constructor(repo: SubscriptionContractRepository);
+    list(filter: Parameters<SubscriptionContractRepository['list']>[0]): Promise<SubscriptionContractRecord[]>;
+    getById(contractId: string): Promise<SubscriptionContractRecord>;
+    findActiveByTenantId(tenantId: string, asOf?: Date): Promise<SubscriptionContractRecord | null>;
+    getActiveInvoiceSnapshotForTenant(tenantId: string, asOf?: Date): Promise<SubscriptionContractInvoiceSnapshot>;
+    create(data: CreateSubscriptionContractData): Promise<SubscriptionContractRecord>;
+    terminate(contractId: string, data: TerminateSubscriptionContractData): Promise<SubscriptionContractRecord>;
+    replaceActiveContract(tenantId: string, data: CreateSubscriptionContractData, terminateAt: Date): Promise<{
+        previous: SubscriptionContractRecord | null;
+        next: SubscriptionContractRecord;
+    }>;
+    createDataFromOffer(offer: CheckoutOfferRow, options: CreateContractFromOfferOptions): CreateSubscriptionContractData;
+    createFromOffer(offer: CheckoutOfferRow, options: CreateContractFromOfferOptions): Promise<SubscriptionContractRecord>;
+    private lineItemsFromOffer;
+    private offerLineItemToContractLineItem;
+    private parseOptionalDate;
+    private priceSnapshotFromOffer;
+    private assertCreateData;
+    private assertTerminable;
+    private cloneCreateData;
+    private cloneLineItemData;
+}
+declare function contractLineItemToInvoiceLineItem(item: ContractLineItemRecord): InvoiceLineItemSnapshot;
+declare function subscriptionContractToInvoiceSnapshot(contract: SubscriptionContractRecord): SubscriptionContractInvoiceSnapshot;
+declare function sortContractLineItemsForInvoice(lineItems: readonly ContractLineItemRecord[]): ContractLineItemRecord[];
+
+export { type CreateContractFromOfferOptions as C, SubscriptionContractService as S, subscriptionContractToInvoiceSnapshot as a, contractLineItemToInvoiceLineItem as c, sortContractLineItemsForInvoice as s };

package/dist/subscription-contract.service--cm47ZJJ.d.ts

@@ -0,0 +1,39 @@
+import { SubscriptionContractRepository, SubscriptionContractRecord, SubscriptionContractInvoiceSnapshot, CreateSubscriptionContractData, TerminateSubscriptionContractData, CheckoutOfferRow, ContractLineItemRecord, InvoiceLineItemSnapshot } from '@saasicat/types';
+
+interface CreateContractFromOfferOptions {
+    tenantId: string;
+    effectiveFrom: Date;
+    effectiveUntil?: Date | null;
+    status?: CreateSubscriptionContractData['status'];
+    entitlementSnapshot?: CreateSubscriptionContractData['entitlementSnapshot'];
+    termsSnapshot?: Record<string, unknown> | null;
+}
+declare class SubscriptionContractService {
+    private readonly repo;
+    constructor(repo: SubscriptionContractRepository);
+    list(filter: Parameters<SubscriptionContractRepository['list']>[0]): Promise<SubscriptionContractRecord[]>;
+    getById(contractId: string): Promise<SubscriptionContractRecord>;
+    findActiveByTenantId(tenantId: string, asOf?: Date): Promise<SubscriptionContractRecord | null>;
+    getActiveInvoiceSnapshotForTenant(tenantId: string, asOf?: Date): Promise<SubscriptionContractInvoiceSnapshot>;
+    create(data: CreateSubscriptionContractData): Promise<SubscriptionContractRecord>;
+    terminate(contractId: string, data: TerminateSubscriptionContractData): Promise<SubscriptionContractRecord>;
+    replaceActiveContract(tenantId: string, data: CreateSubscriptionContractData, terminateAt: Date): Promise<{
+        previous: SubscriptionContractRecord | null;
+        next: SubscriptionContractRecord;
+    }>;
+    createDataFromOffer(offer: CheckoutOfferRow, options: CreateContractFromOfferOptions): CreateSubscriptionContractData;
+    createFromOffer(offer: CheckoutOfferRow, options: CreateContractFromOfferOptions): Promise<SubscriptionContractRecord>;
+    private lineItemsFromOffer;
+    private offerLineItemToContractLineItem;
+    private parseOptionalDate;
+    private priceSnapshotFromOffer;
+    private assertCreateData;
+    private assertTerminable;
+    private cloneCreateData;
+    private cloneLineItemData;
+}
+declare function contractLineItemToInvoiceLineItem(item: ContractLineItemRecord): InvoiceLineItemSnapshot;
+declare function subscriptionContractToInvoiceSnapshot(contract: SubscriptionContractRecord): SubscriptionContractInvoiceSnapshot;
+declare function sortContractLineItemsForInvoice(lineItems: readonly ContractLineItemRecord[]): ContractLineItemRecord[];
+
+export { type CreateContractFromOfferOptions as C, SubscriptionContractService as S, subscriptionContractToInvoiceSnapshot as a, contractLineItemToInvoiceLineItem as c, sortContractLineItemsForInvoice as s };