@coursebuilder/adapter-drizzle 0.1.2 → 0.1.4

package/src/lib/mysql/index.ts

@@ -1,6 +1,16 @@
 import type { AdapterSession, AdapterUser } from '@auth/core/adapters'
 import { addSeconds, isAfter } from 'date-fns'
-import { and, asc, eq, inArray, not, notInArray, or, sql } from 'drizzle-orm'
+import {
+	and,
+	asc,
+	eq,
+	inArray,
+	isNotNull,
+	isNull,
+	not,
+	or,
+	sql,
+} from 'drizzle-orm'
 import {
 	mysqlTable as defaultMySqlTableFn,
 	MySqlDatabase,
@@ -18,14 +28,19 @@ import {
 	MerchantCoupon,
 	merchantCouponSchema,
 	MerchantCustomer,
+	merchantPriceSchema,
 	MerchantProduct,
+	merchantProductSchema,
 	Price,
+	priceSchema,
 	Product,
+	productSchema,
 	Purchase,
 	purchaseSchema,
 	PurchaseUserTransfer,
 	PurchaseUserTransferState,
 	ResourceProgress,
+	resourceProgressSchema,
 	UpgradableProduct,
 	upgradableProductSchema,
 	User,
@@ -35,7 +50,10 @@ import {
 	ContentResourceResourceSchema,
 	ContentResourceSchema,
 } from '@coursebuilder/core/schemas/content-resource-schema'
+import { merchantAccountSchema } from '@coursebuilder/core/schemas/merchant-account-schema'
+import { merchantCustomerSchema } from '@coursebuilder/core/schemas/merchant-customer-schema'
 import { VideoResourceSchema } from '@coursebuilder/core/schemas/video-resource'
+import { validateCoupon } from '@coursebuilder/core/utils/validate-coupon'
 
 import {
 	getAccountsRelationsSchema,
@@ -70,7 +88,10 @@ import {
 	getUsersSchema,
 } from './schemas/auth/users.js'
 import { getVerificationTokensSchema } from './schemas/auth/verification-tokens.js'
-import { getCouponSchema } from './schemas/commerce/coupon.js'
+import {
+	getCouponRelationsSchema,
+	getCouponSchema,
+} from './schemas/commerce/coupon.js'
 import { getMerchantAccountSchema } from './schemas/commerce/merchant-account.js'
 import { getMerchantChargeSchema } from './schemas/commerce/merchant-charge.js'
 import { getMerchantCouponSchema } from './schemas/commerce/merchant-coupon.js'
@@ -79,7 +100,10 @@ import { getMerchantPriceSchema } from './schemas/commerce/merchant-price.js'
 import { getMerchantProductSchema } from './schemas/commerce/merchant-product.js'
 import { getMerchantSessionSchema } from './schemas/commerce/merchant-session.js'
 import { getPriceSchema } from './schemas/commerce/price.js'
-import { getProductSchema } from './schemas/commerce/product.js'
+import {
+	getProductRelationsSchema,
+	getProductSchema,
+} from './schemas/commerce/product.js'
 import { getPurchaseUserTransferSchema } from './schemas/commerce/purchase-user-transfer.js'
 import {
 	getPurchaseRelationsSchema,
@@ -99,6 +123,10 @@ import {
 	getContentContributionRelationsSchema,
 	getContentContributionsSchema,
 } from './schemas/content/content-contributions.js'
+import {
+	getContentResourceProductRelationsSchema,
+	getContentResourceProductSchema,
+} from './schemas/content/content-resource-product.js'
 import {
 	getContentResourceResourceRelationsSchema,
 	getContentResourceResourceSchema,
@@ -133,6 +161,7 @@ export function getCourseBuilderSchema(mysqlTable: MySqlTableFn) {
 		usersRelations: getUsersRelationsSchema(mysqlTable),
 		verificationTokens: getVerificationTokensSchema(mysqlTable),
 		coupon: getCouponSchema(mysqlTable),
+		couponRelations: getCouponRelationsSchema(mysqlTable),
 		merchantAccount: getMerchantAccountSchema(mysqlTable),
 		merchantCharge: getMerchantChargeSchema(mysqlTable),
 		merchantCoupon: getMerchantCouponSchema(mysqlTable),
@@ -165,6 +194,10 @@ export function getCourseBuilderSchema(mysqlTable: MySqlTableFn) {
 		upgradableProducts: getUpgradableProductsSchema(mysqlTable),
 		upgradableProductsRelations:
 			getUpgradableProductsRelationsSchema(mysqlTable),
+		contentResourceProduct: getContentResourceProductSchema(mysqlTable),
+		contentResourceProductRelations:
+			getContentResourceProductRelationsSchema(mysqlTable),
+		productRelations: getProductRelationsSchema(mysqlTable),
 	} as const
 }
 
@@ -198,20 +231,203 @@ export function mySqlDrizzleAdapter(
 		prices,
 		products,
 		upgradableProducts,
+		resourceProgress,
 	} = createTables(tableFn)
 
 	return {
 		client,
+		async redeemFullPriceCoupon(options) {
+			const {
+				email: baseEmail,
+				couponId,
+				productIds,
+				currentUserId,
+				redeemingProductId,
+			} = options
+			const email = String(baseEmail).replace(' ', '+')
+
+			const coupon = await this.getCouponWithBulkPurchases(couponId)
+
+			const productId =
+				(coupon && (coupon.restrictedToProductId as string)) ||
+				redeemingProductId
+
+			if (!productId) throw new Error(`unable-to-find-any-product-id`)
+
+			const couponValidation = validateCoupon(coupon, productIds)
+
+			if (coupon && couponValidation.isRedeemable) {
+				// if the Coupon is the Bulk Coupon of a Bulk Purchase,
+				// then a bulk coupon is being redeemed
+				const bulkCouponRedemption = Boolean(
+					coupon.bulkCouponPurchases[0]?.bulkCouponId,
+				)
+
+				const { user } = await this.findOrCreateUser(email)
+
+				if (!user) throw new Error(`unable-to-create-user-${email}`)
+
+				const currentUser = currentUserId
+					? await this.getUserById(currentUserId)
+					: null
+
+				const redeemingForCurrentUser = currentUser?.id === user.id
+
+				// To prevent double-purchasing, check if this user already has a
+				// Purchase record for this product that is valid and wasn't a bulk
+				// coupon purchase.
+				const existingPurchases =
+					await this.getExistingNonBulkValidPurchasesOfProduct({
+						userId: user.id,
+						productId,
+					})
+
+				if (existingPurchases.length > 0)
+					throw new Error(`already-purchased-${email}`)
+
+				const purchaseId = `purchase-${v4()}`
+
+				await this.createPurchase({
+					id: purchaseId,
+					userId: user.id,
+					couponId: bulkCouponRedemption ? null : coupon.id,
+					redeemedBulkCouponId: bulkCouponRedemption ? coupon.id : null,
+					productId,
+					totalAmount: '0',
+					metadata: {
+						couponUsedId: bulkCouponRedemption ? null : coupon.id,
+					},
+				})
+
+				const newPurchase = await this.getPurchase(purchaseId)
+
+				await this.incrementCouponUsedCount(coupon.id)
+
+				await this.createPurchaseTransfer({
+					sourceUserId: user.id,
+					purchaseId: purchaseId,
+					expiresAt: new Date(Date.now() + 1000 * 60 * 60 * 24 * 7),
+				})
+
+				return { purchase: newPurchase, redeemingForCurrentUser }
+			}
+
+			return null
+		},
+		createPurchaseTransfer: async (options) => {
+			const id = `put_${v4()}`
+			await client.insert(purchaseUserTransfer).values({
+				id,
+				purchaseId: options.purchaseId,
+				sourceUserId: options.sourceUserId,
+				expiresAt: options.expiresAt,
+			})
+		},
+		incrementCouponUsedCount: async (couponId) => {
+			await client
+				.update(coupon)
+				.set({ usedCount: sql`${coupon.usedCount} + 1` })
+				.where(eq(coupon.id, couponId))
+		},
+		getExistingNonBulkValidPurchasesOfProduct: async ({
+			userId,
+			productId,
+		}) => {
+			const existingPurchases = await client.query.purchases.findMany({
+				where: and(
+					eq(purchaseTable.userId, userId),
+					productId ? eq(purchaseTable.productId, productId) : undefined,
+					eq(purchaseTable.status, 'Valid'),
+					isNull(purchaseTable.bulkCouponId),
+				),
+			})
+
+			return z.array(purchaseSchema).parse(existingPurchases)
+		},
+		createMerchantCustomer: async (options) => {
+			await client.insert(merchantCustomer).values({
+				id: `mc_${v4()}`,
+				identifier: options.identifier,
+				merchantAccountId: options.merchantAccountId,
+				userId: options.userId,
+				status: 1,
+			})
+			return merchantCustomerSchema.parse(
+				await client.query.merchantCustomer.findFirst({
+					where: eq(merchantCustomer.identifier, options.identifier),
+				}),
+			)
+		},
+		getMerchantAccount: async (options) => {
+			return merchantAccountSchema.parse(
+				await client.query.merchantAccount.findFirst({
+					where: eq(merchantAccount.label, options.provider),
+				}),
+			)
+		},
+		getMerchantPriceForProductId: async (productId) => {
+			const merchantPriceData = await client.query.merchantPrice.findFirst({
+				where: eq(merchantPrice.merchantProductId, productId),
+			})
+
+			const parsedMerchantPrice =
+				merchantPriceSchema.safeParse(merchantPriceData)
+
+			if (!parsedMerchantPrice.success) {
+				console.error(
+					'Error parsing merchant price',
+					JSON.stringify(parsedMerchantPrice.error),
+				)
+				return null
+			}
+
+			return parsedMerchantPrice.data
+		},
+		getMerchantProductForProductId: async (productId) => {
+			const merchantProductData = await client.query.merchantProduct.findFirst({
+				where: eq(merchantProduct.productId, productId),
+			})
+
+			if (!merchantProductData) return null
+			return merchantProductSchema.parse(merchantProductData)
+		},
+		getMerchantCustomerForUserId: async (userId) => {
+			const merchantCustomerData =
+				await client.query.merchantCustomer.findFirst({
+					where: eq(merchantCustomer.userId, userId),
+				})
+
+			if (!merchantCustomerData) return null
+			return merchantCustomerSchema.parse(merchantCustomerData)
+		},
+		getUpgradableProducts: async (options) => {
+			const { upgradableFromId, upgradableToId } = options
+			return z.array(upgradableProductSchema).parse(
+				await client.query.upgradableProducts.findMany({
+					where: and(
+						eq(upgradableProducts.upgradableFromId, upgradableFromId),
+						eq(upgradableProducts.upgradableToId, upgradableToId),
+					),
+				}),
+			)
+		},
 		availableUpgradesForProduct(
 			purchases: any,
 			productId: string,
-		): Promise<
-			{
-				upgradableTo: { id: string; name: string }
-				upgradableFrom: { id: string; name: string }
-			}[]
-		> {
-			throw new Error('Method not implemented.')
+		): Promise<any[]> {
+			const previousPurchaseProductIds = purchases.map(
+				({ productId }: Purchase) => productId,
+			)
+
+			return client.query.upgradableProducts.findMany({
+				where: and(
+					eq(upgradableProducts.upgradableToId, productId),
+					inArray(
+						upgradableProducts.upgradableFromId,
+						previousPurchaseProductIds,
+					),
+				),
+			})
 		},
 		clearLessonProgressForUser(options: {
 			userId: string
@@ -219,11 +435,56 @@ export function mySqlDrizzleAdapter(
 		}): Promise<void> {
 			throw new Error('Method not implemented.')
 		},
-		completeLessonProgressForUser(options: {
+		async completeLessonProgressForUser(options: {
 			userId: string
 			lessonId?: string
 		}): Promise<ResourceProgress | null> {
-			throw new Error('Method not implemented.')
+			if (!options.lessonId) {
+				throw new Error('No lessonId provided')
+			}
+
+			let lessonProgress = await client.query.resourceProgress.findFirst({
+				where: and(
+					eq(resourceProgress.userId, options.userId),
+					eq(resourceProgress.contentResourceId, options.lessonId),
+				),
+			})
+
+			const now = new Date()
+
+			if (lessonProgress) {
+				if (!lessonProgress.completedAt) {
+					await client
+						.update(resourceProgress)
+						.set({
+							completedAt: now,
+							updatedAt: now,
+						})
+						.where(eq(resourceProgress.contentResourceId, options.lessonId))
+				}
+			} else {
+				await client.insert(resourceProgress).values({
+					userId: options.userId,
+					contentResourceId: options.lessonId,
+					completedAt: now,
+					updatedAt: now,
+				})
+			}
+			lessonProgress = await client.query.resourceProgress.findFirst({
+				where: and(
+					eq(resourceProgress.userId, options.userId),
+					eq(resourceProgress.contentResourceId, options.lessonId),
+				),
+			})
+			const parsedLessonProgress =
+				resourceProgressSchema.safeParse(lessonProgress)
+
+			if (!parsedLessonProgress.success) {
+				console.error('Error parsing lesson progress', lessonProgress)
+				return null
+			}
+
+			return parsedLessonProgress.data
 		},
 		couponForIdOrCode(options: {
 			code?: string
@@ -258,7 +519,7 @@ export function mySqlDrizzleAdapter(
 					)
 
 					const existingPurchaseForCharge = existingMerchantCharge
-						? await client.query.purchase.findFirst({
+						? await client.query.purchases.findFirst({
 								where: eq(
 									purchaseTable.merchantChargeId,
 									existingMerchantCharge.id,
@@ -272,13 +533,13 @@ export function mySqlDrizzleAdapter(
 						: null
 
 					if (existingPurchaseForCharge) {
-						return purchaseSchema.parse(existingPurchaseForCharge)
+						return existingPurchaseForCharge.id
 					}
 
-					const merchantChargeId = v4()
-					const purchaseId = v4()
+					const merchantChargeId = `mc_${v4()}`
+					const purchaseId = `purch_${v4()}`
 
-					const newMerchantCharge = trx.insert(merchantCharge).values({
+					const newMerchantCharge = await client.insert(merchantCharge).values({
 						id: merchantChargeId,
 						userId,
 						identifier: stripeChargeId,
@@ -308,9 +569,20 @@ export function mySqlDrizzleAdapter(
 									eq(purchaseTable.userId, userId),
 								),
 							)
-							.then((res) => res[0] ?? null),
+							.where(
+								and(
+									eq(coupon.restrictedToProductId, productId),
+									eq(purchaseTable.userId, userId),
+								),
+							)
+							.then((res) => {
+								console.log({ res })
+								return res[0]?.coupons ?? null
+							}),
 					)
 
+					console.log({ existingBulkCoupon })
+
 					const isBulkPurchase =
 						quantity > 1 ||
 						Boolean(existingBulkCoupon) ||
@@ -325,7 +597,7 @@ export function mySqlDrizzleAdapter(
 							existingBulkCoupon !== null ? existingBulkCoupon.id : v4()
 
 						if (existingBulkCoupon !== null) {
-							couponToUpdate = trx
+							couponToUpdate = await client
 								.update(coupon)
 								.set({
 									maxUses: (existingBulkCoupon?.maxUses || 0) + quantity,
@@ -340,7 +612,7 @@ export function mySqlDrizzleAdapter(
 									)
 								: null
 
-							couponToUpdate = await trx.insert(coupon).values({
+							couponToUpdate = await client.insert(coupon).values({
 								id: bulkCouponId as string,
 								percentageDiscount: '1.0',
 								restrictedToProductId: productId,
@@ -355,13 +627,17 @@ export function mySqlDrizzleAdapter(
 						}
 					}
 
-					const merchantSessionId = v4()
+					const merchantSessionId = `ms_${v4()}`
 
-					const newMerchantSession = trx.insert(merchantSession).values({
-						id: merchantSessionId,
-						identifier: checkoutSessionId,
-						merchantAccountId,
-					})
+					const newMerchantSession = await client
+						.insert(merchantSession)
+						.values({
+							id: merchantSessionId,
+							identifier: checkoutSessionId,
+							merchantAccountId,
+						})
+
+					console.log({ newMerchantSession })
 
 					const merchantCouponUsed = stripeCouponId
 						? await client.query.merchantCoupon.findFirst({
@@ -369,6 +645,8 @@ export function mySqlDrizzleAdapter(
 							})
 						: null
 
+					console.log({ merchantCouponUsed })
+
 					const pppMerchantCoupon = appliedPPPStripeCouponId
 						? await client.query.merchantCoupon.findFirst({
 								where: and(
@@ -378,12 +656,14 @@ export function mySqlDrizzleAdapter(
 							})
 						: null
 
+					console.log({ pppMerchantCoupon })
+
 					const newPurchaseStatus =
 						merchantCouponUsed?.type === 'ppp' || pppMerchantCoupon
 							? 'Restricted'
 							: 'Valid'
 
-					const newPurchase = trx.insert(purchaseTable).values({
+					const newPurchase = await client.insert(purchaseTable).values({
 						id: purchaseId,
 						status: newPurchaseStatus,
 						userId,
@@ -397,12 +677,14 @@ export function mySqlDrizzleAdapter(
 						couponId: usedCouponId || null,
 					})
 
+					console.log({ newPurchase })
+
 					const oneWeekInMilliseconds = 1000 * 60 * 60 * 24 * 7
 
-					const newPurchaseUserTransfer = trx
+					const newPurchaseUserTransfer = await client
 						.insert(purchaseUserTransfer)
 						.values({
-							id: v4(),
+							id: `put_${v4()}`,
 							purchaseId: purchaseId as string,
 							expiresAt: existingPurchase
 								? new Date()
@@ -410,13 +692,19 @@ export function mySqlDrizzleAdapter(
 							sourceUserId: userId,
 						})
 
-					await Promise.all([
-						newMerchantCharge,
-						newPurchase,
-						newPurchaseUserTransfer,
-						newMerchantSession,
-						...(couponToUpdate ? [couponToUpdate] : []),
-					])
+					console.log({ newPurchaseUserTransfer })
+
+					// const result = await Promise.all([
+					// 	newMerchantCharge,
+					// 	newPurchase,
+					// 	newPurchaseUserTransfer,
+					// 	newMerchantSession,
+					// 	...(couponToUpdate ? [couponToUpdate] : []),
+					// ])
+					//
+					// console.log('result', { result })
+
+					console.log('inside', { purchaseId })
 
 					return purchaseId
 				} catch (error) {
@@ -426,30 +714,90 @@ export function mySqlDrizzleAdapter(
 				}
 			})
 
-			return purchaseSchema.parse(
+			console.log('putside', { purchaseId })
+
+			const parsedPurchase = purchaseSchema.safeParse(
 				await client.query.purchases.findFirst({
 					where: eq(purchaseTable.id, purchaseId as string),
 				}),
 			)
+
+			if (!parsedPurchase.success) {
+				console.error(
+					'Error parsing purchase',
+					parsedPurchase,
+					JSON.stringify(parsedPurchase, null, 2),
+				)
+				throw new Error('Error parsing purchase')
+			}
+
+			return parsedPurchase.data
 		},
-		findOrCreateMerchantCustomer(options: {
+		async findOrCreateMerchantCustomer(options: {
 			user: User
 			identifier: string
 			merchantAccountId: string
 		}): Promise<MerchantCustomer | null> {
-			throw new Error('Method not implemented.')
+			const merchantCustomer = merchantCustomerSchema
+				.nullable()
+				.optional()
+				.parse(
+					await client.query.merchantCustomer.findFirst({
+						where: (merchantCustomer, { eq }) =>
+							eq(merchantCustomer.identifier, options.identifier),
+					}),
+				)
+
+			if (merchantCustomer) {
+				return merchantCustomer
+			}
+
+			return await this.createMerchantCustomer({
+				identifier: options.identifier,
+				merchantAccountId: options.merchantAccountId,
+				userId: options.user.id,
+			})
 		},
-		findOrCreateUser(
+		async findOrCreateUser(
 			email: string,
 			name?: string | null,
 		): Promise<{
 			user: User
 			isNewUser: boolean
 		}> {
-			throw new Error('Method not implemented.')
+			const user = await this.getUserByEmail?.(email)
+
+			if (!user) {
+				const newUser = await this.createUser?.({
+					id: `u_${v4()}`,
+					email,
+					name,
+					emailVerified: null,
+				})
+				if (!newUser) {
+					throw new Error('Could not create user')
+				}
+				return {
+					user: newUser as User,
+					isNewUser: true,
+				}
+			}
+
+			return {
+				user: user as User,
+				isNewUser: false,
+			}
 		},
-		getCoupon(couponIdOrCode: string): Promise<Coupon | null> {
-			throw new Error('Method not implemented.')
+		async getCoupon(couponIdOrCode: string): Promise<Coupon | null> {
+			return couponSchema.nullable().parse(
+				await client
+					.select()
+					.from(coupon)
+					.where(
+						or(eq(coupon.id, couponIdOrCode), eq(coupon.code, couponIdOrCode)),
+					)
+					.then((res) => res[0] ?? null),
+			)
 		},
 		getCouponWithBulkPurchases(couponId: string): Promise<
 			| (Coupon & {
@@ -479,26 +827,100 @@ export function mySqlDrizzleAdapter(
 		getLessonProgresses(): Promise<ResourceProgress[]> {
 			throw new Error('Method not implemented.')
 		},
-		getMerchantCharge(
+		async getMerchantCharge(
 			merchantChargeId: string,
 		): Promise<MerchantCharge | null> {
-			throw new Error('Method not implemented.')
+			const mCharge = await client.query.merchantCharge.findFirst({
+				where: eq(merchantCharge.id, merchantChargeId),
+			})
+			console.log('mCharge', mCharge)
+			const parsed = merchantChargeSchema.safeParse(mCharge)
+			if (!parsed.success) {
+				console.error('Error parsing merchantCharge', mCharge)
+				return null
+			}
+			return parsed.data
 		},
-		getMerchantCoupon(
+		async getMerchantCouponsForTypeAndPercent(params: {
+			type: string
+			percentageDiscount: number
+		}): Promise<MerchantCoupon[]> {
+			return z.array(merchantCouponSchema).parse(
+				await client.query.merchantCoupon.findMany({
+					where: and(
+						eq(merchantCoupon.type, params.type),
+						eq(
+							merchantCoupon.percentageDiscount,
+							params.percentageDiscount.toString(),
+						),
+					),
+				}),
+			)
+		},
+		async getMerchantCouponForTypeAndPercent(params: {
+			type: string
+			percentageDiscount: number
+		}): Promise<MerchantCoupon | null> {
+			const foundMerchantCoupon = await client.query.merchantCoupon.findFirst({
+				where: and(
+					eq(merchantCoupon.type, params.type),
+					eq(
+						merchantCoupon.percentageDiscount,
+						params.percentageDiscount.toString(),
+					),
+				),
+			})
+
+			const parsed = merchantCouponSchema
+				.nullable()
+				.safeParse(foundMerchantCoupon)
+			if (parsed.success) {
+				return parsed.data
+			}
+
+			return null
+		},
+		async getMerchantCoupon(
 			merchantCouponId: string,
 		): Promise<MerchantCoupon | null> {
-			throw new Error('Method not implemented.')
+			const foundMerchantCoupon = await client.query.merchantCoupon.findFirst({
+				where: eq(merchantCoupon.id, merchantCouponId),
+			})
+
+			const parsed = merchantCouponSchema
+				.nullable()
+				.safeParse(foundMerchantCoupon)
+			if (parsed.success) {
+				return parsed.data
+			}
+
+			return null
 		},
-		getMerchantProduct(
+		async getMerchantProduct(
 			stripeProductId: string,
 		): Promise<MerchantProduct | null> {
-			throw new Error('Method not implemented.')
+			return merchantProductSchema.nullable().parse(
+				await client.query.merchantProduct.findFirst({
+					where: eq(merchantProduct.identifier, stripeProductId),
+				}),
+			)
 		},
 		getPrice(productId: string): Promise<Price | null> {
 			throw new Error('Method not implemented.')
 		},
-		getProduct(productId: string): Promise<Product | null> {
-			throw new Error('Method not implemented.')
+		async getPriceForProduct(productId: string): Promise<Price | null> {
+			return priceSchema.nullable().parse(
+				await client.query.prices.findFirst({
+					where: eq(prices.productId, productId),
+				}),
+			)
+		},
+		async getProduct(productId: string): Promise<Product | null> {
+			return productSchema.nullable().parse(
+				await client.query.products.findFirst({
+					where: eq(products.id, productId),
+				}),
+			)
 		},
 		async getPurchase(purchaseId: string): Promise<Purchase | null> {
 			const purchase = await client.query.purchases.findFirst({
@@ -510,7 +932,6 @@ export function mySqlDrizzleAdapter(
 		async createPurchase(options): Promise<Purchase> {
 			const newPurchaseId = options.id || `purchase-${v4()}`
 			await client.insert(purchaseTable).values({
-				state: 'Valid',
 				...options,
 				id: newPurchaseId,
 			})
@@ -519,77 +940,7 @@ export function mySqlDrizzleAdapter(
 
 			return purchaseSchema.parse(newPurchase)
 		},
-		async getPurchaseDetails(
-			purchaseId: string,
-			userId: string,
-		): Promise<{
-			purchase?: Purchase
-			existingPurchase?: Purchase
-			availableUpgrades: UpgradableProduct[]
-		}> {
-			const allPurchases = await this.getPurchasesForUser(userId)
-			const thePurchase = await client.query.purchases.findFirst({
-				where: and(
-					eq(purchaseTable.id, purchaseId),
-					eq(purchaseTable.userId, userId),
-				),
-				with: {
-					user: true,
-					product: true,
-					bulkCoupon: true,
-				},
-			})
-
-			const parsedPurchase = purchaseSchema.safeParse(thePurchase)
-
-			if (!parsedPurchase.success) {
-				console.error('Error parsing purchase', parsedPurchase)
-				return {
-					availableUpgrades: [],
-				}
-			}
-
-			const purchaseCanUpgrade = ['Valid', 'Restricted'].includes(
-				parsedPurchase.data.state || '',
-			)
-
-			if (!purchaseCanUpgrade) {
-				return {
-					availableUpgrades: [],
-				}
-			}
-
-			const availableUpgrades = await client.query.upgradableProducts.findMany({
-				where: and(
-					eq(
-						upgradableProducts.upgradableFromId,
-						parsedPurchase.data.product?.id as string,
-					),
-					not(
-						inArray(
-							upgradableProducts.upgradableToId,
-							allPurchases.map((p) => p.product?.id as string),
-						),
-					),
-				),
-				with: {
-					upgradableTo: true,
-					upgradableFrom: true,
-				},
-			})
-
-			const existingPurchase = allPurchases.find(
-				(p) => p.product?.id === parsedPurchase.data.product?.id,
-			)
 
-			return Promise.resolve({
-				availableUpgrades: z
-					.array(upgradableProductSchema)
-					.parse(availableUpgrades),
-				existingPurchase,
-				purchase: parsedPurchase.data,
-			})
-		},
 		async getPurchaseForStripeCharge(
 			stripeChargeId: string,
 		): Promise<Purchase | null> {
@@ -604,7 +955,9 @@ export function mySqlDrizzleAdapter(
 							eq(merchantCharge.id, purchaseTable.merchantChargeId),
 						),
 					)
-					.then((res) => res[0] ?? null),
+					.then((res) => {
+						return res[0]?.purchases ?? null
+					}),
 			)
 
 			if (!purchase.success) {
@@ -641,7 +994,7 @@ export function mySqlDrizzleAdapter(
 			const userPurchases = await client.query.purchases.findMany({
 				where: and(
 					eq(purchaseTable.userId, userId),
-					inArray(purchaseTable.state, visiblePurchaseStates),
+					inArray(purchaseTable.status, visiblePurchaseStates),
 				),
 				with: {
 					user: true,
@@ -654,12 +1007,106 @@ export function mySqlDrizzleAdapter(
 			const parsedPurchases = z.array(purchaseSchema).safeParse(userPurchases)
 
 			if (!parsedPurchases.success) {
-				console.error('Error parsing purchases', parsedPurchases)
+				console.error(
+					'Error parsing purchases',
+					JSON.stringify(parsedPurchases.error),
+				)
 				return []
 			}
 
 			return parsedPurchases.data
 		},
+		async getPurchaseDetails(
+			purchaseId: string,
+			userId: string,
+		): Promise<{
+			purchase?: Purchase
+			existingPurchase?: Purchase & { product?: Product | null }
+			availableUpgrades: UpgradableProduct[]
+		}> {
+			const visiblePurchaseStates = ['Valid', 'Refunded', 'Restricted']
+
+			const userPurchases = await client.query.purchases.findMany({
+				where: and(
+					eq(purchaseTable.userId, userId),
+					inArray(purchaseTable.status, visiblePurchaseStates),
+				),
+				with: {
+					user: true,
+					product: true,
+					bulkCoupon: true,
+				},
+				orderBy: asc(purchaseTable.createdAt),
+			})
+
+			const parsedPurchases = z.array(purchaseSchema).safeParse(userPurchases)
+
+			const allPurchases = parsedPurchases.success ? parsedPurchases.data : []
+
+			console.log('🦦', { allPurchases })
+
+			const thePurchase = await client.query.purchases.findFirst({
+				where: and(
+					eq(purchaseTable.id, purchaseId),
+					eq(purchaseTable.userId, userId),
+				),
+				with: {
+					user: true,
+					product: true,
+					bulkCoupon: true,
+				},
+			})
+
+			const parsedPurchase = purchaseSchema.safeParse(thePurchase)
+
+			if (!parsedPurchase.success) {
+				console.error('Error parsing purchase', parsedPurchase)
+				return {
+					availableUpgrades: [],
+				}
+			}
+
+			console.log('🦦', { parsedPurchase: parsedPurchase.data })
+
+			const purchaseCanUpgrade = ['Valid', 'Restricted'].includes(
+				parsedPurchase.data.state || '',
+			)
+
+			let availableUpgrades: any[] = []
+
+			if (purchaseCanUpgrade) {
+				availableUpgrades = await client.query.upgradableProducts.findMany({
+					where: and(
+						eq(
+							upgradableProducts.upgradableFromId,
+							parsedPurchase.data.product?.id as string,
+						),
+						not(
+							inArray(
+								upgradableProducts.upgradableToId,
+								allPurchases.map((p) => p.product?.id as string),
+							),
+						),
+					),
+					with: {
+						upgradableTo: true,
+						upgradableFrom: true,
+					},
+				})
+			}
+
+			const existingPurchase = allPurchases.find(
+				(p) => p.product?.id === parsedPurchase.data.product?.id,
+			)
+
+			return Promise.resolve({
+				availableUpgrades: z
+					.array(upgradableProductSchema)
+					.parse(availableUpgrades),
+				existingPurchase,
+				purchase: parsedPurchase.data,
+			})
+		},
 		async getUserById(userId: string): Promise<User | null> {
 			return userSchema.nullable().parse(
 				await client.query.users.findFirst({
@@ -667,11 +1114,47 @@ export function mySqlDrizzleAdapter(
 				}),
 			)
 		},
-		pricesOfPurchasesTowardOneBundle(options: {
+		async pricesOfPurchasesTowardOneBundle({
+			userId,
+			bundleId,
+		}: {
 			userId: string | undefined
 			bundleId: string
 		}): Promise<Price[]> {
-			throw new Error('Method not implemented.')
+			if (userId === undefined) return []
+
+			const canUpgradeProducts = await client.query.upgradableProducts.findMany(
+				{
+					where: eq(upgradableProducts.upgradableToId, bundleId),
+				},
+			)
+
+			const upgradableFrom = z.array(z.string()).parse(
+				canUpgradeProducts.map((product) => {
+					return product.upgradableFromId
+				}),
+			)
+
+			const purchases = await client.query.purchases.findMany({
+				where: and(
+					eq(purchaseTable.userId, userId),
+					inArray(purchaseTable.productId, upgradableFrom),
+				),
+			})
+
+			const productsPurchased = z.array(z.string()).parse(
+				purchases.map((purchase) => {
+					return purchase.productId
+				}),
+			)
+
+			if (productsPurchased.length === 0) return []
+
+			const foundPrices = await client.query.prices.findMany({
+				where: inArray(prices.productId, productsPurchased),
+			})
+
+			return z.array(priceSchema).parse(foundPrices)
 		},
 		toggleLessonProgressForUser(options: {
 			userId: string
@@ -806,7 +1289,7 @@ export function mySqlDrizzleAdapter(
     WHERE
       type = 'videoResource'
       AND (id = ${id});
-      
+
  `
 			return client
 				.execute(query)
@@ -892,7 +1375,6 @@ export function mySqlDrizzleAdapter(
 			return parsedResource.data
 		},
 		async createUser(data) {
-			console.log(data)
 			try {
 				const id = crypto.randomUUID()