@stacksjs/payments 0.75.74 → 0.75.76

package/dist/driver/adyen.d.ts

@@ -0,0 +1,64 @@
+import type { ChargeOptions, CheckoutRequest, CheckoutSession, CreatePaymentOptions, Customer, Money, Payer, PaymentDriver, PaymentEvent, PaymentResult, PaymentStatus, RefundOptions, RefundResult, StoredPaymentMethod, WebhookRequest } from './types';
+/**
+ * Adyen's `resultCode` in our terms. Only `Authorised`, `Refused`, `Error`
+ * and `Cancelled` are final; everything else waits on the payer or a webhook.
+ */
+export declare function adyenStatus(resultCode: string | undefined): PaymentStatus;
+/**
+ * The string Adyen signs for a standard webhook item: eight fields joined by
+ * colons, empty ones as empty strings.
+ */
+export declare function adyenSigningPayload(item: NotificationItem): string;
+/** HMAC-SHA256 of the signing payload under the hex key, base64. */
+export declare function adyenSignature(item: NotificationItem, hmacKey: string): string;
+export declare const ADYEN_API_VERSION: 'v72';
+/**
+ * The Adyen driver (stacksjs/stacks#450), on Checkout API v72.
+ *
+ * Adyen is a processor like Stripe, not a merchant of record, so payments,
+ * hosted checkout, refunds, stored cards and webhooks map across. It has no
+ * product catalog, no subscriptions, no invoices and no customer object:
+ * a payer is a `shopperReference` you choose, and recurring billing is charging
+ * a stored card on your own schedule. Those operations throw
+ * {@link PaymentUnsupportedError}.
+ *
+ * Verified against Adyen's API reference and its published HMAC example; not
+ * yet run against a live merchant account.
+ */
+export declare interface AdyenConfig {
+  apiKey: string
+  merchantAccount: string
+  environment: 'test' | 'live'
+  liveUrlPrefix?: string
+  hmacKey?: string
+  shopperReferencePrefix?: string
+}
+declare interface NotificationItem {
+  pspReference?: string
+  originalReference?: string
+  merchantAccountCode?: string
+  merchantReference?: string
+  amount?: { value?: number, currency?: string }
+  eventCode?: string
+  success?: string | boolean
+  additionalData?: Record<string, string>
+}
+export declare class AdyenDriver implements PaymentDriver {
+  readonly name: string;
+  readonly capabilities: unknown;
+  constructor(config: AdyenConfig, options?: { fetch?: typeof fetch });
+  get baseUrl(): string;
+  shopperReference(payer: Payer): string;
+  customer(payer: Payer): Promise<Customer>;
+  charge(payer: Payer, amount: Money, paymentMethod: string, options?: ChargeOptions): Promise<PaymentResult>;
+  createPayment(payer: Payer, amount: Money, options?: CreatePaymentOptions): Promise<PaymentResult>;
+  refund(paymentId: string, options?: RefundOptions): Promise<RefundResult>;
+  checkout(payer: Payer, request: CheckoutRequest): Promise<CheckoutSession>;
+  paymentMethods(payer: Payer): Promise<StoredPaymentMethod[]>;
+  removePaymentMethod(payer: Payer, paymentMethodId: string): Promise<void>;
+  subscribe(): Promise<never>;
+  cancelSubscription(): Promise<never>;
+  subscriptions(): Promise<never>;
+  verifyWebhook(request: WebhookRequest): Promise<PaymentEvent[]>;
+  acknowledgeWebhook(): Response;
+}

package/dist/driver/adyen.js

