@codelitdev/billing 0.1.0-alpha.1

package/dist/schema/pglite-sql.js

@@ -0,0 +1,226 @@
+/** Canonical DDL used by adapter conformance on PGlite. Mirrors the generator. */
+export const CANONICAL_PGLITE_SQL = `
+CREATE TABLE accounts (
+  id text PRIMARY KEY,
+  email text NOT NULL
+);
+CREATE TABLE workspaces (
+  id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+  name text NOT NULL
+);
+CREATE TABLE billing_price_entries (
+  id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+  offer_key text NOT NULL,
+  plan text NOT NULL,
+  billing_interval text NOT NULL,
+  currency text NOT NULL,
+  amount_minor integer NOT NULL,
+  provider_trial_days integer NOT NULL DEFAULT 0,
+  provider text NOT NULL,
+  provider_product_id text NOT NULL,
+  verified_at timestamptz,
+  created_at timestamptz NOT NULL DEFAULT now(),
+  updated_at timestamptz NOT NULL DEFAULT now(),
+  CONSTRAINT billing_price_entries_amount_check CHECK (amount_minor > 0),
+  CONSTRAINT billing_price_entries_trial_days_check CHECK (provider_trial_days >= 0),
+  CONSTRAINT billing_price_entries_currency_check CHECK (currency ~ '^[A-Z]{3}$'),
+  CONSTRAINT billing_price_entries_plan_check CHECK (plan IN ('pro', 'business')),
+  CONSTRAINT billing_price_entries_interval_check CHECK (billing_interval IN ('month', 'year'))
+);
+CREATE UNIQUE INDEX billing_price_entries_provider_product_uidx
+  ON billing_price_entries (provider, provider_product_id);
+CREATE TABLE billing_catalog_revisions (
+  id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+  revision integer NOT NULL UNIQUE,
+  checkout_provider text NOT NULL,
+  status text NOT NULL DEFAULT 'pending_verification',
+  verified_at timestamptz,
+  activated_at timestamptz,
+  retired_at timestamptz,
+  created_at timestamptz NOT NULL DEFAULT now(),
+  updated_at timestamptz NOT NULL DEFAULT now(),
+  CONSTRAINT billing_catalog_revisions_status_check CHECK (status IN ('pending_verification', 'active', 'retired', 'invalid', 'abandoned')),
+  CONSTRAINT billing_catalog_revisions_revision_check CHECK (revision > 0)
+);
+CREATE UNIQUE INDEX billing_catalog_revisions_active_provider_uidx
+  ON billing_catalog_revisions (checkout_provider) WHERE status = 'active';
+CREATE TABLE billing_catalog_revision_items (
+  id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+  catalog_revision_id uuid NOT NULL REFERENCES billing_catalog_revisions(id) ON DELETE CASCADE,
+  offer_key text NOT NULL,
+  billing_price_entry_id uuid NOT NULL REFERENCES billing_price_entries(id) ON DELETE RESTRICT
+);
+CREATE UNIQUE INDEX billing_catalog_revision_items_revision_key_uidx
+  ON billing_catalog_revision_items (catalog_revision_id, offer_key);
+CREATE TABLE billing_provider_customers (
+  id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+  provider text NOT NULL,
+  payer_id text NOT NULL REFERENCES accounts(id) ON DELETE RESTRICT,
+  payer_email text NOT NULL DEFAULT '',
+  provider_customer_id text,
+  idempotency_key text NOT NULL,
+  status text NOT NULL DEFAULT 'creating',
+  last_error text,
+  created_at timestamptz NOT NULL DEFAULT now(),
+  updated_at timestamptz NOT NULL DEFAULT now(),
+  CONSTRAINT billing_provider_customers_status_check CHECK (status IN ('creating', 'active', 'conflicted'))
+);
+CREATE UNIQUE INDEX billing_provider_customers_provider_payer_uidx
+  ON billing_provider_customers (provider, payer_id);
+CREATE UNIQUE INDEX billing_provider_customers_idempotency_uidx
+  ON billing_provider_customers (idempotency_key);
+CREATE TABLE billing_checkout_attempts (
+  id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+  attempt_id text NOT NULL UNIQUE,
+  billable_entity_id uuid NOT NULL REFERENCES workspaces(id) ON DELETE RESTRICT,
+  payer_id text NOT NULL REFERENCES accounts(id) ON DELETE RESTRICT,
+  payer_email text NOT NULL DEFAULT '',
+  return_url text NOT NULL DEFAULT '',
+  provider text NOT NULL,
+  catalog_revision integer NOT NULL,
+  offer_key text NOT NULL,
+  requested_plan text NOT NULL,
+  requested_interval text NOT NULL,
+  billing_price_entry_id uuid NOT NULL REFERENCES billing_price_entries(id) ON DELETE RESTRICT,
+  quoted_amount_minor integer NOT NULL,
+  quoted_currency text NOT NULL,
+  billing_customer_id uuid REFERENCES billing_provider_customers(id) ON DELETE RESTRICT,
+  provider_checkout_session_id text,
+  checkout_url_encrypted text,
+  idempotency_key text NOT NULL,
+  status text NOT NULL DEFAULT 'creating',
+  expires_at timestamptz NOT NULL,
+  last_error text,
+  completed_at timestamptz,
+  created_at timestamptz NOT NULL DEFAULT now(),
+  updated_at timestamptz NOT NULL DEFAULT now(),
+  CONSTRAINT billing_checkout_attempts_status_check CHECK (status IN ('creating', 'open', 'completed', 'expired', 'abandoned', 'conflicted')),
+  CONSTRAINT billing_checkout_attempts_amount_check CHECK (quoted_amount_minor > 0)
+);
+CREATE UNIQUE INDEX billing_checkout_attempts_idempotency_uidx
+  ON billing_checkout_attempts (idempotency_key);
+CREATE UNIQUE INDEX billing_checkout_attempts_entity_nonterminal_uidx
+  ON billing_checkout_attempts (billable_entity_id) WHERE status IN ('creating', 'open');
+CREATE TABLE billing_webhook_events (
+  id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+  provider text NOT NULL,
+  provider_event_id text NOT NULL,
+  event_type text NOT NULL,
+  occurred_at timestamptz NOT NULL,
+  subscription_id text,
+  checkout_attempt_id text,
+  payload_encrypted text,
+  payload_key_version text,
+  verified_key_version text,
+  status text NOT NULL DEFAULT 'pending',
+  processing_attempts integer NOT NULL DEFAULT 0,
+  last_error text,
+  available_at timestamptz NOT NULL DEFAULT now(),
+  locked_at timestamptz,
+  lease_expires_at timestamptz,
+  worker_id text,
+  received_at timestamptz NOT NULL DEFAULT now(),
+  processed_at timestamptz,
+  CONSTRAINT billing_webhook_events_status_check CHECK (status IN ('pending', 'processing', 'processed', 'ignored', 'quarantined', 'failed'))
+);
+CREATE UNIQUE INDEX billing_webhook_events_provider_event_uidx
+  ON billing_webhook_events (provider, provider_event_id);
+CREATE TABLE billing_subscriptions (
+  id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+  billable_entity_id uuid NOT NULL REFERENCES workspaces(id) ON DELETE RESTRICT,
+  billing_customer_id uuid NOT NULL REFERENCES billing_provider_customers(id) ON DELETE RESTRICT,
+  payer_id text NOT NULL REFERENCES accounts(id) ON DELETE RESTRICT,
+  origin_checkout_attempt_id uuid REFERENCES billing_checkout_attempts(id) ON DELETE RESTRICT,
+  provider text NOT NULL,
+  provider_subscription_id text NOT NULL,
+  provider_product_id text NOT NULL,
+  billing_price_entry_id uuid NOT NULL REFERENCES billing_price_entries(id) ON DELETE RESTRICT,
+  catalog_revision integer NOT NULL,
+  offer_key text NOT NULL,
+  plan text NOT NULL,
+  billing_interval text NOT NULL,
+  status text NOT NULL DEFAULT 'pending',
+  current_period_starts_at timestamptz,
+  current_period_ends_at timestamptz,
+  paid_through_at timestamptz,
+  trial_ends_at timestamptz,
+  cancel_at_period_end boolean NOT NULL DEFAULT false,
+  is_entitlement_source boolean NOT NULL DEFAULT false,
+  provider_occurred_at timestamptz,
+  provider_version text,
+  last_observed_at timestamptz,
+  last_reconciled_at timestamptz,
+  created_at timestamptz NOT NULL DEFAULT now(),
+  updated_at timestamptz NOT NULL DEFAULT now()
+);
+CREATE UNIQUE INDEX billing_subscriptions_provider_subscription_uidx
+  ON billing_subscriptions (provider, provider_subscription_id);
+CREATE UNIQUE INDEX billing_subscriptions_entity_source_uidx
+  ON billing_subscriptions (billable_entity_id) WHERE is_entitlement_source = true;
+CREATE TABLE billing_plan_states (
+  id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+  billable_entity_id uuid NOT NULL UNIQUE REFERENCES workspaces(id) ON DELETE RESTRICT,
+  active_subscription_id uuid REFERENCES billing_subscriptions(id) ON DELETE RESTRICT,
+  projection_version integer NOT NULL DEFAULT 0,
+  created_at timestamptz NOT NULL DEFAULT now(),
+  updated_at timestamptz NOT NULL DEFAULT now()
+);
+CREATE TABLE billing_plan_change_attempts (
+  id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+  change_id text NOT NULL UNIQUE,
+  billable_entity_id uuid NOT NULL REFERENCES workspaces(id) ON DELETE RESTRICT,
+  subscription_id uuid NOT NULL REFERENCES billing_subscriptions(id) ON DELETE RESTRICT,
+  actor_id text NOT NULL,
+  payer_id text NOT NULL REFERENCES accounts(id) ON DELETE RESTRICT,
+  provider text NOT NULL,
+  idempotency_key text NOT NULL,
+  current_catalog_revision integer NOT NULL,
+  current_billing_price_entry_id uuid NOT NULL REFERENCES billing_price_entries(id) ON DELETE RESTRICT,
+  current_plan text NOT NULL,
+  current_interval text NOT NULL,
+  target_catalog_revision integer NOT NULL,
+  target_billing_price_entry_id uuid NOT NULL REFERENCES billing_price_entries(id) ON DELETE RESTRICT,
+  target_plan text NOT NULL,
+  target_interval text NOT NULL,
+  target_offer_key text NOT NULL,
+  effective_at text NOT NULL,
+  proration_mode text NOT NULL,
+  provider_payment_id text,
+  payment_url_encrypted text,
+  status text NOT NULL DEFAULT 'creating',
+  last_error text,
+  completed_at timestamptz,
+  created_at timestamptz NOT NULL DEFAULT now(),
+  updated_at timestamptz NOT NULL DEFAULT now()
+);
+CREATE UNIQUE INDEX billing_plan_change_attempts_idempotency_uidx
+  ON billing_plan_change_attempts (idempotency_key);
+CREATE TABLE billing_reconciliation_jobs (
+  id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+  provider text NOT NULL,
+  checkout_attempt_id uuid REFERENCES billing_checkout_attempts(id) ON DELETE RESTRICT,
+  plan_change_attempt_id uuid REFERENCES billing_plan_change_attempts(id) ON DELETE RESTRICT,
+  subscription_id uuid REFERENCES billing_subscriptions(id) ON DELETE RESTRICT,
+  provider_customer_id uuid REFERENCES billing_provider_customers(id) ON DELETE RESTRICT,
+  operation text NOT NULL DEFAULT 'reconcile',
+  status text NOT NULL DEFAULT 'pending',
+  attempt_count integer NOT NULL DEFAULT 0,
+  available_at timestamptz NOT NULL DEFAULT now(),
+  locked_at timestamptz,
+  lease_expires_at timestamptz,
+  worker_id text,
+  last_error text,
+  created_at timestamptz NOT NULL DEFAULT now(),
+  updated_at timestamptz NOT NULL DEFAULT now(),
+  CONSTRAINT billing_reconciliation_jobs_exactly_one_subject CHECK (
+    ((CASE WHEN checkout_attempt_id IS NOT NULL THEN 1 ELSE 0 END)
+    + (CASE WHEN plan_change_attempt_id IS NOT NULL THEN 1 ELSE 0 END)
+    + (CASE WHEN subscription_id IS NOT NULL THEN 1 ELSE 0 END)
+    + (CASE WHEN provider_customer_id IS NOT NULL THEN 1 ELSE 0 END)) = 1
+  ),
+  CONSTRAINT billing_reconciliation_jobs_operation_check CHECK (
+    operation = 'reconcile' OR (operation = 'cancellation' AND subscription_id IS NOT NULL)
+  )
+);
+`;
+//# sourceMappingURL=pglite-sql.js.map

