mppx 0.17.0 → 0.17.3

package/dist/proxy/internal/Replay.js

@@ -0,0 +1,257 @@
+import { Base64, Bytes, Hash } from 'ox';
+import * as Credential from '../../Credential.js';
+const keyPrefix = 'mppx:proxy:replay:';
+/** Applies defaults to replay options. */
+export function resolve(options) {
+    const ttl = options.ttl ?? 900_000;
+    // AbortSignal.timeout needs a positive integer that fits a 32-bit timer.
+    if (!Number.isSafeInteger(ttl) || ttl <= 0 || ttl > 2_147_483_647)
+        throw new RangeError('replay.ttl must be a positive integer number of milliseconds up to 2147483647.');
+    return {
+        maxAttempts: options.maxAttempts ?? 3,
+        maxBodySize: options.maxBodySize ?? 1_048_576,
+        maxRequestBodySize: options.maxRequestBodySize ?? 1_048_576,
+        retryAfter: options.retryAfter ?? 5,
+        store: options.store,
+        ttl,
+        waitUntil: options.waitUntil,
+    };
+}
+/** Returns the request's Payment credential header value, if it carries one. */
+export function credentialOf(request, headerNames = ['authorization']) {
+    // Only the headers the route's payment handler verifies can name a replay.
+    for (const name of headerNames) {
+        const header = request.headers.get(name);
+        const payment = header ? Credential.extractPaymentScheme(header) : null;
+        if (payment)
+            return payment;
+    }
+    return undefined;
+}
+/** Reads a request body, or returns null when it is larger than maxRequestBodySize. */
+export async function readBody(request, maxRequestBodySize) {
+    const length = Number(request.headers.get('content-length'));
+    if (Number.isFinite(length) && length > maxRequestBodySize)
+        return null;
+    if (!request.body)
+        return new Uint8Array();
+    return keep(request.body, maxRequestBodySize);
+}
+/** Derives the replay key from the credential and the exact request (origin, path, query, method, body) it paid for. */
+export function key(parameters) {
+    const bodyHash = Hash.sha256(parameters.body, { as: 'Hex' });
+    const input = JSON.stringify([
+        parameters.credential,
+        parameters.method.toUpperCase(),
+        parameters.target,
+        bodyHash,
+    ]);
+    return keyPrefix + Hash.sha256(Bytes.fromString(input), { as: 'Hex' }).slice(2);
+}
+/** Rebuilds a request around an already-read body, optionally with another abort signal. */
+export function withBody(request, body, signal, headers) {
+    const method = request.method.toUpperCase();
+    const hasBody = method !== 'GET' && method !== 'HEAD';
+    return new globalThis.Request(request.url, {
+        // An empty body stays absent, as on the original request: payment
+        // transports tell management requests apart by a missing body.
+        body: hasBody && body.byteLength > 0 ? body : null,
+        headers: headers ?? request.headers,
+        method: request.method,
+        redirect: request.redirect,
+        signal: signal ?? request.signal,
+    });
+}
+/** Looks up a delivery and, for a failed one, claims the next upstream attempt. */
+export async function lookup(replay, replayKey) {
+    const now = Date.now();
+    // Read first: only a failed delivery needs an atomic claim, so unknown
+    // credentials never cause a store write.
+    const seen = (await replay.store.get(replayKey));
+    if (!seen)
+        return { type: 'none' };
+    if (seen.expires > now && seen.status !== 'failed')
+        return { response: respond(replay, seen), type: 'respond' };
+    const result = await replay.store.update(replayKey, (current) => {
+        const record = current;
+        if (!record)
+            return { op: 'noop', result: { type: 'none' } };
+        if (record.expires <= now)
+            return { op: 'delete', result: { type: 'none' } };
+        if (record.status !== 'failed' || record.attempts >= replay.maxAttempts)
+            return { op: 'noop', result: record };
+        const attempts = record.attempts + 1;
+        return {
+            op: 'set',
+            value: { ...record, attempts, status: 'pending' },
+            result: {
+                attempts,
+                receipt: record.receipt,
+                requestHeaders: record.requestHeaders,
+                type: 'retry',
+            },
+        };
+    });
+    if ('type' in result)
+        return result;
+    return { response: respond(replay, result), type: 'respond' };
+}
+/** Builds the response for a recorded delivery that is not retried. */
+function respond(replay, record) {
+    if (record.status === 'complete')
+        return fromRecord(record);
+    if (record.status === 'delivered')
+        return Response.json({ error: 'The paid response was delivered and is not stored for replay.' }, { status: 410 });
+    if (record.status === 'pending')
+        return new Response(null, {
+            headers: { 'Retry-After': String(replay.retryAfter) },
+            status: 202,
+        });
+    return withReceiptHeader(Response.json({ error: 'The paid upstream request failed.' }, { status: 502 }), record.receipt);
+}
+/** Runs a paid upstream delivery detached from the client and records its outcome. */
+export async function deliver(parameters) {
+    const { applyReceipt, attempts, replay, replayKey, requestHeaders } = parameters;
+    // Outcomes are kept for ttl from when they are recorded, not from the start.
+    const expires = () => Date.now() + replay.ttl;
+    await record(replay, replayKey, {
+        attempts,
+        expires: expires(),
+        receipt: null,
+        requestHeaders,
+        status: 'pending',
+    });
+    let response;
+    try {
+        // ttl bounds the wait for the upstream to respond, not how long its body
+        // streams: a paid stream keeps going once it has started.
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(new DOMException('Replay ttl elapsed.', 'TimeoutError')), replay.ttl);
+        let upstream;
+        try {
+            upstream = await parameters.run(controller.signal);
+        }
+        finally {
+            clearTimeout(timer);
+        }
+        response = await applyReceipt(upstream);
+    }
+    catch {
+        const failed = await applyReceipt(Response.json({ error: 'The paid upstream request failed.' }, { status: 502 }));
+        await recordFailure(replay, replayKey, attempts, requestHeaders, expires(), failed.headers.get('Payment-Receipt'));
+        return failed;
+    }
+    const receipt = response.headers.get('Payment-Receipt');
+    if (response.status >= 500) {
+        await recordFailure(replay, replayKey, attempts, requestHeaders, expires(), receipt);
+        return response;
+    }
+    if (!response.body) {
+        await record(replay, replayKey, toRecord(response, new Uint8Array(), expires()));
+        return response;
+    }
+    if (/^text\/event-stream/i.test(response.headers.get('content-type') ?? '')) {
+        await record(replay, replayKey, { expires: expires(), status: 'delivered' });
+        return response;
+    }
+    // Keep a copy while the client reads the other branch, so a client that
+    // disconnects mid-body can still collect the response on retry.
+    const [client, kept] = response.body.tee();
+    const stored = keep(kept, replay.maxBodySize)
+        .then((body) => replay.store.put(replayKey, body
+        ? toRecord(response, body, expires())
+        : { expires: expires(), status: 'delivered' }), 
+    // The upstream body broke off: let the payer retry the delivery.
+    () => recordFailure(replay, replayKey, attempts, requestHeaders, expires(), receipt))
+        // A failed background write leaves the record pending until it expires.
+        .catch(() => { });
+    replay.waitUntil?.(stored);
+    return new Response(client, {
+        headers: response.headers,
+        status: response.status,
+        statusText: response.statusText,
+    });
+}
+/** Reads a body branch up to maxBodySize, or returns null when it is larger. */
+async function keep(stream, maxBodySize) {
+    const reader = stream.getReader();
+    const chunks = [];
+    let size = 0;
+    for (;;) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        size += value.byteLength;
+        if (size > maxBodySize) {
+            void reader.cancel().catch(() => { });
+            return null;
+        }
+        chunks.push(value);
+    }
+    const body = new Uint8Array(size);
+    let offset = 0;
+    for (const chunk of chunks) {
+        body.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return body;
+}
+/**
+ * Writes a replay record without letting a store failure break the paid
+ * delivery: the payer still gets the upstream response, only replay is lost.
+ */
+async function record(replay, replayKey, value) {
+    try {
+        await replay.store.put(replayKey, value);
+    }
+    catch { }
+}
+async function recordFailure(replay, replayKey, attempts, requestHeaders, expires, receipt) {
+    await record(replay, replayKey, {
+        attempts,
+        expires,
+        receipt,
+        requestHeaders,
+        status: 'failed',
+    });
+}
+/** Adds a stored receipt to a response built for a retried delivery. */
+export function withReceiptHeader(response, receipt) {
+    if (!receipt)
+        return response;
+    const headers = new Headers(response.headers);
+    headers.set('Payment-Receipt', receipt);
+    headers.set('Cache-Control', withPrivateCacheControl(headers.get('Cache-Control')));
+    return new Response(response.body, {
+        headers,
+        status: response.status,
+        statusText: response.statusText,
+    });
+}
+function withPrivateCacheControl(value) {
+    if (!value)
+        return 'private';
+    const directives = value.split(',').map((directive) => directive.trim().toLowerCase());
+    if (directives.includes('private'))
+        return value;
+    return `${value}, private`;
+}
+function toRecord(response, body, expires) {
+    return {
+        body: Base64.fromBytes(body),
+        expires,
+        headers: [...response.headers.entries()],
+        responseStatus: response.status,
+        status: 'complete',
+        statusText: response.statusText,
+    };
+}
+function fromRecord(record) {
+    const nullBody = [101, 204, 205, 304].includes(record.responseStatus);
+    return new Response(nullBody ? null : Base64.toBytes(record.body), {
+        headers: record.headers,
+        status: record.responseStatus,
+        statusText: record.statusText,
+    });
+}
+//# sourceMappingURL=Replay.js.map

