@tollwyn/baukasten 1.2.3 → 1.3.1

package/dist/server/accounts.d.ts

@@ -102,10 +102,11 @@ export declare function createAccounts(db: Db, secrets: Secrets): {
     resetPassword(token: string, password: string): Promise<string | null>;
     /**
      * Makes the confirmed address the address of the account and voids every other open link of
-     * the account, so that links sent to the old address stop working. An address another account
-     * took in between leaves the link unused.
+     * the account, so that links sent to the old address stop working. `follow` brings the address
+     * to Stripe in the same transaction: when it fails, nothing changed and the link still holds.
+     * An address another account took in between leaves the link unused.
      */
-    confirmEmailChange(token: string): Promise<EmailChange>;
+    confirmEmailChange(token: string, follow: (tx: Queryable, accountId: string, email: string) => Promise<void>): Promise<EmailChange>;
     createApiKey: (accountId: string, name: string, prefix: string) => Promise<{
         key: string;
         apiKey: ApiKey;
@@ -119,8 +120,8 @@ export declare function createAccounts(db: Db, secrets: Secrets): {
     } | null>;
     /**
      * Deletes what is personal in one transaction: first the data of the product through its hook,
-     * then sessions, links and keys; the row stays without address and password, for the numbers
-     * and the books. A failing hook changes nothing.
+     * then sessions, links, keys and an open Checkout; the row stays without address and password,
+     * for the numbers and the books. A failing hook changes nothing.
      */
     delete: (accountId: string, hook: DeleteHook) => Promise<void>;
     /** Removes expired sessions and links; it runs on login, never on a timer. */

package/dist/server/accounts.js

@@ -211,10 +211,11 @@ export function createAccounts(db, secrets) {
         },
         /**
          * Makes the confirmed address the address of the account and voids every other open link of
-         * the account, so that links sent to the old address stop working. An address another account
-         * took in between leaves the link unused.
+         * the account, so that links sent to the old address stop working. `follow` brings the address
+         * to Stripe in the same transaction: when it fails, nothing changed and the link still holds.
+         * An address another account took in between leaves the link unused.
          */
-        async confirmEmailChange(token) {
+        async confirmEmailChange(token, follow) {
             try {
                 return await db.transaction(async (tx) => {
                     const use = await consume(tx, token, 'change_email');
@@ -225,6 +226,7 @@ export function createAccounts(db, secrets) {
                     await tx.query('DELETE FROM baukasten.links WHERE account_id = $1 AND used_at IS NULL', [
                         use.accountId
                     ]);
+                    await follow(tx, use.accountId, use.newEmail);
                     return {
                         kind: 'changed',
                         accountId: use.accountId,
@@ -259,15 +261,15 @@ export function createAccounts(db, secrets) {
         },
         /**
          * Deletes what is personal in one transaction: first the data of the product through its hook,
-         * then sessions, links and keys; the row stays without address and password, for the numbers
-         * and the books. A failing hook changes nothing.
+         * then sessions, links, keys and an open Checkout; the row stays without address and password,
+         * for the numbers and the books. A failing hook changes nothing.
          */
         delete: (accountId, hook) => db.transaction(async (tx) => {
             // The webhook of Stripe locks the account as well: one that comes now waits, and then
             // finds it deleted, instead of writing data of the product to it.
             await tx.query('SELECT 1 FROM baukasten.accounts WHERE id = $1 FOR UPDATE', [accountId]);
             await hook(tx, accountId);
-            for (const table of ['sessions', 'links', 'api_keys']) {
+            for (const table of ['sessions', 'links', 'api_keys', 'checkouts']) {
                 await tx.query(`DELETE FROM baukasten.${table} WHERE account_id = $1`, [accountId]);
             }
             await tx.query(`UPDATE baukasten.accounts SET email = NULL, password_hash = NULL,

package/dist/server/adapter/migrate.js

@@ -61,6 +61,9 @@ class MigrationError extends Error {
 }
 export async function migrate(databaseUrl, sources) {
     const client = new pg.Client({ connectionString: databaseUrl });
+    // A broken connection rejects the query that runs and every one after it, which reports it; the
+    // event of the client says the same, and without a listener it would end the process first.
+    client.on('error', () => undefined);
     await client.connect();
     const db = {
         query: async (sql, params) => (await client.query(sql, params)).rows
@@ -95,6 +98,7 @@ export async function migrate(databaseUrl, sources) {
         await client.end();
     }
 }
+const reasonOf = (error) => (error instanceof Error ? error.message : String(error));
 async function apply(client, layer, file) {
     await client.query('BEGIN');
     try {
@@ -106,8 +110,17 @@ async function apply(client, layer, file) {
         await client.query('COMMIT');
     }
     catch (error) {
-        await client.query('ROLLBACK');
-        const reason = error instanceof Error ? error.message : String(error);
-        throw new MigrationError(`${layer} migration ${file.name} failed: ${reason}`, { cause: error });
+        const failed = `${layer} migration ${file.name} failed: ${reasonOf(error)}`;
+        try {
+            await client.query('ROLLBACK');
+        }
+        catch (rollback) {
+            // The connection broke with the file: the server ends the transaction with it, and the error
+            // of the file is the one that says why.
+            throw new MigrationError(`${failed}; its rollback failed as well: ${reasonOf(rollback)}`, {
+                cause: error
+            });
+        }
+        throw new MigrationError(failed, { cause: error });
     }
 }

package/dist/server/adapter/stripe.js

@@ -24,6 +24,11 @@ async function call(what, request) {
         throw error;
     }
 }
+/**
+ * Stripe writes a currency in small letters, the baukasten and its catalog write its code, like CHF:
+ * here, coming in, and in small letters again on the way out.
+ */
+const codeOf = (currency) => currency.toUpperCase();
 const isMissing = (error) => error instanceof StripeFailed && error.kind === 'resource_missing';
 const idOf = (value) => (typeof value === 'string' ? value : value.id);
 function priceOf(price) {
@@ -31,7 +36,7 @@ function priceOf(price) {
         id: price.id,
         product: idOf(price.product),
         amount: price.unit_amount,
-        currency: price.currency
+        currency: codeOf(price.currency)
     };
     return price.recurring === null
         ? { ...base, type: 'one_time' }
@@ -110,7 +115,7 @@ function sessionOf(raw) {
             customerId: customer,
             paid: raw.payment_status === 'paid',
             amount: raw.amount_total,
-            currency: raw.currency,
+            currency: codeOf(raw.currency),
             product,
             lookupKey
         };
@@ -145,7 +150,7 @@ function eventOf(payload) {
                     id: invoice.id,
                     customerId: invoice.customer,
                     amount: invoice.amount_paid,
-                    currency: invoice.currency,
+                    currency: codeOf(invoice.currency),
                     // A paid invoice has its time of payment; the event is as late.
                     paidAt: at(invoice.status_transitions.paid_at ?? event.created)
                 }
@@ -188,7 +193,7 @@ export function createStripe(config) {
         async createPrice(price) {
             const created = await call('creating a price', () => stripe.prices.create({
                 product: price.product,
-                currency: price.currency,
+                currency: price.currency.toLowerCase(),
                 unit_amount: price.amount,
                 lookup_key: price.lookupKey,
                 transfer_lookup_key: true,
@@ -227,13 +232,19 @@ export function createStripe(config) {
         async updateCustomerEmail(customerId, email) {
             await call('updating a customer', () => stripe.customers.update(customerId, { email }));
         },
-        async subscriptionsOf(customerId) {
-            const { data } = await call('reading subscriptions', () => stripe.subscriptions.list({ customer: customerId, status: 'all', limit: 100 }));
-            return data.map((subscription) => ({
-                id: subscription.id,
-                status: statusOf(subscription.status)
-            }));
-        },
+        subscriptionsOf: (customerId) => call('reading subscriptions', async () => {
+            const all = [];
+            // Page by page: the list gives at most 100 at a time.
+            const pages = stripe.subscriptions.list({
+                customer: customerId,
+                status: 'all',
+                limit: 100
+            });
+            for await (const subscription of pages) {
+                all.push({ id: subscription.id, status: statusOf(subscription.status) });
+            }
+            return all;
+        }),
         async subscription(id) {
             const found = await call('reading a subscription', () => stripe.subscriptions.retrieve(id));
             // The baukasten opens subscriptions of one price; the first item is that price.
@@ -305,7 +316,19 @@ export function createStripe(config) {
             }));
             if (session.url === null)
                 throw new StripeFailed('no_url', 'stripe: Checkout gave no address');
-            return session.url;
+            return { id: session.id, url: session.url };
+        },
+        async retireCheckout(id) {
+            const { status } = await call('reading Checkout', () => stripe.checkout.sessions.retrieve(id));
+            if (status === 'complete')
+                return 'complete';
+            if (status === 'open') {
+                await call('ending Checkout', () => stripe.checkout.sessions.expire(id));
+            }
+            else if (status !== 'expired') {
+                throw new StripeFailed('unexpected_status', `stripe: a Checkout with the status ${String(status)}`);
+            }
+            return 'expired';
         },
         async createPortalSession(session) {
             const created = await call('opening the customer portal', () => stripe.billingPortal.sessions.create({

package/dist/server/baukasten-migrations.js

@@ -121,6 +121,23 @@ CREATE TABLE baukasten.purchases (
 	paid_at timestamptz NOT NULL
 );
 CREATE INDEX purchases_account ON baukasten.purchases (account_id);
+`
+    },
+    {
+        // The version before neither reads nor writes the table; it deletes accounts of the test mode
+        // without knowing it, so a row goes with its account.
+        name: '004_open_checkouts.sql',
+        sql: `-- The open Checkout of a subscription of an account, with the price at Stripe and the quantity it
+-- was opened for: a second click gets the same page instead of a second subscription. The webhook
+-- removes it once it is paid; one for another price or quantity replaces it.
+CREATE TABLE baukasten.checkouts (
+	account_id uuid PRIMARY KEY REFERENCES baukasten.accounts (id) ON DELETE CASCADE,
+	session text NOT NULL UNIQUE,
+	url text NOT NULL,
+	price text NOT NULL,
+	quantity integer NOT NULL CHECK (quantity >= 1),
+	expires_at timestamptz NOT NULL
+);
 `
     }
 ];

package/dist/server/billing.d.ts

@@ -75,8 +75,8 @@ export interface Billing {
     receive(payload: string, signature: string | null): Promise<Received>;
     /** Ends every subscription of the account at once, as when it is deleted. */
     endSubscriptions(accountId: string): Promise<void>;
-    /** Receipts and invoices follow a new login address. */
-    followEmail(accountId: string, email: string): Promise<void>;
+    /** Receipts and invoices follow a new login address; `q` is the transaction of the change. */
+    followEmail(q: Queryable, accountId: string, email: string): Promise<void>;
 }
 /** Billing without Stripe, locally: an account that is no customer has nothing to end or follow. */
 export declare function noBilling(db: Queryable): Billing;

package/dist/server/billing.js

@@ -10,8 +10,10 @@ export class StripeFailed extends Error {
 }
 const ENDED = ['canceled', 'incomplete_expired'];
 const running = (status) => !ENDED.includes(status);
-/** Stripe keeps a Checkout open for at least this long; one from another tab expires soon after. */
+/** Stripe keeps a Checkout open for at least 30 minutes. */
 const CHECKOUT_OPEN_MS = 31 * 60_000;
+/** An open Checkout goes to a second click only while this much of it is left to pay in. */
+const CHECKOUT_LEFT_MS = 10 * 60_000;
 const OWN_PATH = /^\/(?!\/)[^\s\\]*$/;
 function ownPath(path, what) {
     if (!OWN_PATH.test(path))
@@ -28,8 +30,8 @@ async function customerOf(db, accountId) {
 }
 /** Billing without Stripe, locally: an account that is no customer has nothing to end or follow. */
 export function noBilling(db) {
-    const without = async (accountId) => {
-        if ((await customerOf(db, accountId)).id !== null) {
+    const without = async (q, accountId) => {
+        if ((await customerOf(q, accountId)).id !== null) {
             throw new Error(`the account is a customer at Stripe, but ${NOT_CONFIGURED}`);
         }
     };
@@ -38,13 +40,13 @@ export function noBilling(db) {
         portal: () => Promise.reject(new Error(NOT_CONFIGURED)),
         hasCustomer: async (accountId) => (await customerOf(db, accountId)).id !== null,
         receive: () => Promise.reject(new Error(NOT_CONFIGURED)),
-        endSubscriptions: without,
-        followEmail: without
+        endSubscriptions: (accountId) => without(db, accountId),
+        followEmail: (q, accountId) => without(q, accountId)
     };
 }
 export function createBilling(options) {
     const { db, stripe, catalog, shop, mode, hooks, log, now } = options;
-    const currency = catalog.currency.toLowerCase();
+    const { currency } = catalog;
     const prices = new Map(pricesOf(catalog).map((price) => [price.lookupKey, price]));
     const products = new Map(catalog.products.map((product) => [product.id, product]));
     const priceIds = new Map();
@@ -76,13 +78,13 @@ export function createBilling(options) {
      * one first: the stored one wins. An account that gets its customer with the live key is live from
      * then on; one from the test mode has customers of the test mode only.
      */
-    async function customer(account) {
+    async function customer(q, account) {
         // A customer of the other mode is out of reach of this key: Stripe says so loudly.
-        const known = (await customerOf(db, account.id)).id;
+        const known = (await customerOf(q, account.id)).id;
         if (known !== null)
             return known;
         const created = await stripe.createCustomer({ email: account.email, accountId: account.id });
-        const [row] = await db.query(`UPDATE baukasten.accounts SET
+        const [row] = await q.query(`UPDATE baukasten.accounts SET
 				stripe_mode = CASE WHEN stripe_customer_id IS NULL AND $3 THEN 'live' ELSE stripe_mode END,
 				stripe_customer_id = coalesce(stripe_customer_id, $2)
 			 WHERE id = $1 AND deleted_at IS NULL
@@ -91,6 +93,55 @@ export function createBilling(options) {
             throw new Error('the account was deleted');
         return row.stripe_customer_id;
     }
+    /** The Checkout of a subscription that each account waits for in this process. */
+    const checkouts = new Map();
+    /**
+     * Opens the Checkouts of an account in this process one after the other, each in a transaction of
+     * its own: a click that waits for another holds no connection of the pool, and the lock of the
+     * account row still orders those of another process.
+     */
+    function inTurn(accountId, open) {
+        const before = checkouts.get(accountId) ?? Promise.resolve(null);
+        // Whatever became of the one before, its caller has it; this one runs after it.
+        const mine = before.then(open, open);
+        checkouts.set(accountId, mine);
+        const done = () => {
+            if (checkouts.get(accountId) === mine)
+                checkouts.delete(accountId);
+        };
+        void mine.then(done, done);
+        return mine;
+    }
+    /**
+     * A Checkout of a subscription, under the lock of the account: a second click gets the page of the
+     * first, so that only one can be paid, and one for another price or quantity ends the open one
+     * first. A running subscription gets none; the customer portal changes it.
+     */
+    async function subscriptionCheckout(tx, account, request) {
+        await tx.query('SELECT 1 FROM baukasten.accounts WHERE id = $1 FOR UPDATE', [account.id]);
+        const customerId = await customer(tx, account);
+        const subscribed = async () => (await stripe.subscriptionsOf(customerId)).some((s) => running(s.status));
+        if (await subscribed())
+            return { kind: 'subscribed' };
+        const [open] = await tx.query('SELECT session, url, price, quantity, expires_at FROM baukasten.checkouts WHERE account_id = $1', [account.id]);
+        if (open !== undefined) {
+            const same = open.price === request.priceId &&
+                open.quantity === request.quantity &&
+                open.expires_at.getTime() - now().getTime() >= CHECKOUT_LEFT_MS;
+            if (same)
+                return { kind: 'open', url: open.url };
+            // Paid in another tab in the meantime: its subscription runs now.
+            if ((await stripe.retireCheckout(open.session)) === 'complete' && (await subscribed())) {
+                return { kind: 'subscribed' };
+            }
+        }
+        const created = await stripe.createCheckout({ ...request, customerId });
+        await tx.query(`INSERT INTO baukasten.checkouts (account_id, session, url, price, quantity, expires_at)
+			 VALUES ($1, $2, $3, $4, $5, $6)
+			 ON CONFLICT (account_id) DO UPDATE SET session = excluded.session, url = excluded.url,
+				price = excluded.price, quantity = excluded.quantity, expires_at = excluded.expires_at`, [account.id, created.id, created.url, request.priceId, request.quantity, request.expiresAt]);
+        return { kind: 'open', url: created.url };
+    }
     function productOf(price) {
         const product = products.get(price.product);
         if (product === undefined)
@@ -102,8 +153,8 @@ export function createBilling(options) {
      * key does not reach, and its subscriptions move no money. A live customer under the test key, as
      * after a switch to live taken back, is asked for and fails loudly: its subscriptions move money.
      */
-    async function reachable(accountId) {
-        const customer = await customerOf(db, accountId);
+    async function reachable(q, accountId) {
+        const customer = await customerOf(q, accountId);
         if (customer.id === null)
             return { kind: 'none' };
         if (customer.mode === 'test' && mode === 'live')
@@ -111,8 +162,8 @@ export function createBilling(options) {
         return { kind: 'customer', id: customer.id };
     }
     /** The customer to act on at Stripe; one of the test mode under the live key is left alone. */
-    async function actOn(accountId) {
-        const customer = await reachable(accountId);
+    async function actOn(q, accountId) {
+        const customer = await reachable(q, accountId);
         switch (customer.kind) {
             case 'customer':
                 return customer.id;
@@ -191,8 +242,9 @@ export function createBilling(options) {
         if (account === null)
             return;
         otherCurrency(event, session.currency);
+        // The column keeps the currency in small letters, as Stripe writes it (003_stripe_and_sales.sql).
         const inserted = await tx.query(`INSERT INTO baukasten.purchases (id, account_id, product, price, amount, currency, paid_at)
-			 VALUES ($1, $2, $3, $4, $5, $6, $7) ON CONFLICT (id) DO NOTHING RETURNING id`, [
+			 VALUES ($1, $2, $3, $4, $5, lower($6), $7) ON CONFLICT (id) DO NOTHING RETURNING id`, [
             session.id,
             account.id,
             session.product,
@@ -210,14 +262,18 @@ export function createBilling(options) {
             product: session.product,
             price: session.lookupKey,
             amount: session.amount,
-            currency: session.currency.toUpperCase(),
+            currency: session.currency,
             paidAt: event.created
         });
     }
     async function checkoutCompleted(tx, event, session) {
         switch (session.mode) {
             case 'subscription':
-                return syncSubscription(tx, event, session.customerId, session.subscriptionId);
+                await syncSubscription(tx, event, session.customerId, session.subscriptionId);
+                // Paid: the next Checkout of the account is a new one. After the lock of the account, in
+                // the order the Checkout takes them.
+                await tx.query('DELETE FROM baukasten.checkouts WHERE session = $1', [session.id]);
+                return;
             case 'payment':
                 return purchasePaid(tx, event, session);
             case 'other':
@@ -241,7 +297,7 @@ export function createBilling(options) {
                     return;
                 otherCurrency(event, invoice.currency);
                 await tx.query(`INSERT INTO baukasten.invoices (id, account_id, amount, currency, paid_at)
-					 VALUES ($1, $2, $3, $4, $5) ON CONFLICT (id) DO NOTHING`, [invoice.id, account.id, invoice.amount, invoice.currency, invoice.paidAt]);
+					 VALUES ($1, $2, $3, lower($4), $5) ON CONFLICT (id) DO NOTHING`, [invoice.id, account.id, invoice.amount, invoice.currency, invoice.paidAt]);
                 return;
             }
             case 'other':
@@ -269,32 +325,25 @@ export function createBilling(options) {
                         throw new Error(`the quantity of ${order.price} is 1 to ${max}, not ${quantity}`);
                     }
                     const stripePrice = await priceId(wanted);
-                    const customerId = await customer(account);
-                    // A repeated click finds the running subscription. Two Checkouts open at the same time
-                    // can still make two subscriptions; that each expires soon only narrows the window.
-                    const open = (await stripe.subscriptionsOf(customerId)).filter((s) => running(s.status));
-                    if (open.length > 0)
-                        return { kind: 'subscribed' };
-                    const url = await stripe.createCheckout({
+                    const request = {
                         ...base,
-                        customerId,
                         priceId: stripePrice,
                         mode: 'subscription',
                         quantity,
                         adjustable: product.quantity === undefined
                             ? { kind: 'fixed' }
                             : { kind: 'up to', max: product.quantity.max }
-                    });
-                    return { kind: 'open', url };
+                    };
+                    return inTurn(account.id, () => db.transaction((tx) => subscriptionCheckout(tx, account, request)));
                 }
                 case 'purchase': {
                     if (order.quantity !== undefined && order.quantity !== 1) {
                         throw new Error(`a purchase of ${order.price} is one, not ${order.quantity}`);
                     }
                     const stripePrice = await priceId(wanted);
-                    const url = await stripe.createCheckout({
+                    const { url } = await stripe.createCheckout({
                         ...base,
-                        customerId: await customer(account),
+                        customerId: await customer(db, account),
                         priceId: stripePrice,
                         mode: 'payment',
                         product: product.id,
@@ -307,12 +356,12 @@ export function createBilling(options) {
         async portal(account, back) {
             const configurationId = await portalConfiguration();
             return stripe.createPortalSession({
-                customerId: await customer(account),
+                customerId: await customer(db, account),
                 configurationId,
                 returnUrl: `${shop.origin}${ownPath(back, 'back')}`
             });
         },
-        hasCustomer: async (accountId) => (await reachable(accountId)).kind === 'customer',
+        hasCustomer: async (accountId) => (await reachable(db, accountId)).kind === 'customer',
         async receive(payload, signature) {
             const read = stripe.event(payload, signature);
             if (read.kind === 'invalid')
@@ -332,7 +381,7 @@ export function createBilling(options) {
                 : { kind: 'repeated', type: event.type };
         },
         async endSubscriptions(accountId) {
-            const customerId = await actOn(accountId);
+            const customerId = await actOn(db, accountId);
             if (customerId === null)
                 return;
             for (const subscription of await stripe.subscriptionsOf(customerId)) {
@@ -340,8 +389,8 @@ export function createBilling(options) {
                     await stripe.cancelSubscription(subscription.id);
             }
         },
-        async followEmail(accountId, email) {
-            const customerId = await actOn(accountId);
+        async followEmail(q, accountId, email) {
+            const customerId = await actOn(q, accountId);
             if (customerId !== null)
                 await stripe.updateCustomerEmail(customerId, email);
         }

package/dist/server/catalog.d.ts

@@ -5,8 +5,38 @@ export interface Shop {
     name: string;
     origin: string;
 }
-export interface CatalogStep {
-    subject: 'product' | 'price' | 'portal';
+/**
+ * What setting the catalog up does with one thing at Stripe: create it, update it, or leave it as it
+ * exists. A price is never changed: `update` makes a new one that takes the lookup key over.
+ */
+export type CatalogStep = {
+    subject: 'product';
+    id: string;
+    kind: 'create' | 'update' | 'exists';
+    name: string;
+} | ({
+    subject: 'price';
+    id: string;
+    price: NewPrice;
+} & ({
+    kind: 'create' | 'update';
+} | {
+    kind: 'exists';
+    stripeId: string;
+})) | {
+    subject: 'portal';
+    id: string;
+    kind: 'update' | 'exists';
+}
+/** Only the Dashboard creates the default configuration of the customer portal. */
+ | {
+    subject: 'portal';
+    id: null;
+    kind: 'missing';
+};
+/** What setting the catalog up did with one thing at Stripe, as the migration command logs it. */
+export interface CatalogAction {
+    subject: CatalogStep['subject'];
     id: string;
     action: 'created' | 'updated' | 'exists';
 }
@@ -15,9 +45,10 @@ export declare function pricesOf(catalog: Catalog): NewPrice[];
 export declare function priceFits(found: StripePrice, wanted: NewPrice): boolean;
 /**
  * The default configuration of the customer portal names the product and links its own pages: an
- * account copied from another one brings that one's along.
+ * account copied from another one brings that one's along. `ids` holds the price at Stripe of each
+ * lookup key that has one; null while a price the portal offers has none yet.
  */
-export declare function portalConfiguration(catalog: Catalog, shop: Shop, priceId: (lookupKey: string) => string): PortalConfiguration;
+export declare function portalConfiguration(catalog: Catalog, shop: Shop, ids: ReadonlyMap<string, string>): PortalConfiguration | null;
 /**
  * Whether `found` holds every value of `wanted`. Lists hold the same items in any order: Stripe
  * need not keep the order it was given.
@@ -25,9 +56,16 @@ export declare function portalConfiguration(catalog: Catalog, shop: Shop, priceI
 export declare function contains(found: unknown, wanted: unknown): boolean;
 /** Only the Dashboard creates the default configuration of the customer portal. */
 export declare const NO_DEFAULT_PORTAL = "the Stripe account has no default configuration of the customer portal in this mode: save the settings of the customer portal once in the Stripe Dashboard, then migrate again";
-export declare function setUpCatalog(stripe: StripeApi, catalog: Catalog, shop: Shop): Promise<CatalogStep[]>;
+/**
+ * The catalog compared with Stripe: products first, then prices, then the portal, which offers the
+ * prices. A price still to be made changes a portal that offers it: its new id is in no
+ * configuration yet.
+ */
+export declare function catalogPlan(stripe: StripeApi, catalog: Catalog, shop: Shop): Promise<CatalogStep[]>;
 /** What the migration would change at Stripe, as `product <id>`, `price <key>` or `portal`. */
-export declare function catalogDifferences(stripe: StripeApi, catalog: Catalog, shop: Shop): Promise<string[]>;
+export declare function catalogChanges(plan: readonly CatalogStep[]): string[];
+/** Carries the plan out: a second run finds everything as it exists and changes nothing. */
+export declare function setUpCatalog(stripe: StripeApi, catalog: Catalog, shop: Shop): Promise<CatalogAction[]>;
 /**
  * The enabled webhook endpoints of the Stripe account that are not this product's: an account copied
  * from another product brings that one's along, and they would get the events of this one. Named by