@vandenberghinc/volt 1.2.6 → 1.2.7

package/backend/dist/esm/backend/src/payments/stripe/meters.js

@@ -0,0 +1,318 @@
+// meters.ts
+/**
+ * @author Daan van den Bergh
+ * @copyright © 2026 - 2026 Daan van den Bergh. All rights reserved
+ */
+import { ensure_stripe_customer } from "./customers.js";
+import { ExternalStripeError, InternalStripeError } from "./error.js";
+import { assert, public_assert, is_non_empty_string, stripe_api_call, to_unix_seconds, stable_idempotency_key, } from "./utils.js";
+import { MeterProduct } from "./products.js";
+import { list_subscribed_meters } from "./subscriptions.js";
+/**
+ * Convert a money amount in major units (e.g. USD "0.007463") into pico-cents units (10^-12 cents) as an integer string.
+ *
+ * We fix the Stripe price for money meters at:
+ *   unit_amount_decimal (in cents) = "0.000000000001" => 10^-12 cents per unit
+ *
+ * Therefore:
+ *   units = amount_major * 100 (cents) * 10^12 = amount_major * 10^14
+ *
+ * This function never uses float math for the actual scaling; it uses string + BigInt.
+ */
+function money_major_to_pico_cents_units(amount, round) {
+    const s = amount.trim();
+    assert(s.length > 0, "invalid_argument", "Property 'amount' must be a non-empty string.", { amount });
+    // Only non-negative numbers.
+    assert(/^\d+(\.\d+)?$/.test(s), "invalid_argument", "Property 'amount' must be a non-negative decimal.", { amount });
+    const [whole_raw, frac_raw = ""] = s.split(".");
+    const whole = whole_raw ?? "0";
+    const frac = frac_raw ?? "";
+    const SHIFT = MeterProduct.MONEY_METER_MAJOR_TO_PICO_CENTS_SHIFT;
+    const frac_padded = (frac + "0".repeat(SHIFT));
+    const frac_keep = frac_padded.slice(0, SHIFT);
+    const frac_rest = frac_padded.slice(SHIFT);
+    // Determine if remainder is non-zero.
+    const remainder_nonzero = /[1-9]/.test(frac_rest);
+    let increment = false;
+    if (frac.length > SHIFT || remainder_nonzero) {
+        if (round === "exact") {
+            assert(!remainder_nonzero, "invalid_argument", "Property 'amount' has more precision than supported for exact conversion.", {
+                amount,
+                max_decimals: SHIFT,
+            });
+        }
+        else if (round === "floor") {
+            // do nothing
+        }
+        else if (round === "ceil") {
+            increment = remainder_nonzero;
+        }
+        else if (round === "round") {
+            increment = frac_rest.length > 0 && frac_rest[0] >= "5";
+        }
+        else {
+            // @ts-expect-error exhaustive
+            round.toString();
+            throw new InternalStripeError("invalid_argument", `Invalid rounding: ${round}`, { round });
+        }
+    }
+    const raw_int_str = (whole + frac_keep).replace(/^0+/, "") || "0";
+    let units = BigInt(raw_int_str);
+    if (increment) {
+        units += 1n;
+    }
+    return units.toString();
+}
+/**
+ * Normalize an amount input (string or number) to a decimal string.
+ * For numbers: use a high-precision fixed representation and trim.
+ */
+function normalize_amount_to_string(amount) {
+    if (typeof amount === "string") {
+        return amount;
+    }
+    assert(Number.isFinite(amount), "invalid_argument", "Property 'amount' must be a finite number.", { amount });
+    assert(Math.abs(amount) < 1e21, "invalid_argument", "Property 'amount' number is too large.", { amount });
+    // Avoid scientific notation / locale formatting.
+    // Using 20 decimals gives enough headroom; final conversion trunc/rounds to SHIFT anyway.
+    const s = amount.toFixed(20);
+    // Trim trailing zeros and optional dot.
+    return s.replace(/\.?0+$/, "");
+}
+/**
+ * Validate a meter event identifier according to Stripe constraints.
+ */
+function validate_meter_event_identifier(identifier) {
+    assert(identifier.length <= 100, "invalid_argument", "Meter event identifier must be <= 100 characters.", { identifier_length: identifier.length });
+    assert(identifier.trim().length > 0, "invalid_argument", "Meter event identifier must be non-empty.", {
+        identifier_length: identifier.length,
+    });
+    assert(/^[a-zA-Z0-9._-]+$/.test(identifier), "invalid_argument", "Meter event identifier contains invalid characters.", {});
+}
+/**
+ * Validate a meter event timestamp against Stripe constraints.
+ *
+ * Stripe requires:
+ * - within the past 35 calendar days
+ * - or up to 5 minutes in the future
+ * @see https://docs.stripe.com/api/billing/meter-event/create
+ */
+function validate_meter_event_timestamp(now, timestamp) {
+    const now_ms = now.getTime();
+    const ts_ms = timestamp.getTime();
+    assert(Number.isFinite(ts_ms), "invalid_argument", "Meter event timestamp is invalid.", {});
+    // 35 days is expressed as "calendar days" by Stripe; we enforce a strict 35*24h window.
+    // This is slightly stricter around DST/local offsets, but we only use UTC timestamps anyway.
+    const max_past_ms = 35 * 24 * 60 * 60 * 1000;
+    const max_future_ms = 5 * 60 * 1000;
+    assert(ts_ms >= now_ms - max_past_ms, "invalid_argument", "Meter event timestamp is too far in the past.", { now_ms, ts_ms });
+    assert(ts_ms <= now_ms + max_future_ms, "invalid_argument", "Meter event timestamp is too far in the future.", { now_ms, ts_ms });
+}
+/**
+ * Check whether a customer is currently entitled to record usage for a given metered price.
+ *
+ * Stripe docs:
+ * - List subscriptions: https://docs.stripe.com/api/subscriptions/list
+ * - Expand: https://docs.stripe.com/expand
+ */
+async function assert_customer_entitled_for_meter_price(client, server, opts) {
+    // List the subscribed meters.
+    const active_meters = await list_subscribed_meters(client, server, {
+        uid: opts.uid,
+        stripe_customer_id: opts.stripe_customer_id,
+        all_products: opts.all_products,
+    });
+    // If not entitled, this should usually be user-visible (they are not subscribed),
+    // but be careful: this function can also be called internally.
+    if (!active_meters[opts.meter_product.id]) {
+        throw new ExternalStripeError("subscription_not_active", "You must be subscribed to use this metered feature.", { uid: opts.uid, stripe_customer_id: opts.stripe_customer_id, meter_product: opts.meter_product.id });
+    }
+}
+/**
+ * Resolve configured payload keys for a meter product, using Stripe's defaults.
+ *
+ * These defaults must match the meter creation defaults in products.ts:
+ * - customer_mapping.event_payload_key defaults to "stripe_customer_id"
+ * - value_settings.event_payload_key defaults to "value"
+ * @see https://docs.stripe.com/api/billing/meter/create
+ */
+function resolve_meter_payload_keys(product) {
+    const customer_key = product.customer_mapping_event_payload_key ?? "stripe_customer_id";
+    const value_key = product.value_settings_event_payload_key ?? "value";
+    assert(customer_key.trim().length > 0, "invalid_product", "Meter customer payload key must be non-empty.", {
+        product_id: product.id,
+        customer_key,
+    });
+    assert(value_key.trim().length > 0, "invalid_product", "Meter value payload key must be non-empty.", {
+        product_id: product.id,
+        value_key,
+    });
+    // Stripe API docs specify max length 100 for these keys.
+    // @see https://docs.stripe.com/api/billing/meter/create
+    assert(customer_key.length <= 100, "invalid_product", "Meter customer payload key must be <= 100 characters.", {
+        product_id: product.id,
+        customer_key_length: customer_key.length,
+    });
+    assert(value_key.length <= 100, "invalid_product", "Meter value payload key must be <= 100 characters.", {
+        product_id: product.id,
+        value_key_length: value_key.length,
+    });
+    return { customer_key, value_key };
+}
+/**
+ * Record usage for a metered subscription by creating a Stripe Billing Meter Event.
+ *
+ * Security & correctness guarantees:
+ * - Requires that the user has an active-ish subscription containing the meter product's price id.
+ * - Uses the meter's configured payload keys for customer/value mapping.
+ * - Allows caller-provided `identifier` to dedupe retries.
+ *
+ * Stripe docs:
+ * - Create meter event: https://docs.stripe.com/api/billing/meter-event/create
+ * - Record usage guide: https://docs.stripe.com/billing/subscriptions/usage-based/recording-usage-api
+ *
+ * @throws {InternalStripeError} When round mode is `exact` and the amount has more precision than supported.
+ * @throws {InternalStripeError} On internal errors.
+ * @throws {ExternalStripeError} On external errors such as the customer not being entitled to record usage for the meter product.
+ */
+export async function record_meter_usage(client, server, all_products, opts) {
+    // -------------------------------------------------------------------------
+    // Validate inputs.
+    public_assert(is_non_empty_string(opts.uid), "invalid_argument", "Property 'uid' must be a non-empty string.");
+    assert(opts.product.type === "meter", "invalid_argument", "Property 'product' must be a meter product.", {
+        product_type: opts.product.type,
+    });
+    // Validate event name (Stripe limit 100).
+    // @see https://docs.stripe.com/api/billing/meter-event/create
+    assert(is_non_empty_string(opts.product.meter_event_name) && opts.product.meter_event_name.length <= 100, "invalid_product", "Meter product meter_event_name is invalid.", { product_id: opts.product.id, meter_event_name: opts.product.meter_event_name });
+    // Determine the value to send to Stripe.
+    let value_str;
+    const meter_kind = opts.product.kind ?? "units";
+    if (meter_kind === "money") {
+        assert("amount" in opts, "invalid_argument", "Property 'amount' must be provided for money meters.", {
+            product_id: opts.product.id,
+        });
+        const rounding = opts.round ?? "exact";
+        const amount_str = normalize_amount_to_string(opts.amount);
+        value_str = money_major_to_pico_cents_units(amount_str, rounding);
+        // Keep legacy >=0 behavior (0 is allowed); Stripe may effectively ignore it depending on config.
+        // If you want to enforce positive-only, change this to > 0.
+        assert(BigInt(value_str) >= 0n, "invalid_argument", "Property 'amount' must be >= 0.", {
+            amount: amount_str,
+            value_str,
+        });
+    }
+    else if (meter_kind === "units") {
+        assert("value" in opts, "invalid_argument", "Property 'value' must be provided for unit meters.", {
+            product_id: opts.product.id,
+        });
+        // Validate value. We require a finite non-negative integer.
+        assert(Number.isFinite(opts.value), "invalid_argument", "Property 'value' must be a finite number.", { value: opts.value });
+        assert(opts.value >= 0, "invalid_argument", "Property 'value' must be >= 0.", { value: opts.value });
+        assert(Number.isInteger(opts.value), "invalid_argument", "Property 'value' must be an integer.", { value: opts.value });
+        value_str = `${opts.value}`;
+    }
+    else {
+        // @ts-expect-error exhaustive
+        meter_kind.toString();
+        throw new InternalStripeError("invalid_product", `Invalid MeterProduct kind: ${meter_kind}`, {
+            product_id: opts.product.id,
+            meter_kind,
+        });
+    }
+    // Determine identifier (dedupe) and validate.
+    const identifier = opts.identifier;
+    validate_meter_event_identifier(identifier);
+    // Timestamp validation (if provided).
+    const now = new Date();
+    const timestamp_seconds = opts.timestamp ? to_unix_seconds(opts.timestamp) : null;
+    if (opts.timestamp) {
+        validate_meter_event_timestamp(now, opts.timestamp);
+    }
+    // Resolve Stripe customer.
+    const stripe_customer_id = await ensure_stripe_customer(client, server, opts.uid);
+    // Enforce entitlement: only record usage for subscribed users.
+    await assert_customer_entitled_for_meter_price(client, server, {
+        uid: opts.uid,
+        meter_product: opts.product,
+        stripe_customer_id,
+        all_products: all_products,
+    });
+    // Resolve meter payload keys (must match the meter configuration).
+    const { customer_key, value_key } = resolve_meter_payload_keys(opts.product);
+    // -------------------------------------------------------------------------
+    // Build payload.
+    // Stripe expects payload values as strings in many examples; we send a stringified numeric value.
+    // @see https://docs.stripe.com/api/billing/meter-event/create
+    const payload = {
+        [customer_key]: stripe_customer_id,
+        [value_key]: value_str,
+    };
+    // -------------------------------------------------------------------------
+    // Create meter event.
+    // Stripe docs: https://docs.stripe.com/api/billing/meter-event/create
+    const meter_event = await stripe_api_call(() => client.billing.meterEvents.create({
+        event_name: opts.product.meter_event_name,
+        payload,
+        identifier,
+        ...(timestamp_seconds !== null ? { timestamp: timestamp_seconds } : {}),
+    }, 
+    // Idempotency at the HTTP layer in addition to Stripe's identifier dedupe helps during transient retries.
+    { idempotencyKey: stable_idempotency_key(`meter_event_create_${identifier}`, 255) }), {
+        operation: "billing.meterEvents.create",
+        uid: opts.uid,
+        stripe_customer_id,
+        stripe_price_id: opts.product.stripe_price_id,
+        meter_event_name: opts.product.meter_event_name,
+        identifier,
+        timestamp_seconds,
+    });
+    // We only expose minimal safe fields.
+    return {
+        meter_event_identifier: meter_event.identifier,
+        event_name: meter_event.event_name,
+        timestamp: meter_event.timestamp,
+    };
+}
+/**
+ * Cancel a previously recorded meter event by identifier (best-effort within 24 hours).
+ *
+ * This is useful for:
+ * - reverting accidental double-reporting
+ * - compensating failed internal workflows
+ *
+ * Stripe docs:
+ * - Create meter event adjustment: https://docs.stripe.com/api/billing/meter-event-adjustment/create
+ */
+export async function cancel_meter_usage_event(client, server, all_products, opts) {
+    public_assert(opts.product.type === "meter", "invalid_argument", "Property 'product' must be a meter product.", {
+        product_type: opts.product.type,
+    });
+    public_assert(is_non_empty_string(opts.uid), "invalid_argument", "Property 'uid' must be a non-empty string.");
+    public_assert(is_non_empty_string(opts.meter_event_identifier), "invalid_argument", "Property 'identifier' must be a non-empty string.");
+    validate_meter_event_identifier(opts.meter_event_identifier);
+    // Resolve Stripe customer and enforce entitlement before canceling usage.
+    const stripe_customer_id = await ensure_stripe_customer(client, server, opts.uid);
+    await assert_customer_entitled_for_meter_price(client, server, {
+        uid: opts.uid,
+        meter_product: opts.product,
+        stripe_customer_id,
+        all_products: all_products,
+    });
+    // Stripe docs: https://docs.stripe.com/api/billing/meter-event-adjustment/create
+    const adjustment = await stripe_api_call(() => client.billing.meterEventAdjustments.create({
+        event_name: opts.product.meter_event_name,
+        type: "cancel",
+        cancel: { identifier: opts.meter_event_identifier },
+    }, { idempotencyKey: stable_idempotency_key(`meter_event_cancel_${opts.meter_event_identifier}`, 255) }), {
+        operation: "billing.meterEventAdjustments.create",
+        meter_event_name: opts.product.meter_event_name,
+        identifier: opts.meter_event_identifier,
+    });
+    // The adjustment status is typically "pending" initially.
+    // We keep the response minimal and safe.
+    return {
+        meter_event_identifier: opts.meter_event_identifier,
+        status: adjustment.status,
+    };
+}

