@stacksjs/payments 0.70.87 → 0.70.90

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.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.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.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.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.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.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.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.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.js

@@ -0,0 +1,34 @@
+import { saas } from "@stacksjs/config";
+import { err, ok } from "@stacksjs/error-handling";
+import { log } from "@stacksjs/logging";
+import { stripe } from "@stacksjs/payments";
+export async function createStripeProduct() {
+  const plans = saas.plans;
+  try {
+    if (plans !== void 0 && plans.length)
+      for (const plan of plans) {
+        const product = await stripe.products.create({
+          name: plan.productName,
+          description: plan.description,
+          metadata: plan.metadata
+        });
+        for (const pricing of plan.pricing)
+          if (product) {
+            const priceParams = {
+              unit_amount: pricing.price,
+              currency: pricing.currency,
+              product: product.id,
+              lookup_key: pricing.key
+            };
+            if (pricing.interval)
+              priceParams.recurring = { interval: pricing.interval };
+            await stripe.prices.create(priceParams);
+          }
+      }
+    return ok("Migrations generated");
+  } catch (error) {
+    const e = error instanceof Error ? error : Error(String(error));
+    log.error(e);
+    return err(e);
+  }
+}

package/dist/billable/subscription.js

@@ -0,0 +1,138 @@
+import { db } from "@stacksjs/database";
+import { HttpError } from "@stacksjs/error-handling";
+import { isUniqueViolation } from "@stacksjs/orm";
+import { manageCustomer, managePrice, stripe } from "..";
+import { stacksIdempotencyKey } from "../idempotency";
+export const manageSubscription = (() => {
+  async function create(user, type, lookupKey, params) {
+    const price = await managePrice.retrieveByLookupKey(lookupKey);
+    if (!price)
+      throw Error("Price does not exist in Stripe");
+    const subscriptionItems = [
+      {
+        price: price.id,
+        quantity: 1
+      }
+    ], mergedParams = { ...{
+      customer: await manageCustomer.createOrGetStripeUser(user, {}).then((customer) => {
+        if (!customer || !customer.id)
+          throw Error("Customer does not exist in Stripe");
+        return customer.id;
+      }),
+      payment_behavior: "allow_incomplete",
+      expand: ["latest_invoice.payment_intent"],
+      items: subscriptionItems
+    }, ...params }, subscription = await stripe.subscriptions.create(mergedParams, {
+      idempotencyKey: stacksIdempotencyKey("subscription.create", user.id, type, lookupKey)
+    });
+    await storeSubscription(user, type, lookupKey, subscription);
+    return subscription;
+  }
+  async function update(user, type, lookupKey, _params = {}) {
+    const newPrice = await managePrice.retrieveByLookupKey(lookupKey), activeSubscription = await user?.activeSubscription();
+    if (!newPrice)
+      throw Error("New price does not exist in Stripe");
+    if (!activeSubscription)
+      throw Error("No active subscription for user!");
+    const subscriptionId = activeSubscription.subscription?.provider_id;
+    if (!subscriptionId)
+      throw Error("Active subscription has no provider ID");
+    const subscription = await stripe.subscriptions.retrieve(subscriptionId);
+    if (!subscription)
+      throw Error("Subscription does not exist in Stripe");
+    const subscriptionItemId = subscription.items.data[0]?.id;
+    if (!subscriptionItemId)
+      throw Error("No subscription items found in the subscription");
+    await stripe.subscriptions.update(subscriptionId, {
+      items: [{ id: subscriptionItemId, price: newPrice.id, quantity: 1 }],
+      proration_behavior: "create_prorations"
+    }, {
+      idempotencyKey: stacksIdempotencyKey("subscription.update", subscriptionId, newPrice.id)
+    });
+    const updatedSubscription = await stripe.subscriptions.retrieve(subscriptionId);
+    if (!activeSubscription.subscription?.id)
+      throw Error("Active subscription has no database ID");
+    await updateSubscription(activeSubscription.subscription.id, type, updatedSubscription);
+    return updatedSubscription;
+  }
+  async function cancel(subscriptionId, params) {
+    if (!await stripe.subscriptions.retrieve(subscriptionId))
+      throw Error("Subscription does not exist or does not belong to the user");
+    const updatedSubscription = await stripe.subscriptions.cancel(subscriptionId, params, {
+      idempotencyKey: stacksIdempotencyKey("subscription.cancel", subscriptionId)
+    });
+    await updateStoredSubscription(subscriptionId);
+    return updatedSubscription;
+  }
+  async function retrieve(user, subscriptionId) {
+    if (!user.hasStripeId())
+      throw Error("Customer does not exist in Stripe");
+    return await stripe.subscriptions.retrieve(subscriptionId);
+  }
+  async function updateStoredSubscription(subscriptionId) {
+    await db.updateTable("subscriptions").set({ provider_status: "canceled" }).where("provider_id", "=", subscriptionId).executeTakeFirst();
+  }
+  function isActive(subscription) {
+    return subscription.provider_status === "active";
+  }
+  function isTrial(subscription) {
+    return subscription.provider_status === "trialing";
+  }
+  async function isIncomplete(user, type) {
+    const subscription = await db.selectFrom("subscriptions").where("user_id", "=", user.id).where("type", "=", type).selectAll().executeTakeFirst();
+    if (!subscription)
+      return !1;
+    return subscription.provider_status === "incomplete";
+  }
+  async function isValid(user, type) {
+    const subscription = await db.selectFrom("subscriptions").where("user_id", "=", user.id).where("type", "=", type).selectAll().executeTakeFirst();
+    if (!subscription)
+      return !1;
+    const active = await isActive(subscription), trial = await isTrial(subscription);
+    return active || trial;
+  }
+  async function storeSubscription(user, type, _lookupKey, options) {
+    const firstItem = options.items.data[0];
+    if (!firstItem)
+      throw Error("Stripe subscription contains no line items \u2014 cannot store subscription");
+    const data = removeNullValues({
+      user_id: user.id,
+      type,
+      unit_price: Number(firstItem.price.unit_amount),
+      provider_id: options.id,
+      provider_status: options.status,
+      provider_price_id: firstItem.price.id,
+      quantity: firstItem.quantity,
+      trial_ends_at: options.trial_end != null ? String(options.trial_end) : void 0,
+      ends_at: options.current_period_end != null ? String(options.current_period_end) : void 0,
+      provider_type: "stripe",
+      last_used_at: options.current_period_end != null ? String(options.current_period_end) : void 0
+    });
+    let subscriptionModelCreated;
+    try {
+      subscriptionModelCreated = await db.insertInto("subscriptions").values(data).executeTakeFirst();
+    } catch (error) {
+      if (isUniqueViolation(error))
+        throw new HttpError(409, "A subscription with this provider ID already exists");
+      throw error;
+    }
+    if (!subscriptionModelCreated)
+      throw Error("Failed to insert subscription record");
+    return await db.selectFrom("subscriptions").where("id", "=", Number(subscriptionModelCreated.insertId)).selectAll().executeTakeFirst();
+  }
+  async function updateSubscription(activeSubId, type, options) {
+    const subscription = await db.selectFrom("subscriptions").where("id", "=", activeSubId).selectAll().executeTakeFirst(), firstItem = options.items.data[0];
+    if (!firstItem)
+      throw Error("Stripe subscription contains no line items \u2014 cannot update subscription");
+    await db?.updateTable("subscriptions").set({
+      type,
+      provider_price_id: firstItem.price.id,
+      unit_price: Number(firstItem.price.unit_amount)
+    }).where("id", "=", activeSubId).executeTakeFirst();
+    return subscription;
+  }
+  function removeNullValues(obj) {
+    return Object.fromEntries(Object.entries(obj).filter(([_, value]) => value != null));
+  }
+  return { create, update, isValid, isIncomplete, cancel, retrieve };
+})();

