@coursebuilder/adapter-drizzle 0.1.3 → 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,6 +28,7 @@ import {
 	MerchantCoupon,
 	merchantCouponSchema,
 	MerchantCustomer,
+	merchantPriceSchema,
 	MerchantProduct,
 	merchantProductSchema,
 	Price,
@@ -29,6 +40,7 @@ import {
 	PurchaseUserTransfer,
 	PurchaseUserTransferState,
 	ResourceProgress,
+	resourceProgressSchema,
 	UpgradableProduct,
 	upgradableProductSchema,
 	User,
@@ -38,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,
@@ -73,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'
@@ -143,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),
@@ -212,10 +231,186 @@ 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,
@@ -240,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
@@ -279,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,
@@ -293,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,
@@ -329,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) ||
@@ -346,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,
@@ -361,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,
@@ -376,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({
@@ -390,6 +645,8 @@ export function mySqlDrizzleAdapter(
 							})
 						: null
 
+					console.log({ merchantCouponUsed })
+
 					const pppMerchantCoupon = appliedPPPStripeCouponId
 						? await client.query.merchantCoupon.findFirst({
 								where: and(
@@ -399,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,
@@ -418,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()
@@ -431,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) {
@@ -447,27 +714,79 @@ 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,
+			}
 		},
 		async getCoupon(couponIdOrCode: string): Promise<Coupon | null> {
 			return couponSchema.nullable().parse(
@@ -508,10 +827,19 @@ 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
 		},
 		async getMerchantCouponsForTypeAndPercent(params: {
 			type: string
@@ -612,77 +940,7 @@ export function mySqlDrizzleAdapter(
 
 			return purchaseSchema.parse(newPurchase)
 		},
-		async getPurchaseDetails(
-			purchaseId: string,
-			userId: string,
-		): Promise<{
-			purchase?: Purchase
-			existingPurchase?: Purchase & { product?: Product | null }
-			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> {
@@ -697,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) {
@@ -747,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({
@@ -788,19 +1142,16 @@ export function mySqlDrizzleAdapter(
 				),
 			})
 
-			const purchasesMade = z.array(z.string()).parse(
+			const productsPurchased = z.array(z.string()).parse(
 				purchases.map((purchase) => {
 					return purchase.productId
 				}),
 			)
 
-			if (purchasesMade.length === 0) return []
+			if (productsPurchased.length === 0) return []
 
 			const foundPrices = await client.query.prices.findMany({
-				where: and(
-					eq(prices.productId, bundleId),
-					inArray(prices.productId, purchasesMade),
-				),
+				where: inArray(prices.productId, productsPurchased),
 			})
 
 			return z.array(priceSchema).parse(foundPrices)