@jskit-ai/payments-core 0.1.1

package/src/server/service.js

@@ -0,0 +1,160 @@
+import { createHash } from "node:crypto";
+
+class PaymentError extends Error {
+  constructor(code, message, statusCode = 422) {
+    super(message);
+    this.code = code;
+    this.statusCode = statusCode;
+  }
+}
+const fail = (code, message, status) => { throw new PaymentError(code, message, status); };
+function reference(value) {
+  if (typeof value !== "string" || !value || value.length > 150 || ["__proto__", "constructor", "prototype"].includes(value)) fail("payment_input_invalid", "Use a nonempty business reference of at most 150 characters.");
+  return value;
+}
+function units(value) {
+  if (!Number.isSafeInteger(value) || value < 1 || value > 1e9) fail("payment_input_invalid", "Use a positive integer credit quantity, at most one billion.");
+  return value;
+}
+function timestamp(value) {
+  if (!Number.isSafeInteger(value) || value < 0) fail("payment_input_invalid", "Use an integer UTC timestamp in milliseconds.");
+  return value;
+}
+const fingerprint = (value) => createHash("sha256").update(JSON.stringify(value)).digest("hex");
+const unexpired = (lot, now) => lot.expiresAt === null || lot.expiresAt > now;
+const available = (lots, now) => lots.reduce((sum, lot) => sum + (unexpired(lot, now) ? lot.remaining : 0), 0);
+
+async function once(tx, key, input, work) {
+  const digest = fingerprint(input);
+  const previous = await tx.find(key);
+  if (previous) {
+    if (previous.digest !== digest) fail("payment_reference_conflict", "This business reference was already used with different inputs.", 409);
+    return { ...previous.result, duplicate: true };
+  }
+  const result = await work();
+  await tx.record(key, { digest, input, result });
+  return { ...result, duplicate: false };
+}
+
+async function grant(tx, { reference: id, units: quantity, expiresAt }, now) {
+  reference(id); units(quantity);
+  if (expiresAt !== null) timestamp(expiresAt);
+  return once(tx, `grant:${id}`, [quantity, expiresAt], async () => {
+    if (!Number.isSafeInteger(available(tx.state.lots, now) + quantity)) fail("payment_balance_limit", "Credit balance exceeds the supported integer range.");
+    tx.state.lots = tx.state.lots.filter((lot) => unexpired(lot, now));
+    tx.state.lots.push({ id, remaining: quantity, expiresAt });
+    return { granted: quantity, expiresAt };
+  });
+}
+
+// Server-side domain API. The application authorizes the billable subject before
+// invoking it; none of these methods is an HTTP endpoint or a browser authority.
+function createPaymentService({ store, configuration, clock = Date.now }) {
+  if (!store?.withAccount || !store?.inspect || !configuration?.plans) throw new TypeError("Supply payment storage and validated payment configuration.");
+  const plans = structuredClone(configuration.plans);
+  const environments = structuredClone(configuration.environments);
+  function checkScope(scope) {
+    const expected = environments[scope?.environment];
+    if (!expected || expected.integrationId !== scope.integrationId || expected.providerAccountId !== scope.providerAccountId) {
+      fail("payment_scope_invalid", "The payment scope does not match this environment's merchant configuration.", 403);
+    }
+  }
+
+  async function inspect(scope) {
+    checkScope(scope);
+    const state = await store.inspect(scope);
+    const now = timestamp(clock());
+    const subscriptions = Object.values(state.subscriptions);
+    const features = [...new Set(subscriptions.filter((subscription) =>
+      subscription.status === "active" && subscription.periodEnd > now && plans[subscription.planId])
+      .flatMap((subscription) => plans[subscription.planId].features))];
+    return { balance: available(state.lots, now), features, subscriptions };
+  }
+
+  async function requireFeature(scope, feature) {
+    if (!(await inspect(scope)).features.includes(feature)) fail("payment_feature_required", "Your subscription does not include this feature.", 403);
+  }
+
+  async function grantCredits(scope, input) {
+    checkScope(scope);
+    return store.withAccount(scope, (tx) => grant(tx, input, timestamp(clock())));
+  }
+
+  async function debitCredits(scope, { reference: id, units: quantity }) {
+    checkScope(scope);
+    reference(id); units(quantity);
+    return store.withAccount(scope, (tx) => once(tx, `debit:${id}`, [quantity], async () => {
+      const now = timestamp(clock());
+      if (available(tx.state.lots, now) < quantity) fail("payment_insufficient_credits", "Not enough credits for this action.", 409);
+      let remaining = quantity;
+      const allocations = [];
+      const lots = tx.state.lots.filter((lot) => unexpired(lot, now))
+        .sort((a, b) => (a.expiresAt ?? Infinity) - (b.expiresAt ?? Infinity));
+      for (const lot of lots) {
+        const taken = Math.min(remaining, lot.remaining);
+        if (!taken) continue;
+        lot.remaining -= taken;
+        remaining -= taken;
+        allocations.push({ grantId: lot.id, units: taken });
+        if (!remaining) break;
+      }
+      return { debited: quantity, allocations };
+    }));
+  }
+
+  async function refundDebit(scope, { debitReference }) {
+    checkScope(scope);
+    reference(debitReference);
+    return store.withAccount(scope, (tx) => once(tx, `refund:${debitReference}`, [debitReference], async () => {
+      const debit = await tx.find(`debit:${debitReference}`);
+      if (!debit) fail("payment_debit_missing", "No debit exists for this reference.", 404);
+      const now = timestamp(clock());
+      let restored = 0;
+      for (const allocation of debit.result.allocations) {
+        const lot = tx.state.lots.find((item) => item.id === allocation.grantId);
+        if (lot && unexpired(lot, now)) {
+          lot.remaining += allocation.units;
+          restored += allocation.units;
+        }
+      }
+      return { restored, expired: debit.result.debited - restored };
+    }));
+  }
+
+  // Called only after provider signature/account verification. Resolve customer
+  // from a server-created binding; never use a subject ID from webhook metadata.
+  // Load fresh provider facts under the account lock, so reordered events cannot
+  // overwrite newer state. A failed load rolls back the event receipt and grants.
+  async function reconcileEvent(merchantScope, { eventId, customerId, load }) {
+    checkScope(merchantScope);
+    reference(eventId); reference(customerId);
+    if (typeof load !== "function") throw new TypeError("Supply an authenticated provider reconciliation function.");
+    const subjectId = await store.resolveCustomer(merchantScope, customerId);
+    if (!subjectId) fail("payment_customer_unbound", "Bind this provider customer before processing its events.", 409);
+    const scope = { ...merchantScope, subjectId };
+    return store.withAccount(scope, (tx) => once(tx, `event:${eventId}`, [customerId], async () => {
+      const { subscription, renewal } = await load();
+      reference(subscription?.id);
+      if (!["active", "trialing", "past_due", "paused", "canceled", "unpaid", "incomplete", "incomplete_expired"].includes(subscription.status) ||
+          !Object.hasOwn(plans, subscription.planId)) fail("payment_provider_result_invalid", "Check the provider subscription and logical price binding.", 502);
+      timestamp(subscription.periodEnd);
+      tx.state.subscriptions[subscription.id] = {
+        id: subscription.id, status: subscription.status, planId: subscription.planId, periodEnd: subscription.periodEnd
+      };
+      let creditGrant = null;
+      if (renewal) {
+        reference(renewal.id);
+        timestamp(renewal.periodEnd);
+        if (!Object.hasOwn(plans, renewal.planId)) fail("payment_provider_result_invalid", "Check the renewal's logical price binding.", 502);
+        const quantity = plans[renewal.planId].renewalCredits;
+        // A provider invoice/transaction is the business key, not its delivery ID.
+        if (quantity) creditGrant = await grant(tx, { reference: `renewal:${renewal.id}`, units: quantity, expiresAt: renewal.periodEnd }, timestamp(clock()));
+      }
+      return { subscriptionId: subscription.id, creditGrant };
+    }));
+  }
+
+  return Object.freeze({ inspect, requireFeature, grantCredits, debitCredits, refundDebit, reconcileEvent });
+}
+
+export { createPaymentService, PaymentError };