package/dist/billable/transaction.js

@@ -0,0 +1,25 @@
+import { db } from "@stacksjs/database";
+import { PaymentTransaction } from "@stacksjs/orm";
+export const manageTransaction = (() => {
+  async function store(user, productId, options) {
+    const product = await db.selectFrom("payment_products").where("id", "=", productId).selectAll().executeTakeFirst();
+    if (!product)
+      throw Error(`Payment product with id ${productId} not found.`);
+    const data = {
+      name: product.name,
+      description: options.description ?? "",
+      amount: product.unit_price,
+      brand: options.brand,
+      type: options.type ?? "one-time",
+      provider_id: options.provider_id,
+      user_id: user.id
+    }, createdTransaction = await db.insertInto("payment_transactions").values(data).executeTakeFirst();
+    if (!createdTransaction)
+      throw Error("Failed to insert payment transaction");
+    return await db.selectFrom("payment_transactions").where("id", "=", Number(createdTransaction.insertId)).selectAll().executeTakeFirst();
+  }
+  async function list(user) {
+    return await db.selectFrom("payment_transactions").where("user_id", "=", user.id).selectAll().execute();
+  }
+  return { store, list };
+})();

package/dist/billable/webhook.js

@@ -0,0 +1,153 @@
+import { stripe } from "..";
+const handlers = new Map;
+export function onWebhookEvent(eventType, handler) {
+  const existing = handlers.get(eventType) || [];
+  existing.push(handler);
+  handlers.set(eventType, existing);
+}
+export function registerWebhookHandlers(handlerMap) {
+  for (const [eventType, handler] of Object.entries(handlerMap))
+    onWebhookEvent(eventType, handler);
+}
+export function constructEvent(payload, signature, secret, tolerance) {
+  if (tolerance != null && Number.isFinite(tolerance) && tolerance > 0)
+    return stripe.webhooks.constructEvent(payload, signature, secret, tolerance);
+  return stripe.webhooks.constructEvent(payload, signature, secret);
+}
+export async function constructEventAsync(payload, signature, secret, tolerance) {
+  if (tolerance != null && Number.isFinite(tolerance) && tolerance > 0)
+    return await stripe.webhooks.constructEventAsync(payload, signature, secret, tolerance);
+  return await stripe.webhooks.constructEventAsync(payload, signature, secret);
+}
+export async function handleWebhookEvent(event) {
+  const eventHandlers = handlers.get(event.type) || [];
+  if (eventHandlers.length === 0)
+    return { handled: !1, eventType: event.type };
+  const errors = [];
+  for (const handler of eventHandlers)
+    try {
+      await handler(event);
+    } catch (error) {
+      errors.push(error instanceof Error ? error.message : String(error));
+    }
+  return {
+    handled: !0,
+    eventType: event.type,
+    ...errors.length > 0 ? { errors } : {}
+  };
+}
+export async function processWebhook(payload, signature, config) {
+  try {
+    const event = await constructEventAsync(payload, signature, config.secret, config.tolerance), result = await handleWebhookEvent(event);
+    if (result.errors && result.errors.length > 0)
+      return {
+        success: !1,
+        eventType: result.eventType,
+        error: result.errors.join("; ")
+      };
+    return {
+      success: !0,
+      eventType: result.eventType
+    };
+  } catch (error) {
+    return {
+      success: !1,
+      error: error instanceof Error ? error.message : "Unknown error"
+    };
+  }
+}
+export function onPaymentIntent(handlers) {
+  if (handlers.succeeded)
+    onWebhookEvent("payment_intent.succeeded", handlers.succeeded);
+  if (handlers.failed)
+    onWebhookEvent("payment_intent.payment_failed", handlers.failed);
+  if (handlers.created)
+    onWebhookEvent("payment_intent.created", handlers.created);
+  if (handlers.canceled)
+    onWebhookEvent("payment_intent.canceled", handlers.canceled);
+}
+export function onSubscription(handlers) {
+  if (handlers.created)
+    onWebhookEvent("customer.subscription.created", handlers.created);
+  if (handlers.updated)
+    onWebhookEvent("customer.subscription.updated", handlers.updated);
+  if (handlers.deleted)
+    onWebhookEvent("customer.subscription.deleted", handlers.deleted);
+  if (handlers.trialWillEnd)
+    onWebhookEvent("customer.subscription.trial_will_end", handlers.trialWillEnd);
+}
+export function onInvoice(handlers) {
+  if (handlers.paid)
+    onWebhookEvent("invoice.paid", handlers.paid);
+  if (handlers.paymentFailed)
+    onWebhookEvent("invoice.payment_failed", handlers.paymentFailed);
+  if (handlers.created)
+    onWebhookEvent("invoice.created", handlers.created);
+  if (handlers.finalized)
+    onWebhookEvent("invoice.finalized", handlers.finalized);
+}
+export function onCheckout(handlers) {
+  if (handlers.completed)
+    onWebhookEvent("checkout.session.completed", handlers.completed);
+  if (handlers.expired)
+    onWebhookEvent("checkout.session.expired", handlers.expired);
+}
+export function onCharge(handlers) {
+  if (handlers.succeeded)
+    onWebhookEvent("charge.succeeded", handlers.succeeded);
+  if (handlers.failed)
+    onWebhookEvent("charge.failed", handlers.failed);
+  if (handlers.refunded)
+    onWebhookEvent("charge.refunded", handlers.refunded);
+  if (handlers.disputed)
+    onWebhookEvent("charge.dispute.created", handlers.disputed);
+}
+export function getPaymentIntent(event) {
+  if (event.type.startsWith("payment_intent."))
+    return event.data.object;
+  return null;
+}
+export function getSubscription(event) {
+  if (event.type.startsWith("customer.subscription."))
+    return event.data.object;
+  return null;
+}
+export function getInvoice(event) {
+  if (event.type.startsWith("invoice."))
+    return event.data.object;
+  return null;
+}
+export function getCheckoutSession(event) {
+  if (event.type.startsWith("checkout.session."))
+    return event.data.object;
+  return null;
+}
+export function getCharge(event) {
+  if (event.type.startsWith("charge."))
+    return event.data.object;
+  return null;
+}
+export function getCustomer(event) {
+  if (event.type.startsWith("customer.") && !event.type.includes("subscription"))
+    return event.data.object;
+  return null;
+}
+export const manageWebhook = {
+  onWebhookEvent,
+  registerWebhookHandlers,
+  constructEvent,
+  constructEventAsync,
+  handleWebhookEvent,
+  processWebhook,
+  onPaymentIntent,
+  onSubscription,
+  onInvoice,
+  onCheckout,
+  onCharge,
+  getPaymentIntent,
+  getSubscription,
+  getInvoice,
+  getCheckoutSession,
+  getCharge,
+  getCustomer
+};