package/dist/server/Mppx.d.ts

@@ -414,6 +414,8 @@ type ConfiguredHandler<transport extends Transport.AnyTransport = Transport.Http
         _stableBinding?: Method.StableBindingFn<Method.Method> | undefined;
         /** The offer's payment-stage identity verifiers, if any. */
         _paymentIdentity?: readonly Identity.Verifier[] | undefined;
+        /** Whether the route requires identity verifiers (request or payment stage). */
+        _identity?: boolean | undefined;
         _transport: Transport.AnyTransport;
     };
 };

package/dist/server/Mppx.js

@@ -468,6 +468,7 @@ function createMethodFn(parameters) {
             ],
             _canonicalRequest: PaymentRequest.fromMethod(method, { ...defaults, ...rest }),
             _paymentIdentity: paymentVerifiers.length > 0 ? paymentVerifiers : undefined,
+            _identity: identity.length > 0,
             _stableBinding: stableBinding,
             _transport: transport,
         };
@@ -1875,11 +1876,12 @@ function composeHandlers(handlers, composeOptions, selectOffers) {
             }
             mergedHeaders.set('Content-Type', 'text/html; charset=utf-8');
             const firstData = Object.values(dataMap)[0];
+            const entries = await Promise.all(htmlEntries.map(async (entry) => ({
+                challenge: entry.challenge,
+                content: await Html.resolveContent(entry.handler._internal.html.content),
+            })));
             const body = Html.render({
-                entries: htmlEntries.map((entry) => ({
-                    challenge: entry.challenge,
-                    content: entry.handler._internal.html.content,
-                })),
+                entries,
                 dataMap,
                 formattedAmount: firstData.formattedAmount,
                 panels: true,
@@ -1916,11 +1918,11 @@ function composeHandlers(handlers, composeOptions, selectOffers) {
         composed._internal = { offers, handlers: handlers, selectOffers };
     return composed;
 }
-/** Returns the flattened configured offers accepted by a handler. */
 /** Whether two verifier lists hold the same verifiers in the same order. */
 function sameVerifiers(a, b) {
     return a.length === b.length && a.every((verifier, i) => verifier === b[i]);
 }
+/** Returns the flattened configured offers accepted by a handler. */
 function getConfiguredOffers(handler) {
     const internal = handler._internal;
     if (!internal)

package/dist/server/Transport.js

@@ -98,7 +98,7 @@ export function http(options = {}) {
                         },
                     };
                     return Html.render({
-                        entries: [{ challenge, content: options.html.content }],
+                        entries: [{ challenge, content: await Html.resolveContent(options.html.content) }],
                         dataMap,
                         formattedAmount: amount,
                         text,

package/dist/server/internal/html/config.d.ts

@@ -2,7 +2,11 @@ import type * as Challenge from '../../../Challenge.js';
 import type * as Method from '../../../Method.js';
 export type Options = {
     config: Record<string, unknown>;
-    content: string;
+    /**
+     * The payment page's script, or a function that loads it. A loader lets a
+     * method import its (large) page bundle only when a page is rendered.
+     */
+    content: string | (() => Promise<string>);
     formatAmount: (request: any) => string | Promise<string>;
     text: Text | undefined;
     theme: Theme | undefined;
@@ -21,6 +25,8 @@ export type Data<method extends Method.Method = Method.Method, config extends Re
     };
 };
 export { attrs, classNames, ids, params } from './constants.js';
+/** Resolves {@link Options.content}, loading it when it is a loader function. */
+export declare function resolveContent(content: Options['content']): Promise<string>;
 declare class CssVar {
     readonly name: string;
     constructor(token: string);

package/dist/server/internal/html/config.js

@@ -2,6 +2,10 @@ import { Json } from 'ox';
 import { tabScript } from './compose.main.gen.js';
 export { attrs, classNames, ids, params } from './constants.js';
 import { attrs, classNames, ids } from './constants.js';
+/** Resolves {@link Options.content}, loading it when it is a loader function. */
+export async function resolveContent(content) {
+    return typeof content === 'function' ? content() : content;
+}
 function logoColorScheme(colorScheme) {
     return colorScheme === 'dark' || colorScheme === 'light'
         ? `${classNames.logo}--${colorScheme}`

package/dist/stripe/internal/types.d.ts

@@ -1,4 +1,3 @@
-import * as StripeJsTypes from '../../stripe/server/internal/html/types.js';
 /**
  * Duck-typed interface for the Stripe Node SDK (`stripe` npm package).
  * Matches the subset of the API used by mppx for server-side payment verification.
@@ -31,9 +30,86 @@ export type StripeJs = {
     createPaymentMethod(...args: any[]): Promise<Record<string, unknown>>;
     elements(...args: any[]): unknown;
 };
-export type CreatePaymentMethodFromElements = Omit<StripeJsTypes.CreatePaymentMethodFromElements, 'elements'> & {};
-export type StripeElementsOptionsMode = Omit<Extract<StripeJsTypes.StripeElementsOptionsMode, {
-    mode: 'payment';
-}>, 'amount' | 'currency' | 'mode' | 'excludedPaymentMethodTypes' | 'paymentMethodCreation' | 'paymentMethodTypes' | 'payment_method_types'> & {};
-export type StripePaymentElementOptions = StripeJsTypes.StripePaymentElementOptions;
+/** A nested Stripe.js option object, passed through to Stripe.js as is. */
+type StripeJsObject = {
+    readonly [key: string]: any;
+};
+/**
+ * Stripe.js Elements appearance (`Appearance` in `@stripe/stripe-js`).
+ *
+ * @see https://docs.stripe.com/elements/appearance-api
+ */
+export type StripeAppearance = {
+    disableAnimations?: boolean | undefined;
+    theme?: 'stripe' | 'night' | 'flat' | undefined;
+    variables?: StripeJsObject | undefined;
+    rules?: StripeJsObject | undefined;
+    labels?: 'auto' | 'above' | 'floating' | undefined;
+    inputs?: 'spaced' | 'condensed' | undefined;
+};
+/**
+ * Options for `stripe.createPaymentMethod` with Elements, without `elements`
+ * (`CreatePaymentMethodFromElements` in `@stripe/stripe-js`).
+ *
+ * Structural so mppx's types don't depend on `@stripe/stripe-js`; its values stay assignable.
+ */
+export type CreatePaymentMethodFromElements = {
+    /** Payment method parameters (`PaymentMethodCreateParams`). */
+    params?: StripeJsObject | undefined;
+    metadata?: {
+        readonly [name: string]: string | number | null;
+    } | undefined;
+};
+/**
+ * Options for `stripe.elements` in payment mode, without the fields mppx sets from the
+ * Challenge (`StripeElementsOptionsMode` in `@stripe/stripe-js`).
+ *
+ * Structural so mppx's types don't depend on `@stripe/stripe-js`; its values stay assignable.
+ */
+export type StripeElementsOptionsMode = {
+    adaptivePricing?: {
+        allowed?: boolean | undefined;
+    } | undefined;
+    allowedPaymentMethodTypes?: readonly string[] | undefined;
+    appearance?: StripeAppearance | undefined;
+    captureMethod?: 'manual' | 'automatic' | 'automatic_async' | undefined;
+    capture_method?: 'manual' | 'automatic' | 'automatic_async' | undefined;
+    clientSecret?: undefined;
+    customPaymentMethods?: readonly StripeJsObject[] | undefined;
+    customerOptions?: StripeJsObject | undefined;
+    customerSessionClientSecret?: string | undefined;
+    externalPaymentMethodTypes?: readonly string[] | undefined;
+    fonts?: readonly StripeJsObject[] | undefined;
+    loader?: 'auto' | 'always' | 'never' | undefined;
+    locale?: string | undefined;
+    onBehalfOf?: string | undefined;
+    on_behalf_of?: string | undefined;
+    paymentMethodConfiguration?: string | undefined;
+    payment_method_configuration?: string | undefined;
+    paymentMethodOptions?: StripeJsObject | undefined;
+    payment_method_options?: StripeJsObject | undefined;
+    setupFutureUsage?: 'off_session' | 'on_session' | null | undefined;
+    setup_future_usage?: 'off_session' | 'on_session' | null | undefined;
+    syncAddressCheckbox?: 'billing' | 'shipping' | 'none' | undefined;
+};
+/**
+ * Options for the Stripe.js Payment Element (`StripePaymentElementOptions` in `@stripe/stripe-js`).
+ *
+ * Structural so mppx's types don't depend on `@stripe/stripe-js`; its values stay assignable.
+ */
+export type StripePaymentElementOptions = {
+    applePay?: StripeJsObject | undefined;
+    business?: {
+        name: string;
+    } | undefined;
+    defaultValues?: StripeJsObject | undefined;
+    fields?: StripeJsObject | undefined;
+    layout?: string | StripeJsObject | undefined;
+    paymentMethodOrder?: readonly string[] | undefined;
+    readOnly?: boolean | undefined;
+    terms?: StripeJsObject | undefined;
+    walletOptions?: StripeJsObject | undefined;
+    wallets?: StripeJsObject | undefined;
+};
+export {};
 //# sourceMappingURL=types.d.ts.map

package/dist/stripe/server/Charge.js

@@ -5,7 +5,6 @@ import { stripePreviewVersion } from '../internal/constants.js';
 import * as PaymentIntent from '../internal/payment-intent.js';
 import * as Methods from '../Methods.js';
 import { buildAnalytics } from './internal/analytics.js';
-import { html as htmlContent } from './internal/html.gen.js';
 /**
  * Stripe's general minimum charge amounts in each currency's smallest unit.
  * Payment methods with lower provider-specific exceptions remain conservatively
@@ -91,7 +90,7 @@ export function charge(parameters) {
         html: 'publishableKey' in htmlConfig && htmlConfig.publishableKey && htmlConfig.createTokenUrl
             ? {
                 config: htmlConfig,
-                content: htmlContent,
+                content: async () => (await import('./internal/html.gen.js')).html,
                 formatAmount: (request) => {
                     try {
                         const formatter = new Intl.NumberFormat('en', {