@stacksjs/payments 0.70.88 → 0.70.90

package/dist/billable/charge.d.ts

@@ -0,0 +1,9 @@
+import type { UserModel } from '@stacksjs/orm';
+import type Stripe from 'stripe';
+export declare const manageCharge: ManageCharge;
+export declare interface ManageCharge {
+  createPayment: (user: UserModel, amount: number, options: Stripe.PaymentIntentCreateParams) => Promise<Stripe.Response<Stripe.PaymentIntent>>
+  findPayment: (id: string) => Promise<Stripe.PaymentIntent | null>
+  refund: (paymentIntentId: string, options?: Stripe.RefundCreateParams) => Promise<Stripe.Response<Stripe.Refund>>
+  charge: (user: UserModel, amount: number, paymentMethod: string, options: Stripe.PaymentIntentCreateParams) => Promise<Stripe.Response<Stripe.PaymentIntent>>
+}

package/dist/billable/charge.js

@@ -0,0 +1,64 @@
+import { config } from "@stacksjs/config";
+import { log } from "@stacksjs/logging";
+import { stripe } from "..";
+import { freshIdempotencyKey } from "../idempotency";
+function defaultCurrency() {
+  const cfg = config || {};
+  return (cfg.payment?.currency || cfg.billing?.currency || process.env.STRIPE_CURRENCY || "usd").toLowerCase();
+}
+export const manageCharge = (() => {
+  async function createPayment(user, amount, options) {
+    const defaultOptions = {
+      currency: defaultCurrency(),
+      amount
+    };
+    if (user.hasStripeId())
+      defaultOptions.customer = user.stripe_id ?? void 0;
+    const mergedOptions = { ...defaultOptions, ...options };
+    return await stripe.paymentIntents.create(mergedOptions, {
+      idempotencyKey: freshIdempotencyKey("payment_intent.create", user.id, amount)
+    });
+  }
+  async function findPayment(id) {
+    try {
+      return await stripe.paymentIntents.retrieve(id);
+    } catch (error) {
+      log.error(error);
+      return null;
+    }
+  }
+  async function refund(paymentIntentId, options = {}) {
+    if (!paymentIntentId || typeof paymentIntentId !== "string")
+      throw Error("[payments/refund] paymentIntentId is required");
+    if (options.amount != null) {
+      if (typeof options.amount !== "number" || !Number.isFinite(options.amount) || options.amount <= 0)
+        throw Error("[payments/refund] amount must be a positive finite number");
+      try {
+        const original = await stripe.paymentIntents.retrieve(paymentIntentId), captured = original.amount_received ?? original.amount;
+        if (captured && options.amount > captured)
+          throw Error(`[payments/refund] amount ${options.amount} exceeds captured amount ${captured}`);
+      } catch (err) {
+        if (err instanceof Error && err.message.startsWith("[payments/refund]"))
+          throw err;
+      }
+    }
+    const { idempotencyKey, ...rest } = options, refundParams = {
+      payment_intent: paymentIntentId,
+      ...rest
+    }, requestOptions = {
+      idempotencyKey: idempotencyKey || `refund:${paymentIntentId}:${rest.amount ?? "full"}`
+    };
+    return await stripe.refunds.create(refundParams, requestOptions);
+  }
+  async function charge(user, amount, paymentMethod, options) {
+    const mergedOptions = { ...{
+      confirmation_method: "automatic",
+      confirm: !0,
+      payment_method: paymentMethod,
+      currency: defaultCurrency(),
+      amount
+    }, ...options };
+    return await createPayment(user, amount, mergedOptions);
+  }
+  return { createPayment, charge, findPayment, refund };
+})();

package/dist/billable/checkout.d.ts

@@ -0,0 +1,6 @@
+import type { UserModel } from '@stacksjs/orm';
+import type Stripe from 'stripe';
+export declare const manageCheckout: Checkout;
+export declare interface Checkout {
+  create: (user: UserModel, params: Stripe.Checkout.SessionCreateParams) => Promise<Stripe.Response<Stripe.Checkout.Session>>
+}

package/dist/billable/checkout.js

