@volter/twin-stripe 3.0.0 → 3.0.1

package/dist/src/screens/connect-oauth.js

@@ -1,333 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { Consent, CONSENT_CSS, flowPage } from '@volter/world-ui';
-import { PLATFORM_CLIENT_ID, SETTINGS_URL } from "../engine/connect-settings.js";
-import { OAUTH_CONNECTIONS, publicBusinessName } from "../engine/display.js";
-import { redactKey } from "../engine/oauth.js";
-import { accountSettings, nowUnix, PLATFORM_ACCOUNT_ID } from "../engine/stripe.js";
-import { formOf, notFound, seeOther, STRIPE_CONSENT_SKIN } from "./shared.js";
-import { connectOAuthSettings, created, decide } from "../semantics/shared.js";
-/** A code "expires in 5 minutes". */
-const CODE_TTL_SECONDS = 300;
-const CODES = '_oauth_code';
-/** One connection per connected account (the twin's one platform): its scope, tokens, and whether it was revoked. */
-const CONNECTIONS = OAUTH_CONNECTIONS;
-const SCOPES = ['read_write', 'read_only'];
-const json = (body, status = 200) => Response.json(body, { status, headers: { 'request-id': 'req_twin', 'cache-control': 'no-store' } });
-const oauthError = (error, description, status = 400, extra = {}) => json({ error, error_description: description, ...extra }, status);
-// ── authorize ──
-/** A query parameter, or undefined when absent (an empty value is absent too, as a browser form sends one). */
-const param = (q, k) => { const v = q.get(k); return v === null || v === '' ? undefined : v; };
-/** The authorize request checked as Stripe checks it, or the JSON error it answers. */
-function checked(ctx, q) {
-    const state = param(q, 'state');
-    const fail = (error, description) => oauthError(error, description, 400, state !== undefined ? { state } : {});
-    const client = param(q, 'client_id');
-    if (!client)
-        return fail('invalid_request', 'No client_id provided.');
-    if (client !== PLATFORM_CLIENT_ID)
-        return fail('invalid_client', 'No application matches the supplied client identifier');
-    const settings = connectOAuthSettings(ctx);
-    if (!settings.oauth_enabled)
-        return fail('invalid_client', `OAuth is not enabled for this application. Enable it in your Connect OAuth settings (${SETTINGS_URL}).`);
-    const given = q.get('redirect_uri');
-    let redirect;
-    if (given !== null) {
-        if (!settings.redirect_uris.includes(given))
-            return fail('invalid_redirect_uri', `Invalid redirect URI '${given}'. Ensure this uri exactly matches one of the uris specified in your application settings`);
-        redirect = given;
-    }
-    else {
-        redirect = settings.redirect_uris[0];
-        if (!redirect)
-            return fail('invalid_redirect_uri', 'No redirect URI is configured in your application settings');
-    }
-    const type = q.get('response_type');
-    if (type === null || type === '')
-        return fail('invalid_request', 'Missing response_type parameter.');
-    if (type !== 'code')
-        return fail('unsupported_response_type', `Unsupported response_type parameter: ${type}. Currently the only supported response_type is code.`);
-    const scope = param(q, 'scope') ?? 'read_only';
-    if (!SCOPES.includes(scope))
-        return fail('invalid_scope', `Invalid scope parameter provided: '${scope}'. Accepted scopes are 'read_write' or 'read_only'.`);
-    return { redirect, scope: scope, state };
-}
-/** The redirect_uri with these parameters added, each percent-encoded (a space as %20, as Stripe's examples show). */
-function withParams(uri, params) {
-    const [base, fragment] = uri.split('#', 2);
-    const added = params.filter((p) => p[1] !== undefined).map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`).join('&');
-    return `${base}${base.includes('?') ? (base.endsWith('?') || base.endsWith('&') ? '' : '&') : '?'}${added}${fragment !== undefined ? `#${fragment}` : ''}`;
-}
-/** The prefill the request carries, invalid values silently dropped (docs.stripe.com/connect/oauth-reference). Only
- *  what the new account's object shows the platform, or the page shows the person, is read: the person's birth date and
- *  the business address are the account application's, which the twin does not model (the test-mode skip). */
-function prefill(q) {
-    const v = (k) => param(q, `stripe_user[${k}]`)?.trim() || undefined;
-    const out = {};
-    const keep = (k, ok = () => true) => { const s = v(k); if (s !== undefined && ok(s))
-        out[k] = s; };
-    keep('email', (s) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(s));
-    keep('url', (s) => /^https?:\/\/\S+$/i.test(s));
-    keep('country', (s) => /^[A-Z]{2}$/.test(s));
-    keep('phone_number', (s) => /^\d{10}$/.test(s) && out.country !== undefined);
-    keep('business_name');
-    keep('business_type', (s) => ['sole_prop', 'corporation', 'non_profit', 'partnership', 'llc'].includes(s));
-    keep('first_name');
-    keep('last_name');
-    keep('product_description');
-    keep('currency', (s) => /^[a-z]{3}$/.test(s) && out.country !== undefined);
-    return out;
-}
-// the default currency of an account in a country, where the prefill names none (docs.stripe.com/connect/currencies:
-// the account's default is its country's currency); a country outside this list is given usd
-const COUNTRY_CURRENCY = { US: 'usd', CA: 'cad', GB: 'gbp', AU: 'aud', NZ: 'nzd', JP: 'jpy', SG: 'sgd', HK: 'hkd', CH: 'chf', SE: 'sek', NO: 'nok', DK: 'dkk', PL: 'pln', MX: 'mxn', BR: 'brl', IN: 'inr', DE: 'eur', FR: 'eur', ES: 'eur', IT: 'eur', NL: 'eur', IE: 'eur', BE: 'eur', AT: 'eur', PT: 'eur', FI: 'eur' };
-const BUSINESS_TYPE = { sole_prop: 'individual', corporation: 'company', llc: 'company', partnership: 'company', non_profit: 'non_profit' };
-/** The Standard account the skipped form creates, from the prefill. */
-async function createAccount(ctx, p) {
-    const country = p.country ?? 'US';
-    const id = ctx.mint('account');
-    const none = { alternatives: [], current_deadline: null, currently_due: [], disabled_reason: null, errors: [], eventually_due: [], past_due: [], pending_verification: [] };
-    await created(ctx, 'account', { id }, {
-        type: 'standard', country, default_currency: p.currency ?? COUNTRY_CURRENCY[country] ?? 'usd', email: p.email ?? null,
-        business_type: p.business_type ? BUSINESS_TYPE[p.business_type] ?? null : null,
-        business_profile: { name: p.business_name ?? null, url: p.url ?? null, product_description: p.product_description ?? null, support_phone: p.phone_number ?? null, mcc: null },
-        charges_enabled: true, payouts_enabled: true, details_submitted: true,
-        capabilities: { card_payments: 'active', transfers: 'active' },
-        controller: { type: 'account' },
-        requirements: none, future_requirements: none,
-        settings: accountSettings(undefined, p.business_name ? { dashboard: { display_name: p.business_name, timezone: 'Etc/UTC' } } : undefined),
-        external_accounts: { object: 'list', data: [], has_more: false, total_count: 0, url: `/v1/accounts/${id}/external_accounts` },
-        tos_acceptance: { date: null, ip: null, user_agent: null }, metadata: {}, livemode: false,
-    }, { operation: 'account.oauth_connect' });
-    return id;
-}
-/** The platform's application as the account.application.* events carry it. */
-function application(ctx) {
-    return { id: PLATFORM_CLIENT_ID, object: 'application', name: publicBusinessName(ctx.get('account', PLATFORM_ACCOUNT_ID)) };
-}
-/** Send one of the account.application.* events as the connected account's: the notice it is sent for (the kernel
- *  sends it, ../semantics/events.ts renders it). */
-async function applicationEvent(ctx, type, account) {
-    await ctx.write('_application_notice', `${account}:${type}:${ctx.occurredAt}`, { account, application: application(ctx) }, type);
-}
-function page(ctx, action, a, p) {
-    const name = publicBusinessName(ctx.get('account', PLATFORM_ACCOUNT_ID));
-    const who = [p.email, [p.first_name, p.last_name].filter(Boolean).join(' '), p.business_name].filter((s) => s).join(' · ');
-    return flowPage({
-        title: `Connect to ${name} – Stripe`,
-        css: [CONSENT_CSS, STRIPE_CONSENT_SKIN],
-        body: (_jsx(Consent, { heading: `Connect your Stripe account to ${name}`, app: { name }, request: "wants to connect to your Stripe account \u00B7 test mode", permissions: [
-                a.scope === 'read_write'
-                    ? { title: 'Read and write access', detail: 'Create payments, customers and other data on your account, and read its data' }
-                    : { title: 'Read-only access', detail: 'Read your account’s data' },
-                { title: 'A new test account', detail: who || 'No details prefilled' },
-            ], action: action, fields: {}, deny: { name: 'decision', value: 'deny', label: 'Deny access' }, allow: { name: 'decision', value: 'skip', label: 'Skip this form' }, note: `Test mode: skipping the form creates a new test account and connects it. You will be returned to ${new URL(a.redirect).host}.` })),
-    });
-}
-/** The person connects: a new Standard account, its connection's code, the authorized event, and the redirect. */
-async function connect(ctx, a, p) {
-    const account = await createAccount(ctx, p);
-    // the code's row id is minted and its value drawn from the World's secret; the row keeps the value's SHA-256 alone
-    const id = ctx.mint(CODES);
-    const code = `ac_${(await ctx.secret(`stripe-oauth-code:${id}`)).replace(/[^A-Za-z0-9]/g, '').slice(0, 24)}`;
-    await ctx.record(CODES, { client_id: PLATFORM_CLIENT_ID, account, scope: a.scope, redirect_uri: a.redirect, expires_at: nowUnix(ctx.occurredAt) + CODE_TTL_SECONDS, used: false, livemode: false, sha256: ctx.crypto.sha256(code) }, id);
-    await applicationEvent(ctx, 'account.application.authorized', account);
-    return seeOther(withParams(a.redirect, [['scope', a.scope], ['code', code], ['state', a.state]]));
-}
-async function authorize(ctx) {
-    const request = ctx.call.request;
-    const url = new URL(request.url);
-    const form = request.method === 'POST' ? await formOf(request.clone()) : {};
-    const a = checked(ctx, url.searchParams);
-    if (a instanceof Response)
-        return a;
-    const p = prefill(url.searchParams);
-    if (request.method === 'GET')
-        return page(ctx, `${url.pathname}${url.search}`, a, p);
-    if (form.decision === 'deny')
-        return seeOther(withParams(a.redirect, [['error', 'access_denied'], ['error_description', 'The user denied your request'], ['state', a.state]]));
-    if (form.decision === 'skip')
-        return connect(ctx, a, p);
-    return page(ctx, `${url.pathname}${url.search}`, a, p);
-}
-// ── token and deauthorize ──
-/** The request's parameters: a form, as stripe-node and curl send them, or JSON. */
-async function bodyOf(request) {
-    const text = await request.clone().text();
-    if ((request.headers.get('content-type') ?? '').includes('json') || text.trim().startsWith('{')) {
-        try {
-            return Object.fromEntries(Object.entries(JSON.parse(text)).map(([k, v]) => [k, String(v)]));
-        }
-        catch {
-            return {};
-        }
-    }
-    return Object.fromEntries(new URLSearchParams(text));
-}
-/** The secret key a request carries: Bearer, Basic's user, or the client_secret parameter. */
-function secretKey(request, params) {
-    const header = request.headers.get('authorization') ?? '';
-    const bearer = /^bearer\s+(\S+)/i.exec(header)?.[1];
-    if (bearer)
-        return bearer;
-    const basic = /^basic\s+(\S+)/i.exec(header)?.[1];
-    if (basic) {
-        try {
-            const user = atob(basic).split(':')[0];
-            if (user)
-                return user;
-        }
-        catch { /* not base64 */ }
-    }
-    return params.client_secret || undefined;
-}
-/** The refusal of a request without a usable secret key, or undefined when it has one (answered with whether it is live). */
-function keyRefused(key) {
-    if (!key)
-        return oauthError('invalid_request', 'No API key provided. Provide your secret key in the Authorization header, using Bearer auth (e.g. \'Authorization: Bearer YOUR_SECRET_KEY\').', 401);
-    if (!/^(sk|rk)_(test|live)_/.test(key))
-        return oauthError('invalid_request', `Invalid API Key provided: ${redactKey(key)}. This endpoint requires a secret key.`, 401);
-    // a connected account's access_token is that account's key, never the platform's ("Make this call using your secret API
-    // key", the reference): it neither exchanges codes nor refreshes nor deauthorizes
-    if (/^sk_test_oauth_/.test(key))
-        return oauthError('invalid_request', `Invalid API Key provided: ${redactKey(key)}. This endpoint requires your platform's secret key.`, 401);
-    return undefined;
-}
-const live = (key) => /^(sk|rk)_live_/.test(key);
-/** A new access token for a connection: its generation counted from the ones it had. */
-/** A connection's access token of one generation: its account, then a digest of the connection's secret and the
- *  generation (the secret read before the atomic move that numbers the generation). */
-// p3: keyed by the connection's secret, drawn from ctx.secret
-const accessToken = (ctx, secret, account, n) => `sk_test_oauth_${account}_${ctx.crypto.digest('sha256', `${secret}:${n}`, 'base64url').replace(/[-_]/g, '').slice(0, 24)}`;
-/** Revoke an account's connection, once: the check and the write are one move, and only the move that revoked it sends
- *  account.application.deauthorized. Answers whether this call revoked it. */
-async function revoke(ctx, account) {
-    const revoked = await decide(ctx, (rows) => {
-        const held = rows(CONNECTIONS).find((c) => c.id === account);
-        if (!held || held.revoked === true)
-            return { value: false };
-        return { value: true, write: { resource: CONNECTIONS, id: account, fields: { revoked: true, access_token: null, revoked_at: nowUnix(ctx.occurredAt) }, operation: 'oauth_connection.revoke' } };
-    });
-    if (revoked)
-        await applicationEvent(ctx, 'account.application.deauthorized', account);
-    return revoked;
-}
-async function token(ctx) {
-    const request = ctx.call.request;
-    const params = await bodyOf(request);
-    const key = secretKey(request, params);
-    const refused = keyRefused(key);
-    if (refused)
-        return refused;
-    const grant = params.grant_type;
-    if (!grant)
-        return oauthError('invalid_request', 'No grant type specified');
-    if (grant !== 'authorization_code' && grant !== 'refresh_token')
-        return oauthError('unsupported_grant_type', `Unsupported grant type: ${grant}. The only currently supported types are authorization_code and refresh_token.`);
-    if (grant === 'authorization_code') {
-        const code = params.code;
-        if (!code)
-            return oauthError('invalid_request', 'No authorization code provided');
-        if (live(key))
-            return oauthError('invalid_grant', `Authorization code provided does not belong to the livemode of the API key: ${code} is a test mode code, but a live mode key was used.`);
-        const found = await decide(ctx, (rows) => {
-            const row = rows(CODES).find((r) => r.sha256 === ctx.crypto.sha256(code));
-            if (!row)
-                return { value: { outcome: 'missing' } };
-            // a second use is marked in the same move, so the exchange that spent it sees it after writing its connection
-            if (row.used === true)
-                return { value: { outcome: 'used', row }, write: { resource: CODES, id: String(row.id), fields: { reused: true }, operation: 'oauth_code.reuse' } };
-            if (nowUnix(ctx.occurredAt) >= Number(row.expires_at))
-                return { value: { outcome: 'expired', row } };
-            return { value: { outcome: 'ok', row }, write: { resource: CODES, id: String(row.id), fields: { used: true, used_at: nowUnix(ctx.occurredAt) }, operation: 'oauth_code.redeem' } };
-        });
-        if (found.outcome === 'missing')
-            return oauthError('invalid_grant', `Authorization code does not exist: ${code}`);
-        const account = String(found.row.account);
-        if (found.outcome === 'used') {
-            // "Consuming an authorization code more than once revokes the account connection"
-            await revoke(ctx, account);
-            return oauthError('invalid_grant', 'This authorization code has already been used. All tokens issued with this code have been revoked.');
-        }
-        if (found.outcome === 'expired')
-            return oauthError('invalid_grant', `Authorization code expired: ${code}`);
-        const granted = String(found.row.scope);
-        const refresh = `rt_${(await ctx.secret(`stripe-oauth-refresh:${String(found.row.id)}`)).replace(/[-_]/g, '').slice(0, 32)}`;
-        const secret = await ctx.secret(`stripe-oauth-access:${account}`);
-        const connection = { client_id: PLATFORM_CLIENT_ID, account, scope: granted, code: found.row.id, refresh_token: refresh, access_token: accessToken(ctx, secret, account, 1), access_scope: granted, generation: 1, publishable_key: `pk_test_oauth_${account}`, revoked: false, livemode: false };
-        await ctx.record(CONNECTIONS, connection, account);
-        // the code used again while this exchange was writing: that use found no connection to revoke, so this one does
-        if (ctx.rowsRaw(CODES).some((r) => r.id === found.row.id && r.reused === true)) {
-            await revoke(ctx, account);
-            return oauthError('invalid_grant', 'This authorization code has already been used. All tokens issued with this code have been revoked.');
-        }
-        return json(tokenBody(connection, granted));
-    }
-    const refresh = params.refresh_token;
-    if (!refresh)
-        return oauthError('invalid_request', 'No refresh token provided');
-    const held = ctx.rowsRaw(CONNECTIONS).find((c) => c.refresh_token === refresh && c.revoked !== true);
-    if (!held)
-        return oauthError('invalid_grant', `Refresh token does not exist: ${refresh}`);
-    if (live(key))
-        return oauthError('invalid_grant', 'The refresh token provided does not belong to the livemode of the API key.');
-    const asked = params.scope || String(held.scope);
-    if (!SCOPES.includes(asked))
-        return oauthError('invalid_scope', `Invalid scope parameter provided: '${asked}'. Accepted scopes are 'read_write' or 'read_only'.`);
-    if (asked === 'read_write' && held.scope !== 'read_write')
-        return oauthError('invalid_scope', `The requested scope 'read_write' is greater than the scope of the refresh token ('${String(held.scope)}').`);
-    const account = String(held.id);
-    // "Any existing access token with the same scope and mode ... is revoked": the connection holds the one now issued; the
-    // generation is read and written in one move, so two refreshes at once issue two tokens, and a refresh never lands
-    // on a connection revoked meanwhile
-    const secret = await ctx.secret(`stripe-oauth-access:${account}`);
-    const renewed = await decide(ctx, (rows) => {
-        const now = rows(CONNECTIONS).find((c) => c.id === account && c.revoked !== true);
-        if (!now)
-            return { value: undefined };
-        const generation = Number(now.generation ?? 1) + 1;
-        const fields = { access_token: accessToken(ctx, secret, account, generation), access_scope: asked, generation };
-        return { value: { ...now, ...fields }, write: { resource: CONNECTIONS, id: account, fields, operation: 'oauth_connection.refresh' } };
-    });
-    if (!renewed)
-        return oauthError('invalid_grant', `Refresh token does not exist: ${refresh}`);
-    return json(tokenBody(renewed, asked));
-}
-/** The token endpoint's answer, as the reference lists it. */
-function tokenBody(c, scope) {
-    return { access_token: c.access_token, livemode: false, refresh_token: c.refresh_token, scope, stripe_publishable_key: c.publishable_key, stripe_user_id: c.account ?? c.id, token_type: 'bearer' };
-}
-async function deauthorize(ctx) {
-    const request = ctx.call.request;
-    const params = await bodyOf(request);
-    const key = secretKey(request, params);
-    const refused = keyRefused(key);
-    if (refused)
-        return refused;
-    const client = params.client_id;
-    const account = params.stripe_user_id;
-    if (!client)
-        return oauthError('invalid_request', 'No client_id provided');
-    if (!account)
-        return oauthError('invalid_request', 'No stripe_user_id provided');
-    if (client !== PLATFORM_CLIENT_ID)
-        return oauthError('invalid_client', `No such application: '${client}'`);
-    if (live(key))
-        return oauthError('invalid_client', `The API key mode (live) does not match the mode of the client_id ${client} (test).`);
-    // the check and the revocation are one move (revoke): of two deauthorizations at once, one revokes and the other finds
-    // the account no longer connected
-    if (!(await revoke(ctx, account)))
-        return oauthError('invalid_client', `This application is not connected to stripe account ${account}, or that account does not exist.`);
-    return json({ stripe_user_id: account });
-}
-/** connect.stripe.com's OAuth endpoints; Stripe's 404 for anything else there. */
-export async function screen(ctx) {
-    const request = ctx.call.request;
-    const path = new URL(request.url).pathname.replace(/\/+$/, '');
-    if (path === '/oauth/authorize' && (request.method === 'GET' || request.method === 'POST'))
-        return authorize(ctx);
-    if (path === '/oauth/token' && request.method === 'POST')
-        return token(ctx);
-    if (path === '/oauth/deauthorize' && request.method === 'POST')
-        return deauthorize(ctx);
-    return notFound();
-}

