@stacksjs/payments 0.70.88 → 0.70.90

package/dist/payment.d.ts

@@ -0,0 +1,182 @@
+import type { UserModel } from '@stacksjs/orm';
+import type Stripe from 'stripe';
+/**
+ * Create a one-time charge
+ */
+export declare function charge(user: UserModel, amount: number, paymentMethod: string, options?: Partial<Stripe.PaymentIntentCreateParams>): Promise<Stripe.PaymentIntent>;
+/**
+ * Create a payment intent (for client-side confirmation)
+ */
+export declare function createPayment(user: UserModel, amount: number, options?: Partial<Stripe.PaymentIntentCreateParams>): Promise<Stripe.PaymentIntent>;
+/**
+ * Refund a payment
+ */
+export declare function refund(paymentIntentId: string, amount?: number, options?: Partial<Stripe.RefundCreateParams>): Promise<Stripe.Refund>;
+/**
+ * Create a Stripe Checkout session
+ */
+export declare function checkout(user: UserModel, lineItems: Stripe.Checkout.SessionCreateParams.LineItem[], options?: Partial<Stripe.Checkout.SessionCreateParams>): Promise<Stripe.Checkout.Session>;
+/**
+ * Create a subscription checkout session
+ */
+export declare function subscriptionCheckout(user: UserModel, priceId: string, options?: Partial<Stripe.Checkout.SessionCreateParams>): Promise<Stripe.Checkout.Session>;
+/**
+ * Create a new subscription
+ */
+export declare function subscribe(user: UserModel, lookupKey: string, options?: Partial<Stripe.SubscriptionCreateParams>): Promise<Stripe.Subscription>;
+/**
+ * Cancel a subscription
+ */
+export declare function cancelSubscription(subscriptionId: string, immediately?: boolean): Promise<Stripe.Subscription>;
+/**
+ * Check if user has an active subscription
+ */
+export declare function hasActiveSubscription(user: UserModel, type?: string): Promise<boolean>;
+/**
+ * Update subscription to a new price
+ */
+export declare function changeSubscription(user: UserModel, newLookupKey: string, type?: string): Promise<Stripe.Subscription>;
+/**
+ * Get or create a Stripe customer for a user
+ */
+export declare function getOrCreateCustomer(user: UserModel, options?: Stripe.CustomerCreateParams): Promise<Stripe.Customer>;
+/**
+ * Update customer details
+ */
+export declare function updateCustomer(user: UserModel, options: Stripe.CustomerCreateParams): Promise<Stripe.Customer>;
+/**
+ * Delete a customer from Stripe
+ */
+export declare function deleteCustomer(user: UserModel): Promise<Stripe.DeletedCustomer>;
+/**
+ * Add a payment method to a customer
+ */
+export declare function addPaymentMethod(user: UserModel, paymentMethodId: string): Promise<Stripe.PaymentMethod>;
+/**
+ * Set the default payment method
+ */
+export declare function setDefaultPaymentMethod(user: UserModel, paymentMethodId: string): Promise<Stripe.Customer>;
+/**
+ * Remove a payment method.
+ * Accepts either a numeric database ID or a Stripe payment method ID string (pm_xxx).
+ */
+export declare function removePaymentMethod(user: UserModel, paymentMethodId: string | number): Promise<Stripe.PaymentMethod>;
+/**
+ * Create a setup intent for adding payment methods
+ */
+export declare function createSetupIntent(user: UserModel, options?: Partial<Stripe.SetupIntentCreateParams>): Promise<Stripe.SetupIntent>;
+/**
+ * Get user's invoices
+ */
+export declare function getInvoices(user: UserModel): Promise<Stripe.ApiList<Stripe.Invoice>>;
+/**
+ * Create an invoice
+ */
+export declare function createInvoice(customerId: string, options?: Partial<Stripe.InvoiceCreateParams>): Promise<Stripe.Invoice>;
+/**
+ * Pay an invoice
+ */
+export declare function payInvoice(invoiceId: string): Promise<Stripe.Invoice>;
+/**
+ * Create a product with a price
+ */
+export declare function createProduct(name: string, price: number, options?: {
+    currency?: string
+    interval?: 'day' | 'week' | 'month' | 'year'
+    description?: string
+    metadata?: Stripe.MetadataParam
+  }): Promise<{ product: Stripe.Product, price: Stripe.Price }>;
+/**
+ * Get a price by lookup key
+ */
+export declare function getPrice(lookupKey: string): Promise<Stripe.Price | undefined>;
+/**
+ * List all products
+ */
+export declare function listProducts(options?: Stripe.ProductListParams): Promise<Stripe.ApiList<Stripe.Product>>;
+/**
+ * Create a discount coupon
+ */
+export declare function createCoupon(options: {
+    percentOff?: number
+    amountOff?: number
+    currency?: string
+    duration?: 'forever' | 'once' | 'repeating'
+    durationInMonths?: number
+    name?: string
+    maxRedemptions?: number
+  }): Promise<Stripe.Coupon>;
+/**
+ * Create a promotion code from a coupon
+ */
+export declare function createPromoCode(couponId: string, code: string, options?: Partial<Stripe.PromotionCodeCreateParams>): Promise<Stripe.PromotionCode>;
+/**
+ * Validate a promo code
+ */
+export declare function validatePromoCode(code: string): Promise<Stripe.PromotionCode | null>;
+/**
+ * Format amount for display.
+ *
+ * Currency defaults to the project's configured payment currency
+ * (`config.payment.currency` / `STRIPE_CURRENCY`), falling back to USD only
+ * when nothing else is set. Locale follows the same pattern via
+ * `config.app.locale` so EU merchants see €1.234,56 not $1,234.56.
+ */
+export declare function formatAmount(amount: number, currency?: string): string;
+/**
+ * Convert dollars to cents
+ */
+export declare function toCents(dollars: number): number;
+/**
+ * Convert cents to dollars
+ */
+export declare function toDollars(cents: number): number;
+// =============================================================================
+// 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;
+  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;
+  stripe: typeof stripe;
+  customer: unknown;
+  subscription: unknown;
+  invoice: unknown;
+  paymentMethod: unknown;
+  product: unknown;
+  price: unknown;
+  coupon: unknown
+};
+export default Payment;

package/dist/payment.js

@@ -0,0 +1,199 @@
+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;

package/dist/stripe.backup.d.ts

@@ -0,0 +1 @@
+

package/package.json

@@ -2,7 +2,7 @@
   "name": "@stacksjs/payments",
   "type": "module",
   "sideEffects": false,
-  "version": "0.70.88",
+  "version": "0.70.90",
   "description": "The Stacks payments package. Currently supporting Stripe.",
   "author": "Chris Breuer",
   "contributors": [
@@ -67,9 +67,9 @@
     }
   },
   "devDependencies": {
-    "@stacksjs/config": "0.70.88",
+    "@stacksjs/config": "0.70.90",
     "better-dx": "^0.2.16",
-    "@stacksjs/utils": "0.70.88",
+    "@stacksjs/utils": "0.70.90",
     "@stripe/stripe-js": "^8.7.0",
     "stripe": "^21.0.1"
   }