@@ -0,0 +1,43 @@
+import { config } from "@stacksjs/config";
+import { stripe } from "..";
+import { freshIdempotencyKey } from "../idempotency";
+function assertSameOriginUrl(url, label) {
+  if (!url)
+    return;
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    throw Error(`[payments/checkout] ${label} is not a valid URL: ${url}`);
+  }
+  const appUrl = config?.app?.url;
+  if (!appUrl)
+    return;
+  let appOrigin;
+  try {
+    appOrigin = new URL(appUrl.startsWith("http") ? appUrl : `https://${appUrl}`).origin;
+  } catch {
+    return;
+  }
+  if (parsed.origin !== appOrigin)
+    throw Error(`[payments/checkout] ${label} origin (${parsed.origin}) does not match app origin (${appOrigin})`);
+}
+export const manageCheckout = (() => {
+  async function create(user, params) {
+    const customerId = params.customer || user.stripe_id;
+    if (!customerId)
+      throw Error("User has no Stripe customer");
+    assertSameOriginUrl(params.success_url, "success_url");
+    assertSameOriginUrl(params.cancel_url, "cancel_url");
+    const mergedParams = { ...{
+      customer: customerId,
+      mode: "payment",
+      success_url: params.success_url,
+      cancel_url: params.cancel_url
+    }, ...params };
+    return await stripe.checkout.sessions.create(mergedParams, {
+      idempotencyKey: freshIdempotencyKey("checkout.session.create", user.id)
+    });
+  }
+  return { create };
+})();

package/dist/billable/customer.d.ts

@@ -0,0 +1,15 @@
+import type { StripeCustomerOptions } from '@stacksjs/types';
+import type { UserModel } from '@stacksjs/orm';
+import type Stripe from 'stripe';
+export declare const manageCustomer: ManageCustomer;
+export declare interface ManageCustomer {
+  stripeId: (user: UserModel) => string
+  hasStripeId: (user: UserModel) => boolean
+  createStripeCustomer: (user: UserModel, options: Stripe.CustomerCreateParams) => Promise<Stripe.Response<Stripe.Customer>>
+  updateStripeCustomer: (user: UserModel, options: Stripe.CustomerUpdateParams) => Promise<Stripe.Response<Stripe.Customer>>
+  createOrGetStripeUser: (user: UserModel, options: Stripe.CustomerCreateParams) => Promise<Stripe.Response<Stripe.Customer>>
+  retrieveStripeUser: (user: UserModel) => Promise<Stripe.Response<Stripe.Customer> | undefined>
+  createOrUpdateStripeUser: (user: UserModel, options: Stripe.CustomerCreateParams) => Promise<Stripe.Response<Stripe.Customer>>
+  deleteStripeUser: (user: UserModel) => Promise<Stripe.Response<Stripe.DeletedCustomer>>
+  syncStripeCustomerDetails: (user: UserModel, options: StripeCustomerOptions) => Promise<Stripe.Response<Stripe.Customer>>
+}

package/dist/billable/customer.js