package/dist/src/semantics/disputes.d.ts

@@ -1,2 +0,0 @@
-import type { HandlerContext } from '@volter/world-core';
-export declare function GetDisputesDispute(ctx: HandlerContext): Promise<Response>;

package/dist/src/semantics/disputes.js

@@ -1,5 +0,0 @@
-import { at, disputesDisputeMissing } from "./shared.js";
-export async function GetDisputesDispute(ctx) {
-    const d = ctx.get('dispute', at(ctx, 'dispute'));
-    return d ? ctx.reply(d) : disputesDisputeMissing(ctx, at(ctx, 'dispute'));
-}

package/dist/src/semantics/invoiceitems.d.ts

@@ -1,3 +0,0 @@
-import type { HandlerContext } from '@volter/world-core';
-export declare function DeleteInvoiceitemsInvoiceitem(ctx: HandlerContext): Promise<Response>;
-export declare function PostInvoiceitems(ctx: HandlerContext): Promise<Response>;

package/dist/src/semantics/invoiceitems.js

@@ -1,59 +0,0 @@
-import { INV, linesOf } from "../engine/invoices.js";
-import { nowUnix } from "../engine/stripe.js";
-import { at, created, fail, invoiceMissing, itemMissing, pricedItem, resyncDraftLines, writeLines } from "./shared.js";
-// an item is deleted only while its invoice is still editable
-export async function DeleteInvoiceitemsInvoiceitem(ctx) {
-    const id = at(ctx, 'invoiceitem');
-    const it = ctx.get('invoiceitem', id);
-    if (!it)
-        return itemMissing(ctx, id);
-    const onInvoice = typeof it.invoice === 'string' ? ctx.get(INV, it.invoice) : undefined;
-    if (onInvoice && onInvoice.status !== 'draft')
-        return fail(ctx, 'You cannot delete an invoice item that is attached to an invoice that is no longer editable.', 400, 'invoice_not_editable');
-    await ctx.write('invoiceitem', id, { deleted: true }, 'invoiceitem.delete');
-    if (typeof it.invoice === 'string')
-        await resyncDraftLines(ctx, it.invoice);
-    return ctx.reply({ id, object: 'invoiceitem', deleted: true });
-}
-export async function PostInvoiceitems(ctx) {
-    const params = ctx.params;
-    const now = Number(nowUnix(ctx.occurredAt));
-    const qty = Number(params.quantity) || 1;
-    // the served version names the price in `pricing[price]` ("The pricing information for the invoice item", the served
-    // spec); an older version sends `price`. It is kept as the item's price, which the answer renders as `pricing`
-    // (../engine/version.ts)
-    const { pricing: pricingParam, ...stored } = params;
-    const given = pricingParam?.price;
-    const priceRef = typeof given === 'string' && given ? given : typeof params.price === 'string' ? params.price : '';
-    const priced = priceRef ? pricedItem(ctx, priceRef, qty) : undefined;
-    if (priced instanceof Response)
-        return priced;
-    const resolvedAmount = priced?.amount;
-    let resolvedCurrency = priced?.currency;
-    // only a draft invoice takes new items
-    const invoiceRef = typeof params.invoice === 'string' ? params.invoice : '';
-    let target;
-    if (invoiceRef) {
-        target = ctx.get(INV, invoiceRef);
-        if (!target)
-            return invoiceMissing(ctx, invoiceRef);
-        if (target.status !== 'draft')
-            return fail(ctx, `This invoice cannot have invoice items added because it has status ${String(target.status)}.`, 400, 'invoice_not_editable');
-        if (resolvedCurrency === undefined && typeof target.currency === 'string')
-            resolvedCurrency = target.currency;
-    }
-    // an invoice item is dated by `date`, not `created`; its currency is the price's, else the invoice's
-    const item = await created(ctx, 'invoiceitem', { ...stored, ...(priceRef ? { price: priceRef } : {}) }, {
-        livemode: false, discountable: true, proration: false, quantity: qty, quantity_decimal: String(qty),
-        period: { start: now, end: now }, currency: resolvedCurrency ?? 'usd',
-        ...(resolvedAmount !== undefined ? { amount: resolvedAmount } : {}),
-    }, { timeField: 'date' });
-    if (target) {
-        await writeLines(ctx, invoiceRef, [...linesOf(target), {
-                id: `il_${String(item.id)}`, object: 'line_item', type: 'invoiceitem', amount: Number(item.amount) || 0, currency: String(target.currency ?? item.currency ?? 'usd'),
-                quantity: qty, proration: false, invoice_item: item.id, price: item.price ?? null,
-                period: item.period ?? { start: now, end: now }, description: item.description ?? null,
-            }]);
-    }
-    return ctx.reply(item);
-}