package/src/server/stripe.js

@@ -0,0 +1,138 @@
+import Stripe from "stripe";
+import { PaymentError } from "./service.js";
+
+const id = (value) => typeof value === "string" ? value : value?.id;
+const invalid = () => { throw new PaymentError("payment_provider_result_invalid", "Check the Stripe account, price mapping and subscription shape.", 502); };
+
+function createStripePaymentAdapter({ apiKey, webhookSecret, environment, providerAccountId, priceBindings, historicalPriceBindings = {}, client = new Stripe(apiKey, { maxNetworkRetries: 0 }) }) {
+  if (!["sandbox", "live"].includes(environment) || typeof webhookSecret !== "string" || !webhookSecret || !providerAccountId) throw new TypeError("Supply Stripe credentials, environment and account identity.");
+  const live = environment === "live";
+  const prices = structuredClone(priceBindings);
+  const planFor = (priceId) => {
+    const matches = Object.entries(prices).filter(([, value]) => value === priceId);
+    if (!matches.length && Object.hasOwn(historicalPriceBindings, priceId)) return historicalPriceBindings[priceId];
+    if (matches.length !== 1) invalid();
+    return matches[0][0];
+  };
+  function validatePlan(planId) {
+    if (!Object.hasOwn(prices, planId)) throw new PaymentError("payment_plan_unknown", "Select a published payment plan.");
+  }
+  async function verifyAccount() {
+    const account = await client.accounts.retrieve();
+    const balance = await client.balance.retrieve();
+    if (account.id !== providerAccountId || balance.livemode !== live) invalid();
+    return { accountId: account.id, environment, chargesEnabled: account.charges_enabled === true, payoutsEnabled: account.payouts_enabled === true };
+  }
+  async function verifyEvent(rawBody, signature) {
+    if (!Buffer.isBuffer(rawBody)) throw new PaymentError("payment_signature_invalid", "Supply the unmodified webhook request bytes.", 400);
+    let event;
+    try { event = client.webhooks.constructEvent(rawBody, signature, webhookSecret); }
+    catch { throw new PaymentError("payment_signature_invalid", "Stripe webhook verification failed.", 400); }
+    if (event.livemode !== live || (event.account && event.account !== providerAccountId)) invalid();
+    return event;
+  }
+  function eventIdentity(event) {
+    if (["invoice.paid", "invoice.payment_failed", "invoice.payment_action_required"].includes(event.type)) {
+      const invoice = event.data?.object;
+      // A signed standalone invoice has no subscription parent. Ignore it before
+      // looking up an app customer; it does not belong to this billing contract.
+      if (invoice?.parent === null) return null;
+      if (!id(invoice?.parent?.subscription_details?.subscription)) invalid();
+    } else if (!event.type?.startsWith("customer.subscription.")) return null;
+    const customerId = id(event.data?.object?.customer);
+    if (!event.id || !customerId) invalid();
+    return { eventId: event.id, customerId };
+  }
+  async function loadEvent(event) {
+    await verifyAccount();
+    let invoice = null;
+    let subscriptionId;
+    if (["invoice.paid", "invoice.payment_failed", "invoice.payment_action_required"].includes(event.type)) {
+      invoice = await client.invoices.retrieve(event.data.object.id);
+      subscriptionId = id(invoice.parent?.subscription_details?.subscription);
+      if (!subscriptionId) return null;
+    } else if (event.type.startsWith("customer.subscription.")) {
+      subscriptionId = event.data.object.id;
+    } else return null;
+    const subscription = await client.subscriptions.retrieve(subscriptionId);
+    if (subscription.livemode !== live || subscription.items?.has_more || subscription.items?.data?.length !== 1) invalid();
+    const item = subscription.items.data[0];
+    if (item.quantity !== 1) invalid();
+    const result = {
+      subscription: { id: subscription.id, status: subscription.status, planId: planFor(item.price.id), periodEnd: item.current_period_end * 1000 }
+    };
+    if (invoice && (invoice.livemode !== live || id(invoice.customer) !== id(subscription.customer))) invalid();
+    if (invoice?.status === "paid" && ["subscription_create", "subscription_cycle"].includes(invoice.billing_reason)) {
+      if (invoice.lines?.has_more || invoice.lines?.data?.length !== 1) invalid();
+      const line = invoice.lines.data[0];
+      if (line.quantity !== 1 || line.parent?.subscription_item_details?.proration !== false) invalid();
+      result.renewal = { id: invoice.id, planId: planFor(id(line.pricing?.price_details?.price)), periodEnd: line.period.end * 1000 };
+    }
+    return { customerId: id(subscription.customer), ...result };
+  }
+  async function createCustomer({ email, requestId }) {
+    await verifyAccount();
+    const customer = await client.customers.create({ email }, { idempotencyKey: requestId });
+    return customer.id;
+  }
+  async function createCheckout({ customerId, planId, returnUrl, requestId }) {
+    if (!Object.hasOwn(prices, planId)) throw new PaymentError("payment_plan_unknown", "Select a published payment plan.");
+    await verifyAccount();
+    const result = await client.checkout.sessions.create({ mode: "subscription", customer: customerId,
+      line_items: [{ price: prices[planId], quantity: 1 }], success_url: returnUrl, cancel_url: returnUrl
+    }, { idempotencyKey: requestId });
+    if (typeof result.url !== "string") invalid();
+    return { id: result.id, url: result.url };
+  }
+  async function createPortal({ customerId, returnUrl }) {
+    await verifyAccount();
+    const result = await client.billingPortal.sessions.create({ customer: customerId, return_url: returnUrl });
+    return { id: result.id, url: result.url };
+  }
+  async function readHistory({ customerId, collection, after = null }) {
+    if (!["subscriptions", "transactions"].includes(collection)) throw new PaymentError("payment_input_invalid", "Select a billing history collection.");
+    await verifyAccount();
+    const query = { customer: customerId, limit: 20, ...(after ? { starting_after: after } : {}) };
+    const page = collection === "subscriptions"
+      ? await client.subscriptions.list({ ...query, status: "all" })
+      : await client.invoices.list(query);
+    if (!Array.isArray(page.data) || page.data.length > 20 || typeof page.has_more !== "boolean" || (page.has_more && !page.data.length)) invalid();
+    const items = page.data.map((value) => {
+      if (id(value.customer) !== customerId || value.livemode !== live || typeof value.id !== "string" ||
+        typeof value.status !== "string" || !Number.isSafeInteger(value.created)) invalid();
+      const base = { id: value.id, kind: collection === "subscriptions" ? "subscription" : "invoice",
+        status: value.status, createdAt: new Date(value.created * 1000).toISOString() };
+      if (collection === "subscriptions") return base;
+      if (!Number.isSafeInteger(value.total) || !Number.isSafeInteger(value.amount_paid) ||
+        typeof value.currency !== "string" || !/^[a-z]{3}$/.test(value.currency)) invalid();
+      return { ...base, currency: value.currency.toUpperCase(), totalMinor: String(value.total), paidMinor: String(value.amount_paid) };
+    });
+    return { collection, items, nextCursor: page.has_more ? items.at(-1).id : null };
+  }
+  async function readProduct(productId) {
+    await verifyAccount();
+    const value = await client.products.retrieve(productId);
+    return { id: value.id, name: value.name };
+  }
+  async function createProduct({ name, requestId }) {
+    await verifyAccount();
+    return client.products.create({ name }, { idempotencyKey: requestId });
+  }
+  async function renameProduct({ id, name, requestId }) {
+    await verifyAccount();
+    return client.products.update(id, { name }, { idempotencyKey: requestId });
+  }
+  async function readPrice(priceId) {
+    await verifyAccount();
+    const value = await client.prices.retrieve(priceId);
+    if (value.recurring?.interval_count !== 1 || value.billing_scheme !== "per_unit") invalid();
+    return { id: value.id, productId: id(value.product), amount: value.unit_amount, currency: value.currency.toUpperCase(), interval: value.recurring.interval, active: value.active };
+  }
+  async function createPrice({ productId, amount, currency, interval, requestId }) {
+    await verifyAccount();
+    return client.prices.create({ product: productId, unit_amount: amount, currency: currency.toLowerCase(), recurring: { interval } }, { idempotencyKey: requestId });
+  }
+  return Object.freeze({ validatePlan, verifyAccount, verifyEvent, eventIdentity, loadEvent, createCustomer, createCheckout, createPortal, readHistory, readProduct, createProduct, renameProduct, readPrice, createPrice });
+}
+
+export { createStripePaymentAdapter };