@@ -0,0 +1,117 @@
+import { stripe } from "..";
+import { stacksIdempotencyKey } from "../idempotency";
+export const manageCustomer = (() => {
+  function stripeId(user) {
+    return user.stripe_id || "";
+  }
+  function stripeAddress(options) {
+    return {
+      line1: options.address?.line1,
+      city: options.address?.city,
+      state: options.address?.state,
+      postal_code: options.address?.postal_code,
+      country: options.address?.country
+    };
+  }
+  function stripePreferredLocales() {
+    return [];
+  }
+  function stripeMetadata(metadata) {
+    return metadata;
+  }
+  function hasStripeId(user) {
+    return Boolean(user.stripe_id);
+  }
+  async function createStripeCustomer(user, options = {}) {
+    if (hasStripeId(user))
+      throw Error("Customer already created");
+    if (!options.name && stripeName(user))
+      options.name = stripeName(user);
+    if (!options.email && stripeEmail(user))
+      options.email = stripeEmail(user);
+    const customer = await stripe.customers.create(options, {
+      idempotencyKey: stacksIdempotencyKey("customer.create", user.id)
+    });
+    await user.update({ stripe_id: customer.id });
+    return customer;
+  }
+  async function updateStripeCustomer(user, options = {}) {
+    if (!user.stripe_id)
+      throw Error("User does not have a Stripe customer ID. Create a customer first.");
+    return await stripe.customers.update(user.stripe_id, options, {
+      idempotencyKey: stacksIdempotencyKey("customer.update", user.id, user.stripe_id)
+    });
+  }
+  async function deleteStripeUser(user) {
+    if (!hasStripeId(user))
+      throw Error("User does not have a Stripe ID");
+    try {
+      if (!user.stripe_id)
+        throw Error("User has no Stripe ID");
+      const deletedCustomer = await stripe.customers.del(user.stripe_id);
+      await user.update({ stripe_id: "" });
+      return deletedCustomer;
+    } catch (error) {
+      if (error.statusCode === 404)
+        throw Error("Customer not found in Stripe");
+      throw error;
+    }
+  }
+  async function createOrGetStripeUser(user, options = {}) {
+    if (!hasStripeId(user))
+      return await createStripeCustomer(user, options);
+    try {
+      const customer = await stripe.customers.retrieve(user.stripe_id);
+      if (customer.deleted)
+        throw Error("Customer was deleted");
+      return customer;
+    } catch (error) {
+      if (error.statusCode === 404)
+        return await createStripeCustomer(user, options);
+      throw error;
+    }
+  }
+  async function retrieveStripeUser(user) {
+    if (!hasStripeId(user))
+      return;
+    try {
+      const customer = await stripe.customers.retrieve(user.stripe_id);
+      if (customer.deleted)
+        throw Error("Customer was deleted in Stripe");
+      return customer;
+    } catch (error) {
+      if (error.statusCode === 404)
+        throw Error("Customer not found in Stripe");
+      throw error;
+    }
+  }
+  async function createOrUpdateStripeUser(user, options) {
+    if (!hasStripeId(user))
+      return await createStripeCustomer(user, options);
+    try {
+      if ((await stripe.customers.retrieve(user.stripe_id)).deleted)
+        return await createStripeCustomer(user, options);
+      return await updateStripeCustomer(user, options);
+    } catch (error) {
+      if (error.statusCode === 404)
+        return await createStripeCustomer(user, options);
+      throw error;
+    }
+  }
+  async function syncStripeCustomerDetails(user, options) {
+    return await updateStripeCustomer(user, {
+      name: stripeName(user),
+      email: stripeEmail(user),
+      address: stripeAddress(options),
+      preferred_locales: stripePreferredLocales(),
+      metadata: options.metadata ? stripeMetadata(options.metadata) : {}
+    });
+  }
+  function stripeName(user) {
+    return user.name || "";
+  }
+  function stripeEmail(user) {
+    return user.email || "";
+  }
+  return { stripeId, hasStripeId, createStripeCustomer, updateStripeCustomer, createOrGetStripeUser, createOrUpdateStripeUser, deleteStripeUser, retrieveStripeUser, syncStripeCustomerDetails };
+})();

package/dist/billable/index.d.ts

@@ -0,0 +1,13 @@
+// Core Billable Modules
+export * from './charge';
+export * from './checkout';
+export * from './customer';
+export * from './intent';
+export * from './invoice';
+export * from './payment-method';
+export * from './price';
+export * from './product';
+export * from './setup-products';
+export * from './subscription';
+export * from './transaction';
+export * from './webhook';

package/dist/billable/index.js

@@ -0,0 +1,12 @@
+export * from "./charge";
+export * from "./checkout";
+export * from "./customer";
+export * from "./intent";
+export * from "./invoice";
+export * from "./payment-method";
+export * from "./price";
+export * from "./product";
+export * from "./setup-products";
+export * from "./subscription";
+export * from "./transaction";
+export * from "./webhook";

package/dist/billable/intent.d.ts

@@ -0,0 +1,6 @@
+import type { UserModel } from '@stacksjs/orm';
+import type Stripe from 'stripe';
+export declare const manageSetupIntent: SetupIntent;
+export declare interface SetupIntent {
+  create: (user: UserModel, params: Stripe.SetupIntentCreateParams) => Promise<Stripe.Response<Stripe.SetupIntent>>
+}

package/dist/billable/intent.js

