@dainamite/billing 0.17.0

package/src/modules/billing/lib/usageRater.ts

@@ -0,0 +1,250 @@
+/**
+ * Pure functions to rate usage quantity against a `rate_json` payload.
+ *
+ * Three tier models per the spec (`volume` / `graduated` / `flat`) plus
+ * the "simple" flat-rate shape (`{ unit_price }` without a `model`).
+ * The validator at `data/validators.ts` ensures the payload structure
+ * before it reaches this rater — this module trusts the shape but
+ * defends against numeric edge cases (NaN, negative quantity).
+ *
+ * Output:
+ *   - `amount` — numeric string, rounded 2dp half-up, formatted to 4
+ *     decimals to match the `core/sales` numeric(18,4) column shape.
+ *   - `breakdown` — per-tier rated quantity / amount, persisted into
+ *     `SalesInvoiceLine.metadata.usage_tier_breakdown` so operators
+ *     can see how the line was built without re-running the math.
+ */
+
+import type { BillingItem } from '../data/entities'
+
+export type SimpleFlatRate = { unit_price: number }
+export type VolumeTier = { up_to: number | null; unit_price: number }
+export type GraduatedTier = { up_to: number | null; unit_price: number }
+export type FlatTier = { up_to: number | null; flat_amount: number }
+
+export type VolumeRate = { model: 'volume'; tiers: VolumeTier[] }
+export type GraduatedRate = { model: 'graduated'; tiers: GraduatedTier[] }
+export type FlatRate = { model: 'flat'; tiers: FlatTier[] }
+export type TieredRate = VolumeRate | GraduatedRate | FlatRate
+export type UsageRate = SimpleFlatRate | TieredRate
+
+export type TierBreakdownEntry = {
+  tierIndex: number
+  upTo: number | null
+  /** Quantity rated at this tier — 0 for tiers above the consumed range. */
+  rangeQuantity: number
+  /** `unit_price` for volume/graduated; `flat_amount` for flat. */
+  rate: number
+  /** Per-tier amount contribution, rounded 4dp. */
+  amount: string
+}
+
+export type UsageRateResult = {
+  /** Total rated amount, numeric(18,4) string. */
+  amount: string
+  /** Per-tier or single-rate breakdown for invoice-line metadata. */
+  breakdown: TierBreakdownEntry[]
+}
+
+/**
+ * Half-up rounding to 2dp survives the JS floating-point edge case
+ * (`1.005 → 1.01`, `100 × 0.001 + 100 × 0.001 + … → exactly N×0.001`).
+ * Match `invoiceWriter`'s rounding policy so totals are consistent
+ * across line types.
+ */
+function roundHalfUp2dp(value: number): number {
+  return Math.round((value + Number.EPSILON) * 100) / 100
+}
+
+function format4dp(value: number): string {
+  return roundHalfUp2dp(value).toFixed(4)
+}
+
+/**
+ * Format a unit price to 4dp WITHOUT 2dp rounding — sub-cent rates
+ * like `0.001` (per-API-request pricing) are legitimate. The spec's
+ * 2dp half-up rule applies only to line *amounts*, not per-unit
+ * rates.
+ */
+function formatUnitPrice(value: number): string {
+  if (!Number.isFinite(value)) return '0.0000'
+  return value.toFixed(4)
+}
+
+function isTieredRate(rate: UsageRate): rate is TieredRate {
+  return typeof (rate as { model?: unknown }).model === 'string'
+}
+
+function safeQuantity(quantity: number): number {
+  if (!Number.isFinite(quantity) || quantity < 0) return 0
+  return quantity
+}
+
+// ─── Simple flat-rate ────────────────────────────────────────────
+
+function rateSimpleFlat(quantity: number, rate: SimpleFlatRate): UsageRateResult {
+  const q = safeQuantity(quantity)
+  const total = q * rate.unit_price
+  return {
+    amount: format4dp(total),
+    breakdown: [
+      {
+        tierIndex: 0,
+        upTo: null,
+        rangeQuantity: q,
+        rate: rate.unit_price,
+        amount: format4dp(total),
+      },
+    ],
+  }
+}
+
+// ─── Volume tier ─────────────────────────────────────────────────
+//
+// "Entire quantity priced at the unit_price of the tier its total falls
+// into." So we walk tiers in order, find the first tier whose `up_to`
+// is `null` (open-ended) or `>= quantity`, and charge `quantity ×
+// that tier's unit_price`. The unconsumed tiers report 0.
+
+function rateVolume(quantity: number, rate: VolumeRate): UsageRateResult {
+  const q = safeQuantity(quantity)
+  const breakdown: TierBreakdownEntry[] = rate.tiers.map((tier, idx) => ({
+    tierIndex: idx,
+    upTo: tier.up_to,
+    rangeQuantity: 0,
+    rate: tier.unit_price,
+    amount: format4dp(0),
+  }))
+  for (let i = 0; i < rate.tiers.length; i++) {
+    const tier = rate.tiers[i]
+    if (tier.up_to === null || q <= tier.up_to) {
+      const total = q * tier.unit_price
+      breakdown[i] = {
+        tierIndex: i,
+        upTo: tier.up_to,
+        rangeQuantity: q,
+        rate: tier.unit_price,
+        amount: format4dp(total),
+      }
+      return { amount: format4dp(total), breakdown }
+    }
+  }
+  // Should be unreachable: validator enforces an open-ended top tier.
+  return { amount: format4dp(0), breakdown }
+}
+
+// ─── Graduated tier ──────────────────────────────────────────────
+//
+// "Each unit priced at its tier." Walk tiers in order, charging
+// `min(q_remaining, tier_capacity) × unit_price` for each tier the
+// quantity touches.
+
+function rateGraduated(quantity: number, rate: GraduatedRate): UsageRateResult {
+  const q = safeQuantity(quantity)
+  let remaining = q
+  let previousUpTo = 0
+  let total = 0
+  const breakdown: TierBreakdownEntry[] = []
+  for (let i = 0; i < rate.tiers.length; i++) {
+    const tier = rate.tiers[i]
+    const tierCapacity =
+      tier.up_to === null ? Infinity : Math.max(0, tier.up_to - previousUpTo)
+    const consumed = Math.min(remaining, tierCapacity)
+    const tierAmount = consumed * tier.unit_price
+    total += tierAmount
+    breakdown.push({
+      tierIndex: i,
+      upTo: tier.up_to,
+      rangeQuantity: consumed,
+      rate: tier.unit_price,
+      amount: format4dp(tierAmount),
+    })
+    remaining -= consumed
+    previousUpTo = tier.up_to ?? previousUpTo
+    if (remaining <= 0) {
+      // Pad remaining tiers with zeros for breakdown completeness.
+      for (let j = i + 1; j < rate.tiers.length; j++) {
+        breakdown.push({
+          tierIndex: j,
+          upTo: rate.tiers[j].up_to,
+          rangeQuantity: 0,
+          rate: rate.tiers[j].unit_price,
+          amount: format4dp(0),
+        })
+      }
+      break
+    }
+  }
+  return { amount: format4dp(total), breakdown }
+}
+
+// ─── Flat tier ───────────────────────────────────────────────────
+//
+// "One flat fee for the highest tier reached." Find the first tier
+// whose `up_to` is `null` or `>= quantity`. Charge that tier's
+// `flat_amount`. Other tiers report 0.
+
+function rateFlat(quantity: number, rate: FlatRate): UsageRateResult {
+  const q = safeQuantity(quantity)
+  const breakdown: TierBreakdownEntry[] = rate.tiers.map((tier, idx) => ({
+    tierIndex: idx,
+    upTo: tier.up_to,
+    rangeQuantity: 0,
+    rate: tier.flat_amount,
+    amount: format4dp(0),
+  }))
+  for (let i = 0; i < rate.tiers.length; i++) {
+    const tier = rate.tiers[i]
+    if (tier.up_to === null || q <= tier.up_to) {
+      breakdown[i] = {
+        tierIndex: i,
+        upTo: tier.up_to,
+        rangeQuantity: q,
+        rate: tier.flat_amount,
+        amount: format4dp(tier.flat_amount),
+      }
+      return { amount: format4dp(tier.flat_amount), breakdown }
+    }
+  }
+  return { amount: format4dp(0), breakdown }
+}
+
+// ─── Public dispatcher ───────────────────────────────────────────
+
+export function rateUsageQuantity(rate: UsageRate, totalQuantity: number): UsageRateResult {
+  if (!isTieredRate(rate)) {
+    return rateSimpleFlat(totalQuantity, rate)
+  }
+  switch (rate.model) {
+    case 'volume':
+      return rateVolume(totalQuantity, rate)
+    case 'graduated':
+      return rateGraduated(totalQuantity, rate)
+    case 'flat':
+      return rateFlat(totalQuantity, rate)
+  }
+}
+
+/**
+ * Convenience wrapper: takes a BillingItem's `rate_json` (typed as
+ * `unknown` from JSONB) and the total quantity, returns the rated
+ * amount + breakdown. Returns `null` when the rate shape is invalid —
+ * caller falls back to "no charge" + warns instead of crashing the
+ * whole account.
+ */
+export function rateUsageForItem(
+  item: Pick<BillingItem, 'rateJson' | 'type'>,
+  totalQuantity: number,
+): UsageRateResult | null {
+  if (item.type !== 'usage') return null
+  const rate = item.rateJson as UsageRate | null | undefined
+  if (!rate || typeof rate !== 'object') return null
+  if (isTieredRate(rate)) {
+    if (!Array.isArray(rate.tiers) || rate.tiers.length === 0) return null
+  } else if (typeof (rate as SimpleFlatRate).unit_price !== 'number') {
+    return null
+  }
+  return rateUsageQuantity(rate, totalQuantity)
+}
+
+export { roundHalfUp2dp, format4dp, formatUnitPrice }

