chore: wip

Author: glennmichael123

config/saas.ts

@@ -0,0 +1,57 @@
+/**
+ * **Payment Configuration**
+ *
+ * This configuration defines all of your Payment options. Because Stacks is fully-typed,
+ * you may hover any of the options below and the definitions will be provided. In case
+ * you have any questions, feel free to reach out via Discord or GitHub Discussions.
+ */
+export default {
+  plans: [
+    {
+      productName: 'Stacks Pro',
+      description: 'Access to all premium features of Stacks.',
+      pricing: [
+        {
+          key: 'stacks_pro_monthly',
+          price: 2000,
+          interval: 'monthly',
+          currency: 'usd',
+        },
+        {
+          key: 'stacks_pro_yearly',
+          price: 20000,
+          interval: 'yearly',
+          currency: 'usd',
+        },
+      ],
+      metadata: {
+        createdBy: 'admin',
+        version: '1.0.0',
+      },
+    },
+    // Add other plans as needed
+  ],
+
+  webhook: {
+    endpoint: '/webhooks/stripe',
+    secret: '',
+  },
+
+  currencies: ['usd'],
+
+  coupons: [
+    {
+      code: 'SUMMER2024',
+      amountOff: 500,
+      duration: 'once',
+    },
+  ],
+
+  products: [
+    {
+      name: 'Stacks Pro',
+      description: 'Access to all premium features of Stacks.',
+      images: ['url_to_image'],
+    },
+  ],
+} satisfies any

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

@@ -1151,58 +1151,32 @@ export async function generateModelString(
       return await manageSubscription.isValid(this, type)
     }
 
+    async isIncomplete(type: string): Promise<boolean> {
+      return await manageSubscription.isIncomplete(this, type)
+    }
+
     async newSubscriptionInvoice(
       type: string,
       priceId: string,
-    options: Partial<Stripe.SubscriptionCreateParams> = {},
+      options: Partial<Stripe.SubscriptionCreateParams> = {},
     ): Promise<{ subscription: Stripe.Subscription, paymentIntent?: Stripe.PaymentIntent }> {
       return await this.newSubscription(type, priceId, { ...options, days_until_due: 15, collection_method: 'send_invoice' })
     }
 