@@ -0,0 +1,18 @@
+import { manageCustomer, stripe } from "..";
+import { freshIdempotencyKey } from "../idempotency";
+export const manageSetupIntent = (() => {
+  async function create(user, params) {
+    const mergedParams = { ...{
+      customer: await manageCustomer.createOrGetStripeUser(user, {}).then((customer) => {
+        if (!customer || !customer.id)
+          throw Error("Customer does not exist in Stripe");
+        return customer.id;
+      }),
+      payment_method_types: ["card"]
+    }, ...params };
+    return await stripe.setupIntents.create(mergedParams, {
+      idempotencyKey: freshIdempotencyKey("setup_intent.create", user.id)
+    });
+  }
+  return { create };
+})();

package/dist/billable/invoice.d.ts

@@ -0,0 +1,6 @@
+import type { UserModel } from '@stacksjs/orm';
+import type Stripe from 'stripe';
+export declare const manageInvoice: ManageInvoice;
+export declare interface ManageInvoice {
+  list: (user: UserModel) => Promise<Stripe.Response<Stripe.ApiList<Stripe.Invoice>>>
+}

package/dist/billable/invoice.js

@@ -0,0 +1,14 @@
+import { stripe } from "..";
+export const manageInvoice = (() => {
+  async function list(user) {
+    if (!user.hasStripeId())
+      throw Error("Customer does not exist in Stripe");
+    if (!user.stripe_id)
+      throw Error("User has no Stripe ID");
+    return await stripe.invoices.list({
+      customer: user.stripe_id,
+      expand: ["data.payment_intent.payment_method"]
+    });
+  }
+  return { list };
+})();

package/dist/billable/payment-method.d.ts

@@ -0,0 +1,18 @@
+import { PaymentMethod } from '@stacksjs/orm';
+import type { ModelRow, UserModel } from '@stacksjs/orm';
+import type { Selectable } from '@stacksjs/database';
+import type Stripe from 'stripe';
+export declare const managePaymentMethod: ManagePaymentMethod;
+export declare interface ManagePaymentMethod {
+  addPaymentMethod: (user: UserModel, paymentMethod: string | Stripe.PaymentMethod) => Promise<Stripe.Response<Stripe.PaymentMethod>>
+  updatePaymentMethod: (user: UserModel, paymentMethodId: string, updateParams?: Stripe.PaymentMethodUpdateParams) => Promise<Stripe.Response<Stripe.PaymentMethod>>
+  setUserDefaultPayment: (user: UserModel, paymentMethodId: string) => Promise<Stripe.Response<Stripe.Customer>>
+  setDefaultPaymentMethod: (user: UserModel, paymentMethodId: number) => Promise<Stripe.Response<Stripe.Customer>>
+  storePaymentMethod: (user: UserModel, paymentMethodId: Stripe.PaymentMethod) => Promise<PaymentMethodInstance>
+  deletePaymentMethod: (user: UserModel, paymentMethodId: string | number) => Promise<Stripe.Response<Stripe.PaymentMethod>>
+  retrievePaymentMethod: (user: UserModel, paymentMethodId: number) => Promise<PaymentMethodInstance | undefined>
+  retrieveDefaultPaymentMethod: (user: UserModel) => Promise<PaymentMethodInstance | undefined>
+  listPaymentMethods: (user: UserModel, cardType?: string) => Promise<Selectable<PaymentMethodsTable>[]>
+}
+declare type PaymentMethodInstance = NonNullable<Awaited<ReturnType<typeof PaymentMethod.find>>>;
+declare type PaymentMethodsTable = ModelRow<typeof PaymentMethod>;

package/dist/billable/payment-method.js