package/backend/dist/esm/backend/src/payments/stripe/payment_methods.d.ts

@@ -0,0 +1,58 @@
+/**
+ * @author Daan van den Bergh
+ * @copyright © 2026 - 2026 Daan van den Bergh. All rights reserved
+ */
+import Stripe from "stripe";
+import { Server } from "../../server.js";
+/**
+ * Create a Stripe SetupIntent so the client can add a payment method and prepare it for off-session billing.
+ *
+ * Client flow:
+ * - Call this endpoint to get `client_secret`.
+ * - Confirm SetupIntent on the client (e.g. Stripe.js / mobile SDK).
+ * - Call `finalize_payment_method_setup` with the returned `setup_intent_id`.
+ *
+ * Stripe docs:
+ * - SetupIntents overview: https://docs.stripe.com/payments/setup-intents
+ * - Create SetupIntent: https://docs.stripe.com/api/setup_intents/create
+ */
+export declare function create_payment_method_setup_intent(client: Stripe, server: Server, opts: {
+    /** The internal user id, used to resolve/ensure Stripe customer. */
+    uid: string;
+    /** An optional idempotency key. */
+    idempotency_key?: string;
+}): Promise<{
+    /** The SetupIntent id. */
+    id: string;
+    /** The client secret used by the client to confirm the SetupIntent. */
+    client_secret: string;
+    /** The Stripe customer id. */
+    stripe_customer_id: string;
+}>;
+/**
+ * Finalize a confirmed SetupIntent by setting its payment method as the customer's default for invoices/subscriptions.
+ *
+ * This ensures future subscription invoices can be charged automatically.
+ *
+ * Stripe docs:
+ * - Retrieve SetupIntent: https://docs.stripe.com/api/setup_intents/retrieve
+ * - Update customer invoice_settings.default_payment_method: https://docs.stripe.com/api/customers/update
+ */
+export declare function finalize_payment_method_setup(client: Stripe, server: Server, opts: {
+    /** The internal user id, used to resolve/ensure Stripe customer. */
+    uid: string;
+    /**
+     * The SetupIntent id after client confirmation.
+     * The client should send this to the backend once confirmation succeeded.
+     */
+    setup_intent_id: string;
+    /** Optional idempotency key. */
+    idempotency_key?: string;
+}): Promise<{
+    /** The Stripe customer id. */
+    stripe_customer_id: string;
+    /** The payment method id that is now set as default. */
+    payment_method_id: string;
+    /** The SetupIntent id used to finalize. */
+    setup_intent_id: string;
+}>;