package/dist/src/semantics/setup_intents.d.ts

@@ -1,3 +0,0 @@
-import type { HandlerContext } from '@volter/world-core';
-export declare function PostSetupIntents(ctx: HandlerContext): Promise<Response>;
-export declare function PostSetupIntentsIntentConfirm(ctx: HandlerContext): Promise<Response>;

package/dist/src/semantics/setup_intents.js

@@ -1,41 +0,0 @@
-import { SI } from "../engine/setup-intents.js";
-import { asBool, microdepositsNextAction, mintClientSecret, requiresMicrodeposits } from "../engine/stripe.js";
-import { attachable, attachPaymentMethod, confirmOnly, created, load, mergeUpdate, methodFromData, microdepositsAsked } from "./shared.js";
-export async function PostSetupIntents(ctx) {
-    // mandate_data and return_url each "can only be used with `confirm=true`" (the served spec; shared.ts confirmOnly)
-    const unconfirmed = confirmOnly(ctx, ['mandate_data', 'return_url'], asBool(ctx.params.confirm));
-    if (unconfirmed)
-        return unconfirmed;
-    // the id is minted first so the client secret can carry it: Stripe.js parses the id back out
-    const id = typeof ctx.params.id === 'string' && ctx.params.id ? ctx.params.id : ctx.mint(SI);
-    // it waits for a payment method until it has one, then for its confirmation (manifest.ts)
-    const hasMethod = typeof ctx.params.payment_method === 'string' && ctx.params.payment_method !== '';
-    if (hasMethod)
-        ctx.legal(SI, 'status', 'PostSetupIntents', 'requires_payment_method', 'requires_confirmation', id);
-    return ctx.reply(
-    // allowed_payment_method_types in the served version names the methods (docs.stripe.com/api/setup_intents/create)
-    await created(ctx, SI, { ...ctx.params, ...(Array.isArray(ctx.params.allowed_payment_method_types) ? { payment_method_types: ctx.params.allowed_payment_method_types.map(String) } : {}), id }, {
-        status: hasMethod ? 'requires_confirmation' : 'requires_payment_method', usage: 'off_session', client_secret: mintClientSecret(id, await ctx.secret(`client-secret:${id}`)), payment_method_types: ['card'],
-        next_action: null, latest_attempt: null, last_setup_error: null, livemode: false,
-    }));
-}
-// a bank account that needs micro-deposit verification waits in requires_action; anything else succeeds. The confirm's
-// payment_method_data and mandate_data are instructions, not fields of the SetupIntent.
-export async function PostSetupIntentsIntentConfirm(ctx) {
-    const loaded = load(ctx, 'PostSetupIntentsIntentConfirm');
-    if ('answer' in loaded)
-        return loaded.answer;
-    const si = loaded.si;
-    const id = String(si.id);
-    const given = ctx.params;
-    const { payment_method_data: data, mandate_data: _mandate, ...fields } = given;
-    const made = await methodFromData(ctx, data);
-    const pm = made ?? (typeof ctx.params.payment_method === 'string' ? ctx.params.payment_method : typeof si.payment_method === 'string' ? si.payment_method : undefined);
-    if (si.status !== 'requires_action' && (requiresMicrodeposits(ctx.params, si) || microdepositsAsked(ctx, ctx.params, si, pm))) {
-        return ctx.reply(await ctx.write(SI, id, mergeUpdate(ctx, SI, id, { ...fields, ...(pm ? { payment_method: pm } : {}), status: 'requires_action', next_action: microdepositsNextAction() }), 'setup_intent.requires_action'));
-    }
-    // a setup for a customer saves the method to them (docs.stripe.com/payments/save-and-reuse): its payment method is attached
-    const customer = typeof si.customer === 'string' ? si.customer : undefined;
-    const saved = pm && customer && attachable(ctx, pm) && ctx.get('payment_method', pm)?.customer !== customer ? String((await attachPaymentMethod(ctx, pm, customer)).id) : pm;
-    return ctx.reply(await ctx.write(SI, id, mergeUpdate(ctx, SI, id, { ...fields, ...(saved ? { payment_method: saved } : {}), status: 'succeeded' }), 'setup_intent.confirm'));
-}