package/dist/schema/pglite-sql.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pglite-sql.js","sourceRoot":"","sources":["../../src/schema/pglite-sql.ts"],"names":[],"mappings":"AAAA,kFAAkF;AAClF,MAAM,CAAC,MAAM,oBAAoB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+NnC,CAAC"}

package/dist/testing/clocks.d.ts

@@ -0,0 +1,2 @@
+export { frozenClock, advancingClock, systemClock } from "../core/clock.js";
+//# sourceMappingURL=clocks.d.ts.map

package/dist/testing/clocks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clocks.d.ts","sourceRoot":"","sources":["../../src/testing/clocks.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/testing/clocks.js

@@ -0,0 +1,2 @@
+export { frozenClock, advancingClock, systemClock } from "../core/clock.js";
+//# sourceMappingURL=clocks.js.map

package/dist/testing/clocks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"clocks.js","sourceRoot":"","sources":["../../src/testing/clocks.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/testing/consumer-conformance.d.ts

@@ -0,0 +1,12 @@
+/** SendLit-shaped: paid catalog plus an application Free plan that never enters package types. */
+export declare function sendlitShapedCatalog(): {
+    applicationFreePlan: "free";
+    paidOffers: import("../catalog/types.js").BillingOffer[];
+};
+/** CourseLit-shaped: no Free plan; two independently billed entities per payer. */
+export declare function courselitShapedCatalog(): {
+    applicationFreePlan: null;
+    paidOffers: import("../catalog/types.js").BillingOffer[];
+    entitiesPerPayer: number;
+};
+//# sourceMappingURL=consumer-conformance.d.ts.map

package/dist/testing/consumer-conformance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consumer-conformance.d.ts","sourceRoot":"","sources":["../../src/testing/consumer-conformance.ts"],"names":[],"mappings":"AAEA,kGAAkG;AAClG,wBAAgB,oBAAoB;;;EAKnC;AAED,mFAAmF;AACnF,wBAAgB,sBAAsB;;;;EAMrC"}

package/dist/testing/consumer-conformance.js

@@ -0,0 +1,17 @@
+import { REFERENCE_OFFERS } from "./fixtures.js";
+/** SendLit-shaped: paid catalog plus an application Free plan that never enters package types. */
+export function sendlitShapedCatalog() {
+    return {
+        applicationFreePlan: "free",
+        paidOffers: REFERENCE_OFFERS,
+    };
+}
+/** CourseLit-shaped: no Free plan; two independently billed entities per payer. */
+export function courselitShapedCatalog() {
+    return {
+        applicationFreePlan: null,
+        paidOffers: REFERENCE_OFFERS,
+        entitiesPerPayer: 2,
+    };
+}
+//# sourceMappingURL=consumer-conformance.js.map

package/dist/testing/consumer-conformance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"consumer-conformance.js","sourceRoot":"","sources":["../../src/testing/consumer-conformance.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAEjD,kGAAkG;AAClG,MAAM,UAAU,oBAAoB;IAChC,OAAO;QACH,mBAAmB,EAAE,MAAe;QACpC,UAAU,EAAE,gBAAgB;KAC/B,CAAC;AACN,CAAC;AAED,mFAAmF;AACnF,MAAM,UAAU,sBAAsB;IAClC,OAAO;QACH,mBAAmB,EAAE,IAAI;QACzB,UAAU,EAAE,gBAAgB;QAC5B,gBAAgB,EAAE,CAAC;KACtB,CAAC;AACN,CAAC"}

package/dist/testing/fixtures.d.ts

@@ -0,0 +1,9 @@
+import type { BillingOffer } from "../catalog/types.js";
+import type { BillingActionGrant } from "../ports/authorization.js";
+import type { BillableEntityRef, PayerRef } from "../core/ids.js";
+export declare const REFERENCE_OFFERS: BillingOffer[];
+export declare const COURSELIT_OFFER_KEYS: readonly ["pro_month", "pro_year", "business_month", "business_year"];
+export declare function payer(id?: string): PayerRef;
+export declare function entity(id: string, kind?: string): BillableEntityRef;
+export declare function grant(action: BillingActionGrant["action"], targetId: string, actorId?: string, now?: Date): BillingActionGrant;
+//# sourceMappingURL=fixtures.d.ts.map

package/dist/testing/fixtures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fixtures.d.ts","sourceRoot":"","sources":["../../src/testing/fixtures.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AACpE,OAAO,KAAK,EAAE,iBAAiB,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAElE,eAAO,MAAM,gBAAgB,EAAE,YAAY,EA6C1C,CAAC;AAEF,eAAO,MAAM,oBAAoB,uEAKvB,CAAC;AAEX,wBAAgB,KAAK,CAAC,EAAE,SAAe,GAAG,QAAQ,CAEjD;AAED,wBAAgB,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,SAAc,GAAG,iBAAiB,CAExE;AAED,wBAAgB,KAAK,CACjB,MAAM,EAAE,kBAAkB,CAAC,QAAQ,CAAC,EACpC,QAAQ,EAAE,MAAM,EAChB,OAAO,SAAe,EACtB,GAAG,OAAuC,GAC3C,kBAAkB,CASpB"}

package/dist/testing/fixtures.js

@@ -0,0 +1,69 @@
+export const REFERENCE_OFFERS = [
+    {
+        key: "pro_month",
+        revision: 1,
+        plan: "pro",
+        interval: "month",
+        currency: "USD",
+        amountMinor: 4900,
+        provider: "fake",
+        providerProductId: "pdt_pro_month",
+        providerTrialDays: 14,
+    },
+    {
+        key: "pro_year",
+        revision: 1,
+        plan: "pro",
+        interval: "year",
+        currency: "USD",
+        amountMinor: 49000,
+        provider: "fake",
+        providerProductId: "pdt_pro_year",
+        providerTrialDays: 0,
+    },
+    {
+        key: "business_month",
+        revision: 1,
+        plan: "business",
+        interval: "month",
+        currency: "USD",
+        amountMinor: 19900,
+        provider: "fake",
+        providerProductId: "pdt_business_month",
+        providerTrialDays: 0,
+    },
+    {
+        key: "business_year",
+        revision: 1,
+        plan: "business",
+        interval: "year",
+        currency: "USD",
+        amountMinor: 199000,
+        provider: "fake",
+        providerProductId: "pdt_business_year",
+        providerTrialDays: 0,
+    },
+];
+export const COURSELIT_OFFER_KEYS = [
+    "pro_month",
+    "pro_year",
+    "business_month",
+    "business_year",
+];
+export function payer(id = "acct_payer") {
+    return { id, email: "payer@example.com", name: "Payer" };
+}
+export function entity(id, kind = "workspace") {
+    return { kind, id };
+}
+export function grant(action, targetId, actorId = "acct_payer", now = new Date("2026-01-01T00:00:00.000Z")) {
+    return {
+        grantId: `grant_${action}_${targetId}_${now.getTime()}`,
+        actorId,
+        action,
+        target: { kind: "workspace", id: targetId },
+        issuedAt: now,
+        expiresAt: new Date(now.getTime() + 5 * 60 * 1000),
+    };
+}
+//# sourceMappingURL=fixtures.js.map

package/dist/testing/fixtures.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fixtures.js","sourceRoot":"","sources":["../../src/testing/fixtures.ts"],"names":[],"mappings":"AAIA,MAAM,CAAC,MAAM,gBAAgB,GAAmB;IAC5C;QACI,GAAG,EAAE,WAAW;QAChB,QAAQ,EAAE,CAAC;QACX,IAAI,EAAE,KAAK;QACX,QAAQ,EAAE,OAAO;QACjB,QAAQ,EAAE,KAAK;QACf,WAAW,EAAE,IAAI;QACjB,QAAQ,EAAE,MAAM;QAChB,iBAAiB,EAAE,eAAe;QAClC,iBAAiB,EAAE,EAAE;KACxB;IACD;QACI,GAAG,EAAE,UAAU;QACf,QAAQ,EAAE,CAAC;QACX,IAAI,EAAE,KAAK;QACX,QAAQ,EAAE,MAAM;QAChB,QAAQ,EAAE,KAAK;QACf,WAAW,EAAE,KAAK;QAClB,QAAQ,EAAE,MAAM;QAChB,iBAAiB,EAAE,cAAc;QACjC,iBAAiB,EAAE,CAAC;KACvB;IACD;QACI,GAAG,EAAE,gBAAgB;QACrB,QAAQ,EAAE,CAAC;QACX,IAAI,EAAE,UAAU;QAChB,QAAQ,EAAE,OAAO;QACjB,QAAQ,EAAE,KAAK;QACf,WAAW,EAAE,KAAK;QAClB,QAAQ,EAAE,MAAM;QAChB,iBAAiB,EAAE,oBAAoB;QACvC,iBAAiB,EAAE,CAAC;KACvB;IACD;QACI,GAAG,EAAE,eAAe;QACpB,QAAQ,EAAE,CAAC;QACX,IAAI,EAAE,UAAU;QAChB,QAAQ,EAAE,MAAM;QAChB,QAAQ,EAAE,KAAK;QACf,WAAW,EAAE,MAAM;QACnB,QAAQ,EAAE,MAAM;QAChB,iBAAiB,EAAE,mBAAmB;QACtC,iBAAiB,EAAE,CAAC;KACvB;CACJ,CAAC;AAEF,MAAM,CAAC,MAAM,oBAAoB,GAAG;IAChC,WAAW;IACX,UAAU;IACV,gBAAgB;IAChB,eAAe;CACT,CAAC;AAEX,MAAM,UAAU,KAAK,CAAC,EAAE,GAAG,YAAY;IACnC,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,mBAAmB,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC;AAC7D,CAAC;AAED,MAAM,UAAU,MAAM,CAAC,EAAU,EAAE,IAAI,GAAG,WAAW;IACjD,OAAO,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC;AACxB,CAAC;AAED,MAAM,UAAU,KAAK,CACjB,MAAoC,EACpC,QAAgB,EAChB,OAAO,GAAG,YAAY,EACtB,GAAG,GAAG,IAAI,IAAI,CAAC,0BAA0B,CAAC;IAE1C,OAAO;QACH,OAAO,EAAE,SAAS,MAAM,IAAI,QAAQ,IAAI,GAAG,CAAC,OAAO,EAAE,EAAE;QACvD,OAAO;QACP,MAAM;QACN,MAAM,EAAE,EAAE,IAAI,EAAE,WAAW,EAAE,EAAE,EAAE,QAAQ,EAAE;QAC3C,QAAQ,EAAE,GAAG;QACb,SAAS,EAAE,IAAI,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,GAAG,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC;KACrD,CAAC;AACN,CAAC"}

package/dist/testing/index.d.ts

@@ -0,0 +1,7 @@
+export { runBillingProviderContract, createContractFake, } from "./provider-contract.js";
+export { createBillingFrom, createWorkflowHarness, } from "./workflow-harness.js";
+export { REFERENCE_OFFERS, COURSELIT_OFFER_KEYS, payer, entity, grant, } from "./fixtures.js";
+export { sendlitShapedCatalog, courselitShapedCatalog, } from "./consumer-conformance.js";
+export { frozenClock, advancingClock, systemClock } from "./clocks.js";
+export { decideCheckoutTransition, decideCustomerTransition, decidePlanChangeTransition, decideReconciliationTransition, decideSubscriptionTransition, decideWebhookInboxTransition, } from "./state-machine.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/testing/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/testing/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,0BAA0B,EAC1B,kBAAkB,GACrB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACH,iBAAiB,EACjB,qBAAqB,GACxB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACH,gBAAgB,EAChB,oBAAoB,EACpB,KAAK,EACL,MAAM,EACN,KAAK,GACR,MAAM,eAAe,CAAC;AACvB,OAAO,EACH,oBAAoB,EACpB,sBAAsB,GACzB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AACvE,OAAO,EACH,wBAAwB,EACxB,wBAAwB,EACxB,0BAA0B,EAC1B,8BAA8B,EAC9B,4BAA4B,EAC5B,4BAA4B,GAC/B,MAAM,oBAAoB,CAAC"}

