@stacksjs/payments 0.72.103 → 0.73.1

package/dist/billable/subscription.d.ts

@@ -13,7 +13,7 @@ export declare const manageSubscription: SubscriptionManager;
 export declare interface SubscriptionManager {
   create: (user: UserModel, type: string, lookupKey: string, params: Partial<Stripe.SubscriptionCreateParams>) => Promise<Stripe.Response<Stripe.Subscription>>
   update: (user: UserModel, type: string, lookupKey: string, params: Partial<Stripe.SubscriptionUpdateParams>) => Promise<Stripe.Response<Stripe.Subscription>>
-  cancel: (subscriptionId: string, params?: Partial<Stripe.SubscriptionCreateParams>) => Promise<Stripe.Response<Stripe.Subscription>>
+  cancel: (subscriptionId: string, params?: Partial<Stripe.SubscriptionCancelParams>) => Promise<Stripe.Response<Stripe.Subscription>>
   retrieve: (user: UserModel, subscriptionId: string) => Promise<Stripe.Response<Stripe.Subscription>>
   isValid: (user: UserModel, type: string) => Promise<boolean>
   isIncomplete: (user: UserModel, type: string) => Promise<boolean>

package/dist/billable/webhook.d.ts

@@ -169,5 +169,10 @@ export type WebhookEventType = | 'payment_intent.succeeded'
   | 'payment_method.detached'
   | 'setup_intent.succeeded'
   | 'setup_intent.setup_failed'
+  | 'account.updated'
+  | 'account.application.deauthorized'
+  | 'payout.created'
+  | 'payout.paid'
+  | 'payout.failed'
   | string;
 export type WebhookHandler = (_event: Stripe.Event) => Promise<void> | void;

package/dist/connect/account.d.ts

@@ -0,0 +1,42 @@
+import type { UserModel } from '@stacksjs/orm';
+import type Stripe from 'stripe';
+/**
+ * Connected-account ids are `acct_...`. Checking the shape here turns a
+ * confusing Stripe 404 (which reads as "no such account" even when the caller
+ * passed a customer id, a user id, or an empty string) into a local error that
+ * names the argument.
+ */
+export declare function requireAccountId(accountId: string, caller: string): void;
+export declare const manageConnectedAccount: ManageConnectedAccount;
+/**
+ * A connected account's readiness, reduced to the questions a marketplace
+ * actually asks.
+ *
+ * Stripe answers "can this merchant be paid yet" across three booleans and two
+ * nested requirement arrays, and every caller that reaches for the raw account
+ * ends up re-deriving the same digest. Onboarding is not finished when the
+ * merchant returns from the onboarding link - it is finished when
+ * `chargesEnabled` turns true, which can lag by minutes or need more documents.
+ */
+export declare interface ConnectAccountStatus {
+  chargesEnabled: boolean
+  payoutsEnabled: boolean
+  detailsSubmitted: boolean
+  currentlyDue: string[]
+  pastDue: string[]
+  disabledReason: string | null
+  raw: Stripe.Account
+}
+export declare interface ManageConnectedAccount {
+  createConnectedAccount: (user: UserModel, params?: Partial<Stripe.AccountCreateParams>) => Promise<Stripe.Response<Stripe.Account>>
+  createTestConnectedAccount: (user: UserModel, params?: Partial<Stripe.AccountCreateParams>) => Promise<Stripe.Response<Stripe.Account>>
+  accountOnboardingLink: (accountId: string, options: OnboardingLinkOptions) => Promise<Stripe.Response<Stripe.AccountLink>>
+  accountStatus: (accountId: string) => Promise<ConnectAccountStatus>
+  retrieveConnectedAccount: (accountId: string) => Promise<Stripe.Response<Stripe.Account>>
+}
+export declare interface OnboardingLinkOptions {
+  refreshUrl: string
+  returnUrl: string
+  type?: Stripe.AccountLinkCreateParams.Type
+  collect?: Stripe.AccountLinkCreateParams.CollectionOptions.Fields
+}

package/dist/connect/account.js

@@ -0,0 +1 @@
+import{stripe}from"../drivers/stripe";import{stacksIdempotencyKey}from"../idempotency";export const manageConnectedAccount=(()=>{async function createConnectedAccount(user,params={}){const merged={...{type:"express",email:user.email??void 0,metadata:{stacks_user_id:String(user.id)}},...params};return await stripe.accounts.create(merged,{idempotencyKey:stacksIdempotencyKey("connect.account.create",user.id)})}async function createTestConnectedAccount(user,params={}){const merged={...{type:"express",email:user.email??void 0,business_type:"individual",capabilities:{card_payments:{requested:!0},transfers:{requested:!0}},business_profile:{url:"https://example.com",mcc:"5812"},metadata:{stacks_user_id:String(user.id),stacks_test_account:"true"}},...params};return await stripe.accounts.create(merged,{idempotencyKey:stacksIdempotencyKey("connect.account.create_test",user.id)})}async function accountOnboardingLink(accountId,options){requireAccountId(accountId,"accountOnboardingLink");if(!options?.refreshUrl||!options?.returnUrl)throw Error("[payments/connect] accountOnboardingLink requires refreshUrl and returnUrl");return await stripe.accountLinks.create({account:accountId,refresh_url:options.refreshUrl,return_url:options.returnUrl,type:options.type??"account_onboarding",...options.collect?{collection_options:{fields:options.collect}}:{}})}async function retrieveConnectedAccount(accountId){requireAccountId(accountId,"retrieveConnectedAccount");return await stripe.accounts.retrieve(accountId)}async function accountStatus(accountId){const account=await retrieveConnectedAccount(accountId),requirements=account.requirements;return{chargesEnabled:account.charges_enabled===!0,payoutsEnabled:account.payouts_enabled===!0,detailsSubmitted:account.details_submitted===!0,currentlyDue:requirements?.currently_due??[],pastDue:requirements?.past_due??[],disabledReason:requirements?.disabled_reason??null,raw:account}}return{createConnectedAccount,createTestConnectedAccount,accountOnboardingLink,accountStatus,retrieveConnectedAccount}})();export function requireAccountId(accountId,caller){if(!accountId||typeof accountId!=="string")throw Error(`[payments/connect] ${caller} requires a connected account id`);if(!accountId.startsWith("acct_"))throw Error(`[payments/connect] ${caller} expects a connected account id (acct_...), got "${accountId}"`)}

package/dist/connect/charge.d.ts

@@ -0,0 +1,17 @@
+import type { UserModel } from '@stacksjs/orm';
+import type Stripe from 'stripe';
+export declare const manageDestinationCharge: ManageDestinationCharge;
+export declare interface DestinationChargeOptions extends Partial<Stripe.PaymentIntentCreateParams> {
+  applicationFeeAmount?: number
+  platformFeePercent?: number
+  transferGroup?: string
+}
+export declare interface ManageDestinationCharge {
+  destinationCharge: (
+    user: UserModel,
+    amount: number,
+    destinationAccountId: string,
+    options?: DestinationChargeOptions,
+  ) => Promise<Stripe.Response<Stripe.PaymentIntent>>
+  applicationFeeFor: (amount: number, options?: { applicationFeeAmount?: number, platformFeePercent?: number }) => number | undefined
+}

package/dist/connect/charge.js

@@ -0,0 +1 @@
+import{config}from"@stacksjs/config";import{stripe}from"../drivers/stripe";import{freshIdempotencyKey}from"../idempotency";import{requireAccountId}from"./account";function defaultCurrency(){const cfg=config||{};return(cfg.payment?.currency||cfg.billing?.currency||process.env.STRIPE_CURRENCY||"usd").toLowerCase()}function configuredFeePercent(){return(config||{}).payment?.connect?.platformFeePercent}export const manageDestinationCharge=(()=>{function applicationFeeFor(amount,options={}){if(options.applicationFeeAmount!=null){if(!Number.isFinite(options.applicationFeeAmount)||options.applicationFeeAmount<0)throw Error("[payments/connect] applicationFeeAmount must be a non-negative number of minor units");if(options.applicationFeeAmount>amount)throw Error(`[payments/connect] applicationFeeAmount ${options.applicationFeeAmount} exceeds the charge amount ${amount}`);return Math.floor(options.applicationFeeAmount)}const percent=options.platformFeePercent??configuredFeePercent();if(percent==null)return;if(!Number.isFinite(percent)||percent<0||percent>100)throw Error(`[payments/connect] platformFeePercent must be between 0 and 100, got ${percent}`);return Math.floor(amount*percent/100)}async function destinationCharge(user,amount,destinationAccountId,options={}){requireAccountId(destinationAccountId,"destinationCharge");if(!Number.isFinite(amount)||amount<=0)throw Error("[payments/connect] destinationCharge requires a positive amount in minor units");const{applicationFeeAmount,platformFeePercent,transferGroup,...intentParams}=options,fee=applicationFeeFor(amount,{applicationFeeAmount,platformFeePercent}),params={amount,currency:defaultCurrency(),transfer_data:{destination:destinationAccountId},...fee!=null&&fee>0?{application_fee_amount:fee}:{},...transferGroup?{transfer_group:transferGroup}:{},...intentParams};if(!params.customer&&user.hasStripeId())params.customer=user.stripe_id??void 0;return await stripe.paymentIntents.create(params,{idempotencyKey:freshIdempotencyKey("connect.destination_charge",user.id,amount)})}return{destinationCharge,applicationFeeFor}})();

package/dist/connect/index.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Grouped Connect surface, reached as `Payment.connect.*`.
+ */
+export declare const connect: {
+  createAccount: unknown;
+  createTestAccount: unknown;
+  onboardingLink: unknown;
+  accountStatus: unknown;
+  retrieveAccount: unknown;
+  destinationCharge: unknown;
+  applicationFeeFor: unknown;
+  createTransfer: unknown;
+  reverseTransfer: unknown;
+  listTransfers: unknown;
+  retrieveTransfer: unknown;
+  listPayouts: unknown;
+  retrievePayout: unknown;
+  accountBalance: unknown;
+  onAccount: unknown;
+  onPayout: unknown;
+  getAccount: unknown;
+  getPayout: unknown;
+  getConnectedAccountId: unknown;
+  account: unknown;
+  charge: unknown;
+  transfer: unknown;
+  payout: unknown
+};
+/**
+ * Stripe Connect
+ *
+ * Marketplace payments: onboard merchants as connected accounts, charge the
+ * customer on the platform while settling to the merchant, move money between
+ * the two, and follow what Stripe pays out.
+ *
+ * Everything here is additive - an app that charges for itself never touches
+ * it, and the `stripe` client stays lazily resolved, so importing
+ * `@stacksjs/payments` still costs nothing when Stripe is not installed.
+ */
+export * from './account';
+export * from './charge';
+export * from './payout';
+export * from './transfer';
+export * from './webhook';

package/dist/connect/index.js

@@ -0,0 +1 @@
+export*from"./account";export*from"./charge";export*from"./payout";export*from"./transfer";export*from"./webhook";import{manageConnectedAccount}from"./account";import{manageDestinationCharge}from"./charge";import{managePayout}from"./payout";import{manageTransfer}from"./transfer";import{manageConnectWebhook}from"./webhook";export const connect={createAccount:manageConnectedAccount.createConnectedAccount,createTestAccount:manageConnectedAccount.createTestConnectedAccount,onboardingLink:manageConnectedAccount.accountOnboardingLink,accountStatus:manageConnectedAccount.accountStatus,retrieveAccount:manageConnectedAccount.retrieveConnectedAccount,destinationCharge:manageDestinationCharge.destinationCharge,applicationFeeFor:manageDestinationCharge.applicationFeeFor,createTransfer:manageTransfer.createTransfer,reverseTransfer:manageTransfer.reverseTransfer,listTransfers:manageTransfer.listTransfers,retrieveTransfer:manageTransfer.retrieveTransfer,listPayouts:managePayout.listPayouts,retrievePayout:managePayout.retrievePayout,accountBalance:managePayout.accountBalance,onAccount:manageConnectWebhook.onAccount,onPayout:manageConnectWebhook.onPayout,getAccount:manageConnectWebhook.getAccount,getPayout:manageConnectWebhook.getPayout,getConnectedAccountId:manageConnectWebhook.getConnectedAccountId,account:manageConnectedAccount,charge:manageDestinationCharge,transfer:manageTransfer,payout:managePayout};

package/dist/connect/payout.d.ts

@@ -0,0 +1,17 @@
+import type Stripe from 'stripe';
+/**
+ * Payouts as the connected account sees them: bank transfers out of the
+ * merchant's Stripe balance.
+ *
+ * Every call is made *as* the connected account (`stripeAccount`), not as the
+ * platform. Listing payouts on the platform account instead returns the
+ * platform's own bank transfers, which is a quietly wrong answer rather than an
+ * error - a merchant statement page would render the platform's payouts and
+ * nobody would notice until reconciliation.
+ */
+export declare const managePayout: ManagePayout;
+export declare interface ManagePayout {
+  listPayouts: (accountId: string, params?: Stripe.PayoutListParams) => Promise<Stripe.Response<Stripe.ApiList<Stripe.Payout>>>
+  retrievePayout: (accountId: string, payoutId: string) => Promise<Stripe.Response<Stripe.Payout>>
+  accountBalance: (accountId: string) => Promise<Stripe.Response<Stripe.Balance>>
+}

package/dist/connect/payout.js

@@ -0,0 +1 @@
+import{stripe}from"../drivers/stripe";import{requireAccountId}from"./account";export const managePayout=(()=>{async function listPayouts(accountId,params={}){requireAccountId(accountId,"listPayouts");return await stripe.payouts.list(params,{stripeAccount:accountId})}async function retrievePayout(accountId,payoutId){requireAccountId(accountId,"retrievePayout");if(!payoutId||typeof payoutId!=="string")throw Error("[payments/connect] retrievePayout requires a payout id");return await stripe.payouts.retrieve(payoutId,{},{stripeAccount:accountId})}async function accountBalance(accountId){requireAccountId(accountId,"accountBalance");return await stripe.balance.retrieve({},{stripeAccount:accountId})}return{listPayouts,retrievePayout,accountBalance}})();

package/dist/connect/transfer.d.ts

@@ -0,0 +1,25 @@
+import type Stripe from 'stripe';
+/**
+ * Separate transfers, for money movement that is not tied to a single charge at
+ * the moment the customer pays.
+ *
+ * `destinationCharge` covers the common marketplace case. This is the other
+ * one: paying a courier their accumulated earnings, settling a merchant weekly
+ * rather than per order, or splitting one charge across several recipients.
+ */
+export declare const manageTransfer: ManageTransfer;
+export declare interface CreateTransferOptions {
+  amount: number
+  destination: string
+  currency?: string
+  transferGroup?: string
+  sourceTransaction?: string
+  description?: string
+  metadata?: Stripe.MetadataParam
+}
+export declare interface ManageTransfer {
+  createTransfer: (options: CreateTransferOptions) => Promise<Stripe.Response<Stripe.Transfer>>
+  reverseTransfer: (transferId: string, amount?: number) => Promise<Stripe.Response<Stripe.TransferReversal>>
+  listTransfers: (params?: Stripe.TransferListParams) => Promise<Stripe.Response<Stripe.ApiList<Stripe.Transfer>>>
+  retrieveTransfer: (transferId: string) => Promise<Stripe.Response<Stripe.Transfer>>
+}

package/dist/connect/transfer.js

@@ -0,0 +1 @@
+import{config}from"@stacksjs/config";import{stripe}from"../drivers/stripe";import{freshIdempotencyKey}from"../idempotency";import{requireAccountId}from"./account";function defaultCurrency(){const cfg=config||{};return(cfg.payment?.currency||cfg.billing?.currency||process.env.STRIPE_CURRENCY||"usd").toLowerCase()}export const manageTransfer=(()=>{async function createTransfer(options){requireAccountId(options?.destination,"createTransfer");if(!Number.isFinite(options.amount)||options.amount<=0)throw Error("[payments/connect] createTransfer requires a positive amount in minor units");const params={amount:Math.floor(options.amount),currency:(options.currency??defaultCurrency()).toLowerCase(),destination:options.destination,...options.transferGroup?{transfer_group:options.transferGroup}:{},...options.sourceTransaction?{source_transaction:options.sourceTransaction}:{},...options.description?{description:options.description}:{},...options.metadata?{metadata:options.metadata}:{}};return await stripe.transfers.create(params,{idempotencyKey:freshIdempotencyKey("connect.transfer.create",options.destination,options.amount)})}async function reverseTransfer(transferId,amount){if(!transferId||typeof transferId!=="string")throw Error("[payments/connect] reverseTransfer requires a transfer id");if(amount!=null&&(!Number.isFinite(amount)||amount<=0))throw Error("[payments/connect] reverseTransfer amount must be a positive number of minor units");const params=amount==null?{}:{amount:Math.floor(amount)};return await stripe.transfers.createReversal(transferId,params,{idempotencyKey:`stacks:connect.transfer.reverse:${transferId}:${amount??"full"}:v1`})}async function listTransfers(params={}){return await stripe.transfers.list(params)}async function retrieveTransfer(transferId){if(!transferId||typeof transferId!=="string")throw Error("[payments/connect] retrieveTransfer requires a transfer id");return await stripe.transfers.retrieve(transferId)}return{createTransfer,reverseTransfer,listTransfers,retrieveTransfer}})();

package/dist/connect/webhook.d.ts

@@ -0,0 +1,49 @@
+import type { WebhookHandler } from '../billable/webhook';
+import type Stripe from 'stripe';
+/**
+ * Connect webhooks arrive on their own endpoint, with their own signing secret
+ * (`config.payment.connect.webhookSecret`), and every event carries
+ * `event.account` naming the connected account it is about. Verifying them
+ * against the account webhook secret fails every signature, and reading them
+ * without `event.account` loses the only field that says whose money moved.
+ *
+ * Dispatch reuses the account-webhook registry, so `processWebhook` handles
+ * both endpoints - only the secret differs at the route.
+ */
+/**
+ * Account lifecycle. `updated` is the one that matters: it fires when a
+ * merchant finishes onboarding, when Stripe needs more documents, and when an
+ * account is restricted. Treat it as "re-read `accountStatus` and store it"
+ * rather than trying to diff the payload.
+ */
+export declare function onAccount(handlers: {
+  updated?: WebhookHandler
+  deauthorized?: WebhookHandler
+}): void;
+/**
+ * Payout lifecycle for connected accounts. `failed` is the one worth alerting
+ * on - a merchant whose bank details are wrong keeps accruing balance while
+ * believing they are being paid.
+ */
+export declare function onPayout(handlers: {
+  created?: WebhookHandler
+  paid?: WebhookHandler
+  failed?: WebhookHandler
+}): void;
+/**
+ * The connected account an event is about, or null when it is a plain
+ * platform-account event.
+ *
+ * Every Connect handler needs this to know which merchant to update, and it is
+ * easy to miss because it sits on the event rather than in `data.object`.
+ */
+export declare function getConnectedAccountId(event: Stripe.Event): string | null;
+export declare function getAccount(event: Stripe.Event): Stripe.Account | null;
+export declare function getPayout(event: Stripe.Event): Stripe.Payout | null;
+export declare const manageConnectWebhook: {
+  onAccount: typeof onAccount;
+  onPayout: typeof onPayout;
+  getAccount: typeof getAccount;
+  getPayout: typeof getPayout;
+  getConnectedAccountId: typeof getConnectedAccountId
+};

package/dist/connect/webhook.js

@@ -0,0 +1 @@
+import{onWebhookEvent}from"../billable/webhook";export function onAccount(handlers){if(handlers.updated)onWebhookEvent("account.updated",handlers.updated);if(handlers.deauthorized)onWebhookEvent("account.application.deauthorized",handlers.deauthorized)}export function onPayout(handlers){if(handlers.created)onWebhookEvent("payout.created",handlers.created);if(handlers.paid)onWebhookEvent("payout.paid",handlers.paid);if(handlers.failed)onWebhookEvent("payout.failed",handlers.failed)}export function getConnectedAccountId(event){const account=event.account;return typeof account==="string"&&account.length>0?account:null}export function getAccount(event){if(event.type.startsWith("account.")&&!event.type.startsWith("account.application."))return event.data.object;return null}export function getPayout(event){if(event.type.startsWith("payout."))return event.data.object;return null}export const manageConnectWebhook={onAccount,onPayout,getAccount,getPayout,getConnectedAccountId};

package/dist/index.d.ts

@@ -8,6 +8,8 @@ export * from './payment';
 export { default as Payment } from './payment';
 // Billable modules
 export * from './billable/index';
+// Stripe Connect (marketplaces)
+export * from './connect/index';
 // Stripe driver and SDK
 export * from './drivers/stripe';
 // Idempotency-key helpers — passed to every Stripe create/update so

package/dist/index.js

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

package/dist/payment.d.ts

@@ -1,3 +1,4 @@
+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';
@@ -172,6 +173,7 @@ export declare const Payment: {
   onCheckout: typeof onCheckout;
   onCharge: typeof onCharge;
   processWebhook: typeof processWebhook;
+  connect: typeof connect;
   stripe: typeof stripe;
   customer: unknown;
   subscription: unknown;

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{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";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 const Payment={charge,createPayment,refund,checkout,subscriptionCheckout,subscribe,cancelSubscription,hasActiveSubscription,changeSubscription,getOrCreateCustomer,updateCustomer,deleteCustomer,addPaymentMethod,setDefaultPaymentMethod,removePaymentMethod,createSetupIntent,getInvoices,createInvoice,payInvoice,createProduct,getPrice,listProducts,createCoupon,createPromoCode,validatePromoCode,formatAmount,toCents,toDollars,webhook:manageWebhook,onPaymentIntent,onSubscription,onInvoice,onCheckout,onCharge,processWebhook,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{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 const Payment={charge,createPayment,refund,checkout,subscriptionCheckout,subscribe,cancelSubscription,hasActiveSubscription,changeSubscription,getOrCreateCustomer,updateCustomer,deleteCustomer,addPaymentMethod,setDefaultPaymentMethod,removePaymentMethod,createSetupIntent,getInvoices,createInvoice,payInvoice,createProduct,getPrice,listProducts,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.72.103",
+  "version": "0.73.1",
   "description": "The Stacks payments package. Currently supporting Stripe.",
   "author": "Chris Breuer",
   "contributors": [
@@ -72,9 +72,9 @@
     }
   },
   "devDependencies": {
-    "@stacksjs/config": "0.72.103",
+    "@stacksjs/config": "0.73.1",
     "better-dx": "^0.2.24",
-    "@stacksjs/utils": "0.72.103",
+    "@stacksjs/utils": "0.73.1",
     "@stripe/stripe-js": "^9.10.0",
     "stripe": "22.3.2"
   }