package/dist/src/semantics/subscription_items.d.ts

@@ -1,5 +0,0 @@
-import type { HandlerContext } from '@volter/world-core';
-export declare function DeleteSubscriptionItemsItem(ctx: HandlerContext): Promise<Response>;
-export declare function GetSubscriptionItemsItem(ctx: HandlerContext): Promise<Response>;
-export declare function PostSubscriptionItems(ctx: HandlerContext): Promise<Response>;
-export declare function PostSubscriptionItemsItem(ctx: HandlerContext): Promise<Response>;

package/dist/src/semantics/subscription_items.js

@@ -1,55 +0,0 @@
-import { subscriptionItemPrice } from "../engine/stripe.js";
-import { ITEM_ATTRIBUTES, SUB } from "../engine/subscriptions.js";
-import { at, created, fail, finder, subMissing, subscriptionsItemMissing, syncItems, withPeriod } from "./shared.js";
-export async function DeleteSubscriptionItemsItem(ctx) {
-    const id = at(ctx, 'item');
-    const si = ctx.get('subscription_item', id);
-    if (!si)
-        return subscriptionsItemMissing(ctx, id);
-    await ctx.write('subscription_item', id, { deleted: true }, 'subscription_item.delete');
-    await syncItems(ctx, String(si.subscription));
-    return ctx.reply({ id, object: 'subscription_item', deleted: true });
-}
-export async function GetSubscriptionItemsItem(ctx) {
-    const si = ctx.get('subscription_item', at(ctx, 'item'));
-    return si ? ctx.reply(withPeriod(ctx, si)) : subscriptionsItemMissing(ctx, at(ctx, 'item'));
-}
-export async function PostSubscriptionItems(ctx) {
-    const params = ctx.params;
-    const subId = typeof params.subscription === 'string' ? params.subscription : '';
-    if (!subId)
-        return fail(ctx, 'Missing required param: subscription.', 400, 'parameter_missing');
-    if (!ctx.get(SUB, subId))
-        return subMissing(ctx, subId);
-    const priceRef = typeof params.price === 'string' ? params.price : '';
-    if (!priceRef && !(params.price_data && typeof params.price_data === 'object'))
-        return fail(ctx, 'Missing required param: price.', 400, 'parameter_missing');
-    if (priceRef && !ctx.get('price', priceRef))
-        return fail(ctx, `No such price: '${priceRef}'`, 400, 'resource_missing');
-    const quantity = params.quantity !== undefined ? Math.max(0, Math.trunc(Number(params.quantity) || 0)) : 1;
-    // "metadata: Set of key-value pairs that you can attach to an object" (docs.stripe.com/api/subscription_items/create)
-    const metadata = params.metadata && typeof params.metadata === 'object' ? { metadata: params.metadata } : {};
-    const body = await created(ctx, 'subscription_item', { subscription: subId, ...(priceRef ? subscriptionItemPrice(priceRef, finder(ctx)) : { price: null, plan: null }), quantity, ...metadata }, { livemode: false, metadata: {} });
-    await syncItems(ctx, subId);
-    return ctx.reply(withPeriod(ctx, body));
-}
-export async function PostSubscriptionItemsItem(ctx) {
-    const id = at(ctx, 'item');
-    const si = ctx.get('subscription_item', id);
-    if (!si)
-        return subscriptionsItemMissing(ctx, id);
-    // only the item's own attributes are kept; the update's instructions (off_session, payment_behavior, price_data,
-    // proration_behavior, proration_date) are not attributes of the Subscription Item object
-    // (docs.stripe.com/api/subscription_items/object lists none of them)
-    const fields = Object.fromEntries(Object.entries(ctx.params).filter(([k]) => ITEM_ATTRIBUTES.has(k)));
-    if (ctx.params.quantity !== undefined)
-        fields.quantity = Math.max(0, Math.trunc(Number(ctx.params.quantity) || 0));
-    if (typeof ctx.params.price === 'string' && ctx.params.price && !ctx.get('price', ctx.params.price))
-        return fail(ctx, `No such price: '${ctx.params.price}'`, 400, 'resource_missing');
-    // the item carries its Price and plan, as the subscription's own items do (subscriptionItemPrice)
-    if (typeof ctx.params.price === 'string' && ctx.params.price)
-        Object.assign(fields, subscriptionItemPrice(ctx.params.price, finder(ctx)));
-    const out = await ctx.write('subscription_item', id, fields, 'subscription_item.update');
-    await syncItems(ctx, String(si.subscription));
-    return ctx.reply(withPeriod(ctx, out));
-}