package/dist/testing/index.js

@@ -0,0 +1,7 @@
+export { runBillingProviderContract, createContractFake, } from "./provider-contract.js";
+export { createBillingFrom, createWorkflowHarness, } from "./workflow-harness.js";
+export { REFERENCE_OFFERS, COURSELIT_OFFER_KEYS, payer, entity, grant, } from "./fixtures.js";
+export { sendlitShapedCatalog, courselitShapedCatalog, } from "./consumer-conformance.js";
+export { frozenClock, advancingClock, systemClock } from "./clocks.js";
+export { decideCheckoutTransition, decideCustomerTransition, decidePlanChangeTransition, decideReconciliationTransition, decideSubscriptionTransition, decideWebhookInboxTransition, } from "./state-machine.js";
+//# sourceMappingURL=index.js.map

package/dist/testing/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/testing/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,0BAA0B,EAC1B,kBAAkB,GACrB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACH,iBAAiB,EACjB,qBAAqB,GACxB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACH,gBAAgB,EAChB,oBAAoB,EACpB,KAAK,EACL,MAAM,EACN,KAAK,GACR,MAAM,eAAe,CAAC;AACvB,OAAO,EACH,oBAAoB,EACpB,sBAAsB,GACzB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AACvE,OAAO,EACH,wBAAwB,EACxB,wBAAwB,EACxB,0BAA0B,EAC1B,8BAA8B,EAC9B,4BAA4B,EAC5B,4BAA4B,GAC/B,MAAM,oBAAoB,CAAC"}