-  async newSubscription(
-    type: string,
-    priceId: string,
-    options: Partial<Stripe.SubscriptionCreateParams> = {},
-  ): Promise<{ subscription: Stripe.Subscription, paymentIntent?: Stripe.PaymentIntent }> {
-    const price = await managePrice.retrieveByLookupKey(priceId)
-
-    if (!price)
-      throw new Error('Price does not exist in stripe')
-
-    const subscriptionItems = [{
-      price: price.id,
-      quantity: 1,
-    }]
-
-    const customer = await this.createOrGetStripeUser({}).then((customer) => {
-      if (!customer || !customer.id) {
-        throw new Error('Customer does not exist in Stripe')
-      }
-      return customer.id
-    })
+    async newSubscription(
+      type: string,
+      priceId: string,
+      options: Partial<Stripe.SubscriptionCreateParams> = {},
+    ): Promise<{ subscription: Stripe.Subscription, paymentIntent?: Stripe.PaymentIntent }> {
+      const subscription = await manageSubscription.create(this, type, priceId, options)
 
-    const defaultOptions: Stripe.SubscriptionCreateParams = {
-      customer,
-      payment_behavior: 'default_incomplete',
-      expand: ['latest_invoice.payment_intent'],
-      items: subscriptionItems,
-    }
+      const latestInvoice = subscription.latest_invoice as Stripe.Invoice | null
+      const paymentIntent = latestInvoice?.payment_intent as Stripe.PaymentIntent | undefined
 
-    const mergedOptions: Stripe.SubscriptionCreateParams = {
-      ...defaultOptions,
-      ...options,
+      return { subscription, paymentIntent }
     }
 
-    const subscription = await manageSubscription.create(this, type, mergedOptions)
-
-    const latestInvoice = subscription.latest_invoice as Stripe.Invoice | null
-    const paymentIntent = latestInvoice?.payment_intent as Stripe.PaymentIntent | undefined
-
-    return { subscription, paymentIntent }
-  }
-
-
-     async checkout(
+    async checkout(
       priceIds: CheckoutLineItem[],
       options: CheckoutOptions = {},
     ): Promise<Stripe.Response<Stripe.Checkout.Session>> {

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

@@ -3,6 +3,7 @@ import { stripe } from '..'
 
 export interface PriceManager {
   retrieveByLookupKey: (lookupKey: string) => Promise<Stripe.Price>
+  createOrGet: (lookupKey: string, params: Stripe.PriceCreateParams) => Promise<Stripe.Price>
 }
 
 export const managePrice: PriceManager = (() => {
@@ -12,5 +13,22 @@ export const managePrice: PriceManager = (() => {
     return prices.data[0]
   }
 
-  return { retrieveByLookupKey }
+  async function createOrGet(
+    lookupKey: string,
+    params: Stripe.PriceCreateParams,
+  ): Promise<Stripe.Price> {
+    const existingPrice = await retrieveByLookupKey(lookupKey)
+
+    if (existingPrice)
+      return existingPrice
+
+    const newPrice = await stripe.price.create({
+      ...params,
+      lookup_key: lookupKey,
+    })
+
+    return newPrice
+  }
+
+  return { retrieveByLookupKey, createOrGet }
 })()

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

@@ -2,24 +2,40 @@ import type Stripe from 'stripe'
 import type { SubscriptionModel } from '../../../../orm/src/models/Subscription'
 import type { UserModel } from '../../../../orm/src/models/User'
 
-import { stripe } from '..'
+import { manageCustomer, managePrice, stripe } from '..'
 import Subscription from '../../../../orm/src/models/Subscription'
 
 export interface SubscriptionManager {
-  create: (user: UserModel, type: string, params: Stripe.SubscriptionCreateParams) => Promise<Stripe.Response<Stripe.Subscription>>
+  create: (user: UserModel, type: string, priceId: string, params: Partial<Stripe.SubscriptionCreateParams>) => Promise<Stripe.Response<Stripe.Subscription>>
   isValid: (user: UserModel, type: string) => Promise<boolean>
+  isIncomplete: (user: UserModel, type: string) => Promise<boolean>
 }
 
 export const manageSubscription: SubscriptionManager = (() => {
-  async function create(user: UserModel, type: string, params: Stripe.SubscriptionCreateParams): Promise<Stripe.Response<Stripe.Subscription>> {
-    if (!user.hasStripeId()) {
-      throw new Error('Customer does not exist in Stripe')
-    }
+  async function create(user: UserModel, type: string, priceId: string, params: Partial<Stripe.SubscriptionCreateParams>): Promise<Stripe.Response<Stripe.Subscription>> {
+    const price = await managePrice.retrieveByLookupKey(priceId)
+
+    if (!price)
+      throw new Error('Price does not exist in stripe')
+
+    const subscriptionItems = [{
+      price: price.id,
+      quantity: 1,
+    }]
+
+    const customerId = await manageCustomer.createOrGetStripeUser(user, {}).then((customer) => {
+      if (!customer || !customer.id) {
+        throw new Error('Customer does not exist in Stripe')
+      }
+
+      return customer.id
+    })
 
-    const defaultParams: Partial<Stripe.SubscriptionCreateParams> = {
-      customer: user.stripeId(),
+    const defaultParams: Stripe.SubscriptionCreateParams = {
+      customer: customerId,
       payment_behavior: 'default_incomplete',
       expand: ['latest_invoice.payment_intent'],
+      items: subscriptionItems,
     }
 
     const mergedParams = { ...defaultParams, ...params }
@@ -35,14 +51,21 @@ export const manageSubscription: SubscriptionManager = (() => {
     return subscription.stripe_status === 'active'
   }
 
-  async function isIncomplete(subscription: SubscriptionModel): Promise<boolean> {
-    return subscription.stripe_status === 'incomplete'
-  }
-
   async function isTrial(subscription: SubscriptionModel): Promise<boolean> {
     return subscription.stripe_status === 'trialing'
   }
 
+  async function isIncomplete(user: UserModel, type: string): Promise<boolean> {
+    const subscription = await Subscription.where('user_id', user.id)
+      .where('type', type)
+      .first()
+
+    if (!subscription)
+      return false
+
+    return subscription.stripe_status === 'incomplete'
+  }
+
   async function isValid(user: UserModel, type: string): Promise<boolean> {
     const subscription = await Subscription.where('user_id', user.id)
       .where('type', type)

storage/framework/core/payments/src/drivers/stripe.ts

@@ -113,20 +113,30 @@ export const subscription: Subscription = (() => {
 })()
 
 export interface Price {
-  retrieve: (priceId: string, params: Stripe.PriceRetrieveParams) => Promise<Stripe.Response<Stripe.PriceRetrieveParams>>
-  list: (params: Stripe.PriceListParams) => Promise<Stripe.Response<Stripe.ApiListPromise<Stripe.Price>>>
+  retrieve: (priceId: string, params: Stripe.PriceRetrieveParams) => Promise<Stripe.Response<Stripe.Price>>
+  list: (params: Stripe.PriceListParams) => Promise<Stripe.ApiListPromise<Stripe.Price>>
+  create: (params: Stripe.PriceCreateParams) => Promise<Stripe.Response<Stripe.Price>>
+  update: (priceId: string, params: Stripe.PriceUpdateParams) => Promise<Stripe.Response<Stripe.Price>>
 }
 
 export const price: Price = (() => {
-  async function retrieve(priceId: string, params: Stripe.PriceRetrieveParams): Promise<Stripe.Response<Stripe.PriceRetrieveParams>> {
+  async function retrieve(priceId: string, params: Stripe.PriceRetrieveParams): Promise<Stripe.Response<Stripe.Price>> {
     return await client.prices.retrieve(priceId, params)
   }
 
-  async function list(params: Stripe.PriceListParams): Promise<Stripe.Response<Stripe.ApiListPromise<Stripe.Price>>> {
+  async function list(params: Stripe.PriceListParams): Promise<Stripe.ApiListPromise<Stripe.Price>> {
     return await client.prices.list(params)
   }
 
-  return { retrieve, list }
+  async function create(params: Stripe.PriceCreateParams): Promise<Stripe.Response<Stripe.Price>> {
+    return await client.prices.create(params)
+  }
+
+  async function update(priceId: string, params: Stripe.PriceUpdateParams): Promise<Stripe.Response<Stripe.Price>> {
+    return await client.prices.update(priceId, params)
+  }
+
+  return { retrieve, list, create, update }
 })()
 
 export interface Refund {

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

@@ -4,7 +4,7 @@ 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, managePrice, manageSubscription, type Stripe } from '@stacksjs/payments'
+import { manageCharge, manageCheckout, manageCustomer, managePaymentMethod, manageSubscription, type Stripe } from '@stacksjs/payments'
 
 import Post from './Post'
 
@@ -756,49 +756,24 @@ export class UserModel {
     return await manageSubscription.isValid(this, type)
   }
 
+  async isIncomplete(type: string): Promise<boolean> {
+    return await manageSubscription.isIncomplete(this, type)
+  }
+
   async newSubscriptionInvoice(
     type: string,
     priceId: string,
-    options: Partial<Stripe.SubscriptionCreateParams> = {},
+      options: Partial<Stripe.SubscriptionCreateParams> = {},
   ): Promise<{ subscription: Stripe.Subscription, paymentIntent?: Stripe.PaymentIntent }> {
     return await this.newSubscription(type, priceId, { ...options, days_until_due: 15, collection_method: 'send_invoice' })
   }
 
   async newSubscription(
     type: string,
     priceId: string,
-    options: Partial<Stripe.SubscriptionCreateParams> = {},
+      options: Partial<Stripe.SubscriptionCreateParams> = {},
   ): Promise<{ subscription: Stripe.Subscription, paymentIntent?: Stripe.PaymentIntent }> {
-    const price = await managePrice.retrieveByLookupKey(priceId)
-
-    if (!price)
-      throw new Error('Price does not exist in stripe')
-
-    const subscriptionItems = [{
-      price: price.id,
-      quantity: 1,
-    }]
-
-    const customer = await this.createOrGetStripeUser({}).then((customer) => {
-      if (!customer || !customer.id) {
-        throw new Error('Customer does not exist in Stripe')
-      }
-      return customer.id
-    })
-
-    const defaultOptions: Stripe.SubscriptionCreateParams = {
-      customer,
-      payment_behavior: 'default_incomplete',
-      expand: ['latest_invoice.payment_intent'],
-      items: subscriptionItems,
-    }
-
-    const mergedOptions: Stripe.SubscriptionCreateParams = {
-      ...defaultOptions,
-      ...options,
-    }
-
-    const subscription = await manageSubscription.create(this, type, mergedOptions)
+    const subscription = await manageSubscription.create(this, type, priceId, options)
 
     const latestInvoice = subscription.latest_invoice as Stripe.Invoice | null
     const paymentIntent = latestInvoice?.payment_intent as Stripe.PaymentIntent | undefined