package/dist/src/semantics/subscription_schedules.d.ts

@@ -1,4 +0,0 @@
-import type { HandlerContext } from '@volter/world-core';
-export declare function GetSubscriptionSchedulesSchedule(ctx: HandlerContext): Promise<Response>;
-export declare function PostSubscriptionSchedules(ctx: HandlerContext): Promise<Response>;
-export declare function PostSubscriptionSchedulesScheduleRelease(ctx: HandlerContext): Promise<Response>;

package/dist/src/semantics/subscription_schedules.js

@@ -1,60 +0,0 @@
-import { buildSubscriptionItemsList, nowUnix } from "../engine/stripe.js";
-import { SS } from "../engine/subscription-schedules.js";
-import { at, created, end, fail, finder, phasesOf, scheduleMissing, storeItems } from "./shared.js";
-export async function GetSubscriptionSchedulesSchedule(ctx) {
-    const s = ctx.get(SS, at(ctx, 'schedule'));
-    return s ? ctx.reply(s) : scheduleMissing(ctx, at(ctx, 'schedule'));
-}
-// a schedule starts from a customer or from an existing subscription
-export async function PostSubscriptionSchedules(ctx) {
-    const params = ctx.params;
-    const customer = typeof params.customer === 'string' ? params.customer : '';
-    const fromSub = typeof params.from_subscription === 'string' ? params.from_subscription : '';
-    if (!customer && !fromSub)
-        return fail(ctx, 'Missing required param: customer (or from_subscription).', 400, 'parameter_missing');
-    if (customer && !ctx.get('customer', customer))
-        return fail(ctx, `No such customer: '${customer}'`, 404, 'resource_missing');
-    if (fromSub && !ctx.get('subscription', fromSub))
-        return fail(ctx, `No such subscription: '${fromSub}'`, 404, 'resource_missing');
-    // start_date is an instruction ("now" or when), not a field of the schedule
-    const start = params.start_date !== undefined && params.start_date !== 'now' ? Number(params.start_date) : Number(nowUnix(ctx.occurredAt));
-    const phases = phasesOf(ctx, Array.isArray(params.phases) ? params.phases : [], start);
-    const { phases: _p, start_date: _s, default_settings: givenDefaults, ...rest } = params;
-    const defaults = givenDefaults && typeof givenDefaults === 'object' ? givenDefaults : {};
-    const schedId = ctx.mint(SS);
-    // a schedule for a customer whose first phase starts now starts its subscription at once, on that phase's items
-    // (docs.stripe.com/billing/subscriptions/subscription-schedules#managing)
-    let subscription = fromSub || null;
-    if (!fromSub && phases.length) {
-        const now = Number(nowUnix(ctx.occurredAt));
-        const subId = ctx.mint('subscription');
-        const items = buildSubscriptionItemsList(phases[0].items, subId, now, finder(ctx));
-        await created(ctx, 'subscription', { customer, id: subId }, {
-            status: 'active', livemode: false, currency: 'usd', collection_method: String(params.default_settings?.collection_method ?? 'charge_automatically'),
-            cancel_at_period_end: false, start_date: now, billing_cycle_anchor: now, metadata: {}, discounts: [], billing_schedules: [],
-            trial_start: null, trial_end: null, current_period_start: now, current_period_end: phases[0].end_date, items, schedule: schedId,
-            automatic_tax: { enabled: false, liability: null }, billing_mode: { type: 'classic' }, invoice_settings: { issuer: { type: 'self' } },
-        });
-        await storeItems(ctx, subId, items.data ?? []);
-        subscription = subId;
-    }
-    return ctx.reply(await created(ctx, SS, { ...rest, id: schedId }, {
-        status: 'active', livemode: false, phases, current_phase: phases.length ? { start_date: phases[0].start_date, end_date: phases[0].end_date } : null,
-        subscription, released_subscription: null, released_at: null,
-        canceled_at: null, completed_at: null, end_behavior: params.end_behavior ?? 'release',
-        renewal_interval: null, metadata: {}, billing_mode: { type: 'classic' },
-        // "billing_cycle_anchor: Possible values are phase_start or automatic" and invoice_settings are required (the
-        // served spec's default settings); the rest answer what the request set, else null
-        default_settings: {
-            application_fee_percent: defaults.application_fee_percent ?? null, automatic_tax: { enabled: false, liability: null, disabled_reason: null },
-            billing_cycle_anchor: typeof defaults.billing_cycle_anchor === 'string' ? defaults.billing_cycle_anchor : 'automatic', billing_thresholds: null,
-            collection_method: typeof defaults.collection_method === 'string' ? defaults.collection_method : 'charge_automatically', default_payment_method: defaults.default_payment_method ?? null,
-            description: defaults.description ?? null, invoice_settings: { account_tax_ids: null, days_until_due: null, issuer: { type: 'self' } }, on_behalf_of: null, transfer_data: null,
-        },
-        // a schedule made from a subscription is its customer's
-        customer: customer || String(ctx.get('subscription', fromSub)?.customer ?? ''),
-    }));
-}
-export async function PostSubscriptionSchedulesScheduleRelease(ctx) {
-    return (end('release'))(ctx);
-}