@@ -0,0 +1 @@
+import{createHmac,randomUUID,timingSafeEqual}from"node:crypto";import{assertMoney,PaymentProviderError,PaymentUnsupportedError,WebhookSignatureError}from"./types";export const ADYEN_API_VERSION="v72";const CAPABILITIES=new Set(["customers","charge","createPayment","refund","checkout","paymentMethods","webhooks"]);export function adyenStatus(resultCode){switch(resultCode){case"Authorised":return"succeeded";case"Refused":case"Error":return"failed";case"Cancelled":return"canceled";case"RedirectShopper":case"ChallengeShopper":case"IdentifyShopper":case"PresentToShopper":return"requires_action";default:return"processing"}}const EVENT_TYPES={AUTHORISATION:["payment.succeeded","payment.failed"],CANCELLATION:["payment.canceled","unknown"],REFUND:["refund.succeeded","refund.failed"],REFUND_FAILED:["refund.failed","refund.failed"],CANCEL_OR_REFUND:["refund.succeeded","refund.failed"]};export function adyenSigningPayload(item){return[item.pspReference??"",item.originalReference??"",item.merchantAccountCode??"",item.merchantReference??"",item.amount?.value??"",item.amount?.currency??"",item.eventCode??"",String(item.success??"")].join(":")}export function adyenSignature(item,hmacKey){return createHmac("sha256",Buffer.from(hmacKey,"hex")).update(adyenSigningPayload(item),"utf8").digest("base64")}export class AdyenDriver{name="adyen";capabilities=CAPABILITIES;config;fetch;constructor(config,options={}){if(!config.apiKey)throw Error("The Adyen payment driver needs an API key: set ADYEN_API_KEY or payment.adyen.apiKey.");if(!config.merchantAccount)throw Error("The Adyen payment driver needs a merchant account: set ADYEN_MERCHANT_ACCOUNT or payment.adyen.merchantAccount.");if(config.environment==="live"&&!config.liveUrlPrefix)throw Error("Adyen live requests go to your account's own endpoint: set ADYEN_LIVE_URL_PREFIX or payment.adyen.liveUrlPrefix.");this.config=config;this.fetch=options.fetch??fetch}get baseUrl(){return this.config.environment==="live"?`https://${this.config.liveUrlPrefix}-checkout-live.adyenpayments.com/checkout/${ADYEN_API_VERSION}`:`https://checkout-test.adyen.com/${ADYEN_API_VERSION}`}shopperReference(payer){return`${this.config.shopperReferencePrefix??"user-"}${payer.id}`}async request(method,path,options={}){const url=new URL(`${this.baseUrl}${path}`);for(const[key,value]of Object.entries(options.query??{}))url.searchParams.set(key,value);const headers={"X-API-Key":this.config.apiKey,Accept:"application/json"};if(options.body!==void 0)headers["Content-Type"]="application/json";if(options.idempotencyKey)headers["Idempotency-Key"]=options.idempotencyKey;const response=await this.fetch(url,{method,headers,body:options.body===void 0?void 0:JSON.stringify(options.body)});if(response.status===204)return;const text=await response.text(),body=text?JSON.parse(text):void 0;if(!response.ok){const error=body;throw new PaymentProviderError("adyen",response.status,error?.message??response.statusText,error?.errorCode??null)}return body}amount(money){assertMoney(money);return{value:money.amount,currency:money.currency.toUpperCase()}}async customer(payer){return{id:this.shopperReference(payer),email:payer.email??null,name:payer.name??null}}async charge(payer,amount,paymentMethod,options={}){const response=await this.request("POST","/payments",{body:{merchantAccount:this.config.merchantAccount,amount:this.amount(amount),reference:options.reference??randomUUID(),paymentMethod:{type:"scheme",storedPaymentMethodId:paymentMethod},shopperReference:this.shopperReference(payer),shopperInteraction:"ContAuth",recurringProcessingModel:"UnscheduledCardOnFile",...options.metadata?{metadata:options.metadata}:{}},idempotencyKey:options.idempotencyKey});return{id:response.pspReference,status:adyenStatus(response.resultCode),amount:{amount:amount.amount,currency:amount.currency.toLowerCase()},...response.action?.url?{redirectUrl:response.action.url}:{},...response.refusalReason?{failureReason:response.refusalReason}:{},raw:response}}async createPayment(payer,amount,options={}){if(!options.returnUrl)throw TypeError("An Adyen payment session needs a returnUrl: where the payer comes back after authenticating.");const session=await this.request("POST","/sessions",{body:{merchantAccount:this.config.merchantAccount,amount:this.amount(amount),reference:options.reference??randomUUID(),returnUrl:options.returnUrl,mode:"embedded",shopperReference:this.shopperReference(payer),...options.metadata?{metadata:options.metadata}:{}},idempotencyKey:options.idempotencyKey});return{id:session.id,status:"requires_payment_method",amount:{amount:amount.amount,currency:amount.currency.toLowerCase()},clientConfirmation:{provider:"adyen",sessionId:session.id,sessionData:session.sessionData},raw:session}}async refund(paymentId,options={}){const reference=randomUUID(),response=options.amount?await this.request("POST",`/payments/${encodeURIComponent(paymentId)}/refunds`,{body:{merchantAccount:this.config.merchantAccount,amount:this.amount(options.amount),reference},idempotencyKey:options.idempotencyKey}):await this.request("POST",`/payments/${encodeURIComponent(paymentId)}/reversals`,{body:{merchantAccount:this.config.merchantAccount,reference},idempotencyKey:options.idempotencyKey});return{id:response.pspReference,paymentId,status:"pending",amount:options.amount?{amount:options.amount.amount,currency:options.amount.currency.toLowerCase()}:null,raw:response}}async checkout(payer,request){if(request.mode==="subscription")throw new PaymentUnsupportedError("adyen","subscription checkout",'Adyen has no subscriptions; store a card with mode "setup" and charge it on your schedule');if(request.cancelUrl&&request.cancelUrl!==request.successUrl)throw new PaymentUnsupportedError("adyen","a separate cancelUrl","Adyen's hosted checkout returns to one URL, with the outcome in its query string");if(!request.currency)throw TypeError("An Adyen checkout needs a currency.");const lines=request.lines.map((line)=>{if("price"in line)throw new PaymentUnsupportedError("adyen","catalog prices","Adyen has no product catalog; price each line with name and unitAmount");return line}),total=lines.reduce((sum,line)=>sum+line.unitAmount*line.quantity,0),setup=request.mode==="setup",session=await this.request("POST","/sessions",{body:{merchantAccount:this.config.merchantAccount,amount:this.amount({amount:setup?0:total,currency:request.currency}),reference:request.reference??randomUUID(),returnUrl:request.successUrl,mode:"hosted",shopperReference:this.shopperReference(payer),...payer.email?{shopperEmail:payer.email}:{},...setup?{storePaymentMethodMode:"enabled",recurringProcessingModel:"UnscheduledCardOnFile"}:{},...setup?{}:{lineItems:lines.map((line)=>({description:line.name,quantity:line.quantity,amountIncludingTax:line.unitAmount}))},...request.metadata?{metadata:request.metadata}:{}}});if(!session.url)throw new PaymentProviderError("adyen",200,"the hosted session came back without a url");return{id:session.id,url:session.url,expiresAt:session.expiresAt?new Date(session.expiresAt):null,raw:session}}async paymentMethods(payer){return((await this.request("GET","/storedPaymentMethods",{query:{merchantAccount:this.config.merchantAccount,shopperReference:this.shopperReference(payer)}}))?.storedPaymentMethods??[]).map((method)=>({id:String(method.id),type:String(method.type??"scheme"),brand:method.brand??null,last4:method.lastFour??null,expMonth:method.expiryMonth?Number(method.expiryMonth):null,expYear:method.expiryYear?Number(String(method.expiryYear).length===2?`20${method.expiryYear}`:method.expiryYear):null,isDefault:!1,raw:method}))}async removePaymentMethod(payer,paymentMethodId){await this.request("DELETE",`/storedPaymentMethods/${encodeURIComponent(paymentMethodId)}`,{query:{merchantAccount:this.config.merchantAccount,shopperReference:this.shopperReference(payer)}})}async subscribe(){throw new PaymentUnsupportedError("adyen","subscriptions","charge a stored card on your own schedule with charge()")}async cancelSubscription(){throw new PaymentUnsupportedError("adyen","subscriptions")}async subscriptions(){throw new PaymentUnsupportedError("adyen","subscriptions")}async verifyWebhook(request){if(!this.config.hmacKey)throw Error("Adyen webhooks cannot be verified without the HMAC key: set ADYEN_HMAC_KEY or payment.adyen.hmacKey.");let body;try{body=JSON.parse(request.payload)}catch{throw new WebhookSignatureError("adyen","the body is not JSON")}const items=(body.notificationItems??[]).map((entry)=>entry.NotificationRequestItem).filter((item)=>Boolean(item));if(items.length===0)throw new WebhookSignatureError("adyen","the delivery holds no notification items");return items.map((item)=>{const given=item.additionalData?.hmacSignature;if(!given)throw new WebhookSignatureError("adyen",`item ${item.pspReference??"?"} has no hmacSignature`);const expected=Buffer.from(adyenSignature(item,this.config.hmacKey)),actual=Buffer.from(given);if(expected.length!==actual.length||!timingSafeEqual(expected,actual))throw new WebhookSignatureError("adyen",`item ${item.pspReference??"?"} is signed with another key`);const success=String(item.success)==="true",pair=EVENT_TYPES[item.eventCode??""];return{id:`${item.eventCode}:${item.pspReference}`,type:pair?pair[success?0:1]:"unknown",providerType:item.eventCode??"",reference:item.pspReference??null,merchantReference:item.merchantReference??null,amount:item.amount?.value!==void 0&&item.amount.currency?{amount:Number(item.amount.value),currency:item.amount.currency.toLowerCase()}:null,raw:item}})}acknowledgeWebhook(){return new Response("[accepted]",{status:202,headers:{"Content-Type":"text/plain"}})}}