@@ -0,0 +1,119 @@
+import { db } from "@stacksjs/database";
+import { PaymentMethod } from "@stacksjs/orm";
+import { stripe } from "..";
+export const managePaymentMethod = (() => {
+  async function addPaymentMethod(user, paymentMethod) {
+    if (!user.hasStripeId())
+      throw Error("Customer does not exist in Stripe");
+    let stripePaymentMethod;
+    if (typeof paymentMethod === "string")
+      stripePaymentMethod = await stripe.paymentMethods.retrieve(paymentMethod);
+    else
+      stripePaymentMethod = paymentMethod;
+    if (stripePaymentMethod.customer !== user.stripe_id)
+      stripePaymentMethod = await stripe.paymentMethods.attach(stripePaymentMethod.id, {
+        customer: user.stripe_id
+      });
+    await storePaymentMethod(user, stripePaymentMethod);
+    return stripePaymentMethod;
+  }
+  async function setUserDefaultPayment(user, paymentMethodId) {
+    if (!user.hasStripeId())
+      throw Error("Customer does not exist in Stripe");
+    const paymentMethod = await stripe.paymentMethods.retrieve(paymentMethodId), paymentMethodModel = await db.selectFrom("payment_methods").where("provider_id", "=", paymentMethodId).selectAll().executeTakeFirst();
+    if (!user.stripe_id)
+      throw Error("User has no Stripe ID");
+    if (paymentMethod.customer !== user.stripe_id)
+      await stripe.paymentMethods.attach(paymentMethod.id, {
+        customer: user.stripe_id
+      });
+    const updatedCustomer = await stripe.customers.update(user.stripe_id, {
+      invoice_settings: {
+        default_payment_method: paymentMethodId
+      }
+    });
+    await db.updateTable("payment_methods").set({ is_default: !1 }).where("user_id", "=", user.id).executeTakeFirst();
+    if (paymentMethodModel)
+      await updateDefault(paymentMethodModel);
+    return updatedCustomer;
+  }
+  async function setDefaultPaymentMethod(user, paymentId) {
+    if (!user.hasStripeId())
+      throw Error("Customer does not exist in Stripe");
+    const pm = await db.selectFrom("payment_methods").where("id", "=", paymentId).selectAll().executeTakeFirst();
+    if (!pm?.provider_id)
+      throw Error(`Payment method with id ${paymentId} not found`);
+    const paymentMethod = await stripe.paymentMethods.retrieve(String(pm.provider_id));
+    if (paymentMethod.customer !== user.stripe_id)
+      await stripe.paymentMethods.attach(paymentMethod.id, {
+        customer: user.stripe_id
+      });
+    if (!user.stripe_id)
+      throw Error("User has no Stripe ID");
+    const updatedCustomer = await stripe.customers.update(user.stripe_id, {
+      invoice_settings: {
+        default_payment_method: String(pm.provider_id)
+      }
+    });
+    await db.updateTable("payment_methods").set({ is_default: !1 }).where("user_id", "=", user.id).executeTakeFirst();
+    await db.updateTable("payment_methods").set({ is_default: !0 }).where("id", "=", paymentId).executeTakeFirst();
+    return updatedCustomer;
+  }
+  async function storePaymentMethod(user, paymentMethod) {
+    if (!user.hasStripeId())
+      throw Error("Customer does not exist in Stripe");
+    if (!paymentMethod.card?.brand || !paymentMethod.card?.exp_year || !paymentMethod.card?.exp_month)
+      throw Error("Invalid payment method: missing required card details");
+    const method = {
+      type: "card",
+      last_four: String(paymentMethod.card.last4),
+      brand: paymentMethod.card.brand,
+      exp_year: paymentMethod.card.exp_year,
+      exp_month: paymentMethod.card.exp_month,
+      user_id: user.id,
+      provider_id: paymentMethod.id
+    };
+    if (paymentMethod.customer !== user.stripe_id)
+      await stripe.paymentMethods.attach(paymentMethod.id, {
+        customer: user.stripe_id
+      });
+    return await PaymentMethod.create(method);
+  }
+  async function updateDefault(paymentMethodModel) {
+    return await paymentMethodModel.update({ is_default: !0 });
+  }
+  async function deletePaymentMethod(user, paymentMethodId) {
+    if (!user.hasStripeId())
+      throw Error("Customer does not exist in Stripe");
+    const pm = typeof paymentMethodId === "string" ? await db.selectFrom("payment_methods").where("provider_id", "=", paymentMethodId).selectAll().executeTakeFirst() : await PaymentMethod.find(paymentMethodId);
+    if (!pm?.provider_id)
+      throw Error(`Payment method with id ${paymentMethodId} not found`);
+    if ((await stripe.paymentMethods.retrieve(String(pm.provider_id))).customer !== user.stripe_id)
+      throw Error("Payment method does not belong to this customer");
+    await pm.delete();
+    return await stripe.paymentMethods.detach(String(pm.provider_id));
+  }
+  async function updatePaymentMethod(user, paymentMethodId, updateParams) {
+    if (!user.hasStripeId())
+      throw Error("Customer does not exist in Stripe");
+    if ((await stripe.paymentMethods.retrieve(paymentMethodId)).customer !== user.stripe_id)
+      throw Error("Payment method does not belong to this customer");
+    return await stripe.paymentMethods.update(paymentMethodId, updateParams);
+  }
+  async function listPaymentMethods(user) {
+    if (!user.hasStripeId())
+      throw Error("Customer does not exist in Stripe");
+    return await db.selectFrom("payment_methods").selectAll().where("user_id", "=", user.id).execute();
+  }
+  async function retrievePaymentMethod(user, paymentMethodId) {
+    if (!user.hasStripeId())
+      throw Error("Customer does not exist in Stripe");
+    return await db.selectFrom("payment_methods").where("id", "=", paymentMethodId).selectAll().executeTakeFirst();
+  }
+  async function retrieveDefaultPaymentMethod(user) {
+    if (!user.hasStripeId())
+      throw Error("Customer does not exist in Stripe");
+    return await PaymentMethod.where("user_id", user.id).where("is_default", !0).first();
+  }
+  return { addPaymentMethod, deletePaymentMethod, retrieveDefaultPaymentMethod, updatePaymentMethod, listPaymentMethods, setDefaultPaymentMethod, storePaymentMethod, retrievePaymentMethod, setUserDefaultPayment };
+})();

