@tollwyn/baukasten 0.0.2 → 1.2.3

package/dist/testing/stripe.js

@@ -0,0 +1,511 @@
+// A double of Stripe on a free local port, for the tests of a product. It takes any key and moves no
+// money; a customer belongs to the mode of the key that made it, and a key of the other mode does not
+// reach it or its subscriptions, as at Stripe. The catalog it shares between the modes. It starts as
+// an account whose customer portal was saved once in the Dashboard, copied from another product: its
+// head is that product's. It needs nothing but Node, so no image of a product carries a dependency
+// for it.
+import { createHmac } from 'node:crypto';
+import { createServer } from 'node:http';
+/** Stripe's form encoding (`a[b][0][c]=1`) read into nested objects, values as sent. */
+function parseForm(body) {
+    const result = {};
+    for (const [key, value] of new URLSearchParams(body)) {
+        const path = key.replace(/\]/g, '').split('[');
+        let node = result;
+        path.forEach((part, index) => {
+            if (index === path.length - 1) {
+                node[part] = value;
+                return;
+            }
+            const next = node[part];
+            if (typeof next === 'object')
+                node = next;
+            else {
+                const fresh = {};
+                node[part] = fresh;
+                node = fresh;
+            }
+        });
+    }
+    return result;
+}
+/** A form as Stripe keeps it: lists as arrays, flags and whole numbers typed. */
+function typed(value) {
+    if (typeof value === 'string') {
+        if (value === 'true' || value === 'false')
+            return value === 'true';
+        return /^\d+$/.test(value) ? Number(value) : value;
+    }
+    const entries = Object.entries(value);
+    if (entries.length > 0 && entries.every(([key]) => /^\d+$/.test(key))) {
+        return entries.sort(([a], [b]) => Number(a) - Number(b)).map(([, item]) => typed(item));
+    }
+    return Object.fromEntries(entries.map(([key, item]) => [key, typed(item)]));
+}
+function objectOf(value) {
+    const json = typed(value);
+    if (typeof json !== 'object' || json === null || Array.isArray(json)) {
+        throw new Error('the double expected an object in the form');
+    }
+    return json;
+}
+const isObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+/** The value at `path`, if it is there; a list takes the number of its item. */
+function at(value, ...path) {
+    let node = value;
+    for (const key of path) {
+        node = Array.isArray(node) ? node[Number(key)] : isObject(node) ? node[key] : undefined;
+    }
+    return node;
+}
+function text(value, ...path) {
+    const found = at(value, ...path);
+    return typeof found === 'string' ? found : null;
+}
+function whole(value, ...path) {
+    const found = at(value, ...path);
+    return typeof found === 'number' ? found : null;
+}
+/** The metadata of a request, each value as text, as Stripe keeps it. */
+function metadataOf(form) {
+    const metadata = form.metadata;
+    if (!isObject(metadata))
+        return {};
+    return Object.fromEntries(Object.entries(metadata).map(([key, value]) => [
+        key,
+        typeof value === 'string' ? value : JSON.stringify(value)
+    ]));
+}
+/** An update: objects merge key by key, everything else is replaced. */
+function merge(target, changes) {
+    for (const [key, value] of Object.entries(changes)) {
+        const current = target[key];
+        if (isObject(value) && isObject(current))
+            merge(current, value);
+        else
+            target[key] = value;
+    }
+}
+function readBody(request) {
+    return new Promise((resolve, reject) => {
+        let body = '';
+        request.on('data', (chunk) => (body += chunk.toString()));
+        request.on('end', () => resolve(body));
+        request.on('error', reject);
+    });
+}
+const page = (title, body) => `<!doctype html><html><head><title>${title}</title></head><body><h1>${title}</h1>${body}</body></html>`;
+/** The products of a portal configuration come only when they are asked for. */
+function shown(configuration, expanded) {
+    if (expanded)
+        return configuration;
+    const copy = structuredClone(configuration);
+    const update = at(copy, 'features', 'subscription_update');
+    if (isObject(update))
+        delete update.products;
+    return copy;
+}
+/** What the Stripe-Signature header carries for this payload at this time. */
+export function stripeSignature(payload, secret, seconds) {
+    const v1 = createHmac('sha256', secret).update(`${seconds}.${payload}`).digest('hex');
+    return `t=${seconds},v1=${v1}`;
+}
+export async function startStripe(options = {}) {
+    const webhookSecret = 'whsec_double';
+    let counter = 0;
+    const next = (prefix) => `${prefix}_double${++counter}`;
+    let base = '';
+    let connected = null;
+    /** Events on their way, and the answers that were no success. */
+    const pending = new Set();
+    const refused = [];
+    /** Sends an event after the request that caused it is answered, as Stripe does. */
+    function later(type, object) {
+        const delivery = double
+            .send(type, object)
+            .then(async (response) => {
+            if (!response.ok)
+                refused.push(`${type}: ${response.status} ${await response.text()}`);
+        })
+            .catch((error) => {
+            refused.push(`${type}: ${String(error)}`);
+        })
+            .finally(() => pending.delete(delivery));
+        pending.add(delivery);
+    }
+    const double = {
+        url: '',
+        webhookSecret,
+        target: null,
+        products: new Map(),
+        prices: new Map(),
+        portals: new Map(),
+        endpoints: new Map(),
+        customers: new Map(),
+        subscriptions: new Map(),
+        sessions: new Map(),
+        writes: [],
+        retrieved: 0,
+        addEndpoint(url, status = 'enabled') {
+            const id = next('we');
+            double.endpoints.set(id, { id, object: 'webhook_endpoint', url, status });
+            return id;
+        },
+        connect(url, target) {
+            if (connected !== null)
+                connected.status = 'disabled';
+            const id = double.addEndpoint(url);
+            connected = double.endpoints.get(id) ?? null;
+            double.target = target;
+        },
+        async send(type, object, sendOptions = {}) {
+            if (double.target === null)
+                throw new Error('the Stripe double has no target for events');
+            const payload = JSON.stringify({
+                id: sendOptions.id ?? next('evt'),
+                object: 'event',
+                api_version: '2026-08-26.dahlia',
+                created: Math.floor(Date.now() / 1_000),
+                livemode: false,
+                type,
+                data: { object }
+            });
+            const signature = stripeSignature(payload, sendOptions.secret ?? webhookSecret, Math.floor(Date.now() / 1_000));
+            return fetch(double.target, {
+                method: 'POST',
+                headers: { 'content-type': 'application/json', 'stripe-signature': signature },
+                body: payload
+            });
+        },
+        async pay(sessionId, payOptions = {}) {
+            const session = double.sessions.get(sessionId);
+            if (session === undefined)
+                throw new Error(`the double has no session ${sessionId}`);
+            const price = double.prices.get(session.item.price);
+            if (price === undefined)
+                throw new Error(`the double has no price ${session.item.price}`);
+            const quantity = payOptions.quantity ?? session.item.quantity;
+            if (session.mode === 'subscription') {
+                const invoice = next('in');
+                const subscription = {
+                    id: next('sub'),
+                    object: 'subscription',
+                    customer: session.customer,
+                    status: 'active',
+                    latest_invoice: invoice,
+                    items: {
+                        object: 'list',
+                        data: [{ id: next('si'), object: 'subscription_item', quantity, price }]
+                    }
+                };
+                double.subscriptions.set(subscription.id, subscription);
+                session.subscription = subscription.id;
+                session.payment_status = 'paid';
+                await expectOk(double.send('checkout.session.completed', session));
+                await expectOk(double.send('customer.subscription.created', subscription));
+                await expectOk(double.send('invoice.paid', {
+                    id: invoice,
+                    object: 'invoice',
+                    customer: session.customer,
+                    amount_paid: price.unit_amount * quantity,
+                    currency: price.currency,
+                    status_transitions: { paid_at: Math.floor(Date.now() / 1_000) }
+                }));
+                return;
+            }
+            session.amount_total = price.unit_amount;
+            session.currency = price.currency;
+            session.payment_status = payOptions.later === true ? 'unpaid' : 'paid';
+            await expectOk(double.send('checkout.session.completed', session));
+            if (payOptions.later === true) {
+                session.payment_status = 'paid';
+                await expectOk(double.send('checkout.session.async_payment_succeeded', session));
+            }
+        },
+        async idle() {
+            while (pending.size > 0)
+                await Promise.all([...pending]);
+            if (refused.length > 0) {
+                throw new Error(`the webhook of the app refused: ${refused.splice(0).join('; ')}`);
+            }
+        },
+        async stop() {
+            while (pending.size > 0)
+                await Promise.all([...pending]);
+            await new Promise((resolve) => server.close(() => resolve()));
+        }
+    };
+    async function expectOk(sent) {
+        const response = await sent;
+        if (!response.ok) {
+            throw new Error(`the webhook of the app answered ${response.status}: ${await response.text()}`);
+        }
+    }
+    // The default configuration, as an account copied from another product brings it along.
+    if (options.portal ?? true) {
+        double.portals.set('bpc_double', {
+            id: 'bpc_double',
+            object: 'billing_portal.configuration',
+            active: true,
+            is_default: true,
+            business_profile: {
+                headline: 'Another product',
+                privacy_policy_url: 'https://another.example/privacy',
+                terms_of_service_url: 'https://another.example/terms'
+            },
+            default_return_url: null,
+            features: {
+                customer_update: { enabled: false, allowed_updates: [] },
+                invoice_history: { enabled: true },
+                payment_method_update: { enabled: false },
+                subscription_cancel: { enabled: false, mode: 'at_period_end', proration_behavior: 'none' },
+                subscription_update: {
+                    enabled: false,
+                    default_allowed_updates: [],
+                    proration_behavior: 'none',
+                    products: []
+                }
+            }
+        });
+    }
+    const server = createServer((request, response) => {
+        void (async () => {
+            const url = new URL(request.url ?? '/', base);
+            const body = await readBody(request);
+            const send = (status, value) => response
+                .writeHead(status, { 'content-type': 'application/json' })
+                .end(JSON.stringify(value));
+            const html = (value) => response.writeHead(200, { 'content-type': 'text/html' }).end(value);
+            const failed = (status, message, code) => send(status, {
+                error: { type: 'invalid_request_error', message, ...(code === undefined ? {} : { code }) }
+            });
+            const missing = (what) => failed(404, `No such ${what}`, 'resource_missing');
+            const path = url.pathname;
+            const form = objectOf(parseForm(body));
+            const query = objectOf(parseForm(url.search.slice(1)));
+            const method = request.method ?? 'GET';
+            const livemode = /^Bearer (?:sk|rk)_live_/.test(request.headers.authorization ?? '');
+            /** A customer of the mode of the key; one of the other mode is missing for it. */
+            const customerOf = (id) => {
+                const customer = double.customers.get(id ?? '');
+                return customer?.livemode === livemode ? customer : undefined;
+            };
+            if (method !== 'GET' && path.startsWith('/v1/'))
+                double.writes.push(`${method} ${path}`);
+            const list = (data) => send(200, { object: 'list', data, has_more: false, url: path });
+            let match;
+            if (path === '/v1/products' && method === 'POST') {
+                const id = text(form, 'id') ?? next('prod');
+                if (double.products.has(id)) {
+                    return failed(400, 'Product already exists.', 'resource_already_exists');
+                }
+                const product = {
+                    id,
+                    object: 'product',
+                    name: text(form, 'name') ?? '',
+                    active: true
+                };
+                double.products.set(id, product);
+                return send(200, product);
+            }
+            if ((match = /^\/v1\/products\/([^/]+)$/.exec(path)) !== null) {
+                const product = double.products.get(match[1] ?? '');
+                if (product === undefined)
+                    return missing('product');
+                if (method === 'POST') {
+                    product.name = text(form, 'name') ?? product.name;
+                    const active = at(form, 'active');
+                    if (typeof active === 'boolean')
+                        product.active = active;
+                }
+                return send(200, product);
+            }
+            if (path === '/v1/prices' && method === 'GET') {
+                const keys = at(query, 'lookup_keys');
+                const active = at(query, 'active');
+                return list([...double.prices.values()].filter((price) => (!Array.isArray(keys) || keys.includes(price.lookup_key ?? '')) &&
+                    (typeof active !== 'boolean' || price.active === active)));
+            }
+            if (path === '/v1/prices' && method === 'POST') {
+                const key = text(form, 'lookup_key');
+                const holder = [...double.prices.values()].find((price) => price.lookup_key === key);
+                if (holder !== undefined && key !== null) {
+                    if (at(form, 'transfer_lookup_key') !== true) {
+                        return failed(400, `A price (\`${holder.id}\`) already uses that lookup key.`);
+                    }
+                    holder.lookup_key = null;
+                }
+                const interval = text(form, 'recurring', 'interval');
+                const price = {
+                    id: next('price'),
+                    object: 'price',
+                    product: text(form, 'product') ?? '',
+                    lookup_key: key,
+                    unit_amount: whole(form, 'unit_amount') ?? 0,
+                    currency: text(form, 'currency') ?? '',
+                    active: true,
+                    type: interval === null ? 'one_time' : 'recurring',
+                    recurring: interval === null ? null : { interval, interval_count: 1 }
+                };
+                double.prices.set(price.id, price);
+                return send(200, price);
+            }
+            if (path === '/v1/billing_portal/configurations' && method === 'GET') {
+                const expand = at(query, 'expand');
+                const expanded = Array.isArray(expand) && expand.includes('data.features.subscription_update.products');
+                return list([...double.portals.values()]
+                    .filter((portal) => {
+                    const wanted = at(query, 'is_default');
+                    return typeof wanted !== 'boolean' || portal.is_default === wanted;
+                })
+                    .map((portal) => shown(portal, expanded)));
+            }
+            if ((match = /^\/v1\/billing_portal\/configurations\/([^/]+)$/.exec(path)) !== null) {
+                const portal = double.portals.get(match[1] ?? '');
+                if (portal === undefined)
+                    return missing('configuration');
+                const { expand, ...changes } = form;
+                merge(portal, changes);
+                const expanded = Array.isArray(expand) && expand.includes('features.subscription_update.products');
+                return send(200, shown(portal, expanded));
+            }
+            if (path === '/v1/webhook_endpoints' && method === 'GET') {
+                return list([...double.endpoints.values()]);
+            }
+            if (path === '/v1/customers' && method === 'POST') {
+                const customer = {
+                    id: next('cus'),
+                    object: 'customer',
+                    email: text(form, 'email') ?? '',
+                    metadata: metadataOf(form),
+                    livemode
+                };
+                double.customers.set(customer.id, customer);
+                return send(200, customer);
+            }
+            if ((match = /^\/v1\/customers\/([^/]+)$/.exec(path)) !== null && method === 'POST') {
+                const customer = customerOf(match[1] ?? null);
+                if (customer === undefined)
+                    return missing('customer');
+                customer.email = text(form, 'email') ?? customer.email;
+                return send(200, customer);
+            }
+            if (path === '/v1/subscriptions' && method === 'GET') {
+                const customer = customerOf(text(query, 'customer'));
+                if (customer === undefined)
+                    return missing('customer');
+                return list([...double.subscriptions.values()].filter((item) => item.customer === customer.id));
+            }
+            if ((match = /^\/v1\/subscriptions\/([^/]+)$/.exec(path)) !== null) {
+                const subscription = double.subscriptions.get(match[1] ?? '');
+                if (method === 'GET')
+                    double.retrieved += 1;
+                if (subscription === undefined || customerOf(subscription.customer) === undefined) {
+                    return missing('subscription');
+                }
+                if (method === 'DELETE') {
+                    subscription.status = 'canceled';
+                    send(200, subscription);
+                    // Stripe sends the event on its own time, after its answer.
+                    later('customer.subscription.deleted', subscription);
+                    return;
+                }
+                return send(200, subscription);
+            }
+            if (path === '/v1/checkout/sessions' && method === 'POST') {
+                if (customerOf(text(form, 'customer')) === undefined)
+                    return missing('customer');
+                const id = next('cs');
+                const max = whole(form, 'line_items', '0', 'adjustable_quantity', 'maximum');
+                const session = {
+                    id,
+                    object: 'checkout.session',
+                    mode: text(form, 'mode') ?? '',
+                    customer: text(form, 'customer') ?? '',
+                    url: `${base}/pay/${id}`,
+                    subscription: null,
+                    payment_status: 'unpaid',
+                    amount_total: null,
+                    currency: null,
+                    metadata: metadataOf(form),
+                    success_url: text(form, 'success_url') ?? '',
+                    cancel_url: text(form, 'cancel_url') ?? '',
+                    item: {
+                        price: text(form, 'line_items', '0', 'price') ?? '',
+                        quantity: whole(form, 'line_items', '0', 'quantity') ?? 1,
+                        max
+                    },
+                    request: form
+                };
+                double.sessions.set(id, session);
+                return send(200, session);
+            }
+            if (path === '/v1/billing_portal/sessions' && method === 'POST') {
+                if (customerOf(text(form, 'customer')) === undefined)
+                    return missing('customer');
+                const configuration = double.portals.get(text(form, 'configuration') ?? '');
+                if (configuration === undefined) {
+                    return failed(400, 'No configuration provided and your default configuration has not been created.');
+                }
+                const back = encodeURIComponent(text(form, 'return_url') ?? '');
+                return send(200, {
+                    id: next('bps'),
+                    object: 'billing_portal.session',
+                    url: `${base}/portal/${text(form, 'customer') ?? ''}?return=${back}`
+                });
+            }
+            // The pages a person sees at Stripe.
+            if ((match = /^\/pay\/([^/]+)$/.exec(path)) !== null) {
+                const session = double.sessions.get(match[1] ?? '');
+                if (session === undefined)
+                    return send(404, {});
+                if (method === 'POST') {
+                    const quantity = new URLSearchParams(body).get('quantity');
+                    await double.pay(session.id, quantity === null ? {} : { quantity: Number(quantity) });
+                    response.writeHead(303, { location: session.success_url }).end();
+                    return;
+                }
+                const field = session.item.max === null
+                    ? ''
+                    : `<label>Quantity <input name="quantity" type="number" min="1" max="${session.item.max}" value="${session.item.quantity}"></label>`;
+                return html(page('Stripe Checkout (test double)', `<form method="POST">${field}<button type="submit">Pay</button></form>`));
+            }
+            if ((match = /^\/portal\/([^/]+)$/.exec(path)) !== null) {
+                const customer = match[1] ?? '';
+                const back = url.searchParams.get('return') ?? '/';
+                const subscription = [...double.subscriptions.values()].find((candidate) => candidate.customer === customer && candidate.status === 'active');
+                const item = subscription?.items.data[0];
+                if (method === 'POST' && subscription !== undefined && item !== undefined) {
+                    const action = new URLSearchParams(body);
+                    if (action.has('cancel'))
+                        subscription.status = 'canceled';
+                    else
+                        item.quantity = Number(action.get('quantity'));
+                    await expectOk(double.send(action.has('cancel')
+                        ? 'customer.subscription.deleted'
+                        : 'customer.subscription.updated', subscription));
+                    response.writeHead(303, { location: back }).end();
+                    return;
+                }
+                return html(page('Stripe customer portal (test double)', (item === undefined
+                    ? '<p>No subscription.</p>'
+                    : `<form method="POST"><label>Quantity <input name="quantity" type="number" min="1" value="${item.quantity}"></label><button type="submit">Update</button></form>` +
+                        '<form method="POST"><input type="hidden" name="cancel" value="1"><button type="submit">Cancel subscription</button></form>') +
+                    `<p><a href="${back}">Back</a></p>`));
+            }
+            return failed(404, `unknown ${method} ${path}`);
+        })().catch((error) => {
+            if (response.headersSent)
+                response.destroy(error instanceof Error ? error : undefined);
+            else
+                response.writeHead(500, { 'content-type': 'text/plain' }).end(String(error));
+        });
+    });
+    await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
+    const address = server.address();
+    if (address === null || typeof address === 'string')
+        throw new Error('the Stripe double has no port');
+    base = `http://127.0.0.1:${address.port}`;
+    double.url = base;
+    return double;
+}