package/dist/driver/index.d.ts

@@ -0,0 +1,23 @@
+import { stripe } from '../drivers/stripe';
+import type { AdyenConfig } from './adyen';
+import type { PaymentDriver } from './types';
+import type { StripeOperations } from './stripe';
+/**
+ * Make a driver of your own available as `config.payment.driver`. A built-in
+ * name cannot be replaced, so `stripe` always means Stacks' Stripe driver.
+ */
+export declare function registerPaymentDriver(name: string, factory: DriverFactory): void;
+/** Adyen's settings: config/payment.ts, then the ADYEN_* environment. */
+export declare function adyenConfig(settings?: Partial<AdyenConfig>, env?: Record<string, string | undefined>): AdyenConfig;
+/**
+ * The payment driver `config.payment.driver` names - `stripe` unless it says
+ * otherwise - or the one named here. This is the first thing to read that
+ * setting: it used to be declared, typed as `'stripe'`, and ignored.
+ */
+export declare function paymentDriver(name?: string): PaymentDriver;
+/** Stripe through the billable modules Stacks already had, so behaviour does not change. */
+export declare const defaultStripeOperations: StripeOperations;
+declare type DriverFactory = () => PaymentDriver;
+export * from './adyen';
+export * from './stripe';
+export * from './types';

package/dist/driver/index.js

@@ -0,0 +1 @@
+import process from"node:process";import{config,services}from"@stacksjs/config";import{manageCharge}from"../billable/charge";import{manageCheckout}from"../billable/checkout";import{manageCustomer}from"../billable/customer";import{managePaymentMethod}from"../billable/payment-method";import{manageSubscription}from"../billable/subscription";import{constructEvent}from"../billable/webhook";import{stripe}from"../drivers/stripe";import{freshIdempotencyKey}from"../idempotency";import{AdyenDriver}from"./adyen";import{StripeDriver}from"./stripe";export*from"./adyen";export*from"./stripe";export*from"./types";export const defaultStripeOperations={customer:(payer)=>manageCustomer.createOrGetStripeUser(payer,{}),createIntent:(payer,params,idempotencyKey)=>stripe.paymentIntents.create(params,{idempotencyKey:idempotencyKey??freshIdempotencyKey("payment_intent.create",payer.id,params.amount)}),refund:(paymentIntentId,params)=>manageCharge.refund(paymentIntentId,params),createCheckout:(payer,params)=>manageCheckout.create(payer,params),listPaymentMethods:async(customerId)=>(await stripe.paymentMethods.list({customer:customerId,limit:100})).data,deletePaymentMethod:(payer,paymentMethodId)=>managePaymentMethod.deletePaymentMethod(payer,paymentMethodId),subscribe:(payer,type,lookupKey)=>manageSubscription.create(payer,type,lookupKey,{}),cancelSubscription:(subscriptionId,atPeriodEnd)=>atPeriodEnd?stripe.subscriptions.update(subscriptionId,{cancel_at_period_end:!0}):manageSubscription.cancel(subscriptionId),listSubscriptions:async(customerId)=>(await stripe.subscriptions.list({customer:customerId,status:"all",limit:100})).data,constructEvent:(payload,signature,secret)=>constructEvent(payload,signature,secret)};const custom=new Map;export function registerPaymentDriver(name,factory){if(name==="stripe"||name==="adyen")throw Error(`"${name}" is a built-in payment driver and cannot be replaced.`);custom.set(name,factory)}export function adyenConfig(settings={},env=process.env){const environment=settings.environment??(env.ADYEN_ENVIRONMENT==="live"?"live":"test");return{apiKey:settings.apiKey||env.ADYEN_API_KEY||"",merchantAccount:settings.merchantAccount||env.ADYEN_MERCHANT_ACCOUNT||"",environment,liveUrlPrefix:settings.liveUrlPrefix||env.ADYEN_LIVE_URL_PREFIX||void 0,hmacKey:settings.hmacKey||env.ADYEN_HMAC_KEY||void 0,shopperReferencePrefix:settings.shopperReferencePrefix}}export function paymentDriver(name){const settings=config.payment??{},chosen=name??settings.driver??"stripe";if(chosen==="stripe")return new StripeDriver({operations:defaultStripeOperations,webhookSecret:settings.stripe?.webhookSecret||services?.stripe?.webhookSecret||process.env.STRIPE_WEBHOOK_SECRET||void 0});if(chosen==="adyen")return new AdyenDriver(adyenConfig(settings.adyen));const factory=custom.get(chosen);if(!factory)throw Error(`No payment driver named "${chosen}". Built in: stripe, adyen${custom.size?`; registered: ${[...custom.keys()].join(", ")}`:""}.`);return factory()}

package/dist/driver/stripe.d.ts

@@ -0,0 +1,46 @@
+import type { ChargeOptions, CheckoutRequest, CheckoutSession, CreatePaymentOptions, Customer, Money, Payer, PaymentDriver, PaymentEvent, PaymentResult, PaymentStatus, RefundOptions, RefundResult, StoredPaymentMethod, SubscriptionSummary, WebhookRequest } from './types';
+import type Stripe from 'stripe';
+/**
+ * A PaymentIntent's status in our terms. `requires_capture` is authorised but
+ * not yet captured - no money has moved - so it is still `processing`.
+ */
+export declare function stripePaymentStatus(intent: Pick<Stripe.PaymentIntent, 'status' | 'last_payment_error'>): PaymentStatus;
+/**
+ * The Stripe calls the driver needs, separated from the mapping so the mapping
+ * is testable without Stripe. The defaults delegate to the billable modules
+ * Stacks already had, so a Stripe app keeps their idempotency keys,
+ * same-origin redirect checks and `stripe_id` bookkeeping unchanged.
+ */
+export declare interface StripeOperations {
+  customer: (payer: Payer) => Promise<Stripe.Customer>
+  createIntent: (payer: Payer, params: Stripe.PaymentIntentCreateParams, idempotencyKey?: string) => Promise<Stripe.PaymentIntent>
+  refund: (paymentIntentId: string, params: Stripe.RefundCreateParams & { idempotencyKey?: string }) => Promise<Stripe.Refund>
+  createCheckout: (payer: Payer, params: Stripe.Checkout.SessionCreateParams) => Promise<Stripe.Checkout.Session>
+  listPaymentMethods: (customerId: string) => Promise<Stripe.PaymentMethod[]>
+  deletePaymentMethod: (payer: Payer, paymentMethodId: string) => Promise<unknown>
+  subscribe: (payer: Payer, type: string, lookupKey: string) => Promise<Stripe.Subscription>
+  cancelSubscription: (subscriptionId: string, atPeriodEnd: boolean) => Promise<Stripe.Subscription>
+  listSubscriptions: (customerId: string) => Promise<Stripe.Subscription[]>
+  constructEvent: (payload: string, signature: string, secret: string) => Promise<Stripe.Event>
+}
+export declare interface StripeDriverOptions {
+  operations: StripeOperations
+  webhookSecret?: string
+}
+export declare class StripeDriver implements PaymentDriver {
+  readonly name: string;
+  readonly capabilities: unknown;
+  constructor(options: StripeDriverOptions);
+  customer(payer: Payer): Promise<Customer>;
+  charge(payer: Payer, amount: Money, paymentMethod: string, options?: ChargeOptions): Promise<PaymentResult>;
+  createPayment(payer: Payer, amount: Money, options?: CreatePaymentOptions): Promise<PaymentResult>;
+  refund(paymentId: string, options?: RefundOptions): Promise<RefundResult>;
+  checkout(payer: Payer, request: CheckoutRequest): Promise<CheckoutSession>;
+  paymentMethods(payer: Payer): Promise<StoredPaymentMethod[]>;
+  removePaymentMethod(payer: Payer, paymentMethodId: string): Promise<void>;
+  subscribe(payer: Payer, price: string, options?: { type?: string }): Promise<SubscriptionSummary>;
+  cancelSubscription(subscriptionId: string, options?: { atPeriodEnd?: boolean }): Promise<SubscriptionSummary>;
+  subscriptions(payer: Payer): Promise<SubscriptionSummary[]>;
+  verifyWebhook(request: WebhookRequest): Promise<PaymentEvent[]>;
+  acknowledgeWebhook(): Response;
+}

