@tollwyn/baukasten 1.2.3 → 1.3.0

package/dist/server/test-accounts.js

@@ -1,5 +1,5 @@
 /** What else points at an account in the schema of the baukasten, deleted before the account. */
-const OF_ACCOUNTS = ['sessions', 'links', 'api_keys', 'subscriptions'];
+const OF_ACCOUNTS = ['sessions', 'links', 'api_keys', 'subscriptions', 'checkouts'];
 const TEST = "a.stripe_mode = 'test'";
 /** The accounts from the test mode, oldest first. */
 export async function testAccounts(db) {

package/dist/shopify/config.js

@@ -1,7 +1,7 @@
 // Locally mail may be missing (mails go to the log); Shopify is needed in either mode, since
 // without it no page of the app opens.
 import { z } from 'zod';
-import { ConfigError, DEFAULT_PORT, MUST, problemsOf, SHAPE, valueOf } from '../server/config.js';
+import { ConfigError, MUST, readVariables, SHAPE, valueOf } from '../server/config.js';
 import { SHOPIFY_STANDARD_VARIABLES } from '../variables.js';
 import { sealKey } from './seal.js';
 import { APP_TOML, appToml } from './toml.js';
@@ -28,8 +28,6 @@ const SHARED = {
     MAIL_FROM_NAME: SHAPE.MAIL_FROM_NAME,
     OPERATOR_NAME: SHAPE.OPERATOR_NAME,
     OPERATOR_ADDRESS: SHAPE.OPERATOR_ADDRESS,
-    // Required like every standard variable, yet unread: the privacy text names the server of the fleet.
-    HOSTING_LOCATION: SHAPE.HOSTING_LOCATION,
     VERTRIEB_TOKEN: SHAPE.VERTRIEB_TOKEN
 };
 const FULL_SHAPE = { ...SHARED, ...OWN_SHAPE };
@@ -43,7 +41,6 @@ const MUST_OF = {
     MAIL_FROM_NAME: MUST.MAIL_FROM_NAME,
     OPERATOR_NAME: MUST.OPERATOR_NAME,
     OPERATOR_ADDRESS: MUST.OPERATOR_ADDRESS,
-    HOSTING_LOCATION: MUST.HOSTING_LOCATION,
     VERTRIEB_TOKEN: MUST.VERTRIEB_TOKEN,
     ...OWN_MUST
 };
@@ -56,66 +53,42 @@ const LOCAL = z.object({
     SMTP_PORT: FULL_SHAPE.SMTP_PORT.optional(),
     MAIL_FROM: FULL_SHAPE.MAIL_FROM.optional()
 });
-/** The Shopify double of the tests: only on this machine, so that no setting sends a token elsewhere. */
-const SHOPIFY_API_BASE = z
-    .url({ protocol: /^http$/, hostname: /^(?:127\.0\.0\.1|localhost|\[::1\])$/ })
-    .transform((value) => new URL(value).origin);
-function mailOf(data) {
-    const { SMTP_HOST: host, SMTP_PORT: port, MAIL_FROM: from } = data;
-    return host !== undefined && port !== undefined && from !== undefined
-        ? { kind: 'smtp', host, port, from }
-        : { kind: 'log' };
-}
 /** Reads the configuration; ConfigError names every problem at once. `toml` is the text of the file. */
 export function loadShopifyConfig(env, app, toml) {
-    const inProduction = env.NODE_ENV === 'production';
-    const input = Object.fromEntries(SHOPIFY_STANDARD_VARIABLES.map((name) => [name, valueOf(env, name)]));
-    const names = Object.keys(app.env);
-    const ownInput = Object.fromEntries(names.map((name) => [name, valueOf(env, name)]));
-    const base = (inProduction ? PRODUCTION : LOCAL).safeParse(input);
-    const own = z.object(app.env).safeParse(ownInput);
-    const apiBase = valueOf(env, 'SHOPIFY_API_BASE');
-    const double = apiBase === undefined ? null : SHOPIFY_API_BASE.safeParse(apiBase);
+    const read = readVariables(env, {
+        names: SHOPIFY_STANDARD_VARIABLES,
+        production: PRODUCTION,
+        local: LOCAL,
+        must: MUST_OF,
+        groups: [{ label: 'mail', names: MAIL }],
+        double: {
+            name: 'SHOPIFY_API_BASE',
+            problem: 'SHOPIFY_API_BASE must be an http origin on this machine, for the Shopify double'
+        },
+        product: app.env
+    });
     // The double gives the app a client ID of its own: until the app is linked, its file has none.
     const testClientId = valueOf(env, 'SHOPIFY_CLIENT_ID');
     const file = toml === undefined
         ? { kind: 'problems', problems: [`${APP_TOML} is missing in the root of the app`] }
         : appToml(toml);
-    const absent = MAIL.filter((name) => input[name] === undefined);
     const problems = [
-        ...(base.success
-            ? []
-            : problemsOf(base.error.issues, SHOPIFY_STANDARD_VARIABLES, input, (name) => `${name} must be ${MUST_OF[name]}`)),
-        ...(double === null || double.success
-            ? []
-            : ['SHOPIFY_API_BASE must be an http origin on this machine, for the Shopify double']),
-        ...(testClientId !== undefined && double === null
+        ...(read.kind === 'problems' ? read.problems : []),
+        ...(testClientId !== undefined && valueOf(env, 'SHOPIFY_API_BASE') === undefined
             ? [
                 `SHOPIFY_CLIENT_ID is only for the Shopify double of the tests; the client ID comes from ${APP_TOML}`
             ]
             : []),
-        ...(own.success
-            ? []
-            : problemsOf(own.error.issues, names, ownInput, (name, issue) => `${name} is invalid: ${issue.message}`)),
-        ...(file.kind === 'problems' ? file.problems : []),
-        ...(!inProduction && absent.length > 0 && absent.length < MAIL.length
-            ? [`mail is set only in part: ${absent.join(', ')} missing`]
-            : [])
+        ...(file.kind === 'problems' ? file.problems : [])
     ];
-    if (!base.success || !own.success || file.kind === 'problems' || problems.length > 0) {
+    if (read.kind === 'problems' || file.kind === 'problems' || problems.length > 0) {
         throw new ConfigError(problems);
     }
-    const data = base.data;
+    const { config, data, double } = read.value;
     return {
-        mode: inProduction ? 'production' : 'local',
+        ...config,
         language: app.language,
-        publicOrigin: data.PUBLIC_ORIGIN,
-        port: data.PORT ?? DEFAULT_PORT,
-        databaseUrl: data.DATABASE_URL,
-        name: data.MAIL_FROM_NAME,
-        mail: mailOf(data),
         operator: { name: data.OPERATOR_NAME, address: data.OPERATOR_ADDRESS },
-        salesToken: data.VERTRIEB_TOKEN,
         shopify: {
             clientId: testClientId ?? file.toml.clientId,
             handle: file.toml.handle,
@@ -123,11 +96,7 @@ export function loadShopifyConfig(env, app, toml) {
             secret: data.SHOPIFY_API_SECRET,
             tokenKey: sealKey(data.SHOPIFY_TOKEN_KEY),
             partner: { token: data.SHOPIFY_PARTNER_TOKEN, organization: data.SHOPIFY_PARTNER_ORG },
-            api: double === null || !double.success
-                ? { kind: 'shopify' }
-                : { kind: 'double', url: double.data }
-        },
-        missing: inProduction ? [] : absent,
-        product: own.data
+            api: double === null ? { kind: 'shopify' } : { kind: 'double', url: double }
+        }
     };
 }

package/dist/shopify/hook.d.ts

@@ -1,6 +1,6 @@
 import type { Handle, HandleServerError, ServerInit } from '@sveltejs/kit';
 import type { ProductEnv } from '../product.js';
-import { type Limits } from '../server/limits.js';
+import type { Limits } from '../server/limits.js';
 import type { Log } from '../server/log.js';
 import type { Db, Mailer } from '../server/ports.js';
 import { type AdminApi } from './admin.js';

package/dist/shopify/hook.js

@@ -1,13 +1,9 @@
 import { randomBytes } from 'node:crypto';
 import { existsSync, readFileSync } from 'node:fs';
 import { setTimeout as wait } from 'node:timers/promises';
-import { createDb } from '../server/adapter/db.js';
-import { exitAfterLog, log } from '../server/adapter/log.js';
-import { createMailer } from '../server/adapter/mailer.js';
-import { migrationSources, migrationStatus } from '../server/adapter/migrate.js';
-import { ConfigError } from '../server/config.js';
-import { CHECK_TIMEOUT_MS, CheckFailed, databaseCheck, deepHealth, mailCheck } from '../server/health.js';
-import { createLimits } from '../server/limits.js';
+import { log } from '../server/adapter/log.js';
+import { json, policyGuard, serverCore } from '../server/core.js';
+import { CheckFailed } from '../server/health.js';
 import { periodic } from '../server/runs.js';
 import { bearerFits, SALES_PATH } from '../server/sales.js';
 import { ShopifyFailed, shopifyApi } from './adapter/shopify.js';
@@ -24,8 +20,6 @@ import { createShops } from './shops.js';
 import { SHOPIFY_TEXTS } from './texts.js';
 import { APP_TOML } from './toml.js';
 import { createWebhooks } from './webhooks.js';
-const HEALTH = '/health';
-const DEEP = '/health/deep';
 const PRIVACY = '/privacy';
 /** The app's src/app.html, a stub, takes the language and the client ID from these. */
 const LANG = '%baukasten.lang%';
@@ -34,77 +28,43 @@ const CLIENT_ID = '%baukasten.clientId%';
 const RETRY = { 'x-shopify-retry-invalid-session-request': '1' };
 /** The parameters of the admin that a page of the app is opened with, which the bounce page drops. */
 const ADMIN_PARAMS = ['id_token'];
-const PROBE_TIMEOUT_MS = CHECK_TIMEOUT_MS - 1_000;
 /** The run of the webhooks beats this often, and touches the database only when it is marked. */
 const WEBHOOK_BEAT_MS = 1_000;
 const SAFE_METHODS = ['GET', 'HEAD', 'OPTIONS'];
-function json(body, status, headers = {}) {
-    return new Response(JSON.stringify(body), {
-        status,
-        headers: { 'content-type': 'application/json', 'cache-control': 'no-store', ...headers }
-    });
-}
 function laterOf(a, b) {
     return a > b ? a : b;
 }
 export function shopifyBaukasten(app, hooks = {}) {
-    const appChecks = hooks.checks ?? {};
-    if ('database' in appChecks || 'mail' in appChecks || 'shopify' in appChecks) {
-        throw new Error('the checks database, mail and shopify belong to the baukasten');
-    }
+    /** The shop of each request that got in, by its request, which its loads and actions share. */
+    const sessions = new WeakMap();
+    const withPolicy = policyGuard('SHOPIFY_SVELTEKIT_OPTIONS', 'app');
+    const core = serverCore({
+        noun: 'app',
+        art: 'shopify',
+        check: 'shopify',
+        hooks,
+        load: (root) => {
+            const toml = `${root}/${APP_TOML}`;
+            return loadShopifyConfig(process.env, app, existsSync(toml) ? readFileSync(toml, 'utf8') : undefined);
+        },
+        open,
+        respond,
+        headers: SHOPIFY_SECURITY_HEADERS,
+        // The shop of a request that got in goes with it, the privacy text says so, and a request that
+        // did not get in has none.
+        logged: (event) => ({ shop: sessions.get(event.request)?.domain })
+    });
     // The privacy text promises a merchant what the app keeps of a customer, and its deletion.
     if (app.privacy.data.length > 0 &&
         (hooks.customerData === undefined || hooks.redactCustomer === undefined)) {
         throw new Error('the app keeps personal data for the merchant (privacy.data): it gives the hooks customerData and redactCustomer');
     }
-    let state = { kind: 'waiting' };
-    /** The shop of each request that got in, by its request, which its loads and actions share. */
-    const sessions = new WeakMap();
-    function running() {
-        switch (state.kind) {
-            case 'running':
-                return state;
-            case 'building':
-                throw new Error('the baukasten is used in the build: its pages read the configuration of the running app and cannot be prerendered');
-            case 'waiting':
-                throw new Error('the baukasten is used before init ran');
-        }
-    }
-    async function stop(applying, context) {
-        await applying.stop();
-        try {
-            await hooks.stop?.(context);
-        }
-        catch (error) {
-            process.exitCode = 1;
-            log.error('the stop hook of the app failed', { error });
-        }
-        await context.db.close();
-        log.info('stopped');
-    }
-    async function start() {
-        const root = process.cwd();
-        const toml = `${root}/${APP_TOML}`;
-        let config;
-        try {
-            config = loadShopifyConfig(process.env, app, existsSync(toml) ? readFileSync(toml, 'utf8') : undefined);
-        }
-        catch (error) {
-            if (!(error instanceof ConfigError))
-                throw error;
-            log.error('configuration incomplete, not starting', { problems: error.problems });
-            return exitAfterLog(1);
-        }
-        if (config.missing.length > 0) {
-            log.warn('running without what production needs', { missing: config.missing });
-        }
+    /** Installation, shops, webhooks and the privacy text, on the pool and mail of the core. */
+    function open(context) {
+        const { config, db, mail } = context;
         if (config.shopify.clientId === null) {
             log.error(`the app is not linked at Shopify: ${APP_TOML} has no client_id, and no shop gets in`);
         }
-        const db = createDb(config.databaseUrl, log);
-        const mail = createMailer(config.mail, config.name, log);
-        const limits = createLimits({ now: () => Date.now() });
-        const context = { config, db, log, mail, limits };
         const api = shopifyApi(config.shopify, { now: () => new Date() });
         const shops = createShops({
             db,
@@ -145,10 +105,6 @@ export function shopifyBaukasten(app, hooks = {}) {
                 retry?.unref();
             }
         });
-        const stopRetry = () => {
-            if (retry !== null)
-                clearTimeout(retry);
-        };
         const privacy = shopifyPrivacy({
             language: config.language,
             name: config.name,
@@ -157,10 +113,7 @@ export function shopifyBaukasten(app, hooks = {}) {
             privacy: app.privacy,
             version: laterOf(SHOPIFY_PRIVACY_DATE, app.privacyDate)
         });
-        const probe = db.withTimeout(PROBE_TIMEOUT_MS);
-        const sources = migrationSources(root, 'shopify');
-        const checks = Object.fromEntries(Object.entries(appChecks).map(([name, check]) => [name, () => check(context)]));
-        const shopifyHealth = async () => {
+        const check = async () => {
             if (config.shopify.clientId === null) {
                 throw new CheckFailed(`no client_id in ${APP_TOML}: link the app at Shopify`);
             }
@@ -178,52 +131,29 @@ export function shopifyBaukasten(app, hooks = {}) {
                 throw new CheckFailed(error instanceof ShopifyFailed ? 'the Partner API refused' : 'unreachable');
             }
         };
-        const health = deepHealth({
-            checks: {
-                database: databaseCheck(probe, () => migrationStatus(probe, sources), log),
-                mail: mailCheck(mail, log),
-                shopify: shopifyHealth,
-                ...checks
-            },
-            now: () => Date.now(),
-            log
-        });
-        state = { kind: 'running', context, api, shops, webhooks, applying, privacy, health };
-        log.info('starting', {
-            mode: config.mode,
-            origin: config.publicOrigin,
-            language: config.language
-        });
-        applying.start({ db, log });
-        // Webhooks that were kept before a restart are applied now.
-        applying.mark();
-        await hooks.start?.(context);
-        process.once('sveltekit:shutdown', () => {
-            stopRetry();
-            void stop(applying, context);
-        });
-    }
-    const init = (building) => () => {
-        if (!building)
-            return start();
-        state = { kind: 'building' };
-    };
-    async function health(event) {
-        if (event.request.method !== 'GET' && event.request.method !== 'HEAD') {
-            return new Response(null, { status: 405, headers: { allow: 'GET, HEAD' } });
-        }
-        // Plain health answers without the database: Neon may sleep, the process still lives.
-        if (event.url.pathname === HEALTH)
-            return json({ status: 'ok' }, 200);
-        const report = await running().health();
-        return json(report, report.status === 'ok' ? 200 : 503);
+        return {
+            services: { api, shops, webhooks, applying, privacy },
+            check,
+            runs: {
+                start: () => {
+                    applying.start({ db, log });
+                    // Webhooks that were kept before a restart are applied now.
+                    applying.mark();
+                },
+                stop: () => {
+                    if (retry !== null)
+                        clearTimeout(retry);
+                    return applying.stop();
+                }
+            }
+        };
     }
     async function webhook(s, event) {
         if (event.request.method !== 'POST') {
             return new Response(null, { status: 405, headers: { allow: 'POST' } });
         }
         const body = new Uint8Array(await event.request.arrayBuffer());
-        const received = await s.webhooks.receive(body, event.request.headers);
+        const received = await s.services.webhooks.receive(body, event.request.headers);
         switch (received.kind) {
             case 'unsigned':
                 log.warn('shopify: a webhook without the signature of the app');
@@ -232,7 +162,7 @@ export function shopifyBaukasten(app, hooks = {}) {
                 log.warn('shopify: a webhook of an unknown form', { reason: received.reason });
                 return new Response(null, { status: 400 });
             case 'queued':
-                s.applying.mark();
+                s.services.applying.mark();
                 return new Response(null, { status: 200 });
             case 'repeated':
                 return new Response(null, { status: 200 });
@@ -257,7 +187,11 @@ export function shopifyBaukasten(app, hooks = {}) {
             case SALES_PATH:
                 return sales(s, event);
             case PRIVACY:
-                return legalPage({ name: config.name, language: config.language, legal: s.privacy });
+                return legalPage({
+                    name: config.name,
+                    language: config.language,
+                    legal: s.services.privacy
+                });
             case SHOPIFY_AUTH_PATH:
                 return outsidePage({ name: config.name, language: config.language, texts });
             case SHOPIFY_BOUNCE_PATH: {
@@ -330,7 +264,7 @@ export function shopifyBaukasten(app, hooks = {}) {
     }
     async function entered(s, url, shop, idToken, document) {
         const { config } = s.context;
-        const entry = await s.shops.enter(shop, idToken);
+        const entry = await s.services.shops.enter(shop, idToken);
         switch (entry.kind) {
             case 'in':
                 return { kind: 'in', shop, document };
@@ -357,7 +291,7 @@ export function shopifyBaukasten(app, hooks = {}) {
         try {
             // Back from the plan page of Shopify, the page asks the plan again at once; its requests,
             // which may carry the parameter as well, take what it found.
-            plan = await s.shops.plan(shop, document && event.url.searchParams.has('plan_handle'));
+            plan = await s.services.shops.plan(shop, document && event.url.searchParams.has('plan_handle'));
         }
         catch (error) {
             log.error('shopify: the plan of a shop could not be read', { shop, error });
@@ -386,37 +320,18 @@ export function shopifyBaukasten(app, hooks = {}) {
             })
         };
     }
-    /**
-     * A page without its content security policy does not go out: the policy comes from
-     * SHOPIFY_SVELTEKIT_OPTIONS in the configuration of the app; with it, only the admin of the shop
-     * may frame the page.
-     */
-    let policyMissing = false;
+    /** With its content security policy, a page of the app may be framed by the admin of its shop. */
     function framed(response, shop, path) {
-        const page = response.headers.get('content-type')?.startsWith('text/html') === true;
-        if (!page)
-            return response;
-        const policy = response.headers.get('content-security-policy');
-        if (policy === null) {
-            if (response.status >= 500)
-                return response;
-            if (!policyMissing) {
-                policyMissing = true;
-                log.error('a page without its content security policy: SHOPIFY_SVELTEKIT_OPTIONS of the baukasten is missing in sveltekit() of vite.config.ts, or an endpoint of the app answers HTML of its own; every such answer is a 500', { path });
-            }
-            return new Response('Internal Error', {
-                status: 500,
-                headers: { 'content-type': 'text/plain; charset=utf-8' }
-            });
+        const guarded = withPolicy(response, path);
+        const page = guarded.headers.get('content-type')?.startsWith('text/html') === true;
+        const policy = guarded.headers.get('content-security-policy');
+        if (page && policy !== null) {
+            guarded.headers.set('content-security-policy', `${policy}; ${frameAncestors(shop)}`);
         }
-        response.headers.set('content-security-policy', `${policy}; ${frameAncestors(shop)}`);
-        return response;
+        return guarded;
     }
-    async function respondTo(event, resolve) {
+    async function respond(s, event, resolve) {
         const path = event.url.pathname;
-        if (path === HEALTH || path === DEEP)
-            return health(event);
-        const s = running();
         const { config } = s.context;
         const answer = own(s, event);
         if (answer !== null)
@@ -450,49 +365,11 @@ export function shopifyBaukasten(app, hooks = {}) {
         });
         return framed(response, gated.shop, path);
     }
-    const handle = async ({ event, resolve }) => {
-        // Prerendering in the build is no request of anyone.
-        if (state.kind === 'building')
-            return resolve(event);
-        const started = performance.now();
-        let status = 500;
-        try {
-            const response = await respondTo(event, resolve);
-            for (const [name, value] of Object.entries(SHOPIFY_SECURITY_HEADERS)) {
-                response.headers.set(name, value);
-            }
-            status = response.status;
-            return response;
-        }
-        finally {
-            // The container polls /health; it is logged only at debug. The path goes without its query,
-            // which carries the ID token; the shop of a request that got in goes with it, the privacy
-            // text says so, and a request that did not get in has none.
-            (event.url.pathname === HEALTH ? log.debug : log.info)('request', {
-                method: event.request.method,
-                path: event.url.pathname,
-                status,
-                ms: Math.round(performance.now() - started),
-                shop: sessions.get(event.request)?.domain
-            });
-        }
-    };
-    const handleError = ({ error, event, status, message }) => {
-        if (status === 404)
-            return { message };
-        (status >= 500 ? log.error : log.warn)('request failed', {
-            method: event.request.method,
-            path: event.url.pathname,
-            status,
-            error
-        });
-        return { message: status >= 500 ? 'Internal Error' : message };
-    };
     return {
-        init,
-        handle,
-        handleError,
-        context: () => running().context,
+        init: core.init,
+        handle: core.handle,
+        handleError: core.handleError,
+        context: () => core.running().context,
         shop: (event) => {
             const session = sessions.get(event.request);
             if (session === undefined) {
@@ -501,8 +378,8 @@ export function shopifyBaukasten(app, hooks = {}) {
             return session;
         },
         admin: (shop) => {
-            const s = running();
-            return adminApi(shop, { api: s.api, shops: s.shops, log, wait: (ms) => wait(ms) });
+            const { api, shops } = core.running().services;
+            return adminApi(shop, { api, shops, log, wait: (ms) => wait(ms) });
         }
     };
 }

package/dist/testing/connection.js

@@ -24,7 +24,6 @@ const STANDARD = {
     OPERATOR_REGISTER: 'none',
     OPERATOR_VAT: 'none',
     OPERATOR_JURISDICTION: 'Baden',
-    HOSTING_LOCATION: 'Example Hosting, Nuremberg',
     VERTRIEB_TOKEN: 'v'.repeat(64)
 };
 const VIA = 'connection-test';

package/dist/testing/env-example.js

@@ -1,5 +1,5 @@
 import { isShopifyApp } from '../shopify/app.js';
-import { SHOPIFY_VARIABLES, WEBAPP_VARIABLES } from '../variables.js';
+import { RETIRED_VARIABLES, SHOPIFY_VARIABLES, WEBAPP_VARIABLES } from '../variables.js';
 const LINE = /^([A-Z][A-Z0-9_]*)=(.*)$/;
 /** What is wrong with the text of `.env.example`; empty when nothing is. */
 export function envExampleProblems(text, product) {
@@ -26,7 +26,8 @@ export function envExampleProblems(text, product) {
     const lacking = read.filter((name) => !named.includes(name));
     if (lacking.length > 0)
         problems.push(`.env.example lacks ${lacking.join(', ')}`);
-    const unread = named.filter((name) => !read.includes(name));
+    const retired = RETIRED_VARIABLES;
+    const unread = named.filter((name) => !read.includes(name) && !retired.includes(name));
     if (unread.length > 0)
         problems.push(`.env.example names what nothing reads: ${unread.join(', ')}`);
     return problems;

package/dist/testing/shopify-connection.js

@@ -19,7 +19,6 @@ const STANDARD = {
     MAIL_FROM_NAME: 'Connection Test',
     OPERATOR_NAME: 'Connection Test Operator',
     OPERATOR_ADDRESS: 'Street 1, 5400 Baden',
-    HOSTING_LOCATION: 'Example Hosting, Nuremberg',
     VERTRIEB_TOKEN: 'v'.repeat(64)
 };
 const SHOP = 'connection-test.myshopify.com';

package/dist/testing/stripe.d.ts

@@ -41,6 +41,8 @@ export interface DoubleSession {
     mode: string;
     customer: string;
     url: string;
+    /** Open until it is paid or expired; only an open one can be paid. */
+    status: 'open' | 'complete' | 'expired';
     subscription: string | null;
     payment_status: 'paid' | 'unpaid';
     amount_total: number | null;

package/dist/testing/stripe.js

@@ -181,6 +181,10 @@ export async function startStripe(options = {}) {
             const session = double.sessions.get(sessionId);
             if (session === undefined)
                 throw new Error(`the double has no session ${sessionId}`);
+            if (session.status !== 'open') {
+                throw new Error(`the double cannot pay the session ${sessionId}: it is ${session.status}`);
+            }
+            session.status = 'complete';
             const price = double.prices.get(session.item.price);
             if (price === undefined)
                 throw new Error(`the double has no price ${session.item.price}`);
@@ -292,7 +296,21 @@ export async function startStripe(options = {}) {
             };
             if (method !== 'GET' && path.startsWith('/v1/'))
                 double.writes.push(`${method} ${path}`);
-            const list = (data) => send(200, { object: 'list', data, has_more: false, url: path });
+            /** One page of a list, as Stripe gives it: `limit` items (10 without), after `starting_after`. */
+            const list = (data) => {
+                const limit = whole(query, 'limit') ?? 10;
+                const after = text(query, 'starting_after');
+                const at = after === null ? -1 : data.findIndex((item) => item.id === after);
+                if (after !== null && at < 0)
+                    return missing(`object: '${after}'`);
+                const from = at + 1;
+                return send(200, {
+                    object: 'list',
+                    data: data.slice(from, from + limit),
+                    has_more: from + limit < data.length,
+                    url: path
+                });
+            };
             let match;
             if (path === '/v1/products' && method === 'POST') {
                 const id = text(form, 'id') ?? next('prod');
@@ -423,6 +441,7 @@ export async function startStripe(options = {}) {
                     mode: text(form, 'mode') ?? '',
                     customer: text(form, 'customer') ?? '',
                     url: `${base}/pay/${id}`,
+                    status: 'open',
                     subscription: null,
                     payment_status: 'unpaid',
                     amount_total: null,
@@ -440,6 +459,21 @@ export async function startStripe(options = {}) {
                 double.sessions.set(id, session);
                 return send(200, session);
             }
+            if ((match = /^\/v1\/checkout\/sessions\/([^/]+)(\/expire)?$/.exec(path)) !== null) {
+                const session = double.sessions.get(match[1] ?? '');
+                if (session === undefined || customerOf(session.customer) === undefined) {
+                    return missing('checkout.session');
+                }
+                if (match[2] === undefined)
+                    return send(200, session);
+                if (method !== 'POST')
+                    return failed(405, `unknown ${method} ${path}`);
+                if (session.status !== 'open') {
+                    return failed(400, `Only Checkout Sessions with a status in [open] can be expired.`);
+                }
+                session.status = 'expired';
+                return send(200, session);
+            }
             if (path === '/v1/billing_portal/sessions' && method === 'POST') {
                 if (customerOf(text(form, 'customer')) === undefined)
                     return missing('customer');