@tuppence/js 0.0.0-stage → 0.1.1

package/dist/express-mount.js

@@ -0,0 +1,272 @@
+import { appearanceFor } from "./appearance.js";
+import { TuppenceError } from "./errors.js";
+import { noStripe, wrap, } from "./express.js";
+/**
+ * The store's wallet buttons and address once they are mounted (85-10). `mount()` loads this
+ * module and nothing loads it before, so a page that takes a payment with `@tuppence/js` and
+ * shows neither (a payer's pay page) never downloads it: apps/web/scripts/check-pay-entry.mjs
+ * weighs that page.
+ */
+/**
+ * Stripe gives a wallet sheet's address and delivery events 20 s to answer before the sheet
+ * gives up on the shopper (plan/85 Gotchas). A quote that hasn't come back in 15 s is refused,
+ * so the sheet says so in its own words and the shopper can try again, instead of hanging.
+ */
+const QUOTE_TIMEOUT_MS = 15000;
+const DAY_MS = 86400000;
+/**
+ * A wallet's or the Address Element's address, as the quote takes it. Wallets redact it until
+ * the payment is authorised (a city, a region, part of a postcode). A region that is a name
+ * ("West Yorkshire") is no code, so it is left out.
+ */
+export function cartAddressOf(address) {
+    const region = address.state?.trim().toUpperCase() ?? "";
+    const postcode = address.postal_code?.trim() ?? "";
+    return {
+        country: (address.country ?? "").trim().toUpperCase(),
+        region: /^[A-Z0-9]{1,3}$/.test(region) ? region : null,
+        postcode: postcode && postcode.length <= 12 ? postcode : null,
+    };
+}
+/** The address as the basket's quote takes it, once there is a country. */
+export const asCartAddress = (value) => value?.address?.country ? cartAddressOf(value.address) : null;
+/** Days from `today` to a `YYYY-MM-DD` promise date, never fewer than none. */
+function daysTo(date, today) {
+    const from = Date.UTC(today.getFullYear(), today.getMonth(), today.getDate());
+    return Math.max(0, Math.round((Date.parse(`${date}T00:00:00Z`) - from) / DAY_MS));
+}
+/**
+ * What `ExpressCheckout` does once it is mounted (85-10): Stripe's Express Checkout Element (Apple
+ * Pay, Google Pay, Link) for a store's basket, in deferred mode: nothing is made until the shopper
+ * approves. Each address and delivery choice in the sheet is priced by the basket's quote and the
+ * sheet's total follows it (`elements.update({ amount })`); the server charges its own figure at
+ * the end. One per `ExpressCheckout`, so a remount keeps the basket as last quoted.
+ */
+export class Wallet {
+    constructor(host, tuppence, payable, options, cart) {
+        this.host = host;
+        this.tuppence = tuppence;
+        this.payable = payable;
+        this.options = options;
+        this.cart = cart;
+        this.address = null;
+        this.delivery = null;
+        this.elements = null;
+        this.basket = options.basket ?? null;
+        this.amount = payable.amount;
+    }
+    /** The delivery choices as the sheet lists them: the chosen one first, as Stripe selects it. */
+    ratesOf(basket) {
+        const today = this.options.now?.() ?? new Date();
+        const options = [...(basket?.delivery_options ?? [])].sort((a, b) => Number(b.selected) - Number(a.selected));
+        return options.map((o) => ({
+            id: o.key,
+            displayName: o.name,
+            amount: o.amount,
+            deliveryEstimate: {
+                minimum: { unit: "day", value: daysTo(o.earliest, today) },
+                maximum: { unit: "day", value: daysTo(o.latest, today) },
+            },
+        }));
+    }
+    /** A quote, or why there is none: refused after 15 s rather than left to hang the sheet. */
+    async within(ask) {
+        let timer;
+        const late = new Promise((_, reject) => {
+            timer = setTimeout(() => reject(new TuppenceError({
+                type: "api_connection_error",
+                code: "quote_timeout",
+                message: "The delivery prices took too long to come back. Try again.",
+            })), QUOTE_TIMEOUT_MS);
+        });
+        try {
+            return await Promise.race([ask(), late]);
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    /** The quote's answer for the sheet, or the reason it can't be delivered. */
+    deliverable(basket) {
+        if (!basket.totals || basket.delivery_options.length === 0) {
+            throw new TuppenceError({
+                type: "invalid_request_error",
+                code: basket.delivery_refusal?.code ?? "no_delivery_options",
+                message: basket.delivery_refusal?.message ?? "This basket can't be delivered there.",
+            });
+        }
+        return basket;
+    }
+    priced(basket) {
+        this.basket = basket;
+        this.delivery = basket.delivery_options.find((o) => o.selected)?.key ?? null;
+        this.amount = basket.totals?.due ?? this.amount;
+        this.elements?.update({ amount: this.amount });
+        this.host.emit("total", basket);
+    }
+    async addressChanged(event) {
+        const address = cartAddressOf(event.address);
+        const delivery = this.delivery;
+        try {
+            const ask = this.options.onShippingAddressChange ?? (() => this.cart.quote({ address, delivery }));
+            const basket = this.deliverable(await this.within(() => ask({ name: event.name, address, delivery })));
+            if (this.host.destroyed())
+                return;
+            this.address = address;
+            this.priced(basket);
+            event.resolve({ shippingRates: this.ratesOf(basket) });
+        }
+        catch (caught) {
+            event.reject();
+            this.host.emit("error", wrap(caught));
+        }
+    }
+    async rateChanged(event) {
+        const delivery = event.shippingRate.id;
+        const address = this.address;
+        try {
+            const ask = this.options.onShippingRateChange ?? (() => this.cart.quote({ address, delivery }));
+            const basket = this.deliverable(await this.within(() => ask({ delivery, address })));
+            if (this.host.destroyed())
+                return;
+            // The server falls back when a choice isn't offered any more: the sheet mustn't show it.
+            if (!basket.delivery_options.some((o) => o.key === delivery && o.selected)) {
+                throw new TuppenceError({
+                    type: "invalid_request_error",
+                    code: "delivery_unavailable",
+                    message: "That delivery choice isn't available any more. Choose another.",
+                });
+            }
+            this.priced(basket);
+            event.resolve();
+        }
+        catch (caught) {
+            event.reject();
+            this.host.emit("error", wrap(caught));
+        }
+    }
+    async confirmed(event) {
+        const elements = this.elements;
+        if (!elements)
+            return;
+        const failed = (error) => {
+            event.paymentFailed({ reason: "fail", message: error.message });
+            this.host.emit("error", error);
+        };
+        const token = await this.tuppence.confirmationToken(elements);
+        if ("error" in token)
+            return failed(token.error);
+        try {
+            const outcome = await this.options.onConfirm({
+                confirmationToken: token.id,
+                amount: this.amount,
+                delivery: event.shippingRate?.id ?? (this.options.shipping === false ? null : this.delivery),
+                email: event.billingDetails?.email ?? null,
+                phone: event.billingDetails?.phone ?? null,
+                shippingAddress: event.shippingAddress ?? null,
+                billingDetails: event.billingDetails ?? null,
+                expressPaymentType: event.expressPaymentType,
+                basket: this.basket,
+            });
+            const refusal = outcome?.error;
+            if (refusal) {
+                failed(new TuppenceError({
+                    type: "api_error",
+                    message: typeof refusal.message === "string"
+                        ? refusal.message
+                        : "The payment didn't go through.",
+                }));
+            }
+        }
+        catch (caught) {
+            failed(wrap(caught));
+        }
+    }
+    async load(target) {
+        const shipping = this.options.shipping !== false;
+        const [elements, basket] = await Promise.all([
+            this.tuppence.elements(this.payable, {
+                appearance: this.options.appearance ?? appearanceFor(this.payable.branding),
+            }),
+            this.basket || !shipping ? this.basket : this.cart.get(),
+        ]);
+        if (this.host.destroyed())
+            return;
+        if (!elements)
+            return this.host.emit("error", noStripe("wallet"));
+        this.elements = elements;
+        this.basket = basket;
+        this.delivery = basket?.delivery_options.find((o) => o.selected)?.key ?? null;
+        const name = this.payable.branding?.display_name;
+        const element = elements.create("expressCheckout", {
+            ...this.options.buttons,
+            emailRequired: true,
+            phoneNumberRequired: this.options.phone === true,
+            shippingAddressRequired: shipping,
+            ...(this.options.allowedShippingCountries
+                ? { allowedShippingCountries: this.options.allowedShippingCountries }
+                : {}),
+            ...(name ? { business: { name } } : {}),
+        });
+        this.host.attach(element);
+        element.on("ready", (event) => this.host.emit("ready", Object.entries(event.availablePaymentMethods ?? {})
+            .filter(([, on]) => on)
+            .map(([method]) => method)));
+        element.on("loaderror", (event) => this.host.emit("error", TuppenceError.fromStripe(event.error)));
+        // Stripe allows one second: the sheet opens on the choices already known.
+        element.on("click", (event) => {
+            const rates = this.ratesOf(this.basket);
+            if (shipping && rates.length === 0) {
+                event.reject();
+                return this.host.emit("error", noDelivery(this.basket));
+            }
+            event.resolve(shipping ? { shippingRates: rates } : {});
+        });
+        element.on("shippingaddresschange", (event) => void this.addressChanged(event));
+        element.on("shippingratechange", (event) => void this.rateChanged(event));
+        element.on("cancel", () => {
+            // The quote changed nothing: the page's total is the basket's again.
+            this.amount = this.payable.amount;
+            this.address = null;
+            elements.update({ amount: this.amount });
+            this.host.emit("cancel", undefined);
+        });
+        element.on("confirm", (event) => void this.confirmed(event));
+        element.mount(target);
+    }
+}
+const noDelivery = (basket) => new TuppenceError({
+    type: "invalid_request_error",
+    code: basket?.delivery_refusal?.code ?? "no_delivery_options",
+    message: basket?.delivery_refusal?.message ?? "This basket has no delivery options yet.",
+});
+/** Stripe's Address Element, with Stripe's autocomplete, for `AddressField`. */
+export async function mountAddress(host, tuppence, from, options, target) {
+    const elements = "create" in from
+        ? from
+        : await tuppence.elements(from, {
+            appearance: options.appearance ?? appearanceFor(from.branding),
+        });
+    if (host.destroyed())
+        return;
+    if (!elements)
+        return host.emit("error", noStripe("Stripe address field"));
+    const { mode, defaultValues, allowedCountries, phone } = options;
+    const element = elements.create("address", {
+        mode,
+        autocomplete: { mode: "automatic" },
+        ...(defaultValues ? { defaultValues } : {}),
+        ...(allowedCountries ? { allowedCountries } : {}),
+        ...(phone ? { fields: { phone } } : {}),
+    });
+    host.attach(element);
+    element.on("ready", () => host.emit("ready", undefined));
+    element.on("change", (event) => host.emit("change", {
+        complete: event.complete,
+        empty: event.empty,
+        value: event.value,
+        address: asCartAddress(event.value),
+    }));
+    element.on("loaderror", (event) => host.emit("error", TuppenceError.fromStripe(event.error)));
+    element.mount(target);
+}

package/dist/express.d.ts

@@ -0,0 +1,154 @@
+import type { Appearance, BillingDetails, ExpressPaymentType, ShippingAddress, StripeAddressElementChangeEvent, StripeAddressElementOptions, StripeElements, StripeExpressCheckoutElementOptions } from "@stripe/stripe-js";
+import { TuppenceError } from "./errors.js";
+import type { CartAddress, StorefrontCart, StorefrontCartClient, StorefrontOptions } from "./storefront.js";
+import type { Payable, Tuppence } from "./tuppence.js";
+export declare const wrap: (caught: unknown) => TuppenceError;
+/** No Stripe behind the environment (the simulated gateway): no wallet, no Stripe address. */
+export declare const noStripe: (what: string) => TuppenceError;
+/** What the mounted half may do to what the page holds: tell the page, and own the element. */
+export interface Host<H extends Record<string, (detail: never) => void>> {
+    emit<E extends keyof H>(event: E, detail: Parameters<H[E]>[0]): void;
+    destroyed(): boolean;
+    attach(element: {
+        destroy(): void;
+    }): void;
+}
+/** Something mounted where the page says, telling the page what happens to it. */
+declare abstract class Mountable<H extends Record<string, (detail: never) => void>> {
+    private handlers;
+    protected mounted: Promise<void> | null;
+    protected destroyed: boolean;
+    protected element: {
+        destroy(): void;
+    } | null;
+    on<E extends keyof H>(event: E, handler: H[E]): this;
+    /** Shows it in `target` (an element, or a selector). Loads Stripe.js if it must. */
+    mount(target: string | HTMLElement): this;
+    /** Takes it off the page (or keeps it off, while it loads) and says nothing more. */
+    destroy(): void;
+    protected emit<E extends keyof H>(event: E, detail: Parameters<H[E]>[0]): void;
+    /** What the mounted half (`./express-mount.js`) may do to this. */
+    protected host(): Host<H>;
+    protected abstract load(target: string | HTMLElement): Promise<void>;
+}
+/** What the page hears from the wallet buttons. */
+export type ExpressHandlers = {
+    /** The buttons are showing: which wallets this device and browser offer. */
+    ready: (available: string[]) => void;
+    /** The sheet's address or delivery choice was priced: the basket as quoted. */
+    total: (basket: StorefrontCart) => void;
+    /** The shopper closed the sheet. */
+    cancel: (detail: undefined) => void;
+    error: (error: TuppenceError) => void;
+};
+/** What a wallet hands the page once the shopper approves the payment. */
+export interface ExpressConfirm {
+    /** Stripe's confirmation token (`ctoken_…`): the page's server pays with it. */
+    confirmationToken: string;
+    /** What the sheet showed, in the smallest unit: the server must charge its own figure. */
+    amount: number;
+    /** The chosen delivery option's key, or null when nothing was shipped. */
+    delivery: string | null;
+    email: string | null;
+    phone: string | null;
+    shippingAddress: ShippingAddress | null;
+    billingDetails: BillingDetails | null;
+    expressPaymentType: ExpressPaymentType;
+    /** The basket as last quoted for this sheet. */
+    basket: StorefrontCart | null;
+}
+export interface ExpressCheckoutOptions {
+    /**
+     * The basket being paid: its routes answer the sheet's address and delivery changes
+     * (`POST /storefront/v1/cart/quote`). The store's own domain unless you say.
+     */
+    cart?: StorefrontCartClient | StorefrontOptions;
+    /** The basket as the page last read it: its delivery choices open the sheet. Read if not. */
+    basket?: StorefrontCart;
+    /** Prices a new address: the basket's quote unless you pass your own. */
+    onShippingAddressChange?: (change: {
+        name: string;
+        address: CartAddress;
+        delivery: string | null;
+    }) => Promise<StorefrontCart>;
+    /** Prices a new delivery choice: the basket's quote, with the sheet's address, unless you say. */
+    onShippingRateChange?: (change: {
+        delivery: string;
+        address: CartAddress | null;
+    }) => Promise<StorefrontCart>;
+    /**
+     * The shopper approved: pay with `confirmationToken` on your server. Answer `{ error }` (or
+     * throw) and the sheet says the payment failed, with your message where the wallet shows one.
+     */
+    onConfirm: (confirm: ExpressConfirm) => Promise<unknown>;
+    /** How the buttons and Stripe's sheet look: the business's branding unless you say. */
+    appearance?: Appearance;
+    /** Collect a delivery address in the sheet (the default), or not (nothing is shipped). */
+    shipping?: boolean;
+    /** Ask the wallet for a phone number too. */
+    phone?: boolean;
+    allowedShippingCountries?: string[];
+    /** Stripe's own button options, passed as they are. */
+    buttons?: Pick<StripeExpressCheckoutElementOptions, "buttonHeight" | "buttonTheme" | "buttonType" | "layout" | "paymentMethods" | "paymentMethodOrder">;
+    /** For the delivery dates in the sheet: today, unless a test says otherwise. */
+    now?: () => Date;
+}
+/**
+ * Stripe's Express Checkout Element (Apple Pay, Google Pay, Link) for a store's basket, in
+ * deferred mode: nothing is made until the shopper approves. Each address and delivery choice in
+ * the sheet is priced by the basket's quote and the sheet's total follows it
+ * (`elements.update({ amount })`); the server charges its own figure at the end.
+ */
+export declare class ExpressCheckout extends Mountable<ExpressHandlers> {
+    private readonly tuppence;
+    private readonly payable;
+    private readonly options;
+    private readonly cart;
+    private wallet;
+    constructor(tuppence: Tuppence, payable: Payable, options: ExpressCheckoutOptions, cart: StorefrontCartClient);
+    protected load(target: string | HTMLElement): Promise<void>;
+}
+/** What the page hears from the address. */
+export type AddressHandlers = {
+    ready: (detail: undefined) => void;
+    change: (change: AddressChange) => void;
+    error: (error: TuppenceError) => void;
+};
+export type AddressValue = StripeAddressElementChangeEvent["value"];
+/** The address as typed, and as the basket's quote takes it once there is a country. */
+export interface AddressChange {
+    complete: boolean;
+    empty: boolean;
+    value: AddressValue;
+    address: CartAddress | null;
+}
+export interface AddressOptions {
+    /** `shipping`: where the order goes (and the payment's shipping). `billing`: the card's. */
+    mode: "shipping" | "billing";
+    defaultValues?: StripeAddressElementOptions["defaultValues"];
+    /** The countries the store delivers to, for a shipping address. */
+    allowedCountries?: string[];
+    /** Ask for a phone number with the address. */
+    phone?: "always" | "never" | "auto";
+    /** Only when made from a payment alone: the business's branding unless you say. */
+    appearance?: Appearance;
+}
+/**
+ * Stripe's Address Element, with Stripe's autocomplete. In the payment's own Elements group (the
+ * `elements` a sheet or `tuppence.elements()` made) a shipping address goes with the payment,
+ * and Stripe's autocomplete works with no key of yours.
+ */
+export declare class AddressField extends Mountable<AddressHandlers> {
+    private readonly tuppence;
+    private readonly from;
+    private readonly options;
+    constructor(tuppence: Tuppence, from: StripeElements | Payable, options: AddressOptions);
+    /** The address, checked: Stripe shows what is missing beside its field. */
+    value(): Promise<{
+        complete: boolean;
+        value: AddressValue;
+        address: CartAddress | null;
+    }>;
+    protected load(target: string | HTMLElement): Promise<void>;
+}
+export {};

package/dist/express.js

@@ -0,0 +1,114 @@
+import { TuppenceError } from "./errors.js";
+/**
+ * The store's wallet buttons and address (85-10). What the page holds is here; what they do once
+ * mounted is in `./express-mount.js`, which `mount()` loads, so a page that only takes a payment
+ * (a payer's pay page) never downloads it (apps/web/scripts/check-pay-entry.mjs).
+ */
+const mounting = () => import("./express-mount.js");
+export const wrap = (caught) => caught instanceof TuppenceError
+    ? caught
+    : new TuppenceError({ type: "api_error", message: String(caught) });
+/** No Stripe behind the environment (the simulated gateway): no wallet, no Stripe address. */
+export const noStripe = (what) => new TuppenceError({
+    type: "invalid_request_error",
+    code: "no_card_fields",
+    message: `There is no ${what} here: this environment runs the simulated gateway.`,
+});
+/** Something mounted where the page says, telling the page what happens to it. */
+class Mountable {
+    constructor() {
+        this.handlers = {};
+        this.mounted = null;
+        this.destroyed = false;
+        this.element = null;
+    }
+    on(event, handler) {
+        const list = this.handlers[event] ?? [];
+        list.push(handler);
+        this.handlers[event] = list;
+        return this;
+    }
+    /** Shows it in `target` (an element, or a selector). Loads Stripe.js if it must. */
+    mount(target) {
+        this.destroyed = false;
+        this.mounted ?? (this.mounted = this.load(target).catch((caught) => this.emit("error", wrap(caught))));
+        return this;
+    }
+    /** Takes it off the page (or keeps it off, while it loads) and says nothing more. */
+    destroy() {
+        this.destroyed = true;
+        this.mounted = null;
+        this.element?.destroy();
+        this.element = null;
+    }
+    emit(event, detail) {
+        if (this.destroyed)
+            return;
+        for (const handler of this.handlers[event] ?? [])
+            handler(detail);
+    }
+    /** What the mounted half (`./express-mount.js`) may do to this. */
+    host() {
+        return {
+            emit: (event, detail) => this.emit(event, detail),
+            destroyed: () => this.destroyed,
+            attach: (element) => {
+                this.element = element;
+            },
+        };
+    }
+}
+/**
+ * Stripe's Express Checkout Element (Apple Pay, Google Pay, Link) for a store's basket, in
+ * deferred mode: nothing is made until the shopper approves. Each address and delivery choice in
+ * the sheet is priced by the basket's quote and the sheet's total follows it
+ * (`elements.update({ amount })`); the server charges its own figure at the end.
+ */
+export class ExpressCheckout extends Mountable {
+    constructor(tuppence, payable, options, cart) {
+        super();
+        this.tuppence = tuppence;
+        this.payable = payable;
+        this.options = options;
+        this.cart = cart;
+        this.wallet = null;
+    }
+    async load(target) {
+        const { Wallet } = await mounting();
+        if (this.destroyed)
+            return;
+        this.wallet ?? (this.wallet = new Wallet(this.host(), this.tuppence, this.payable, this.options, this.cart));
+        await this.wallet.load(target);
+    }
+}
+/**
+ * Stripe's Address Element, with Stripe's autocomplete. In the payment's own Elements group (the
+ * `elements` a sheet or `tuppence.elements()` made) a shipping address goes with the payment,
+ * and Stripe's autocomplete works with no key of yours.
+ */
+export class AddressField extends Mountable {
+    constructor(tuppence, from, options) {
+        super();
+        this.tuppence = tuppence;
+        this.from = from;
+        this.options = options;
+    }
+    /** The address, checked: Stripe shows what is missing beside its field. */
+    async value() {
+        await this.mounted;
+        const element = this.element;
+        if (!element)
+            throw new TypeError("Mount the address, and let it load, before reading it.");
+        const [{ complete, value }, { asCartAddress }] = await Promise.all([
+            element.getValue(),
+            mounting(),
+        ]);
+        return { complete, value, address: asCartAddress(value) };
+    }
+    async load(target) {
+        const { mountAddress } = await mounting();
+        if (this.destroyed)
+            return;
+        await mountAddress(this.host(), this.tuppence, this.from, this.options, target);
+    }
+}

package/dist/http.d.ts

@@ -0,0 +1,19 @@
+export type Fetch = (input: string, init: RequestInit) => Promise<Response>;
+/**
+ * The browser's routes, with nothing ambient: no cookie rides along (`credentials: "omit"`; a
+ * store's basket on its own host is the one exception, `StorefrontCartClient`), and
+ * a secret — a publishable key, a client secret — only ever travels in a header, never a URL.
+ */
+export declare class Http {
+    private readonly base;
+    private readonly fetchImpl;
+    private readonly sleep;
+    /** `same-origin` only for a store's own basket routes, whose cookie is the basket (85-10). */
+    private readonly credentials;
+    constructor(base: string, fetchImpl: Fetch, sleep?: (ms: number) => Promise<void>, 
+    /** `same-origin` only for a store's own basket routes, whose cookie is the basket (85-10). */
+    credentials?: RequestCredentials);
+    get<T>(path: string, headers: Record<string, string>): Promise<T>;
+    post<T>(path: string, headers: Record<string, string>, body: unknown): Promise<T>;
+    private request;
+}

package/dist/http.js

@@ -0,0 +1,69 @@
+import { TuppenceError } from "./errors.js";
+/**
+ * A read the server briefly couldn't answer — no answer, a 502/503/504, a 429 — is sent again,
+ * twice at most (56-03: the client conformance scenario's 503). Only a read: a confirm is never
+ * sent twice, so the card is never presented twice; its lost answer is read back instead.
+ */
+const READ_RETRIES = 2;
+const RETRY_BASE_MS = 250;
+const RETRY_MAX_MS = 2000;
+const TRANSIENT = new Set([429, 502, 503, 504]);
+/**
+ * The browser's routes, with nothing ambient: no cookie rides along (`credentials: "omit"`; a
+ * store's basket on its own host is the one exception, `StorefrontCartClient`), and
+ * a secret — a publishable key, a client secret — only ever travels in a header, never a URL.
+ */
+export class Http {
+    constructor(base, fetchImpl, sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms)), 
+    /** `same-origin` only for a store's own basket routes, whose cookie is the basket (85-10). */
+    credentials = "omit") {
+        this.base = base;
+        this.fetchImpl = fetchImpl;
+        this.sleep = sleep;
+        this.credentials = credentials;
+    }
+    get(path, headers) {
+        return this.request("GET", path, headers);
+    }
+    post(path, headers, body) {
+        return this.request("POST", path, headers, body);
+    }
+    async request(method, path, headers, body) {
+        const retries = method === "GET" ? READ_RETRIES : 0;
+        for (let attempt = 0;; attempt += 1) {
+            const wait = Math.min(RETRY_MAX_MS, RETRY_BASE_MS * 2 ** attempt);
+            let response;
+            try {
+                response = await this.fetchImpl(`${this.base}${path}`, {
+                    method,
+                    credentials: this.credentials,
+                    headers: {
+                        Accept: "application/json",
+                        ...(body === undefined ? {} : { "Content-Type": "application/json" }),
+                        ...headers,
+                    },
+                    ...(body === undefined ? {} : { body: JSON.stringify(body) }),
+                });
+            }
+            catch {
+                if (attempt < retries) {
+                    await this.sleep(wait);
+                    continue;
+                }
+                throw new TuppenceError({
+                    type: "api_connection_error",
+                    message: "Tuppence could not be reached. Check the connection and try again.",
+                });
+            }
+            const json = await response.json().catch(() => null);
+            if (response.ok)
+                return json;
+            if (attempt < retries && TRANSIENT.has(response.status)) {
+                const after = Number(response.headers.get("retry-after"));
+                await this.sleep(after > 0 ? Math.min(after * 1000, RETRY_MAX_MS) : wait);
+                continue;
+            }
+            throw TuppenceError.fromEnvelope(response.status, json);
+        }
+    }
+}