package/dist/driver/stripe.js

@@ -0,0 +1 @@
+import{assertMoney,headerOf,WebhookSignatureError}from"./types";const CAPABILITIES=new Set(["customers","charge","createPayment","refund","checkout","paymentMethods","subscriptions","webhooks"]);export function stripePaymentStatus(intent){switch(intent.status){case"succeeded":return"succeeded";case"canceled":return"canceled";case"requires_action":return"requires_action";case"processing":case"requires_capture":return"processing";default:return intent.last_payment_error?"failed":"requires_payment_method"}}function refundStatus(status){if(status==="succeeded"||status==="failed"||status==="canceled")return status;return"pending"}const SUBSCRIPTION_STATUSES=new Set(["active","trialing","past_due","canceled","incomplete","unpaid","paused"]);function subscriptionStatus(status){if(status==="incomplete_expired")return"canceled";return SUBSCRIPTION_STATUSES.has(status)?status:"unknown"}function summarizeSubscription(subscription){const item=subscription.items?.data?.[0],periodEnd=item?.current_period_end??subscription.current_period_end;return{id:subscription.id,status:subscriptionStatus(subscription.status),price:item?.price?.id??null,currentPeriodEnd:periodEnd?new Date(periodEnd*1000):null,cancelAtPeriodEnd:Boolean(subscription.cancel_at_period_end),raw:subscription}}const EVENT_TYPES={"payment_intent.succeeded":"payment.succeeded","payment_intent.payment_failed":"payment.failed","payment_intent.canceled":"payment.canceled","charge.refunded":"refund.succeeded","refund.failed":"refund.failed","checkout.session.completed":"checkout.completed","customer.subscription.created":"subscription.created","customer.subscription.updated":"subscription.updated","customer.subscription.deleted":"subscription.canceled","invoice.paid":"invoice.paid","invoice.payment_failed":"invoice.payment_failed"};function toPayment(intent){const status=stripePaymentStatus(intent);return{id:intent.id,status,amount:{amount:intent.amount,currency:intent.currency},...intent.client_secret&&(status==="requires_payment_method"||status==="requires_action")?{clientConfirmation:{provider:"stripe",clientSecret:intent.client_secret}}:{},...intent.next_action?.redirect_to_url?.url?{redirectUrl:intent.next_action.redirect_to_url.url}:{},...intent.last_payment_error?.message?{failureReason:intent.last_payment_error.message}:{},raw:intent}}export class StripeDriver{name="stripe";capabilities=CAPABILITIES;ops;webhookSecret;constructor(options){this.ops=options.operations;this.webhookSecret=options.webhookSecret}async customer(payer){const customer=await this.ops.customer(payer);return{id:customer.id,email:customer.email??null,name:customer.name??null}}async charge(payer,amount,paymentMethod,options={}){assertMoney(amount);const customer=await this.ops.customer(payer),intent=await this.ops.createIntent(payer,{amount:amount.amount,currency:amount.currency.toLowerCase(),customer:customer.id,payment_method:paymentMethod,confirm:!0,automatic_payment_methods:{enabled:!0,allow_redirects:"never"},off_session:!0,...options.description?{description:options.description}:{},metadata:{...options.metadata,...options.reference?{reference:options.reference}:{}}},options.idempotencyKey);return toPayment(intent)}async createPayment(payer,amount,options={}){assertMoney(amount);const customer=await this.ops.customer(payer),intent=await this.ops.createIntent(payer,{amount:amount.amount,currency:amount.currency.toLowerCase(),customer:customer.id,automatic_payment_methods:{enabled:!0},...options.description?{description:options.description}:{},metadata:{...options.metadata,...options.reference?{reference:options.reference}:{}}},options.idempotencyKey);return toPayment(intent)}async refund(paymentId,options={}){if(options.amount)assertMoney(options.amount,"refund amount");const refund=await this.ops.refund(paymentId,{...options.amount?{amount:options.amount.amount}:{},...options.reason?{reason:options.reason}:{},...options.idempotencyKey?{idempotencyKey:options.idempotencyKey}:{}});return{id:refund.id,paymentId,status:refundStatus(refund.status),amount:{amount:refund.amount,currency:refund.currency},raw:refund}}async checkout(payer,request){const customer=await this.ops.customer(payer),lineItems=request.lines.map((line)=>{if("price"in line)return{price:line.price,quantity:line.quantity};if(!request.currency)throw TypeError("A checkout line priced with unitAmount needs the checkout's currency.");return{quantity:line.quantity,price_data:{currency:request.currency.toLowerCase(),unit_amount:line.unitAmount,product_data:{name:line.name}}}}),session=await this.ops.createCheckout(payer,{customer:customer.id,mode:request.mode,success_url:request.successUrl,...request.cancelUrl?{cancel_url:request.cancelUrl}:{},...request.mode==="setup"?{currency:request.currency?.toLowerCase()}:{line_items:lineItems},...request.reference?{client_reference_id:request.reference}:{},...request.metadata?{metadata:request.metadata}:{}});if(!session.url)throw Error("Stripe returned a checkout session without a url.");return{id:session.id,url:session.url,expiresAt:session.expires_at?new Date(session.expires_at*1000):null,raw:session}}async paymentMethods(payer){const customer=await this.ops.customer(payer),defaultId=typeof customer.invoice_settings?.default_payment_method==="string"?customer.invoice_settings.default_payment_method:customer.invoice_settings?.default_payment_method?.id??null;return(await this.ops.listPaymentMethods(customer.id)).map((method)=>({id:method.id,type:method.type,brand:method.card?.brand??null,last4:method.card?.last4??null,expMonth:method.card?.exp_month??null,expYear:method.card?.exp_year??null,isDefault:method.id===defaultId,raw:method}))}async removePaymentMethod(payer,paymentMethodId){await this.ops.deletePaymentMethod(payer,paymentMethodId)}async subscribe(payer,price,options={}){return summarizeSubscription(await this.ops.subscribe(payer,options.type??"default",price))}async cancelSubscription(subscriptionId,options={}){return summarizeSubscription(await this.ops.cancelSubscription(subscriptionId,options.atPeriodEnd??!1))}async subscriptions(payer){const customer=await this.ops.customer(payer);return(await this.ops.listSubscriptions(customer.id)).map(summarizeSubscription)}async verifyWebhook(request){if(!this.webhookSecret)throw Error("Stripe webhooks cannot be verified without the signing secret: set STRIPE_WEBHOOK_SECRET or payment.stripe.webhookSecret.");const signature=headerOf(request.headers,"stripe-signature");if(!signature)throw new WebhookSignatureError("stripe","there is no Stripe-Signature header");let event;try{event=await this.ops.constructEvent(request.payload,signature,this.webhookSecret)}catch(error){throw new WebhookSignatureError("stripe",error.message)}const object=event.data.object,reference=event.type==="charge.refunded"?object.payment_intent??object.id:object.id,amount=typeof object.amount==="number"&&object.currency?{amount:object.amount,currency:String(object.currency)}:typeof object.amount_total==="number"&&object.currency?{amount:object.amount_total,currency:String(object.currency)}:null;return[{id:event.id,type:EVENT_TYPES[event.type]??"unknown",providerType:event.type,reference:typeof reference==="string"?reference:null,merchantReference:object.client_reference_id??object.metadata?.reference??null,amount,raw:event}]}acknowledgeWebhook(){return Response.json({received:!0})}}