package/dist/texts.d.ts

@@ -0,0 +1,139 @@
+import type { Language } from './product.js';
+export interface Linked {
+    before: string;
+    link: string;
+    after: string;
+}
+export interface Texts {
+    frame: {
+        navigation: string;
+        accountMenu: string;
+        logIn: string;
+        signUp: string;
+        account: string;
+        logOut: string;
+        unverified: string;
+        unverifiedLink: string;
+        legal: string;
+        imprint: string;
+        privacy: string;
+        terms: string;
+    };
+    error: {
+        notFound: string;
+        failed: string;
+        back: string;
+    };
+    wait: string;
+    signup: {
+        email: string;
+        password: string;
+        terms: Linked;
+        business: string;
+        button: string;
+        haveAccount: Linked;
+        takenLogIn: string;
+        takenReset: string;
+    };
+    login: {
+        title: string;
+        email: string;
+        password: string;
+        button: string;
+        forgot: string;
+        noAccount: Linked;
+        verified: string;
+        emailChanged: string;
+    };
+    logout: {
+        title: string;
+        button: string;
+        done: string;
+        deleted: string;
+        again: string;
+    };
+    forgot: {
+        title: string;
+        lead: string;
+        email: string;
+        button: string;
+        sent: string;
+        again: string;
+    };
+    reset: {
+        title: string;
+        password: string;
+        button: string;
+        invalid: Linked;
+    };
+    verify: {
+        title: string;
+        button: string;
+        apiAccount: string;
+        password: string;
+        invalid: string;
+        newLink: Linked;
+        logIn: Linked;
+        pending: (email: string) => string;
+        unsent: string;
+        resend: string;
+        resent: (email: string) => string;
+        confirmed: string;
+        continue: string;
+    };
+    confirm: {
+        title: string;
+        becomes: (email: string) => string;
+        button: string;
+        invalid: string;
+    };
+    account: {
+        title: string;
+        loggedIn: (email: string) => string;
+        verified: string;
+        emailChanged: string;
+        email: {
+            title: string;
+            current: (email: string) => string;
+            new: string;
+            password: string;
+            button: string;
+            sent: (email: string) => string;
+        };
+        password: {
+            title: string;
+            current: string;
+            new: string;
+            change: string;
+            set: string;
+            done: string;
+        };
+        keys: {
+            title: string;
+            lead: (example: string) => string;
+            name: string;
+            button: string;
+            created: string;
+            confirmFirst: string;
+            none: string;
+            columns: {
+                name: string;
+                key: string;
+                created: string;
+            };
+            revoke: string;
+        };
+        billing: {
+            title: string;
+            lead: string;
+            button: string;
+        };
+        delete: {
+            title: string;
+            lead: string;
+            confirm: string;
+            button: string;
+        };
+    };
+}
+export declare const TEXTS: Record<Language, Texts>;