package/dist/testing/provider-contract.d.ts

@@ -0,0 +1,14 @@
+import type { BillingProviderAdapter } from "../providers/contract.js";
+import { FakeBillingProvider } from "../providers/fake/index.js";
+export declare function runBillingProviderContract(adapter: BillingProviderAdapter, helpers: {
+    signWebhook: FakeBillingProvider["signWebhook"];
+    simulatePayment: FakeBillingProvider["simulatePayment"];
+    productId: string;
+    otherProductId: string;
+    injectTimeoutAfter?: (mutation: "createCustomer" | "createCheckout" | "planChange" | "cancellation") => void;
+}): Promise<void>;
+export declare function createContractFake(): {
+    adapter: FakeBillingProvider;
+    helpers: Parameters<typeof runBillingProviderContract>[1];
+};
+//# sourceMappingURL=provider-contract.d.ts.map

package/dist/testing/provider-contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider-contract.d.ts","sourceRoot":"","sources":["../../src/testing/provider-contract.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AACvE,OAAO,EACH,mBAAmB,EAEtB,MAAM,4BAA4B,CAAC;AAoBpC,wBAAsB,0BAA0B,CAC5C,OAAO,EAAE,sBAAsB,EAC/B,OAAO,EAAE;IACL,WAAW,EAAE,mBAAmB,CAAC,aAAa,CAAC,CAAC;IAChD,eAAe,EAAE,mBAAmB,CAAC,iBAAiB,CAAC,CAAC;IACxD,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,kBAAkB,CAAC,EAAE,CACjB,QAAQ,EACF,gBAAgB,GAChB,gBAAgB,GAChB,YAAY,GACZ,cAAc,KACnB,IAAI,CAAC;CACb,GACF,OAAO,CAAC,IAAI,CAAC,CAyUf;AAED,wBAAgB,kBAAkB,IAAI;IAClC,OAAO,EAAE,mBAAmB,CAAC;IAC7B,OAAO,EAAE,UAAU,CAAC,OAAO,0BAA0B,CAAC,CAAC,CAAC,CAAC,CAAC;CAC7D,CAiBA"}