package/dist/driver/types.d.ts

@@ -0,0 +1,188 @@
+/** Read a header from either a `Headers` or a plain object, case-insensitively. */
+export declare function headerOf(headers: WebhookRequest['headers'], name: string): string | null;
+/** Validate an amount before it reaches a provider: a positive whole number of minor units. */
+export declare function assertMoney(money: Money, label?: string): void;
+/**
+ * The provider-neutral payments contract (stacksjs/stacks#665, #450).
+ *
+ * `@stacksjs/payments` was Stripe's SDK with a facade on it: every function
+ * returned a `Stripe.*` type, and `config.payment.driver` was read by nothing.
+ * A `PaymentDriver` describes what an application needs from a payment
+ * provider in the application's terms - money in minor units, statuses of our
+ * own, events of our own - and each provider implements it.
+ *
+ * Providers are not the same kind of thing, and the interface does not
+ * pretend otherwise. A driver lists what it can do in `capabilities`; calling
+ * anything else throws a {@link PaymentUnsupportedError} naming the driver and
+ * the operation, rather than a stack trace from an SDK the app never
+ * installed or a result that only looks like success.
+ */
+/** An amount in the currency's minor unit (cents), never a float. */
+export declare interface Money {
+  amount: number
+  currency: string
+}
+/** Who is paying, as the application knows them. Any Stacks user model fits. */
+export declare interface Payer {
+  id: number | string
+  email?: string | null
+  name?: string | null
+  stripe_id?: string | null
+  update?: (values: Record<string, unknown>) => Promise<unknown>
+}
+export declare interface Customer {
+  id: string
+  email: string | null
+  name: string | null
+}
+export declare interface PaymentResult {
+  id: string
+  status: PaymentStatus
+  amount: Money
+  clientConfirmation?: ClientConfirmation
+  redirectUrl?: string
+  failureReason?: string
+  raw: unknown
+}
+export declare interface RefundResult {
+  id: string
+  paymentId: string
+  status: RefundStatus
+  amount: Money | null
+  raw: unknown
+}
+export declare interface CheckoutRequest {
+  mode: 'payment' | 'subscription' | 'setup'
+  lines: CheckoutLine[]
+  currency?: string
+  successUrl: string
+  cancelUrl?: string
+  reference?: string
+  metadata?: Record<string, string>
+}
+export declare interface CheckoutSession {
+  id: string
+  url: string
+  expiresAt: Date | null
+  raw: unknown
+}
+export declare interface StoredPaymentMethod {
+  id: string
+  type: string
+  brand: string | null
+  last4: string | null
+  expMonth: number | null
+  expYear: number | null
+  isDefault: boolean
+  raw: unknown
+}
+export declare interface SubscriptionSummary {
+  id: string
+  status: SubscriptionStatus
+  price: string | null
+  currentPeriodEnd: Date | null
+  cancelAtPeriodEnd: boolean
+  raw: unknown
+}
+/** A verified webhook notification, in our terms. */
+export declare interface PaymentEvent {
+  id: string
+  type: PaymentEventType
+  providerType: string
+  reference: string | null
+  merchantReference: string | null
+  amount: Money | null
+  raw: unknown
+}
+export declare interface WebhookRequest {
+  payload: string
+  headers: Headers | Record<string, string | undefined>
+}
+export declare interface ChargeOptions {
+  reference?: string
+  description?: string
+  metadata?: Record<string, string>
+  idempotencyKey?: string
+}
+export declare interface CreatePaymentOptions extends ChargeOptions {
+  returnUrl?: string
+}
+export declare interface RefundOptions {
+  amount?: Money
+  reason?: 'duplicate' | 'fraudulent' | 'requested_by_customer'
+  idempotencyKey?: string
+}
+export declare interface PaymentDriver {
+  readonly name: string
+  readonly capabilities: ReadonlySet<PaymentOperation>
+  customer: (payer: Payer) => Promise<Customer>
+  charge: (payer: Payer, amount: Money, paymentMethod: string, options?: ChargeOptions) => Promise<PaymentResult>
+  createPayment: (payer: Payer, amount: Money, options?: CreatePaymentOptions) => Promise<PaymentResult>
+  refund: (paymentId: string, options?: RefundOptions) => Promise<RefundResult>
+  checkout: (payer: Payer, request: CheckoutRequest) => Promise<CheckoutSession>
+  paymentMethods: (payer: Payer) => Promise<StoredPaymentMethod[]>
+  removePaymentMethod: (payer: Payer, paymentMethodId: string) => Promise<void>
+  subscribe: (payer: Payer, price: string, options?: { type?: string }) => Promise<SubscriptionSummary>
+  cancelSubscription: (subscriptionId: string, options?: { atPeriodEnd?: boolean }) => Promise<SubscriptionSummary>
+  subscriptions: (payer: Payer) => Promise<SubscriptionSummary[]>
+  verifyWebhook: (request: WebhookRequest) => Promise<PaymentEvent[]>
+  acknowledgeWebhook: () => Response
+}
+export type PaymentOperation = | 'customers'
+  | 'charge'
+  | 'createPayment'
+  | 'refund'
+  | 'checkout'
+  | 'paymentMethods'
+  | 'subscriptions'
+  | 'webhooks';
+/**
+ * Where a payment stands.
+ *
+ * `requires_action`: the payer has to do something - authenticate, be
+ * redirected. `processing`: accepted, outcome not known yet (it arrives by
+ * webhook). Only `succeeded`, `failed` and `canceled` are final.
+ */
+export type PaymentStatus = 'succeeded' | 'processing' | 'requires_action' | 'requires_payment_method' | 'failed' | 'canceled';
+/**
+ * What the browser needs to finish a payment on the provider's own client SDK.
+ * Tagged by provider, because the SDKs differ: Stripe.js confirms a client
+ * secret, Adyen's Drop-in mounts a session.
+ */
+export type ClientConfirmation = | { provider: 'stripe', clientSecret: string }
+  | { provider: 'adyen', sessionId: string, sessionData: string }
+export type RefundStatus = 'pending' | 'succeeded' | 'failed' | 'canceled';
+/** A line on a checkout: priced here, or a price the provider's catalog holds. */
+export type CheckoutLine = | { name: string, unitAmount: number, quantity: number }
+  | { price: string, quantity: number }
+/** `unknown`: a status the provider added after this driver was written; `raw` has it. */
+export type SubscriptionStatus = 'active' | 'trialing' | 'past_due' | 'canceled' | 'incomplete' | 'unpaid' | 'paused' | 'unknown';
+export type PaymentEventType = | 'payment.succeeded'
+  | 'payment.failed'
+  | 'payment.canceled'
+  | 'refund.succeeded'
+  | 'refund.failed'
+  | 'checkout.completed'
+  | 'subscription.created'
+  | 'subscription.updated'
+  | 'subscription.canceled'
+  | 'invoice.paid'
+  | 'invoice.payment_failed'
+  | 'unknown';
+/** An operation the configured provider cannot do. */
+export declare class PaymentUnsupportedError extends Error {
+  readonly driver: string;
+  readonly operation: string;
+  constructor(driver: string, operation: string, detail?: string);
+}
+/** A provider rejected a request. Carries its status and code. */
+export declare class PaymentProviderError extends Error {
+  readonly driver: string;
+  readonly status: number;
+  readonly code: string | null;
+  constructor(driver: string, status: number, message: string, code?: string | null);
+}
+/** A webhook delivery whose signature does not verify. */
+export declare class WebhookSignatureError extends Error {
+  constructor(driver: string, detail: string);
+}