package/src/shared/configuration.js

@@ -0,0 +1,40 @@
+import Ajv from "ajv";
+import schema from "../../contracts/configuration.schema.json" with { type: "json" };
+
+const validate = new Ajv({ allErrors: true, strict: true }).compile(schema);
+
+function validatePaymentConfiguration(document) {
+  const value = document?.extensions?.payments;
+  if (!validate(value)) {
+    const error = new Error("Check the application's payment configuration.");
+    error.code = "payment_configuration_invalid";
+    error.statusCode = 422;
+    error.fieldErrors = validate.errors.map(({ instancePath, message }) => ({ path: `extensions.payments${instancePath}`, message }));
+    throw error;
+  }
+  for (const [environment, binding] of Object.entries(value.environments)) {
+    const slot = document.integrations?.[binding.integrationId];
+    const path = `extensions.payments/environments/${environment}`;
+    const fieldErrors = [];
+    if (!slot || !["stripe", "paddle"].includes(slot.provider) || slot.accountMode !== "shared" ||
+        slot.authentication?.method !== "api-key" || !/^env:[A-Z_][A-Z0-9_]*$/.test(slot.authentication.secretRef || "")) {
+      fieldErrors.push({ path: `${path}/integrationId`, message: `Select a shared Stripe or Paddle connection with a backend API-key Env reference for ${environment}.` });
+    }
+    if (slot?.provider === "paddle") {
+      if (slot.settings?.environment !== environment) fieldErrors.push({ path: `${path}/integrationId`, message: `Select a Paddle connection configured for ${environment}.` });
+      if (!binding.taxCategory) fieldErrors.push({ path: `${path}/taxCategory`, message: "Choose the Paddle tax category for the products this app sells." });
+      if (!binding.publicClientTokenRef) fieldErrors.push({ path: `${path}/publicClientTokenRef`, message: "Set the Env reference for this environment's Paddle public client token." });
+    }
+    if (fieldErrors.length) {
+      const error = new Error(fieldErrors[0].message);
+      error.code = "payment_configuration_invalid";
+      error.statusCode = 422;
+      error.fieldErrors = fieldErrors;
+      throw error;
+    }
+  }
+  // The validated declaration is JSON data; callers may supply reactive proxies.
+  return JSON.parse(JSON.stringify(value));
+}
+
+export { validatePaymentConfiguration };