package/dist/billable/price.d.ts

@@ -0,0 +1,6 @@
+import type Stripe from 'stripe';
+export declare const managePrice: PriceManager;
+export declare interface PriceManager {
+  retrieveByLookupKey: (lookupKey: string) => Promise<Stripe.Price | undefined>
+  createOrGet: (lookupKey: string, params: Stripe.PriceCreateParams) => Promise<Stripe.Price>
+}

package/dist/billable/price.js

@@ -0,0 +1,19 @@
+import { stripe } from "..";
+export const managePrice = (() => {
+  async function retrieveByLookupKey(lookupKey) {
+    const prices = await stripe.prices.list({ lookup_keys: [lookupKey] });
+    if (!prices.data.length)
+      return;
+    return prices.data[0];
+  }
+  async function createOrGet(lookupKey, params) {
+    const existingPrice = await retrieveByLookupKey(lookupKey);
+    if (existingPrice)
+      return existingPrice;
+    return await stripe.prices.create({
+      ...params,
+      lookup_key: lookupKey
+    });
+  }
+  return { retrieveByLookupKey, createOrGet };
+})();

package/dist/billable/product.d.ts

@@ -0,0 +1,37 @@
+import type Stripe from 'stripe';
+export declare const manageProduct: ProductManager;
+export declare const managePriceExtended: ExtendedPriceManager;
+export declare const manageCoupon: CouponManager;
+export declare interface ProductManager {
+  create: (params: Stripe.ProductCreateParams) => Promise<Stripe.Response<Stripe.Product>>
+  retrieve: (productId: string) => Promise<Stripe.Response<Stripe.Product>>
+  update: (productId: string, params: Stripe.ProductUpdateParams) => Promise<Stripe.Response<Stripe.Product>>
+  list: (params?: Stripe.ProductListParams) => Promise<Stripe.Response<Stripe.ApiList<Stripe.Product>>>
+  archive: (productId: string) => Promise<Stripe.Response<Stripe.Product>>
+  createWithPrice: (product: Stripe.ProductCreateParams, price: Omit<Stripe.PriceCreateParams, 'product'>) => Promise<{ product: Stripe.Product, price: Stripe.Price }>
+  search: (query: string, params?: Stripe.ProductSearchParams) => Promise<Stripe.Response<Stripe.ApiSearchResult<Stripe.Product>>>
+}
+// =============================================================================
+// Extended Price Management
+// =============================================================================
+export declare interface ExtendedPriceManager {
+  create: (params: Stripe.PriceCreateParams) => Promise<Stripe.Response<Stripe.Price>>
+  retrieve: (priceId: string) => Promise<Stripe.Response<Stripe.Price>>
+  update: (priceId: string, params: Stripe.PriceUpdateParams) => Promise<Stripe.Response<Stripe.Price>>
+  list: (params?: Stripe.PriceListParams) => Promise<Stripe.Response<Stripe.ApiList<Stripe.Price>>>
+  listByProduct: (productId: string, params?: Stripe.PriceListParams) => Promise<Stripe.Response<Stripe.ApiList<Stripe.Price>>>
+  search: (query: string, params?: Stripe.PriceSearchParams) => Promise<Stripe.Response<Stripe.ApiSearchResult<Stripe.Price>>>
+  archive: (priceId: string) => Promise<Stripe.Response<Stripe.Price>>
+}
+// =============================================================================
+// Coupon and Promotion Code Management
+// =============================================================================
+export declare interface CouponManager {
+  create: (params: Stripe.CouponCreateParams) => Promise<Stripe.Response<Stripe.Coupon>>
+  retrieve: (couponId: string) => Promise<Stripe.Response<Stripe.Coupon>>
+  update: (couponId: string, params: Stripe.CouponUpdateParams) => Promise<Stripe.Response<Stripe.Coupon>>
+  delete: (couponId: string) => Promise<Stripe.Response<Stripe.DeletedCoupon>>
+  list: (params?: Stripe.CouponListParams) => Promise<Stripe.Response<Stripe.ApiList<Stripe.Coupon>>>
+  createPromotionCode: (params: Stripe.PromotionCodeCreateParams) => Promise<Stripe.Response<Stripe.PromotionCode>>
+  retrievePromotionCode: (code: string) => Promise<Stripe.PromotionCode | null>
+}