package/dist/drivers/stripe.js

@@ -0,0 +1,25 @@
+import { createRequire } from "node:module";
+import { services } from "@stacksjs/config";
+const require = createRequire(import.meta.url);
+function StripeCtor() {
+  try {
+    return require("stripe");
+  } catch {
+    throw Error("Stripe payments are being used but the `stripe` package is not installed. " + "It is an opt-in dependency \u2014 run `bun add stripe` to enable server-side Stripe payments.");
+  }
+}
+let _stripe = null;
+export const stripe = new Proxy({}, {
+  get(_target, prop) {
+    if (!_stripe) {
+      const apiKey = services?.stripe?.secretKey;
+      if (!apiKey)
+        throw Error("Stripe secret key is not configured. Set STRIPE_SECRET_KEY in your .env file.");
+      const apiVersion = "2026-03-25.dahlia", configuredVersion = services?.stripe?.apiVersion;
+      if (configuredVersion && configuredVersion !== apiVersion)
+        throw Error(`Stripe API version ${configuredVersion} does not match the installed SDK version ${apiVersion}`);
+      _stripe = new (StripeCtor())(apiKey, { apiVersion });
+    }
+    return _stripe[prop];
+  }
+});

package/dist/idempotency.js

@@ -0,0 +1,13 @@
+import { createHash } from "node:crypto";
+const KEY_PREFIX = "stacks", KEY_VERSION = "v1", MAX_KEY_LENGTH = 255;
+export function stacksIdempotencyKey(scope, ...parts) {
+  const tail = parts.filter((p) => p !== null && p !== void 0 && p !== "").map((p) => String(p)).join(":"), raw = tail ? `${KEY_PREFIX}:${scope}:${tail}:${KEY_VERSION}` : `${KEY_PREFIX}:${scope}:${KEY_VERSION}`;
+  if (raw.length <= MAX_KEY_LENGTH)
+    return raw;
+  const hashed = createHash("sha256").update(tail).digest("hex").slice(0, 32);
+  return `${KEY_PREFIX}:${scope}:${hashed}:${KEY_VERSION}`;
+}
+export function freshIdempotencyKey(scope, ...parts) {
+  const random = createHash("sha256").update(`${Date.now()}:${Math.random()}`).digest("hex").slice(0, 16);
+  return stacksIdempotencyKey(scope, ...parts, random);
+}