package/dist/driver/types.js

@@ -0,0 +1 @@
+export class PaymentUnsupportedError extends Error{driver;operation;constructor(driver,operation,detail){super(`The ${driver} payment driver does not support ${operation}${detail?`: ${detail}`:"."}`);this.name="PaymentUnsupportedError";this.driver=driver;this.operation=operation}}export class PaymentProviderError extends Error{driver;status;code;constructor(driver,status,message,code=null){super(`${driver} rejected the request (${status}${code?` ${code}`:""}): ${message}`);this.name="PaymentProviderError";this.driver=driver;this.status=status;this.code=code}}export class WebhookSignatureError extends Error{constructor(driver,detail){super(`The ${driver} webhook signature does not verify: ${detail}`);this.name="WebhookSignatureError"}}export function headerOf(headers,name){if(typeof headers.get==="function")return headers.get(name);const wanted=name.toLowerCase();for(const[key,value]of Object.entries(headers))if(key.toLowerCase()===wanted)return value??null;return null}export function assertMoney(money,label="amount"){if(!Number.isInteger(money.amount)||money.amount<0)throw TypeError(`${label} must be a whole number of minor units (cents), got ${money.amount}`);if(!/^[a-z]{3}$/i.test(money.currency))throw TypeError(`${label} currency must be an ISO 4217 code, got "${money.currency}"`)}

package/dist/index.d.ts

@@ -6,6 +6,10 @@ export type { StripeSdk as Stripe };
 // Main Payment facade
 export * from './payment';
 export { default as Payment } from './payment';
+// The provider-neutral driver contract, and the Stripe and Adyen drivers
+// (stacksjs/stacks#665, #450). `paymentDriver()` is the one config.payment.driver
+// selects.
+export * from './driver/index';
 // Billable modules
 export * from './billable/index';
 // Stripe Connect (marketplaces)

package/dist/index.js

@@ -1 +1 @@
-export*from"./payment";export{default as Payment}from"./payment";export*from"./billable";export*from"./connect";export*from"./drivers/stripe";export{freshIdempotencyKey,stacksIdempotencyKey}from"./idempotency";
+export*from"./payment";export{default as Payment}from"./payment";export*from"./driver";export*from"./billable";export*from"./connect";export*from"./drivers/stripe";export{freshIdempotencyKey,stacksIdempotencyKey}from"./idempotency";

package/dist/payment.d.ts