package/dist/testing/provider-contract.js

@@ -0,0 +1,238 @@
+import { BillingProviderError } from "../core/errors.js";
+import { FakeBillingProvider, FAKE_BILLING_WEBHOOK_KEY, } from "../providers/fake/index.js";
+function assert(condition, message) {
+    if (!condition)
+        throw new Error(message);
+}
+async function assertRejects(fn, test, message) {
+    try {
+        await fn();
+    }
+    catch (error) {
+        assert(test(error), message);
+        return;
+    }
+    throw new Error(`${message}: did not reject`);
+}
+export async function runBillingProviderContract(adapter, helpers) {
+    assert(adapter.capabilities.portalPlanChanges === false, "portalPlanChanges");
+    assert(adapter.capabilities.portalIntervalChanges === false, "portalIntervalChanges");
+    assert(adapter.capabilities.mutationRecovery.createCustomer !== "unsupported", "createCustomer recovery");
+    assert(adapter.capabilities.mutationRecovery.createCheckout !== "unsupported", "createCheckout recovery");
+    const product = await adapter.retrieveProduct(helpers.productId);
+    assert(product.provider === adapter.provider, "product provider");
+    assert(product.providerProductId === helpers.productId, "product id");
+    assert(product.amountMinor > 0, "amount");
+    assert(product.interval === "month" || product.interval === "year", "interval");
+    await assertRejects(() => adapter.retrieveProduct("pdt_unknown"), (error) => error instanceof BillingProviderError, "unknown product");
+    const customer = await adapter.createCustomer({
+        email: "payer@example.com",
+        name: "Payer",
+        idempotencyKey: "customer:contract:1",
+    });
+    const customerAgain = await adapter.createCustomer({
+        email: "payer@example.com",
+        name: "Payer",
+        idempotencyKey: "customer:contract:1",
+    });
+    assert(customerAgain.providerCustomerId === customer.providerCustomerId, "customer idempotent");
+    if (helpers.injectTimeoutAfter) {
+        helpers.injectTimeoutAfter("createCustomer");
+        const timeoutCustomerKey = "customer:contract:timeout";
+        await assertRejects(() => adapter.createCustomer({
+            email: "timeout@example.com",
+            name: "Timeout",
+            idempotencyKey: timeoutCustomerKey,
+        }), (error) => error instanceof BillingProviderError &&
+            error.code === "unavailable", "customer timeout");
+        const recoveredCustomer = await adapter.createCustomer({
+            email: "timeout@example.com",
+            name: "Timeout",
+            idempotencyKey: timeoutCustomerKey,
+        });
+        assert(/^cus_/.test(recoveredCustomer.providerCustomerId), "recovered customer id");
+        const recoveredAgain = await adapter.createCustomer({
+            email: "timeout@example.com",
+            name: "Timeout",
+            idempotencyKey: timeoutCustomerKey,
+        });
+        assert(recoveredAgain.providerCustomerId ===
+            recoveredCustomer.providerCustomerId, "customer timeout retry same id");
+    }
+    const checkout = await adapter.createCheckout({
+        productId: helpers.productId,
+        currency: product.currency,
+        customerId: customer.providerCustomerId,
+        payerEmail: "payer@example.com",
+        returnUrl: "https://app.test/billing",
+        attemptId: "bca_attempt_1",
+        catalogKey: "pro_month",
+        trialDays: 14,
+        idempotencyKey: "checkout:contract:1",
+    });
+    assert(checkout.checkoutUrl.startsWith("http"), "checkout url");
+    const checkoutAgain = await adapter.createCheckout({
+        productId: helpers.productId,
+        currency: product.currency,
+        customerId: customer.providerCustomerId,
+        payerEmail: "payer@example.com",
+        returnUrl: "https://app.test/billing",
+        attemptId: "bca_attempt_1",
+        catalogKey: "pro_month",
+        trialDays: 14,
+        idempotencyKey: "checkout:contract:1",
+    });
+    assert(checkoutAgain.providerCheckoutSessionId ===
+        checkout.providerCheckoutSessionId, "checkout idempotent");
+    if (helpers.injectTimeoutAfter) {
+        helpers.injectTimeoutAfter("createCheckout");
+        const timeoutCheckoutKey = "checkout:contract:timeout";
+        await assertRejects(() => adapter.createCheckout({
+            productId: helpers.productId,
+            currency: product.currency,
+            customerId: customer.providerCustomerId,
+            payerEmail: "payer@example.com",
+            returnUrl: "https://app.test/billing",
+            attemptId: "bca_attempt_timeout",
+            catalogKey: "pro_month",
+            trialDays: 0,
+            idempotencyKey: timeoutCheckoutKey,
+        }), (error) => error instanceof BillingProviderError &&
+            error.code === "unavailable", "checkout timeout");
+        const recoveredCheckout = await adapter.createCheckout({
+            productId: helpers.productId,
+            currency: product.currency,
+            customerId: customer.providerCustomerId,
+            payerEmail: "payer@example.com",
+            returnUrl: "https://app.test/billing",
+            attemptId: "bca_attempt_timeout",
+            catalogKey: "pro_month",
+            trialDays: 0,
+            idempotencyKey: timeoutCheckoutKey,
+        });
+        const recoveredCheckoutAgain = await adapter.createCheckout({
+            productId: helpers.productId,
+            currency: product.currency,
+            customerId: customer.providerCustomerId,
+            payerEmail: "payer@example.com",
+            returnUrl: "https://app.test/billing",
+            attemptId: "bca_attempt_timeout",
+            catalogKey: "pro_month",
+            trialDays: 0,
+            idempotencyKey: timeoutCheckoutKey,
+        });
+        assert(recoveredCheckoutAgain.providerCheckoutSessionId ===
+            recoveredCheckout.providerCheckoutSessionId, "checkout timeout retry same id");
+    }
+    const paid = await helpers.simulatePayment(checkout.providerCheckoutSessionId);
+    assert(paid.status === "trialing" || paid.status === "active", "paid status");
+    assert(paid.metadata.checkoutAttemptId === "bca_attempt_1", "attempt metadata");
+    assert(!/sendlit/.test(JSON.stringify(paid.metadata)), "no sendlit keys");
+    const retrieved = await adapter.retrieveSubscription(paid.providerSubscriptionId);
+    assert(retrieved.providerProductId === helpers.productId, "retrieved product");
+    assert(retrieved.providerCustomerId === customer.providerCustomerId, "retrieved customer");
+    assert(retrieved.observedAt instanceof Date, "observedAt");
+    if (adapter.capabilities.planChanges) {
+        if (helpers.injectTimeoutAfter) {
+            helpers.injectTimeoutAfter("planChange");
+            await assertRejects(() => adapter.changeSubscriptionPlan({
+                providerSubscriptionId: paid.providerSubscriptionId,
+                targetProviderProductId: helpers.otherProductId,
+                effectiveAt: "immediately",
+                prorationMode: "prorated_immediately",
+                idempotencyKey: "plan-change:contract:timeout",
+            }), (error) => error instanceof BillingProviderError &&
+                error.code === "unavailable", "plan change timeout");
+            const recoveredChange = await adapter.changeSubscriptionPlan({
+                providerSubscriptionId: paid.providerSubscriptionId,
+                targetProviderProductId: helpers.otherProductId,
+                effectiveAt: "immediately",
+                prorationMode: "prorated_immediately",
+                idempotencyKey: "plan-change:contract:timeout",
+            });
+            const recoveredChangeAgain = await adapter.changeSubscriptionPlan({
+                providerSubscriptionId: paid.providerSubscriptionId,
+                targetProviderProductId: helpers.otherProductId,
+                effectiveAt: "immediately",
+                prorationMode: "prorated_immediately",
+                idempotencyKey: "plan-change:contract:timeout",
+            });
+            assert(recoveredChangeAgain.providerPaymentId ===
+                recoveredChange.providerPaymentId, "plan change timeout retry same payment");
+        }
+        else {
+            const changed = await adapter.changeSubscriptionPlan({
+                providerSubscriptionId: paid.providerSubscriptionId,
+                targetProviderProductId: helpers.otherProductId,
+                effectiveAt: "immediately",
+                prorationMode: "prorated_immediately",
+                idempotencyKey: "plan-change:contract:1",
+            });
+            assert(changed.provider === adapter.provider, "plan change provider");
+        }
+        const afterChange = await adapter.retrieveSubscription(paid.providerSubscriptionId);
+        assert(afterChange.providerProductId === helpers.otherProductId, "product after change");
+    }
+    const portal = await adapter.createPortalSession({
+        customerId: customer.providerCustomerId,
+        returnUrl: "https://app.test/billing",
+    });
+    assert(portal.portalUrl.startsWith("http"), "portal url");
+    if (helpers.injectTimeoutAfter) {
+        helpers.injectTimeoutAfter("cancellation");
+        await assertRejects(() => adapter.cancelSubscription(paid.providerSubscriptionId, "cancel:contract:timeout"), (error) => error instanceof BillingProviderError &&
+            error.code === "unavailable", "cancel timeout");
+        await adapter.cancelSubscription(paid.providerSubscriptionId, "cancel:contract:timeout");
+    }
+    else {
+        await adapter.cancelSubscription(paid.providerSubscriptionId, "cancel:contract:1");
+    }
+    const cancelled = await adapter.retrieveSubscription(paid.providerSubscriptionId);
+    assert(cancelled.status === "cancelled", "cancelled");
+    const signed = helpers.signWebhook(JSON.stringify({
+        type: "subscription.updated",
+        data: {
+            subscription_id: paid.providerSubscriptionId,
+            customer_id: customer.providerCustomerId,
+            product_id: helpers.otherProductId,
+            status: "cancelled",
+            metadata: { checkoutAttemptId: "bca_attempt_1" },
+        },
+    }));
+    const event = await adapter.parseWebhook(signed);
+    assert(event.provider === adapter.provider, "envelope provider");
+    assert(event.subscriptionId === paid.providerSubscriptionId, "envelope sub");
+    assert(event.eventType === "subscription.updated", "envelope type");
+    assert(!("snapshot" in event), "envelope vs snapshot");
+    assert(Boolean(event.verifiedKeyVersion), "verified key");
+    await assertRejects(() => adapter.parseWebhook({
+        body: signed.body,
+        headers: {
+            ...signed.headers,
+            "webhook-signature": "v1,deadbeef",
+        },
+    }), (error) => error instanceof Error &&
+        /webhook_signature_invalid/.test(error.message), "bad signature");
+    const stale = helpers.signWebhook(JSON.stringify({ type: "subscription.updated", data: {} }), "evt_stale", new Date(Date.now() - 10 * 60 * 1000));
+    await assertRejects(() => adapter.parseWebhook(stale), (error) => error instanceof Error &&
+        /webhook_timestamp_stale/.test(error.message), "stale webhook");
+}
+export function createContractFake() {
+    const adapter = new FakeBillingProvider({
+        webhookKey: FAKE_BILLING_WEBHOOK_KEY,
+    });
+    adapter.seedDefaultCatalog();
+    return {
+        adapter,
+        helpers: {
+            signWebhook: adapter.signWebhook.bind(adapter),
+            simulatePayment: adapter.simulatePayment.bind(adapter),
+            productId: "pdt_pro_month",
+            otherProductId: "pdt_business_month",
+            injectTimeoutAfter: (mutation) => {
+                adapter.controls.timeoutAfter = { [mutation]: true };
+            },
+        },
+    };
+}
+//# sourceMappingURL=provider-contract.js.map