package/src/modules/billing/lib/usageRunner.ts

@@ -0,0 +1,189 @@
+import type { EntityManager } from '@mikro-orm/postgresql'
+import { type BillingAccount, type BillingItem } from '../data/entities'
+import type { BillPeriod } from './billPeriod'
+import type { InvoiceLineDescriptor } from './invoiceWriter'
+import { format4dp, formatUnitPrice, rateUsageForItem, type UsageRate } from './usageRater'
+
+/**
+ * Per-account usage processing — Phase 3.
+ *
+ * ## Scale design
+ *
+ * This module's hot path runs once per account per Bill Run. For
+ * telco / infra customers the spec's "Shape B" scenario projects
+ * **millions of usage records per account per cycle**. A naive
+ * `em.find(BillingAccountUsage, …)` materialises every row in JS
+ * memory before we can sum, which OOMs on those tenants.
+ *
+ * Phase 4f refactor: replace the load-all-then-aggregate path with a
+ * single Postgres `GROUP BY uom_code` aggregate. Memory is now bounded
+ * by `O(distinct uom_codes per account)` (a small number, typically
+ * 1-20) rather than `O(records)`. The corresponding "mark as rated"
+ * UPDATE happens engine-side via a `uom_code IN (…)` predicate so we
+ * never enumerate ids into memory either.
+ *
+ * ## Spec behaviour
+ *
+ * Selects all unrated usage records whose `period_end <= bill_period_end`,
+ * groups them by `uom_code`, matches each group against the account's
+ * `type=usage` Billing Items (exact `uom_code` match per spec — NO
+ * conversion), rates the aggregated quantity, and emits ONE invoice
+ * line per matched item.
+ *
+ * Per-record `line_description` itemization is deferred to a follow-up
+ * (would require a non-aggregate path; the engine keeps the invoice
+ * clean with one aggregated line per item for now).
+ *
+ * Unmatched UoMs:
+ *   - When usage records exist for a `uom_code` that does NOT match
+ *     any active `type=usage` Billing Item, those records are LEFT
+ *     un-rated (`rated_in_bill_run_id` stays NULL) and the uom is
+ *     surfaced in `unmatchedUoms` so the account outcome carries it
+ *     as `success_with_warnings`. Operator's fix: add the missing
+ *     Billing Item, then trigger retry-failed.
+ *
+ * Mode handling:
+ *   - real: the engine marks `rated_in_bill_run_id` on records matching
+ *     the returned `matchedUoms` via a single bulk UPDATE.
+ *   - test / dry: the engine skips the UPDATE; same usage stays
+ *     consumable by a follow-up run.
+ */
+
+export type UsageRunResult = {
+  /** Invoice line descriptors ready for `writeDraftInvoice`. */
+  lines: InvoiceLineDescriptor[]
+  /**
+   * `uom_code`s the engine should mark as rated. The engine issues a
+   * single `UPDATE ... WHERE uom_code IN (matchedUoms) AND <scope>`
+   * after this returns — no id list materialisation.
+   */
+  matchedUoms: string[]
+  /** UoMs present in usage records but missing from `type=usage` items. */
+  unmatchedUoms: string[]
+  /** Count of usage records rated this cycle (for the run summary). */
+  ratedCount: number
+}
+
+const EMPTY_RESULT: UsageRunResult = {
+  lines: [],
+  matchedUoms: [],
+  unmatchedUoms: [],
+  ratedCount: 0,
+}
+
+function nonNullUomItems(items: readonly BillingItem[]): Map<string, BillingItem> {
+  const out = new Map<string, BillingItem>()
+  for (const item of items) {
+    if (item.type !== 'usage') continue
+    if (!item.isActive || item.deletedAt) continue
+    if (!item.uomCode) continue
+    out.set(item.uomCode, item)
+  }
+  return out
+}
+
+type UsageAggregateRow = {
+  uom_code: string
+  total_quantity: string
+  record_count: string
+}
+
+/**
+ * Single Postgres aggregate: bucket unrated usage records by `uom_code`,
+ * sum the quantities, count the records. Returns one row per uom — a
+ * small, bounded result set regardless of how many millions of records
+ * the account actually has.
+ *
+ * The matching index is the partial index on
+ * `(bill_account_id, uom_code, rated_in_bill_run_id, period_end)` shipped
+ * in Phase 0's migration — both the filter and the GROUP BY land on
+ * the same index.
+ */
+async function fetchUsageAggregate(
+  em: EntityManager,
+  account: BillingAccount,
+  period: BillPeriod,
+): Promise<UsageAggregateRow[]> {
+  const rows = (await em.execute(
+    `SELECT uom_code,
+            SUM(quantity)::text AS total_quantity,
+            COUNT(*)::text     AS record_count
+     FROM billing_account_usage
+     WHERE tenant_id = ?
+       AND organization_id = ?
+       AND bill_account_id = ?
+       AND deleted_at IS NULL
+       AND rated_in_bill_run_id IS NULL
+       AND period_end <= ?
+     GROUP BY uom_code`,
+    [account.tenantId, account.organizationId, account.id, period.periodEnd],
+  )) as unknown as UsageAggregateRow[] | undefined
+  return rows ?? []
+}
+
+export async function processUsageForAccount(
+  em: EntityManager,
+  account: BillingAccount,
+  period: BillPeriod,
+  usageItems: readonly BillingItem[],
+): Promise<UsageRunResult> {
+  const aggregateRows = await fetchUsageAggregate(em, account, period)
+  if (aggregateRows.length === 0) return EMPTY_RESULT
+
+  const itemByUom = nonNullUomItems(usageItems)
+
+  const lines: InvoiceLineDescriptor[] = []
+  const matchedUoms: string[] = []
+  const unmatchedUoms: string[] = []
+  let ratedCount = 0
+
+  for (const row of aggregateRows) {
+    const uom = row.uom_code
+    const totalQuantity = Number.parseFloat(row.total_quantity)
+    const recordCount = Number.parseInt(row.record_count, 10)
+
+    const item = itemByUom.get(uom)
+    if (!item) {
+      unmatchedUoms.push(uom)
+      continue
+    }
+    if (!Number.isFinite(totalQuantity) || totalQuantity === 0) continue
+
+    const rated = rateUsageForItem(item, totalQuantity)
+    if (!rated) {
+      // Malformed rate_json on a passing-validation item is rare but
+      // possible if an operator hand-edited it. Surface as unmatched
+      // so the operator knows to look rather than silently dropping
+      // revenue.
+      unmatchedUoms.push(uom)
+      continue
+    }
+
+    const isSimpleFlat = !('model' in (item.rateJson as Record<string, unknown>))
+    const unitPriceNet = isSimpleFlat
+      ? formatUnitPrice((item.rateJson as { unit_price: number }).unit_price)
+      : '0'
+    lines.push({
+      billingItemId: item.id,
+      billingType: 'usage',
+      description: item.description,
+      unitPriceNet,
+      quantity: format4dp(totalQuantity),
+      totalNetAmount: rated.amount,
+      metadataExtra: {
+        uom_code: uom,
+        usage_record_count: recordCount,
+        usage_tier_breakdown: rated.breakdown,
+      },
+    })
+    matchedUoms.push(uom)
+    ratedCount += Number.isFinite(recordCount) ? recordCount : 0
+  }
+
+  return { lines, matchedUoms, unmatchedUoms, ratedCount }
+}
+
+export { EMPTY_RESULT as __EMPTY_USAGE_RESULT }
+
+// Suppress unused-export warning for the type alias.
+export type _UsageRateAlias = UsageRate