package/dist/billable/product.js

@@ -0,0 +1,101 @@
+import { stripe } from "..";
+export const manageProduct = (() => {
+  async function create(params) {
+    return await stripe.products.create(params);
+  }
+  async function retrieve(productId) {
+    return await stripe.products.retrieve(productId);
+  }
+  async function update(productId, params) {
+    return await stripe.products.update(productId, params);
+  }
+  async function list(params = {}) {
+    return await stripe.products.list({
+      active: !0,
+      ...params
+    });
+  }
+  async function archive(productId) {
+    return await stripe.products.update(productId, { active: !1 });
+  }
+  async function createWithPrice(productParams, priceParams) {
+    const product = await stripe.products.create(productParams), price = await stripe.prices.create({
+      ...priceParams,
+      product: product.id
+    });
+    return { product, price };
+  }
+  async function search(query, params = { query: "" }) {
+    return await stripe.products.search({
+      ...params,
+      query
+    });
+  }
+  return { create, retrieve, update, list, archive, createWithPrice, search };
+})(), managePriceExtended = (() => {
+  async function create(params) {
+    return await stripe.prices.create(params);
+  }
+  async function retrieve(priceId) {
+    return await stripe.prices.retrieve(priceId);
+  }
+  async function update(priceId, params) {
+    return await stripe.prices.update(priceId, params);
+  }
+  async function list(params = {}) {
+    return await stripe.prices.list({
+      active: !0,
+      ...params
+    });
+  }
+  async function listByProduct(productId, params = {}) {
+    return await stripe.prices.list({
+      product: productId,
+      active: !0,
+      ...params
+    });
+  }
+  async function search(query, params = { query: "" }) {
+    return await stripe.prices.search({
+      ...params,
+      query
+    });
+  }
+  async function archive(priceId) {
+    return await stripe.prices.update(priceId, { active: !1 });
+  }
+  return { create, retrieve, update, list, listByProduct, search, archive };
+})(), manageCoupon = (() => {
+  async function create(params) {
+    return await stripe.coupons.create(params);
+  }
+  async function retrieve(couponId) {
+    return await stripe.coupons.retrieve(couponId);
+  }
+  async function update(couponId, params) {
+    return await stripe.coupons.update(couponId, params);
+  }
+  async function deleteCoupon(couponId) {
+    return await stripe.coupons.del(couponId);
+  }
+  async function list(params = {}) {
+    return await stripe.coupons.list(params);
+  }
+  async function createPromotionCode(params) {
+    return await stripe.promotionCodes.create(params);
+  }
+  async function retrievePromotionCode(code) {
+    try {
+      const promotionCodes = await stripe.promotionCodes.list({
+        code,
+        active: !0
+      });
+      if (promotionCodes.data.length > 0)
+        return promotionCodes.data[0] ?? null;
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  return { create, retrieve, update, delete: deleteCoupon, list, createPromotionCode, retrievePromotionCode };
+})();

package/dist/billable/setup-products.d.ts

@@ -0,0 +1,2 @@
+import type { Result } from '@stacksjs/error-handling';
+export declare function createStripeProduct(): Promise<Result<string, Error>>;