package/test/catalogue.test.js

@@ -0,0 +1,112 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import knex from 'knex';
+import migration from '../migrations/payments_core_initial.cjs';
+import { createKnexPaymentStore } from '../src/server/knexStore.js';
+import { createPaymentCatalogue } from '../src/server/catalogue.js';
+
+const scope = { applicationId: 'app', integrationId: 'billing', providerAccountId: 'acct_a', environment: 'sandbox' };
+const config = { environments: { sandbox: { integrationId: 'billing', providerAccountId: 'acct_a' } }, plans: {
+  pro: { name: 'Pro', amount: 1200, currency: 'USD', interval: 'month', features: [], renewalCredits: 10 }
+} };
+
+test('reviewed catalogue publication preserves IDs, handles drift, and recovers a partial write', async () => {
+  const db = knex({ client: 'better-sqlite3', connection: { filename: ':memory:' }, useNullAsDefault: true, pool: { min: 1, max: 1 } });
+  await migration.up(db);
+  const store = createKnexPaymentStore({ knex: db });
+  const products = new Map(); const prices = new Map();
+  let writes = 0; let failPrice = false;
+  const adapter = {
+    async createProduct({ name }) { const value = { id: `product-${products.size}`, name }; products.set(value.id, value); writes++; return value; },
+    async renameProduct({ id, name }) { const value = { id, name }; products.set(id, value); writes++; return value; },
+    async readProduct(id) { return products.get(id); },
+    async createPrice(input) {
+      const value = { ...input, active: true, id: `price-${prices.size}` }; prices.set(value.id, value); writes++;
+      assert.equal((await store.inspectCatalogue(scope)).pending.action, 'create-price');
+      if (failPrice) throw new Error('response lost after provider accepted price');
+      return value;
+    },
+    async readPrice(id) { return prices.get(id); }
+  };
+  const make = (configuration = config) => createPaymentCatalogue({ store, adapter, scope, configuration });
+  try {
+    const first = await make().preview();
+    assert.deepEqual(first.changes.map((item) => item.action), ['create-product', 'create-price']);
+    assert.equal(writes, 0);
+    await assert.rejects(make().publish({ reviewId: 'stale' }), { code: 'payment_catalogue_review_required' });
+    await make().publish({ reviewId: first.reviewId });
+    const stable = await make().preview();
+    assert.deepEqual(stable.changes, []);
+    await make().publish({ reviewId: stable.reviewId });
+    assert.equal(writes, 2);
+    const changed = structuredClone(config); changed.plans.pro.amount = 1500;
+    failPrice = true;
+    const review = await make(changed).preview();
+    await assert.rejects(make(changed).publish({ reviewId: review.reviewId }), { code: 'payment_catalogue_uncertain' });
+    const pending = await make(changed).preview();
+    assert.equal(pending.pending.action, 'create-price');
+    await assert.rejects(make(changed).publish({ reviewId: pending.reviewId }), { code: 'payment_catalogue_review_required' });
+    assert.equal(writes, 3);
+    await assert.rejects(make(changed).recover({ reviewId: pending.reviewId, providerId: 'price-0' }), { code: 'payment_catalogue_review_required' });
+    await assert.rejects(make(changed).recover({ reviewId: review.reviewId, providerId: 'price-1' }), { code: 'payment_catalogue_review_required' });
+    prices.get('price-1').active = false;
+    await assert.rejects(make(changed).recover({ reviewId: pending.reviewId, providerId: 'price-1' }), { code: 'payment_catalogue_review_required' });
+    prices.get('price-1').active = true;
+    await make(changed).recover({ reviewId: pending.reviewId, providerId: 'price-1' });
+    const state = await store.inspectCatalogue(scope);
+    assert.equal(state.plans.pro.priceId, 'price-1');
+    assert.equal(state.history[0].priceId, 'price-0');
+    assert.deepEqual((await make(changed).preview()).changes, []);
+    prices.get('price-1').active = false;
+    const drift = await make(changed).preview();
+    assert.equal(drift.drift.length, 1);
+    await assert.rejects(make(changed).publish({ reviewId: drift.reviewId }), { code: 'payment_catalogue_review_required' });
+    assert.deepEqual((await store.inspectCatalogue({ ...scope, environment: 'live' })).plans, {});
+  } finally { await migration.down(db); await db.destroy(); }
+});
+
+test('sandbox and live publish independently and cannot reuse each other’s review', async () => {
+  const db = knex({ client: 'better-sqlite3', connection: { filename: ':memory:' }, useNullAsDefault: true, pool: { min: 1, max: 1 } });
+  await migration.up(db);
+  const store = createKnexPaymentStore({ knex: db });
+  const configuration = structuredClone(config);
+  configuration.environments.live = { integrationId: 'billing-live', providerAccountId: 'acct_live' };
+  const liveScope = { ...scope, environment: 'live', ...configuration.environments.live };
+  const writes = [];
+  const services = {};
+  for (const selected of [scope, liveScope]) {
+    const objects = new Map();
+    const save = (kind, input) => {
+      const value = { ...input, id: `${selected.environment}-${kind}`, active: true };
+      objects.set(value.id, value);
+      writes.push(value.id);
+      return value;
+    };
+    services[selected.environment] = createPaymentCatalogue({ store, scope: selected, configuration, adapter: {
+      async createProduct(input) { return save('product', input); },
+      async createPrice(input) { return save('price', input); },
+      async readProduct(id) { return objects.get(id); },
+      async readPrice(id) { return objects.get(id); }
+    } });
+  }
+  try {
+    const sandboxReview = await services.sandbox.preview();
+    const liveReview = await services.live.preview();
+    assert.notEqual(sandboxReview.reviewId, liveReview.reviewId);
+    await assert.rejects(services.live.publish({ reviewId: sandboxReview.reviewId }), { code: 'payment_catalogue_review_required' });
+    assert.deepEqual(writes, []);
+    await services.sandbox.publish({ reviewId: sandboxReview.reviewId });
+    const sandboxState = await store.inspectCatalogue(scope);
+    assert.deepEqual((await store.inspectCatalogue(liveScope)).plans, {});
+    await services.live.publish({ reviewId: liveReview.reviewId });
+    assert.deepEqual(await store.inspectCatalogue(scope), sandboxState);
+    assert.equal(sandboxState.plans.pro.priceId, 'sandbox-price');
+    assert.equal((await store.inspectCatalogue(liveScope)).plans.pro.priceId, 'live-price');
+    for (const service of Object.values(services)) {
+      const review = await service.preview();
+      assert.deepEqual(review.changes, []);
+      await service.publish({ reviewId: review.reviewId });
+    }
+    assert.deepEqual(writes, ['sandbox-product', 'sandbox-price', 'live-product', 'live-price']);
+  } finally { await migration.down(db); await db.destroy(); }
+});