package/dist/index.js

@@ -1,2 +1,5 @@
-// @bun
-import{createRequire as t}from"module";import{services as u}from"@stacksjs/config";var e=t(import.meta.url);function TT(){try{return e("stripe")}catch{throw Error("Stripe payments are being used but the `stripe` package is not installed. "+"It is an opt-in dependency \u2014 run `bun add stripe` to enable server-side Stripe payments.")}}var b=null,_=new Proxy({},{get(T,x){if(!b){let w=u?.stripe?.secretKey;if(!w)throw Error("Stripe secret key is not configured. Set STRIPE_SECRET_KEY in your .env file.");let $="2026-03-25.dahlia",z=u?.stripe?.apiVersion;if(z&&z!==$)throw Error(`Stripe API version ${z} does not match the installed SDK version ${$}`);b=new(TT())(w,{apiVersion:$})}return b[x]}});import{config as wT}from"@stacksjs/config";import{log as _T}from"@stacksjs/logging";import{createHash as d}from"crypto";var I="stacks",y="v1",xT=255;function D(T,...x){let w=x.filter((Q)=>Q!==null&&Q!==void 0&&Q!=="").map((Q)=>String(Q)).join(":"),$=w?`${I}:${T}:${w}:${y}`:`${I}:${T}:${y}`;if($.length<=xT)return $;let z=d("sha256").update(w).digest("hex").slice(0,32);return`${I}:${T}:${z}:${y}`}function W(T,...x){let w=d("sha256").update(`${Date.now()}:${Math.random()}`).digest("hex").slice(0,16);return D(T,...x,w)}function i(){let T=wT||{};return(T.payment?.currency||T.billing?.currency||process.env.STRIPE_CURRENCY||"usd").toLowerCase()}var C=(()=>{async function T(z,Q,X){let B={currency:i(),amount:Q};if(z.hasStripeId())B.customer=z.stripe_id??void 0;let H={...B,...X};return await _.paymentIntents.create(H,{idempotencyKey:W("payment_intent.create",z.id,Q)})}async function x(z){try{return await _.paymentIntents.retrieve(z)}catch(Q){return _T.error(Q),null}}async function w(z,Q={}){if(!z||typeof z!=="string")throw Error("[payments/refund] paymentIntentId is required");if(Q.amount!=null){if(typeof Q.amount!=="number"||!Number.isFinite(Q.amount)||Q.amount<=0)throw Error("[payments/refund] amount must be a positive finite number");try{let J=await _.paymentIntents.retrieve(z),L=J.amount_received??J.amount;if(L&&Q.amount>L)throw Error(`[payments/refund] amount ${Q.amount} exceeds captured amount ${L}`)}catch(J){if(J instanceof Error&&J.message.startsWith("[payments/refund]"))throw J}}let{idempotencyKey:X,...B}=Q,H={payment_intent:z,...B},N={idempotencyKey:X||`refund:${z}:${B.amount??"full"}`};return await _.refunds.create(H,N)}async function $(z,Q,X,B){let N={...{confirmation_method:"automatic",confirm:!0,payment_method:X,currency:i(),amount:Q},...B};return await T(z,Q,N)}return{createPayment:T,charge:$,findPayment:x,refund:w}})();import{config as FT}from"@stacksjs/config";function a(T,x){if(!T)return;let w;try{w=new URL(T)}catch{throw Error(`[payments/checkout] ${x} is not a valid URL: ${T}`)}let $=FT?.app?.url;if(!$)return;let z;try{z=new URL($.startsWith("http")?$:`https://${$}`).origin}catch{return}if(w.origin!==z)throw Error(`[payments/checkout] ${x} origin (${w.origin}) does not match app origin (${z})`)}var l=(()=>{async function T(x,w){let $=w.customer||x.stripe_id;if(!$)throw Error("User has no Stripe customer");a(w.success_url,"success_url"),a(w.cancel_url,"cancel_url");let Q={...{customer:$,mode:"payment",success_url:w.success_url,cancel_url:w.cancel_url},...w};return await _.checkout.sessions.create(Q,{idempotencyKey:W("checkout.session.create",x.id)})}return{create:T}})();var O=(()=>{function T(F){return F.stripe_id||""}function x(F){return{line1:F.address?.line1,city:F.address?.city,state:F.address?.state,postal_code:F.address?.postal_code,country:F.address?.country}}function w(){return[]}function $(F){return F}function z(F){return Boolean(F.stripe_id)}async function Q(F,Z={}){if(z(F))throw Error("Customer already created");if(!Z.name&&G(F))Z.name=G(F);if(!Z.email&&R(F))Z.email=R(F);let A=await _.customers.create(Z,{idempotencyKey:D("customer.create",F.id)});return await F.update({stripe_id:A.id}),A}async function X(F,Z={}){if(!F.stripe_id)throw Error("User does not have a Stripe customer ID. Create a customer first.");return await _.customers.update(F.stripe_id,Z,{idempotencyKey:D("customer.update",F.id,F.stripe_id)})}async function B(F){if(!z(F))throw Error("User does not have a Stripe ID");try{if(!F.stripe_id)throw Error("User has no Stripe ID");let Z=await _.customers.del(F.stripe_id);return await F.update({stripe_id:""}),Z}catch(Z){if(Z.statusCode===404)throw Error("Customer not found in Stripe");throw Z}}async function H(F,Z={}){if(!z(F))return await Q(F,Z);try{let A=await _.customers.retrieve(F.stripe_id);if(A.deleted)throw Error("Customer was deleted");return A}catch(A){if(A.statusCode===404)return await Q(F,Z);throw A}}async function N(F){if(!z(F))return;try{let Z=await _.customers.retrieve(F.stripe_id);if(Z.deleted)throw Error("Customer was deleted in Stripe");return Z}catch(Z){if(Z.statusCode===404)throw Error("Customer not found in Stripe");throw Z}}async function J(F,Z){if(!z(F))return await Q(F,Z);try{if((await _.customers.retrieve(F.stripe_id)).deleted)return await Q(F,Z);return await X(F,Z)}catch(A){if(A.statusCode===404)return await Q(F,Z);throw A}}async function L(F,Z){return await X(F,{name:G(F),email:R(F),address:x(Z),preferred_locales:w(),metadata:Z.metadata?$(Z.metadata):{}})}function G(F){return F.name||""}function R(F){return F.email||""}return{stripeId:T,hasStripeId:z,createStripeCustomer:Q,updateStripeCustomer:X,createOrGetStripeUser:H,createOrUpdateStripeUser:J,deleteStripeUser:B,retrieveStripeUser:N,syncStripeCustomerDetails:L}})();var p=(()=>{async function T(x){if(!x.hasStripeId())throw Error("Customer does not exist in Stripe");if(!x.stripe_id)throw Error("User has no Stripe ID");return await _.invoices.list({customer:x.stripe_id,expand:["data.payment_intent.payment_method"]})}return{list:T}})();import{db as V}from"@stacksjs/database";import{PaymentMethod as h}from"@stacksjs/orm";var k=(()=>{async function T(J,L){if(!J.hasStripeId())throw Error("Customer does not exist in Stripe");let G;if(typeof L==="string")G=await _.paymentMethods.retrieve(L);else G=L;if(G.customer!==J.stripe_id)G=await _.paymentMethods.attach(G.id,{customer:J.stripe_id});return await $(J,G),G}async function x(J,L){if(!J.hasStripeId())throw Error("Customer does not exist in Stripe");let G=await _.paymentMethods.retrieve(L),R=await V.selectFrom("payment_methods").where("provider_id","=",L).selectAll().executeTakeFirst();if(!J.stripe_id)throw Error("User has no Stripe ID");if(G.customer!==J.stripe_id)await _.paymentMethods.attach(G.id,{customer:J.stripe_id});let F=await _.customers.update(J.stripe_id,{invoice_settings:{default_payment_method:L}});if(await V.updateTable("payment_methods").set({is_default:!1}).where("user_id","=",J.id).executeTakeFirst(),R)await z(R);return F}async function w(J,L){if(!J.hasStripeId())throw Error("Customer does not exist in Stripe");let G=await V.selectFrom("payment_methods").where("id","=",L).selectAll().executeTakeFirst();if(!G?.provider_id)throw Error(`Payment method with id ${L} not found`);let R=await _.paymentMethods.retrieve(String(G.provider_id));if(R.customer!==J.stripe_id)await _.paymentMethods.attach(R.id,{customer:J.stripe_id});if(!J.stripe_id)throw Error("User has no Stripe ID");let F=await _.customers.update(J.stripe_id,{invoice_settings:{default_payment_method:String(G.provider_id)}});return await V.updateTable("payment_methods").set({is_default:!1}).where("user_id","=",J.id).executeTakeFirst(),await V.updateTable("payment_methods").set({is_default:!0}).where("id","=",L).executeTakeFirst(),F}async function $(J,L){if(!J.hasStripeId())throw Error("Customer does not exist in Stripe");if(!L.card?.brand||!L.card?.exp_year||!L.card?.exp_month)throw Error("Invalid payment method: missing required card details");let G={type:"card",last_four:String(L.card.last4),brand:L.card.brand,exp_year:L.card.exp_year,exp_month:L.card.exp_month,user_id:J.id,provider_id:L.id};if(L.customer!==J.stripe_id)await _.paymentMethods.attach(L.id,{customer:J.stripe_id});return await h.create(G)}async function z(J){return await J.update({is_default:!0})}async function Q(J,L){if(!J.hasStripeId())throw Error("Customer does not exist in Stripe");let G=typeof L==="string"?await V.selectFrom("payment_methods").where("provider_id","=",L).selectAll().executeTakeFirst():await h.find(L);if(!G?.provider_id)throw Error(`Payment method with id ${L} not found`);if((await _.paymentMethods.retrieve(String(G.provider_id))).customer!==J.stripe_id)throw Error("Payment method does not belong to this customer");return await G.delete(),await _.paymentMethods.detach(String(G.provider_id))}async function X(J,L,G){if(!J.hasStripeId())throw Error("Customer does not exist in Stripe");if((await _.paymentMethods.retrieve(L)).customer!==J.stripe_id)throw Error("Payment method does not belong to this customer");return await _.paymentMethods.update(L,G)}async function B(J){if(!J.hasStripeId())throw Error("Customer does not exist in Stripe");return await V.selectFrom("payment_methods").selectAll().where("user_id","=",J.id).execute()}async function H(J,L){if(!J.hasStripeId())throw Error("Customer does not exist in Stripe");return await V.selectFrom("payment_methods").where("id","=",L).selectAll().executeTakeFirst()}async function N(J){if(!J.hasStripeId())throw Error("Customer does not exist in Stripe");return await h.where("user_id",J.id).where("is_default",!0).first()}return{addPaymentMethod:T,deletePaymentMethod:Q,retrieveDefaultPaymentMethod:N,updatePaymentMethod:X,listPaymentMethods:B,setDefaultPaymentMethod:w,storePaymentMethod:$,retrievePaymentMethod:H,setUserDefaultPayment:x}})();var E=(()=>{async function T(w){let $=await _.prices.list({lookup_keys:[w]});if(!$.data.length)return;return $.data[0]}async function x(w,$){let z=await T(w);if(z)return z;return await _.prices.create({...$,lookup_key:w})}return{retrieveByLookupKey:T,createOrGet:x}})();var c=(()=>{async function T(B){return await _.products.create(B)}async function x(B){return await _.products.retrieve(B)}async function w(B,H){return await _.products.update(B,H)}async function $(B={}){return await _.products.list({active:!0,...B})}async function z(B){return await _.products.update(B,{active:!1})}async function Q(B,H){let N=await _.products.create(B),J=await _.prices.create({...H,product:N.id});return{product:N,price:J}}async function X(B,H={query:""}){return await _.products.search({...H,query:B})}return{create:T,retrieve:x,update:w,list:$,archive:z,createWithPrice:Q,search:X}})(),$T=(()=>{async function T(B){return await _.prices.create(B)}async function x(B){return await _.prices.retrieve(B)}async function w(B,H){return await _.prices.update(B,H)}async function $(B={}){return await _.prices.list({active:!0,...B})}async function z(B,H={}){return await _.prices.list({product:B,active:!0,...H})}async function Q(B,H={query:""}){return await _.prices.search({...H,query:B})}async function X(B){return await _.prices.update(B,{active:!1})}return{create:T,retrieve:x,update:w,list:$,listByProduct:z,search:Q,archive:X}})(),M=(()=>{async function T(B){return await _.coupons.create(B)}async function x(B){return await _.coupons.retrieve(B)}async function w(B,H){return await _.coupons.update(B,H)}async function $(B){return await _.coupons.del(B)}async function z(B={}){return await _.coupons.list(B)}async function Q(B){return await _.promotionCodes.create(B)}async function X(B){try{let H=await _.promotionCodes.list({code:B,active:!0});if(H.data.length>0)return H.data[0]??null;return null}catch{return null}}return{create:T,retrieve:x,update:w,delete:$,list:z,createPromotionCode:Q,retrievePromotionCode:X}})();import{db as f}from"@stacksjs/database";import{HttpError as zT}from"@stacksjs/error-handling";import{isUniqueViolation as BT}from"@stacksjs/orm";var P=(()=>{async function T(G,R,F,Z){let A=await E.retrieveByLookupKey(F);if(!A)throw Error("Price does not exist in Stripe");let U=[{price:A.id,quantity:1}],j={...{customer:await O.createOrGetStripeUser(G,{}).then((g)=>{if(!g||!g.id)throw Error("Customer does not exist in Stripe");return g.id}),payment_behavior:"allow_incomplete",expand:["latest_invoice.payment_intent"],items:U},...Z},K=await _.subscriptions.create(j,{idempotencyKey:D("subscription.create",G.id,R,F)});return await N(G,R,F,K),K}async function x(G,R,F,Z={}){let A=await E.retrieveByLookupKey(F),U=await G?.activeSubscription();if(!A)throw Error("New price does not exist in Stripe");if(!U)throw Error("No active subscription for user!");let q=U.subscription?.provider_id;if(!q)throw Error("Active subscription has no provider ID");let S=await _.subscriptions.retrieve(q);if(!S)throw Error("Subscription does not exist in Stripe");let j=S.items.data[0]?.id;if(!j)throw Error("No subscription items found in the subscription");await _.subscriptions.update(q,{items:[{id:j,price:A.id,quantity:1}],proration_behavior:"create_prorations"},{idempotencyKey:D("subscription.update",q,A.id)});let K=await _.subscriptions.retrieve(q);if(!U.subscription?.id)throw Error("Active subscription has no database ID");return await J(U.subscription.id,R,K),K}async function w(G,R){if(!await _.subscriptions.retrieve(G))throw Error("Subscription does not exist or does not belong to the user");let Z=await _.subscriptions.cancel(G,R,{idempotencyKey:D("subscription.cancel",G)});return await z(G),Z}async function $(G,R){if(!G.hasStripeId())throw Error("Customer does not exist in Stripe");return await _.subscriptions.retrieve(R)}async function z(G){await f.updateTable("subscriptions").set({provider_status:"canceled"}).where("provider_id","=",G).executeTakeFirst()}function Q(G){return G.provider_status==="active"}function X(G){return G.provider_status==="trialing"}async function B(G,R){let F=await f.selectFrom("subscriptions").where("user_id","=",G.id).where("type","=",R).selectAll().executeTakeFirst();if(!F)return!1;return F.provider_status==="incomplete"}async function H(G,R){let F=await f.selectFrom("subscriptions").where("user_id","=",G.id).where("type","=",R).selectAll().executeTakeFirst();if(!F)return!1;let Z=await Q(F),A=await X(F);return Z||A}async function N(G,R,F,Z){let A=Z.items.data[0];if(!A)throw Error("Stripe subscription contains no line items \u2014 cannot store subscription");let U=L({user_id:G.id,type:R,unit_price:Number(A.price.unit_amount),provider_id:Z.id,provider_status:Z.status,provider_price_id:A.price.id,quantity:A.quantity,trial_ends_at:Z.trial_end!=null?String(Z.trial_end):void 0,ends_at:Z.current_period_end!=null?String(Z.current_period_end):void 0,provider_type:"stripe",last_used_at:Z.current_period_end!=null?String(Z.current_period_end):void 0}),q;try{q=await f.insertInto("subscriptions").values(U).executeTakeFirst()}catch(j){if(BT(j))throw new zT(409,"A subscription with this provider ID already exists");throw j}if(!q)throw Error("Failed to insert subscription record");return await f.selectFrom("subscriptions").where("id","=",Number(q.insertId)).selectAll().executeTakeFirst()}async function J(G,R,F){let Z=await f.selectFrom("subscriptions").where("id","=",G).selectAll().executeTakeFirst(),A=F.items.data[0];if(!A)throw Error("Stripe subscription contains no line items \u2014 cannot update subscription");return await f?.updateTable("subscriptions").set({type:R,provider_price_id:A.price.id,unit_price:Number(A.price.unit_amount)}).where("id","=",G).executeTakeFirst(),Z}function L(G){return Object.fromEntries(Object.entries(G).filter(([R,F])=>F!=null))}return{create:T,update:x,isValid:H,isIncomplete:B,cancel:w,retrieve:$}})();var n=(()=>{async function T(x,w){let Q={...{customer:await O.createOrGetStripeUser(x,{}).then((X)=>{if(!X||!X.id)throw Error("Customer does not exist in Stripe");return X.id}),payment_method_types:["card"]},...w};return await _.setupIntents.create(Q,{idempotencyKey:W("setup_intent.create",x.id)})}return{create:T}})();var m=new Map;function Y(T,x){let w=m.get(T)||[];w.push(x),m.set(T,w)}function GT(T){for(let[x,w]of Object.entries(T))Y(x,w)}function JT(T,x,w,$){if($!=null&&Number.isFinite($)&&$>0)return _.webhooks.constructEvent(T,x,w,$);return _.webhooks.constructEvent(T,x,w)}async function o(T,x,w,$){if($!=null&&Number.isFinite($)&&$>0)return await _.webhooks.constructEventAsync(T,x,w,$);return await _.webhooks.constructEventAsync(T,x,w)}async function r(T){let x=m.get(T.type)||[];if(x.length===0)return{handled:!1,eventType:T.type};let w=[];for(let $ of x)try{await $(T)}catch(z){w.push(z instanceof Error?z.message:String(z))}return{handled:!0,eventType:T.type,...w.length>0?{errors:w}:{}}}async function QT(T,x,w){try{let $=await o(T,x,w.secret,w.tolerance),z=await r($);if(z.errors&&z.errors.length>0)return{success:!1,eventType:z.eventType,error:z.errors.join("; ")};return{success:!0,eventType:z.eventType}}catch($){return{success:!1,error:$ instanceof Error?$.message:"Unknown error"}}}function ZT(T){if(T.succeeded)Y("payment_intent.succeeded",T.succeeded);if(T.failed)Y("payment_intent.payment_failed",T.failed);if(T.created)Y("payment_intent.created",T.created);if(T.canceled)Y("payment_intent.canceled",T.canceled)}function LT(T){if(T.created)Y("customer.subscription.created",T.created);if(T.updated)Y("customer.subscription.updated",T.updated);if(T.deleted)Y("customer.subscription.deleted",T.deleted);if(T.trialWillEnd)Y("customer.subscription.trial_will_end",T.trialWillEnd)}function AT(T){if(T.paid)Y("invoice.paid",T.paid);if(T.paymentFailed)Y("invoice.payment_failed",T.paymentFailed);if(T.created)Y("invoice.created",T.created);if(T.finalized)Y("invoice.finalized",T.finalized)}function RT(T){if(T.completed)Y("checkout.session.completed",T.completed);if(T.expired)Y("checkout.session.expired",T.expired)}function HT(T){if(T.succeeded)Y("charge.succeeded",T.succeeded);if(T.failed)Y("charge.failed",T.failed);if(T.refunded)Y("charge.refunded",T.refunded);if(T.disputed)Y("charge.dispute.created",T.disputed)}function XT(T){if(T.type.startsWith("payment_intent."))return T.data.object;return null}function YT(T){if(T.type.startsWith("customer.subscription."))return T.data.object;return null}function NT(T){if(T.type.startsWith("invoice."))return T.data.object;return null}function qT(T){if(T.type.startsWith("checkout.session."))return T.data.object;return null}function UT(T){if(T.type.startsWith("charge."))return T.data.object;return null}function DT(T){if(T.type.startsWith("customer.")&&!T.type.includes("subscription"))return T.data.object;return null}var Jx={onWebhookEvent:Y,registerWebhookHandlers:GT,constructEvent:JT,constructEventAsync:o,handleWebhookEvent:r,processWebhook:QT,onPaymentIntent:ZT,onSubscription:LT,onInvoice:AT,onCheckout:RT,onCharge:HT,getPaymentIntent:XT,getSubscription:YT,getInvoice:NT,getCheckoutSession:qT,getCharge:UT,getCustomer:DT};async function Dx(T,x,w,$={}){return C.charge(T,x,w,$)}async function Ox(T,x,w={}){return C.createPayment(T,x,w)}async function Vx(T,x,w={}){return C.refund(T,{amount:x,...w})}async function jx(T,x,w={}){return l.create(T,{line_items:x,mode:"payment",...w})}async function fx(T,x,w={}){return l.create(T,{line_items:[{price:x,quantity:1}],mode:"subscription",...w})}async function Wx(T,x,w={}){return P.create(T,"default",x,w)}async function Kx(T,x=!1){return P.cancel(T,{prorate:!x,invoice_now:x})}async function Ex(T,x="default"){return P.isValid(T,x)}async function Px(T,x,w="default"){return P.update(T,w,x,{})}async function Sx(T,x={}){return O.createOrGetStripeUser(T,x)}async function Cx(T,x){return O.updateStripeCustomer(T,x)}async function kx(T){return O.deleteStripeUser(T)}async function Mx(T,x){return k.addPaymentMethod(T,x)}async function vx(T,x){return k.setUserDefaultPayment(T,x)}async function gx(T,x){return k.deletePaymentMethod(T,x)}async function bx(T,x={}){return n.create(T,x)}async function Ix(T){return p.list(T)}async function yx(T,x={}){return _.invoices.create({customer:T,...x})}async function lx(T){return _.invoices.pay(T)}async function hx(T,x,w={}){let{currency:$="usd",interval:z,description:Q,metadata:X}=w,B={unit_amount:x,currency:$};if(z)B.recurring={interval:z};return c.createWithPrice({name:T,description:Q,metadata:X},B)}async function cx(T){return E.retrieveByLookupKey(T)}async function mx(T={}){return c.list(T)}async function ux(T){let x={duration:T.duration||"once"};if(T.percentOff)x.percent_off=T.percentOff;else if(T.amountOff)x.amount_off=T.amountOff,x.currency=T.currency||"usd";if(T.name)x.name=T.name;if(T.durationInMonths)x.duration_in_months=T.durationInMonths;if(T.maxRedemptions)x.max_redemptions=T.maxRedemptions;return M.create(x)}async function dx(T,x,w={}){return M.createPromotionCode({promotion:{type:"coupon",coupon:T},code:x,...w})}async function ix(T){return M.retrievePromotionCode(T)}function ax(T,x){let w=globalThis.config||{},$=(x||w.payment?.currency||w.billing?.currency||process.env.STRIPE_CURRENCY||"usd").toLowerCase(),z=w.app?.locale||"en-US";return new Intl.NumberFormat(z,{style:"currency",currency:$.toUpperCase()}).format(T/100)}function px(T){return Math.round(T*100)}function nx(T){return T/100}import{saas as OT}from"@stacksjs/config";import{err as VT,ok as jT}from"@stacksjs/error-handling";import{log as fT}from"@stacksjs/logging";import{stripe as s}from"@stacksjs/payments";async function Tw(){let T=OT.plans;try{if(T!==void 0&&T.length)for(let x of T){let w=await s.products.create({name:x.productName,description:x.description,metadata:x.metadata});for(let $ of x.pricing)if(w){let z={unit_amount:$.price,currency:$.currency,product:w.id,lookup_key:$.key};if($.interval)z.recurring={interval:$.interval};await s.prices.create(z)}}return jT("Migrations generated")}catch(x){let w=x instanceof Error?x:Error(String(x));return fT.error(w),VT(w)}}import{db as v}from"@stacksjs/database";var _w=(()=>{async function T(w,$,z){let Q=await v.selectFrom("payment_products").where("id","=",$).selectAll().executeTakeFirst();if(!Q)throw Error(`Payment product with id ${$} not found.`);let X={name:Q.name,description:z.description??"",amount:Q.unit_price,brand:z.brand,type:z.type??"one-time",provider_id:z.provider_id,user_id:w.id},B=await v.insertInto("payment_transactions").values(X).executeTakeFirst();if(!B)throw Error("Failed to insert payment transaction");return await v.selectFrom("payment_transactions").where("id","=",Number(B.insertId)).selectAll().executeTakeFirst()}async function x(w){return await v.selectFrom("payment_transactions").where("user_id","=",w.id).selectAll().execute()}return{store:T,list:x}})();export{ix as validatePromoCode,Cx as updateCustomer,nx as toDollars,px as toCents,fx as subscriptionCheckout,Wx as subscribe,_ as stripe,Aw as stacksIdempotencyKey,vx as setDefaultPaymentMethod,gx as removePaymentMethod,GT as registerWebhookHandlers,Vx as refund,QT as processWebhook,lx as payInvoice,Y as onWebhookEvent,LT as onSubscription,ZT as onPaymentIntent,AT as onInvoice,RT as onCheckout,HT as onCharge,Jx as manageWebhook,_w as manageTransaction,P as manageSubscription,n as manageSetupIntent,c as manageProduct,$T as managePriceExtended,E as managePrice,k as managePaymentMethod,p as manageInvoice,O as manageCustomer,M as manageCoupon,l as manageCheckout,C as manageCharge,mx as listProducts,Ex as hasActiveSubscription,r as handleWebhookEvent,YT as getSubscription,cx as getPrice,XT as getPaymentIntent,Sx as getOrCreateCustomer,Ix as getInvoices,NT as getInvoice,DT as getCustomer,qT as getCheckoutSession,UT as getCharge,Lw as freshIdempotencyKey,ax as formatAmount,kx as deleteCustomer,Tw as createStripeProduct,bx as createSetupIntent,dx as createPromoCode,hx as createProduct,Ox as createPayment,yx as createInvoice,ux as createCoupon,o as constructEventAsync,JT as constructEvent,jx as checkout,Dx as charge,Px as changeSubscription,Kx as cancelSubscription,Mx as addPaymentMethod,Gw as Payment};
+export * from "./payment";
+export { default as Payment } from "./payment";
+export * from "./billable";
+export * from "./drivers/stripe";
+export { freshIdempotencyKey, stacksIdempotencyKey } from "./idempotency";

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.87",
+  "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.87",
+    "@stacksjs/config": "0.70.90",
     "better-dx": "^0.2.16",
-    "@stacksjs/utils": "0.70.87",
+    "@stacksjs/utils": "0.70.90",
     "@stripe/stripe-js": "^8.7.0",
     "stripe": "^21.0.1"
   }