package/backend/dist/esm/backend/src/payments/stripe/payment_methods.js

@@ -0,0 +1,135 @@
+/**
+ * @author Daan van den Bergh
+ * @copyright © 2026 - 2026 Daan van den Bergh. All rights reserved
+ */
+import { ensure_stripe_customer } from "./customers.js";
+import { ExternalStripeError, InternalStripeError } from "./error.js";
+import { assert, public_assert, stripe_api_call, is_non_empty_string, stable_idempotency_key } from "./utils.js";
+// -------------------------------------------------------------------------------------------------
+// Internal helpers.
+/**
+ * Resolve a payment method id from a SetupIntent safely.
+ */
+function resolve_payment_method_id_from_setup_intent(setup_intent) {
+    const payment_method = setup_intent.payment_method;
+    // SetupIntent.payment_method is string | PaymentMethod | null.
+    if (!payment_method) {
+        throw new ExternalStripeError("payment_method_missing", "No payment method was provided. Please try again.", { setup_intent_id: setup_intent.id, status: setup_intent.status });
+    }
+    if (typeof payment_method === "string") {
+        return payment_method;
+    }
+    // If expanded, it is a PaymentMethod object with an id.
+    const id = payment_method.id;
+    if (!is_non_empty_string(id)) {
+        throw new ExternalStripeError("payment_method_missing", "No payment method was provided. Please try again.", { setup_intent_id: setup_intent.id, status: setup_intent.status });
+    }
+    return id;
+}
+/**
+ * Ensure a SetupIntent belongs to the expected customer.
+ */
+function assert_setup_intent_belongs_to_customer(opts) {
+    const { setup_intent, expected_customer_id, uid } = opts;
+    // SetupIntent.customer is string | Customer | null.
+    const setup_intent_customer = setup_intent.customer;
+    // If missing, the intent is not usable for our flow.
+    public_assert(setup_intent_customer !== null, "invalid_argument", "Setup intent is missing a customer association.", { uid, setup_intent_id: setup_intent.id });
+    const setup_customer_id = typeof setup_intent_customer === "string" ? setup_intent_customer : setup_intent_customer.id;
+    // Security: prevent a user from finalizing an intent that belongs to someone else.
+    public_assert(setup_customer_id === expected_customer_id, "invalid_argument", "Setup intent does not belong to this customer.", { uid, setup_intent_id: setup_intent.id, expected_customer_id, setup_customer_id });
+}
+// -------------------------------------------------------------------------------------------------
+// Public API.
+/**
+ * Create a Stripe SetupIntent so the client can add a payment method and prepare it for off-session billing.
+ *
+ * Client flow:
+ * - Call this endpoint to get `client_secret`.
+ * - Confirm SetupIntent on the client (e.g. Stripe.js / mobile SDK).
+ * - Call `finalize_payment_method_setup` with the returned `setup_intent_id`.
+ *
+ * Stripe docs:
+ * - SetupIntents overview: https://docs.stripe.com/payments/setup-intents
+ * - Create SetupIntent: https://docs.stripe.com/api/setup_intents/create
+ */
+export async function create_payment_method_setup_intent(client, server, opts) {
+    public_assert(is_non_empty_string(opts.uid), "invalid_argument", "Property 'uid' must be a non-empty string.");
+    // Ensure a Stripe customer exists for this user.
+    const stripe_customer_id = await ensure_stripe_customer(client, server, opts.uid);
+    // Create a SetupIntent for off-session usage so the resulting payment method can be used for subscriptions/invoices.
+    // Stripe docs: https://docs.stripe.com/api/setup_intents/create
+    let setup_intent;
+    try {
+        setup_intent = await stripe_api_call(() => client.setupIntents.create({
+            customer: stripe_customer_id,
+            // off_session indicates we plan to charge when the customer is not actively in-session.
+            usage: "off_session",
+        }, {
+            idempotencyKey: opts.idempotency_key,
+        }), { operation: "setupIntents.create", uid: opts.uid, stripe_customer_id });
+    }
+    catch (error) {
+        throw new InternalStripeError("api_error", "Failed to create a payment method setup intent.", { uid: opts.uid, stripe_customer_id }, error);
+    }
+    const client_secret = setup_intent.client_secret;
+    // SetupIntents should always return a client_secret for confirmation.
+    assert(is_non_empty_string(client_secret), "api_error", "Stripe did not return a SetupIntent client_secret.", { uid: opts.uid, stripe_customer_id, setup_intent_id: setup_intent.id });
+    return {
+        id: setup_intent.id,
+        client_secret,
+        stripe_customer_id,
+    };
+}
+/**
+ * Finalize a confirmed SetupIntent by setting its payment method as the customer's default for invoices/subscriptions.
+ *
+ * This ensures future subscription invoices can be charged automatically.
+ *
+ * Stripe docs:
+ * - Retrieve SetupIntent: https://docs.stripe.com/api/setup_intents/retrieve
+ * - Update customer invoice_settings.default_payment_method: https://docs.stripe.com/api/customers/update
+ */
+export async function finalize_payment_method_setup(client, server, opts) {
+    public_assert(is_non_empty_string(opts.uid), "invalid_argument", "Property 'uid' must be a non-empty string.");
+    public_assert(is_non_empty_string(opts.setup_intent_id), "invalid_argument", "Property 'setup_intent_id' must be a non-empty string.");
+    // Always derive the customer from uid on the server.
+    const stripe_customer_id = await ensure_stripe_customer(client, server, opts.uid);
+    // Retrieve the SetupIntent (expand payment_method to avoid extra round-trips if needed).
+    // Stripe docs: https://docs.stripe.com/api/setup_intents/retrieve
+    const setup_intent = await stripe_api_call(() => client.setupIntents.retrieve(opts.setup_intent_id, {
+        expand: ["payment_method"],
+    }), { operation: "setupIntents.retrieve", uid: opts.uid, setup_intent_id: opts.setup_intent_id });
+    // Security: ensure this SetupIntent is for the expected customer.
+    assert_setup_intent_belongs_to_customer({
+        setup_intent,
+        expected_customer_id: stripe_customer_id,
+        uid: opts.uid,
+    });
+    // The SetupIntent must be succeeded before we can safely set defaults.
+    // SetupIntent statuses: https://docs.stripe.com/api/setup_intents/object#setup_intent_object-status
+    public_assert(setup_intent.status === "succeeded", "invalid_argument", "Payment method setup is not complete. Please finish adding your payment method.", { uid: opts.uid, setup_intent_id: setup_intent.id, status: setup_intent.status });
+    // Extract the payment method id (string or expanded object).
+    const payment_method_id = resolve_payment_method_id_from_setup_intent(setup_intent);
+    // Set as default payment method for invoices/subscriptions.
+    // Stripe docs: https://docs.stripe.com/api/customers/update
+    await stripe_api_call(() => client.customers.update(stripe_customer_id, {
+        invoice_settings: {
+            default_payment_method: payment_method_id,
+        },
+    }, {
+        idempotencyKey: opts.idempotency_key ?? stable_idempotency_key(`finalize_payment_method_setup:${opts.uid}:${setup_intent.id}`),
+    }), {
+        operation: "customers.update",
+        uid: opts.uid,
+        stripe_customer_id: stripe_customer_id,
+        setup_intent_id: setup_intent.id,
+        payment_method_id,
+        action: "set_default_payment_method",
+    });
+    return {
+        stripe_customer_id: stripe_customer_id,
+        payment_method_id,
+        setup_intent_id: setup_intent.id,
+    };
+}