@stacksjs/payments 0.70.45 → 0.70.54

package/dist/src/billable/webhook.d.ts

@@ -17,6 +17,15 @@ export declare function registerWebhookHandlers(handlerMap: Record<WebhookEventT
  * silently ignored.
  */
 export declare function constructEvent(payload: string | Buffer, signature: string, secret: string, tolerance?: number): Stripe.Event;
+/**
+ * Async variant of {@link constructEvent}. Some runtimes (notably Bun) resolve
+ * the Stripe SDK's crypto provider to WebCrypto's `SubtleCrypto`, which is
+ * async-only — the synchronous `constructEvent` then throws
+ * "SubtleCryptoProvider cannot be used in a synchronous context". Verifying via
+ * `constructEventAsync` works across Node and Bun, so webhook processing uses
+ * this path.
+ */
+export declare function constructEventAsync(payload: string | Buffer, signature: string, secret: string, tolerance?: number): Promise<Stripe.Event>;
 /**
  * Handle an incoming webhook event
  */

package/dist/src/idempotency.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Build a deterministic Stripe idempotency key for an operation.
+ * The `scope` should be a stable string identifying the call site
+ * (e.g. `'customer.create'`, `'subscription.create'`); `parts` are
+ * any extra identifying values (user id, lookup key, etc.) that
+ * uniquely scope the operation within that user's lifetime.
+ *
+ * @param scope - stable operation name; never user input
+ * @param parts - identifying values appended after scope (coerced
+ *                to string; nullish values are skipped)
+ */
+export declare function stacksIdempotencyKey(scope: string, ...parts: Array<string | number | null | undefined>): string;
+/**
+ * Build a one-shot idempotency key for operations that are NOT
+ * naturally retryable (a unique-per-attempt key that won't collide
+ * with anything). Used when the caller WANTS a fresh Stripe object
+ * each time but still wants the safety of a single network retry
+ * within a single attempt. The key includes a random suffix so
+ * sequential attempts produce different keys.
+ *
+ * Used for payment intents, checkout sessions — operations where
+ * "create another one" is the right semantic on a retry by the
+ * caller, but where a single network blip during a single attempt
+ * still benefits from in-flight idempotency.
+ */
+export declare function freshIdempotencyKey(scope: string, ...parts: Array<string | number | null | undefined>): string;

package/dist/src/index.d.ts

@@ -11,3 +11,6 @@ export * from './billable/index';
 // Stripe driver and SDK
 export * from './drivers/stripe';
 export * as Stripe from 'stripe';
+// Idempotency-key helpers — passed to every Stripe create/update so
+// retries don't produce duplicate objects (stacksjs/stacks#1876 X-1).
+export { freshIdempotencyKey, stacksIdempotencyKey } from './idempotency';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/payments",
   "type": "module",
-  "version": "0.70.45",
+  "version": "0.70.54",
   "description": "The Stacks payments package. Currently supporting Stripe.",
   "author": "Chris Breuer",
   "contributors": [
@@ -50,9 +50,9 @@
     "prepublishOnly": "bun run build"
   },
   "devDependencies": {
-    "@stacksjs/config": "^0.70.45",
+    "@stacksjs/config": "0.70.54",
     "better-dx": "^0.2.12",
-    "@stacksjs/utils": "^0.70.45",
+    "@stacksjs/utils": "0.70.54",
     "@stripe/stripe-js": "^8.7.0",
     "stripe": "^21.0.1"
   }