package/src/modules/billing/migrations/Migration20260519000000_billing.ts

@@ -0,0 +1,175 @@
+import { Migration } from '@mikro-orm/migrations'
+
+/**
+ * Initial Billing module schema (XD-249 Phase 0).
+ *
+ * Frozen as hand-written. Why this is OK despite the "no hand-written
+ * migrations" rule in AGENTS.md:
+ *
+ *   - At Phase 0 (May 2026) the standalone-app build of
+ *     `@open-mercato/cli@0.6.0` did not auto-discover entities from
+ *     `@dainamite/*` workspaces, so `yarn mercato db generate` produced
+ *     an empty diff. The CLI patch shipped in this PR fixes the
+ *     resolver going forward (see `packages/cpq/scripts/cli-resolver.patch.mjs`
+ *     usage), but **regenerating THIS initial migration would mean
+ *     wiping every existing billing_* table on every tenant** to let
+ *     the CLI re-emit the same `create table` statements. That's
+ *     never safe on a live system.
+ *   - The 1:1 mapping against `packages/billing/src/modules/billing/data/entities.ts`
+ *     has been validated against production-shape data (CPQ → billing
+ *     end-to-end flow). Any subsequent schema change MUST go through
+ *     `yarn mercato db generate` — the CLI now correctly walks
+ *     workspace `@dainamite/*` packages, so future migration files
+ *     in this folder will be generated, not hand-written.
+ */
+export class Migration20260519000000_billing extends Migration {
+  async up(): Promise<void> {
+    // ─── billing_accounts ────────────────────────────────────
+    this.addSql(`create table "billing_accounts" (
+      "id" uuid not null default gen_random_uuid(),
+      "organization_id" uuid not null,
+      "tenant_id" uuid not null,
+      "customer_id" text not null,
+      "name" text not null,
+      "currency_code" text not null,
+      "bill_cycle" text not null,
+      "bill_cycle_anchor" text not null,
+      "invoice_email" text not null,
+      "invoice_language" text not null,
+      "tax_id" text null,
+      "invoice_address" jsonb not null,
+      "next_bill_date" date not null,
+      "last_bill_date" date null,
+      "is_active" boolean not null default true,
+      "created_at" timestamptz not null,
+      "updated_at" timestamptz not null,
+      "deleted_at" timestamptz null,
+      constraint "billing_accounts_pkey" primary key ("id")
+    );`)
+    this.addSql(`create index "billing_accounts_next_bill_date_idx" on "billing_accounts" ("organization_id", "tenant_id", "next_bill_date") where "deleted_at" is null;`)
+    this.addSql(`create index "billing_accounts_customer_idx" on "billing_accounts" ("organization_id", "tenant_id", "customer_id");`)
+    this.addSql(`create index "billing_accounts_sort_idx" on "billing_accounts" ("organization_id", "tenant_id", "deleted_at", "created_at");`)
+
+    // ─── billing_items ───────────────────────────────────────
+    this.addSql(`create table "billing_items" (
+      "id" uuid not null default gen_random_uuid(),
+      "organization_id" uuid not null,
+      "tenant_id" uuid not null,
+      "bill_account_id" uuid not null,
+      "type" text not null,
+      "bill_start_date" date not null,
+      "bill_end_date" date null,
+      "description" text not null,
+      "rate_json" jsonb not null,
+      "uom_code" text null,
+      "subscription_id" text null,
+      "subscription_item_id" text null,
+      "source_ref" text null,
+      "currency_mismatch" boolean not null default false,
+      "billed_to_date" date null,
+      "is_active" boolean not null default true,
+      "created_at" timestamptz not null,
+      "updated_at" timestamptz not null,
+      "deleted_at" timestamptz null,
+      constraint "billing_items_pkey" primary key ("id")
+    );`)
+    this.addSql(`alter table "billing_items" add constraint "billing_items_source_ref_unique" unique ("tenant_id", "bill_account_id", "source_ref");`)
+    this.addSql(`create index "billing_items_account_type_idx" on "billing_items" ("bill_account_id", "type");`)
+    this.addSql(`create index "billing_items_account_active_idx" on "billing_items" ("bill_account_id", "type", "is_active") where "deleted_at" is null;`)
+    this.addSql(`create index "billing_items_subscription_idx" on "billing_items" ("organization_id", "tenant_id", "subscription_id");`)
+
+    // ─── billing_account_usage ───────────────────────────────
+    this.addSql(`create table "billing_account_usage" (
+      "id" uuid not null default gen_random_uuid(),
+      "organization_id" uuid not null,
+      "tenant_id" uuid not null,
+      "bill_account_id" uuid not null,
+      "uom_code" text not null,
+      "quantity" numeric(18, 4) not null,
+      "period_start" timestamptz not null,
+      "period_end" timestamptz not null,
+      "line_description" text null,
+      "source_ref" text null,
+      "rated_in_bill_run_id" uuid null,
+      "is_active" boolean not null default true,
+      "created_at" timestamptz not null,
+      "updated_at" timestamptz not null,
+      "deleted_at" timestamptz null,
+      constraint "billing_account_usage_pkey" primary key ("id")
+    );`)
+    this.addSql(`alter table "billing_account_usage" add constraint "billing_account_usage_source_ref_unique" unique ("tenant_id", "bill_account_id", "source_ref");`)
+    this.addSql(`create index "billing_account_usage_rating_idx" on "billing_account_usage" ("bill_account_id", "uom_code", "rated_in_bill_run_id", "period_end");`)
+
+    // ─── billing_runs ────────────────────────────────────────
+    this.addSql(`create table "billing_runs" (
+      "id" uuid not null default gen_random_uuid(),
+      "organization_id" uuid not null,
+      "tenant_id" uuid not null,
+      "triggered_by" text not null,
+      "parent_run_id" uuid null,
+      "dry_run" boolean not null default false,
+      "test_mode" boolean not null default false,
+      "catch_up" boolean not null default false,
+      "scoped_account_ids" jsonb null,
+      "as_of_date" date not null,
+      "started_at" timestamptz null,
+      "finished_at" timestamptz null,
+      "status" text not null,
+      "summary" jsonb null,
+      "is_active" boolean not null default true,
+      "created_at" timestamptz not null,
+      "updated_at" timestamptz not null,
+      "deleted_at" timestamptz null,
+      constraint "billing_runs_pkey" primary key ("id")
+    );`)
+    this.addSql(`create index "billing_runs_tenant_status_idx" on "billing_runs" ("tenant_id", "status", "started_at");`)
+    this.addSql(`create index "billing_runs_parent_idx" on "billing_runs" ("parent_run_id");`)
+
+    // ─── billing_run_outcomes ────────────────────────────────
+    this.addSql(`create table "billing_run_outcomes" (
+      "id" uuid not null default gen_random_uuid(),
+      "organization_id" uuid not null,
+      "tenant_id" uuid not null,
+      "bill_run_id" uuid not null,
+      "bill_account_id" uuid not null,
+      "status" text not null,
+      "error_message" text null,
+      "warnings" jsonb null,
+      "draft_invoice_id" uuid null,
+      "is_active" boolean not null default true,
+      "created_at" timestamptz not null,
+      "updated_at" timestamptz not null,
+      "deleted_at" timestamptz null,
+      constraint "billing_run_outcomes_pkey" primary key ("id")
+    );`)
+    this.addSql(`create index "billing_run_outcomes_run_status_idx" on "billing_run_outcomes" ("bill_run_id", "status");`)
+    this.addSql(`create index "billing_run_outcomes_account_history_idx" on "billing_run_outcomes" ("organization_id", "tenant_id", "bill_account_id", "created_at");`)
+
+    // ─── billing_draft_invoice_edits ─────────────────────────
+    this.addSql(`create table "billing_draft_invoice_edits" (
+      "id" uuid not null default gen_random_uuid(),
+      "organization_id" uuid not null,
+      "tenant_id" uuid not null,
+      "invoice_id" uuid not null,
+      "invoice_line_id" uuid null,
+      "user_id" uuid not null,
+      "action" text not null,
+      "before_json" jsonb null,
+      "after_json" jsonb null,
+      "created_at" timestamptz not null,
+      "deleted_at" timestamptz null,
+      constraint "billing_draft_invoice_edits_pkey" primary key ("id")
+    );`)
+    this.addSql(`create index "billing_draft_invoice_edits_invoice_idx" on "billing_draft_invoice_edits" ("organization_id", "tenant_id", "invoice_id", "created_at");`)
+    this.addSql(`create index "billing_draft_invoice_edits_user_idx" on "billing_draft_invoice_edits" ("organization_id", "tenant_id", "user_id", "created_at");`)
+  }
+
+  async down(): Promise<void> {
+    this.addSql(`drop table if exists "billing_draft_invoice_edits" cascade;`)
+    this.addSql(`drop table if exists "billing_run_outcomes" cascade;`)
+    this.addSql(`drop table if exists "billing_runs" cascade;`)
+    this.addSql(`drop table if exists "billing_account_usage" cascade;`)
+    this.addSql(`drop table if exists "billing_items" cascade;`)
+    this.addSql(`drop table if exists "billing_accounts" cascade;`)
+  }
+}