@@ -1,6 +1,3 @@
-import { connect } from './connect/index';
-import { onCharge, onCheckout, onInvoice, onPaymentIntent, onSubscription, processWebhook } from './billable/webhook';
-import { stripe } from './drivers/stripe';
 import type { UserModel } from '@stacksjs/orm';
 import type Stripe from 'stripe';
 /**
@@ -143,51 +140,5 @@ export declare function billingPortal(customer: string | UserModel, options?: {
 // =============================================================================
 // Payment Facade Object
 // =============================================================================
-export declare const Payment: {
-  charge: typeof charge;
-  createPayment: typeof createPayment;
-  refund: typeof refund;
-  checkout: typeof checkout;
-  subscriptionCheckout: typeof subscriptionCheckout;
-  subscribe: typeof subscribe;
-  cancelSubscription: typeof cancelSubscription;
-  hasActiveSubscription: typeof hasActiveSubscription;
-  changeSubscription: typeof changeSubscription;
-  getOrCreateCustomer: typeof getOrCreateCustomer;
-  updateCustomer: typeof updateCustomer;
-  deleteCustomer: typeof deleteCustomer;
-  addPaymentMethod: typeof addPaymentMethod;
-  setDefaultPaymentMethod: typeof setDefaultPaymentMethod;
-  removePaymentMethod: typeof removePaymentMethod;
-  createSetupIntent: typeof createSetupIntent;
-  getInvoices: typeof getInvoices;
-  createInvoice: typeof createInvoice;
-  payInvoice: typeof payInvoice;
-  createProduct: typeof createProduct;
-  getPrice: typeof getPrice;
-  listProducts: typeof listProducts;
-  billingPortal: typeof billingPortal;
-  createCoupon: typeof createCoupon;
-  createPromoCode: typeof createPromoCode;
-  validatePromoCode: typeof validatePromoCode;
-  formatAmount: typeof formatAmount;
-  toCents: typeof toCents;
-  toDollars: typeof toDollars;
-  webhook: unknown;
-  onPaymentIntent: typeof onPaymentIntent;
-  onSubscription: typeof onSubscription;
-  onInvoice: typeof onInvoice;
-  onCheckout: typeof onCheckout;
-  onCharge: typeof onCharge;
-  processWebhook: typeof processWebhook;
-  connect: typeof connect;
-  stripe: typeof stripe;
-  customer: unknown;
-  subscription: unknown;
-  invoice: unknown;
-  paymentMethod: unknown;
-  product: unknown;
-  price: unknown;
-  coupon: unknown
-};
+export declare const Payment: {};
 export default Payment;

package/dist/payment.js

@@ -1 +1 @@
-import{stripe}from"./drivers/stripe";import{manageCharge}from"./billable/charge";import{manageCheckout}from"./billable/checkout";import{manageCustomer}from"./billable/customer";import{manageInvoice}from"./billable/invoice";import{managePaymentMethod}from"./billable/payment-method";import{managePrice}from"./billable/price";import{manageBillingPortal}from"./billable/portal";import{manageCoupon,managePriceExtended,manageProduct}from"./billable/product";import{manageSubscription}from"./billable/subscription";import{manageSetupIntent}from"./billable/intent";import{manageWebhook,onCharge,onCheckout,onInvoice,onPaymentIntent,onSubscription,processWebhook}from"./billable/webhook";import{connect}from"./connect";export async function charge(user,amount,paymentMethod,options={}){return manageCharge.charge(user,amount,paymentMethod,options)}export async function createPayment(user,amount,options={}){return manageCharge.createPayment(user,amount,options)}export async function refund(paymentIntentId,amount,options={}){return manageCharge.refund(paymentIntentId,{amount,...options})}export async function checkout(user,lineItems,options={}){return manageCheckout.create(user,{line_items:lineItems,mode:"payment",...options})}export async function subscriptionCheckout(user,priceId,options={}){return manageCheckout.create(user,{line_items:[{price:priceId,quantity:1}],mode:"subscription",...options})}export async function subscribe(user,lookupKey,options={}){return manageSubscription.create(user,"default",lookupKey,options)}export async function cancelSubscription(subscriptionId,immediately=!1){return manageSubscription.cancel(subscriptionId,{prorate:!immediately,invoice_now:immediately})}export async function hasActiveSubscription(user,type="default"){return manageSubscription.isValid(user,type)}export async function changeSubscription(user,newLookupKey,type="default"){return manageSubscription.update(user,type,newLookupKey,{})}export async function getOrCreateCustomer(user,options={}){return manageCustomer.createOrGetStripeUser(user,options)}export async function updateCustomer(user,options){return manageCustomer.updateStripeCustomer(user,options)}export async function deleteCustomer(user){return manageCustomer.deleteStripeUser(user)}export async function addPaymentMethod(user,paymentMethodId){return managePaymentMethod.addPaymentMethod(user,paymentMethodId)}export async function setDefaultPaymentMethod(user,paymentMethodId){return managePaymentMethod.setUserDefaultPayment(user,paymentMethodId)}export async function removePaymentMethod(user,paymentMethodId){return managePaymentMethod.deletePaymentMethod(user,paymentMethodId)}export async function createSetupIntent(user,options={}){return manageSetupIntent.create(user,options)}export async function getInvoices(user){return manageInvoice.list(user)}export async function createInvoice(customerId,options={}){return stripe.invoices.create({customer:customerId,...options})}export async function payInvoice(invoiceId){return stripe.invoices.pay(invoiceId)}export async function createProduct(name,price,options={}){const{currency="usd",interval,description,metadata}=options,priceParams={unit_amount:price,currency};if(interval)priceParams.recurring={interval};return manageProduct.createWithPrice({name,description,metadata},priceParams)}export async function getPrice(lookupKey){return managePrice.retrieveByLookupKey(lookupKey)}export async function listProducts(options={}){return manageProduct.list(options)}export async function createCoupon(options){const params={duration:options.duration||"once"};if(options.percentOff)params.percent_off=options.percentOff;else if(options.amountOff){params.amount_off=options.amountOff;params.currency=options.currency||"usd"}if(options.name)params.name=options.name;if(options.durationInMonths)params.duration_in_months=options.durationInMonths;if(options.maxRedemptions)params.max_redemptions=options.maxRedemptions;return manageCoupon.create(params)}export async function createPromoCode(couponId,code,options={}){return manageCoupon.createPromotionCode({promotion:{type:"coupon",coupon:couponId},code,...options})}export async function validatePromoCode(code){return manageCoupon.retrievePromotionCode(code)}export function formatAmount(amount,currency){const cfg=globalThis.config||{},ccy=(currency||cfg.payment?.currency||cfg.billing?.currency||process.env.STRIPE_CURRENCY||"usd").toLowerCase(),locale=cfg.app?.locale||"en-US";return new Intl.NumberFormat(locale,{style:"currency",currency:ccy.toUpperCase()}).format(amount/100)}export function toCents(dollars){return Math.round(dollars*100)}export function toDollars(cents){return cents/100}export async function billingPortal(customer,options={}){const customerId=typeof customer==="string"?customer:customer.stripe_id;if(!customerId)throw Error("billingPortal needs a Stripe customer: this user has no stripe_id yet.");return manageBillingPortal.createSession(customerId,options)}export const Payment={charge,createPayment,refund,checkout,subscriptionCheckout,subscribe,cancelSubscription,hasActiveSubscription,changeSubscription,getOrCreateCustomer,updateCustomer,deleteCustomer,addPaymentMethod,setDefaultPaymentMethod,removePaymentMethod,createSetupIntent,getInvoices,createInvoice,payInvoice,createProduct,getPrice,listProducts,billingPortal,createCoupon,createPromoCode,validatePromoCode,formatAmount,toCents,toDollars,webhook:manageWebhook,onPaymentIntent,onSubscription,onInvoice,onCheckout,onCharge,processWebhook,connect,stripe,customer:manageCustomer,subscription:manageSubscription,invoice:manageInvoice,paymentMethod:managePaymentMethod,product:manageProduct,price:managePriceExtended,coupon:manageCoupon};export default Payment;
+import{stripe}from"./drivers/stripe";import{manageCharge}from"./billable/charge";import{manageCheckout}from"./billable/checkout";import{manageCustomer}from"./billable/customer";import{manageInvoice}from"./billable/invoice";import{managePaymentMethod}from"./billable/payment-method";import{managePrice}from"./billable/price";import{manageBillingPortal}from"./billable/portal";import{manageCoupon,managePriceExtended,manageProduct}from"./billable/product";import{manageSubscription}from"./billable/subscription";import{manageSetupIntent}from"./billable/intent";import{manageWebhook,onCharge,onCheckout,onInvoice,onPaymentIntent,onSubscription,processWebhook}from"./billable/webhook";import{connect}from"./connect";import{paymentDriver}from"./driver";export async function charge(user,amount,paymentMethod,options={}){return manageCharge.charge(user,amount,paymentMethod,options)}export async function createPayment(user,amount,options={}){return manageCharge.createPayment(user,amount,options)}export async function refund(paymentIntentId,amount,options={}){return manageCharge.refund(paymentIntentId,{amount,...options})}export async function checkout(user,lineItems,options={}){return manageCheckout.create(user,{line_items:lineItems,mode:"payment",...options})}export async function subscriptionCheckout(user,priceId,options={}){return manageCheckout.create(user,{line_items:[{price:priceId,quantity:1}],mode:"subscription",...options})}export async function subscribe(user,lookupKey,options={}){return manageSubscription.create(user,"default",lookupKey,options)}export async function cancelSubscription(subscriptionId,immediately=!1){return manageSubscription.cancel(subscriptionId,{prorate:!immediately,invoice_now:immediately})}export async function hasActiveSubscription(user,type="default"){return manageSubscription.isValid(user,type)}export async function changeSubscription(user,newLookupKey,type="default"){return manageSubscription.update(user,type,newLookupKey,{})}export async function getOrCreateCustomer(user,options={}){return manageCustomer.createOrGetStripeUser(user,options)}export async function updateCustomer(user,options){return manageCustomer.updateStripeCustomer(user,options)}export async function deleteCustomer(user){return manageCustomer.deleteStripeUser(user)}export async function addPaymentMethod(user,paymentMethodId){return managePaymentMethod.addPaymentMethod(user,paymentMethodId)}export async function setDefaultPaymentMethod(user,paymentMethodId){return managePaymentMethod.setUserDefaultPayment(user,paymentMethodId)}export async function removePaymentMethod(user,paymentMethodId){return managePaymentMethod.deletePaymentMethod(user,paymentMethodId)}export async function createSetupIntent(user,options={}){return manageSetupIntent.create(user,options)}export async function getInvoices(user){return manageInvoice.list(user)}export async function createInvoice(customerId,options={}){return stripe.invoices.create({customer:customerId,...options})}export async function payInvoice(invoiceId){return stripe.invoices.pay(invoiceId)}export async function createProduct(name,price,options={}){const{currency="usd",interval,description,metadata}=options,priceParams={unit_amount:price,currency};if(interval)priceParams.recurring={interval};return manageProduct.createWithPrice({name,description,metadata},priceParams)}export async function getPrice(lookupKey){return managePrice.retrieveByLookupKey(lookupKey)}export async function listProducts(options={}){return manageProduct.list(options)}export async function createCoupon(options){const params={duration:options.duration||"once"};if(options.percentOff)params.percent_off=options.percentOff;else if(options.amountOff){params.amount_off=options.amountOff;params.currency=options.currency||"usd"}if(options.name)params.name=options.name;if(options.durationInMonths)params.duration_in_months=options.durationInMonths;if(options.maxRedemptions)params.max_redemptions=options.maxRedemptions;return manageCoupon.create(params)}export async function createPromoCode(couponId,code,options={}){return manageCoupon.createPromotionCode({promotion:{type:"coupon",coupon:couponId},code,...options})}export async function validatePromoCode(code){return manageCoupon.retrievePromotionCode(code)}export function formatAmount(amount,currency){const cfg=globalThis.config||{},ccy=(currency||cfg.payment?.currency||cfg.billing?.currency||process.env.STRIPE_CURRENCY||"usd").toLowerCase(),locale=cfg.app?.locale||"en-US";return new Intl.NumberFormat(locale,{style:"currency",currency:ccy.toUpperCase()}).format(amount/100)}export function toCents(dollars){return Math.round(dollars*100)}export function toDollars(cents){return cents/100}export async function billingPortal(customer,options={}){const customerId=typeof customer==="string"?customer:customer.stripe_id;if(!customerId)throw Error("billingPortal needs a Stripe customer: this user has no stripe_id yet.");return manageBillingPortal.createSession(customerId,options)}export const Payment={driver:paymentDriver,charge,createPayment,refund,checkout,subscriptionCheckout,subscribe,cancelSubscription,hasActiveSubscription,changeSubscription,getOrCreateCustomer,updateCustomer,deleteCustomer,addPaymentMethod,setDefaultPaymentMethod,removePaymentMethod,createSetupIntent,getInvoices,createInvoice,payInvoice,createProduct,getPrice,listProducts,billingPortal,createCoupon,createPromoCode,validatePromoCode,formatAmount,toCents,toDollars,webhook:manageWebhook,onPaymentIntent,onSubscription,onInvoice,onCheckout,onCharge,processWebhook,connect,stripe,customer:manageCustomer,subscription:manageSubscription,invoice:manageInvoice,paymentMethod:managePaymentMethod,product:manageProduct,price:managePriceExtended,coupon:manageCoupon};export default Payment;

package/package.json

@@ -2,7 +2,7 @@
   "name": "@stacksjs/payments",
   "type": "module",
   "sideEffects": false,
-  "version": "0.75.74",
+  "version": "0.75.76",
   "description": "The Stacks payments package. Currently supporting Stripe.",
   "author": "Chris Breuer",
   "contributors": [
@@ -60,12 +60,12 @@
     "prepublishOnly": "bun run build"
   },
   "dependencies": {
-    "@stacksjs/config": "0.75.74",
-    "@stacksjs/database": "0.75.74",
-    "@stacksjs/error-handling": "0.75.74",
-    "@stacksjs/logging": "0.75.74",
-    "@stacksjs/orm": "0.75.74",
-    "@stacksjs/types": "0.75.74"
+    "@stacksjs/config": "0.75.76",
+    "@stacksjs/database": "0.75.76",
+    "@stacksjs/error-handling": "0.75.76",
+    "@stacksjs/logging": "0.75.76",
+    "@stacksjs/orm": "0.75.76",
+    "@stacksjs/types": "0.75.76"
   },
   "peerDependencies": {
     "@stripe/stripe-js": "^10.0.0",
@@ -80,7 +80,7 @@
     }
   },
   "devDependencies": {
-    "@stacksjs/utils": "0.75.74",
+    "@stacksjs/utils": "0.75.76",
     "@stripe/stripe-js": "^10.0.0",
     "better-dx": "^0.2.24",
     "stripe": "23.0.0"