package/src/engine/billing.ts

@@ -1,16 +0,0 @@
-// Billing semantics: meters (how usage events aggregate), the meter events that report usage and
-// the summaries that aggregate them, prepaid credit grants and the balance they leave, and usage
-// alerts. The machines in ../manifest.ts say how a meter and an alert move. Lists and retrieves
-// with no scoping of their own are the derived core's.
-import type { Row } from './common.ts';
-
-export const METER = 'billing.meter';
-export const objectOf = (v: unknown): Row => (v && typeof v === 'object' ? (v as Row) : {});
-
-// ── credit grants: a customer's prepaid credit, paid or promotional, in a monetary amount ──
-
-export const GRANT = 'billing.credit_grant';
-
-// ── alerts: a usage threshold on a meter ──
-
-export const ALERT = 'billing.alert';

package/src/engine/charges.ts

@@ -1,19 +0,0 @@
-// Charge semantics. The machine in ../manifest.ts says a charge is captured once; these handlers
-// compute the money: a charge's `refunds` sub-list is derived on every read from the refunds that
-// point at it, never a stored snapshot, while the cumulative `amount_refunded` / `refunded` stay
-// stored (a partial capture moves them for a reason that is also a Refund row).
-import type { Row } from './common.ts';
-
-// A charge is written as the event Stripe sends for it (docs.stripe.com/api/events/types; Stripe has no
-// `charge.created`): charge.succeeded, "Occurs whenever a charge is successful", for one made or authorized
-// (capture=false: its status is succeeded, captured false), and charge.failed, "Occurs whenever a failed charge attempt
-// occurs", for a declined attempt. The twin makes no pending charge (charge.pending, "Occurs whenever a pending charge is
-// created"): its charges settle when made.
-/** The create's parameters as the charge keeps them: without `card`, the request's card details ("A token, like the ones
- *  returned by Stripe.js", or a hash of the number, expiry and CVC). The Charge object has no `card` property (served
- *  spec, charge); the card it was made with is its payment_method_details. Kept, it answered the card's full number and
- *  CVC back on every read of the charge. */
-export function withoutCard(params: Row): Row {
-  const { card: _card, ...rest } = params;
-  return rest;
-}