chore: wip

Author: glennmichael123

app/Actions/Payment/CreateCheckoutAction.ts

@@ -1,19 +1,23 @@
-import type { RequestInstance } from '@stacksjs/types'
 import { Action } from '@stacksjs/actions'
 import User from '../../../storage/framework/orm/src/models/User.ts'
 
 export default new Action({
   name: 'CreateCheckoutAction',
   description: 'Create Checkout link for stripe',
   method: 'POST',
-  async handle(request: RequestInstance) {
+  async handle() {
     const user = await User.find(1)
 
-    const checkout = await user?.checkout({
-      price_1QBEfsBv6MhUdo23avVV0kqx: 1,
-    }, {
-      automatic_tax: { enabled: true },
-      allow_promotion_codes: true,
+    const checkout = await user?.checkout([
+      {
+        priceId: 'price_1QBEfsBv6MhUdo23avVV0kqx',
+        quantity: 1,
+      },
+    ], {
+      enableTax: true,
+      allowPromotions: true,
+      cancel_url: 'https://google.com',
+      success_url: 'https://google.com',
     })
 
     return checkout

app/Actions/Payment/CreateSubscriptionAction.ts

@@ -1,28 +1,17 @@
 import { Action } from '@stacksjs/actions'
-import { stripe } from '@stacksjs/payments'
+import User from '../../../storage/framework/orm/src/models/User.ts'
 
 export default new Action({
   name: 'CreateSubscriptionAction',
   description: 'Create Subscription for stripe',
   method: 'POST',
   async handle() {
-    const subscription = await stripe.subscription.create({
-      customer: 'cus_R5DJaEyyeKKlAN',
-      items: [
-        {
-          price: 'price_1QCjMXBv6MhUdo23Pvb5dwUd',
-        },
-      ],
-      payment_behavior: 'default_incomplete',
-      trial_period_days: 7,
-      expand: ['latest_invoice.payment_intent'],
-    })
+    const user = await User.find(1)
 
-    // Step 3: Get the PaymentIntent for the first invoice from the subscription
-    const latestInvoice = subscription.latest_invoice
-    const paymentIntent = typeof latestInvoice === 'object' ? latestInvoice?.payment_intent : undefined
+    const subscription = await user?.newSubscription('price_1QCjMXBv6MhUdo23Pvb5dwUd', {
+      allowPromotions: true, // Example option for allowing promotions
+    })
 
-    // Step 4: Pass the client_secret to the front end for Stripe Elements
-    return paymentIntent
+    return subscription
   },
 })

app/Actions/Payment/UpdateCustomerAction.ts

@@ -15,7 +15,7 @@ export default new Action({
       state: 'TX',
       postal_code: '78701',
       country: 'US',
-    }})
+    } })
 
     return customer
   },

storage/framework/core/orm/src/utils.ts

@@ -1104,25 +1104,87 @@ export async function generateModelString(
       return customer
     }
 
+    async newSubscription(
+      priceId: string,
+      options: SubscriptionOptions = {},
+    ): Promise<{ subscription: Stripe.Subscription, paymentIntent?: Stripe.PaymentIntent }> {
+      // Map price IDs to Stripe subscription items
+      const subscriptionItems = [{
+        price: priceId,
+        quantity: 1,
+      }]
+
+      // Ensure the customer is retrieved correctly
+      const customer = await this.createOrGetStripeUser({}).then((customer) => {
+        if (!customer || !customer.id) {
+          throw new Error('Customer does not exist in Stripe')
+        }
+        return customer.id // Ensure customer.id is always a string
+      })
+
+      // Configure optional subscription parameters based on options
+      const newOptions: Partial<Stripe.SubscriptionCreateParams> = {
+        items: subscriptionItems,
+        automatic_tax: options.enableTax ? { enabled: true } : undefined,
+        payment_behavior: options.allowPromotions ? 'default_incomplete' : undefined,
+        trial_period_days: options.trialDays,
+      }
+
+      // Define core subscription parameters, including customer association and expansion options
+      const defaultOptions: Stripe.SubscriptionCreateParams = {
+        customer, // This is guaranteed to be a string
+        payment_behavior: 'default_incomplete',
+        expand: ['latest_invoice.payment_intent'],
+        // Apply trial_days only if specified
+        trial_period_days: options.trialDays || undefined,
+        items: subscriptionItems, // Add the subscription items here
+      }
+
+      // Merge new options with default options, giving priority to provided options
+      const mergedOptions: Stripe.SubscriptionCreateParams = {
+        ...defaultOptions,
+        ...newOptions,
+      }
+
+      // Create the subscription
+      const subscription = await manageSubscription.create(this, mergedOptions)
 
-    async checkout(
-      priceIds: Record<string, number | undefined>,
-      options: Partial<Stripe.Checkout.SessionCreateParams> = {}
+      // Retrieve the latest invoice and payment intent for further use
+      const latestInvoice = subscription.latest_invoice as Stripe.Invoice | null
+      const paymentIntent = latestInvoice?.payment_intent as Stripe.PaymentIntent | undefined
+
+      return { subscription, paymentIntent }
+    }
+
+     async checkout(
+      priceIds: CheckoutLineItem[],
+      options: CheckoutOptions = {},
     ): Promise<Stripe.Response<Stripe.Checkout.Session>> {
-    const defaultOptions: Partial<Stripe.Checkout.SessionCreateParams> = {
-      mode: 'payment',
-      customer: await this.createOrGetStripeUser({}).then(customer => customer.id),
-      line_items: Object.entries(priceIds).map(([priceId, quantity]) => ({
-        price: priceId,
-        quantity: quantity || 1
-      })),
-      success_url: 'http://localhost:3008/checkout/success?session_id={CHECKOUT_SESSION_ID}',
-      cancel_url: 'http://localhost:3008/checkout/cancel',
-    };
+      const newOptions: Partial<Stripe.Checkout.SessionCreateParams> = {}
+
+      if (options.enableTax) {
+        newOptions.automatic_tax = { enabled: true }
+        delete options.enableTax
+      }
+
+      if (options.allowPromotions) {
+        newOptions.allow_promotion_codes = true
+        delete options.allowPromotions
+      }
+
+      const defaultOptions: Partial<Stripe.Checkout.SessionCreateParams> = {
+        mode: 'payment',
+        customer: await this.createOrGetStripeUser({}).then(customer => customer.id),
+        line_items: priceIds.map((item: CheckoutLineItem) => ({
+          price: item.priceId,
+          quantity: item.quantity || 1,
+        })),
+
+      }
 
-      const mergedOptions = { ...defaultOptions, ...options };
+      const mergedOptions = { ...defaultOptions, ...newOptions, ...options }
 
-      return await manageCheckout.create(this, mergedOptions);
+      return await manageCheckout.create(this, mergedOptions)
     }
     `
 
@@ -1250,9 +1312,9 @@ export async function generateModelString(
   const fillable = JSON.stringify(getFillableAttributes(model.attributes))
 
   return `import type { Generated, Insertable, Selectable, Updateable } from 'kysely'
-    import { manageCustomer, manageCheckout, managePaymentMethod, manageCharge, type Stripe } from '@stacksjs/payments'
+    import { manageCharge, manageCheckout, manageCustomer, managePaymentMethod, manageSubscription, type Stripe } from '@stacksjs/payments'
     import { db, sql } from '@stacksjs/database'
-    import { StripeCustomerOptions } from '@stacksjs/types'
+    import type { CheckoutLineItem, CheckoutOptions, StripeCustomerOptions, SubscriptionOptions } from '@stacksjs/types'
     import { HttpError } from '@stacksjs/error-handling'
     import { dispatch } from '@stacksjs/events'
     import { generateTwoFactorSecret } from '@stacksjs/auth'

storage/framework/core/payments/src/billable/subscription.ts

@@ -0,0 +1,31 @@
+import type Stripe from 'stripe'
+import type { UserModel } from '../../../../orm/src/models/User'
+import { stripe } from '..'
+
+export interface SubscriptionManager {
+  create: (user: UserModel, params: Stripe.SubscriptionCreateParams) => Promise<Stripe.Response<Stripe.Subscription>>
+}
+
+export const manageSubscription: SubscriptionManager = (() => {
+  async function create(user: UserModel, params: Stripe.SubscriptionCreateParams): Promise<Stripe.Response<Stripe.Subscription>> {
+    // Check if the user has a Stripe customer ID
+    if (!user.hasStripeId()) {
+      throw new Error('Customer does not exist in Stripe')
+    }
+
+    // Define default parameters
+    const defaultParams: Partial<Stripe.SubscriptionCreateParams> = {
+      customer: user.stripeId(),
+      payment_behavior: 'default_incomplete',
+      expand: ['latest_invoice.payment_intent'],
+    }
+
+    // Merge provided params with defaultParams
+    const mergedParams = { ...defaultParams, ...params }
+
+    // Create and return the subscription
+    return await stripe.subscription.create(mergedParams)
+  }
+
+  return { create }
+})()

storage/framework/core/payments/src/index.ts

@@ -2,5 +2,6 @@ export * from './billable/charge'
 export * from './billable/checkout'
 export * from './billable/customer'
 export * from './billable/payment-method'
+export * from './billable/subscription'
 export * as stripe from './drivers/stripe'
 export * from 'stripe'

storage/framework/core/types/src/payments.ts

@@ -80,3 +80,19 @@ export interface EventOptions {
     type?: string
   }
 }
+
+export interface CheckoutLineItem {
+  priceId: string
+  quantity: number
+}
+
+export interface CheckoutOptions extends Partial<Stripe.Checkout.SessionCreateParams> {
+  enableTax?: boolean
+  allowPromotions?: boolean
+}
+
+export interface SubscriptionOptions extends Partial<Stripe.SubscriptionCreateParams> {
+  enableTax?: boolean
+  allowPromotions?: boolean
+  trialDays?: number
+}

storage/framework/orm/src/models/User.ts

@@ -1,10 +1,10 @@
-import type { StripeCustomerOptions } from '@stacksjs/types'
+import type { CheckoutLineItem, CheckoutOptions, StripeCustomerOptions, SubscriptionOptions } from '@stacksjs/types'
 import type { Generated, Insertable, Selectable, Updateable } from 'kysely'
 import { cache } from '@stacksjs/cache'
 import { db, sql } from '@stacksjs/database'
 import { HttpError } from '@stacksjs/error-handling'
 import { dispatch } from '@stacksjs/events'
-import { manageCharge, manageCheckout, manageCustomer, managePaymentMethod, type Stripe } from '@stacksjs/payments'
+import { manageCharge, manageCheckout, manageCustomer, managePaymentMethod, manageSubscription, type Stripe } from '@stacksjs/payments'
 
 import Post from './Post'
 
@@ -53,7 +53,7 @@ export type Users = UserType[]
 export type UserColumn = Users
 export type UserColumns = Array<keyof Users>
 
-type SortDirection = 'asc' | 'desc'
+    type SortDirection = 'asc' | 'desc'
 interface SortOptions { column: UserType, order: SortDirection }
 // Define a type for the options parameter
 interface QueryOptions {
@@ -736,22 +736,85 @@ export class UserModel {
     return customer
   }
 
+  async newSubscription(
+    priceId: string,
+      options: SubscriptionOptions = {},
+  ): Promise<{ subscription: Stripe.Subscription, paymentIntent?: Stripe.PaymentIntent }> {
+    // Map price IDs to Stripe subscription items
+    const subscriptionItems = [{
+      price: priceId,
+      quantity: 1,
+    }]
+
+    // Ensure the customer is retrieved correctly
+    const customer = await this.createOrGetStripeUser({}).then((customer) => {
+      if (!customer || !customer.id) {
+        throw new Error('Customer does not exist in Stripe')
+      }
+      return customer.id // Ensure customer.id is always a string
+    })
+
+    // Configure optional subscription parameters based on options
+    const newOptions: Partial<Stripe.SubscriptionCreateParams> = {
+      items: subscriptionItems,
+      automatic_tax: options.enableTax ? { enabled: true } : undefined,
+      payment_behavior: options.allowPromotions ? 'default_incomplete' : undefined,
+      trial_period_days: options.trialDays,
+    }
+
+    // Define core subscription parameters, including customer association and expansion options
+    const defaultOptions: Stripe.SubscriptionCreateParams = {
+      customer, // This is guaranteed to be a string
+      payment_behavior: 'default_incomplete',
+      expand: ['latest_invoice.payment_intent'],
+      // Apply trial_days only if specified
+      trial_period_days: options.trialDays || undefined,
+      items: subscriptionItems, // Add the subscription items here
+    }
+
+    // Merge new options with default options, giving priority to provided options
+    const mergedOptions: Stripe.SubscriptionCreateParams = {
+      ...defaultOptions,
+      ...newOptions,
+    }
+
+    // Create the subscription
+    const subscription = await manageSubscription.create(this, mergedOptions)
+
+    // Retrieve the latest invoice and payment intent for further use
+    const latestInvoice = subscription.latest_invoice as Stripe.Invoice | null
+    const paymentIntent = latestInvoice?.payment_intent as Stripe.PaymentIntent | undefined
+
+    return { subscription, paymentIntent }
+  }
+
   async checkout(
-    priceIds: Record<string, number | undefined>,
-    options: Partial<Stripe.Checkout.SessionCreateParams> = {},
+    priceIds: CheckoutLineItem[],
+      options: CheckoutOptions = {},
   ): Promise<Stripe.Response<Stripe.Checkout.Session>> {
+    const newOptions: Partial<Stripe.Checkout.SessionCreateParams> = {}
+
+    if (options.enableTax) {
+      newOptions.automatic_tax = { enabled: true }
+      delete options.enableTax
+    }
+
+    if (options.allowPromotions) {
+      newOptions.allow_promotion_codes = true
+      delete options.allowPromotions
+    }
+
     const defaultOptions: Partial<Stripe.Checkout.SessionCreateParams> = {
       mode: 'payment',
       customer: await this.createOrGetStripeUser({}).then(customer => customer.id),
-      line_items: Object.entries(priceIds).map(([priceId, quantity]) => ({
-        price: priceId,
-        quantity: quantity || 1,
+      line_items: priceIds.map((item: CheckoutLineItem) => ({
+        price: item.priceId,
+        quantity: item.quantity || 1,
       })),
-      success_url: 'http://localhost:3008/checkout/success?session_id={CHECKOUT_SESSION_ID}',
-      cancel_url: 'http://localhost:3008/checkout/cancel',
+
     }
 
-    const mergedOptions = { ...defaultOptions, ...options }
+    const mergedOptions = { ...defaultOptions, ...newOptions, ...options }
 
     return await manageCheckout.create(this, mergedOptions)
   }