@coursebuilder/adapter-drizzle 0.1.4 → 0.3.0

package/src/lib/mysql/index.ts

@@ -3,7 +3,9 @@ import { addSeconds, isAfter } from 'date-fns'
 import {
 	and,
 	asc,
+	desc,
 	eq,
+	gte,
 	inArray,
 	isNotNull,
 	isNull,
@@ -38,6 +40,7 @@ import {
 	Purchase,
 	purchaseSchema,
 	PurchaseUserTransfer,
+	purchaseUserTransferSchema,
 	PurchaseUserTransferState,
 	ResourceProgress,
 	resourceProgressSchema,
@@ -52,7 +55,9 @@ import {
 } 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 { type ModuleProgress } from '@coursebuilder/core/schemas/resource-progress-schema'
 import { VideoResourceSchema } from '@coursebuilder/core/schemas/video-resource'
+import { logger } from '@coursebuilder/core/utils/logger'
 import { validateCoupon } from '@coursebuilder/core/utils/validate-coupon'
 
 import {
@@ -93,7 +98,10 @@ import {
 	getCouponSchema,
 } from './schemas/commerce/coupon.js'
 import { getMerchantAccountSchema } from './schemas/commerce/merchant-account.js'
-import { getMerchantChargeSchema } from './schemas/commerce/merchant-charge.js'
+import {
+	getMerchantChargeRelationsSchema,
+	getMerchantChargeSchema,
+} from './schemas/commerce/merchant-charge.js'
 import { getMerchantCouponSchema } from './schemas/commerce/merchant-coupon.js'
 import { getMerchantCustomerSchema } from './schemas/commerce/merchant-customer.js'
 import { getMerchantPriceSchema } from './schemas/commerce/merchant-price.js'
@@ -104,7 +112,10 @@ import {
 	getProductRelationsSchema,
 	getProductSchema,
 } from './schemas/commerce/product.js'
-import { getPurchaseUserTransferSchema } from './schemas/commerce/purchase-user-transfer.js'
+import {
+	getPurchaseUserTransferRelationsSchema,
+	getPurchaseUserTransferSchema,
+} from './schemas/commerce/purchase-user-transfer.js'
 import {
 	getPurchaseRelationsSchema,
 	getPurchaseSchema,
@@ -164,6 +175,7 @@ export function getCourseBuilderSchema(mysqlTable: MySqlTableFn) {
 		couponRelations: getCouponRelationsSchema(mysqlTable),
 		merchantAccount: getMerchantAccountSchema(mysqlTable),
 		merchantCharge: getMerchantChargeSchema(mysqlTable),
+		merchantChargeRelations: getMerchantChargeRelationsSchema(mysqlTable),
 		merchantCoupon: getMerchantCouponSchema(mysqlTable),
 		merchantCustomer: getMerchantCustomerSchema(mysqlTable),
 		merchantPrice: getMerchantPriceSchema(mysqlTable),
@@ -174,6 +186,8 @@ export function getCourseBuilderSchema(mysqlTable: MySqlTableFn) {
 		purchases: getPurchaseSchema(mysqlTable),
 		purchaseRelations: getPurchaseRelationsSchema(mysqlTable),
 		purchaseUserTransfer: getPurchaseUserTransferSchema(mysqlTable),
+		purchaseUserTransferRelations:
+			getPurchaseUserTransferRelationsSchema(mysqlTable),
 		communicationChannel: getCommunicationChannelSchema(mysqlTable),
 		communicationPreferenceTypes:
 			getCommunicationPreferenceTypesSchema(mysqlTable),
@@ -234,7 +248,7 @@ export function mySqlDrizzleAdapter(
 		resourceProgress,
 	} = createTables(tableFn)
 
-	return {
+	const adapter: CourseBuilderAdapter = {
 		client,
 		async redeemFullPriceCoupon(options) {
 			const {
@@ -246,7 +260,7 @@ export function mySqlDrizzleAdapter(
 			} = options
 			const email = String(baseEmail).replace(' ', '+')
 
-			const coupon = await this.getCouponWithBulkPurchases(couponId)
+			const coupon = await adapter.getCouponWithBulkPurchases(couponId)
 
 			const productId =
 				(coupon && (coupon.restrictedToProductId as string)) ||
@@ -259,16 +273,14 @@ export function mySqlDrizzleAdapter(
 			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 bulkCouponRedemption = Boolean(coupon.bulkPurchase?.bulkCouponId)
 
-				const { user } = await this.findOrCreateUser(email)
+				const { user } = await adapter.findOrCreateUser(email)
 
 				if (!user) throw new Error(`unable-to-create-user-${email}`)
 
 				const currentUser = currentUserId
-					? await this.getUserById(currentUserId)
+					? await adapter.getUserById(currentUserId)
 					: null
 
 				const redeemingForCurrentUser = currentUser?.id === user.id
@@ -277,7 +289,7 @@ export function mySqlDrizzleAdapter(
 				// Purchase record for this product that is valid and wasn't a bulk
 				// coupon purchase.
 				const existingPurchases =
-					await this.getExistingNonBulkValidPurchasesOfProduct({
+					await adapter.getExistingNonBulkValidPurchasesOfProduct({
 						userId: user.id,
 						productId,
 					})
@@ -287,7 +299,7 @@ export function mySqlDrizzleAdapter(
 
 				const purchaseId = `purchase-${v4()}`
 
-				await this.createPurchase({
+				await adapter.createPurchase({
 					id: purchaseId,
 					userId: user.id,
 					couponId: bulkCouponRedemption ? null : coupon.id,
@@ -299,11 +311,11 @@ export function mySqlDrizzleAdapter(
 					},
 				})
 
-				const newPurchase = await this.getPurchase(purchaseId)
+				const newPurchase = await adapter.getPurchase(purchaseId)
 
-				await this.incrementCouponUsedCount(coupon.id)
+				await adapter.incrementCouponUsedCount(coupon.id)
 
-				await this.createPurchaseTransfer({
+				await adapter.createPurchaseTransfer({
 					sourceUserId: user.id,
 					purchaseId: purchaseId,
 					expiresAt: new Date(Date.now() + 1000 * 60 * 60 * 24 * 7),
@@ -411,7 +423,7 @@ export function mySqlDrizzleAdapter(
 				}),
 			)
 		},
-		availableUpgradesForProduct(
+		async availableUpgradesForProduct(
 			purchases: any,
 			productId: string,
 		): Promise<any[]> {
@@ -419,21 +431,24 @@ export function mySqlDrizzleAdapter(
 				({ productId }: Purchase) => productId,
 			)
 
-			return client.query.upgradableProducts.findMany({
-				where: and(
-					eq(upgradableProducts.upgradableToId, productId),
-					inArray(
-						upgradableProducts.upgradableFromId,
-						previousPurchaseProductIds,
+			if (previousPurchaseProductIds.length > 0) {
+				return await client.query.upgradableProducts.findMany({
+					where: and(
+						eq(upgradableProducts.upgradableToId, productId),
+						inArray(
+							upgradableProducts.upgradableFromId,
+							previousPurchaseProductIds,
+						),
 					),
-				),
-			})
+				})
+			}
+			return []
 		},
 		clearLessonProgressForUser(options: {
 			userId: string
 			lessons: { id: string; slug: string }[]
 		}): Promise<void> {
-			throw new Error('Method not implemented.')
+			throw new Error('clearLessonProgressForUser Method not implemented.')
 		},
 		async completeLessonProgressForUser(options: {
 			userId: string
@@ -486,11 +501,40 @@ export function mySqlDrizzleAdapter(
 
 			return parsedLessonProgress.data
 		},
-		couponForIdOrCode(options: {
+		async couponForIdOrCode(options: {
 			code?: string
 			couponId?: string
 		}): Promise<(Coupon & { merchantCoupon: MerchantCoupon }) | null> {
-			throw new Error('Method not implemented.')
+			if (!options.couponId && !options.code) return null
+			const couponForIdOrCode = await client.query.coupon.findFirst({
+				where: or(
+					and(
+						or(
+							options.code ? eq(coupon.code, options.code) : undefined,
+							options.couponId ? eq(coupon.id, options.couponId) : undefined,
+						),
+						gte(coupon.expires, new Date()),
+					),
+					and(
+						or(
+							options.code ? eq(coupon.code, options.code) : undefined,
+							options.couponId ? eq(coupon.id, options.couponId) : undefined,
+						),
+						isNull(coupon.expires),
+					),
+				),
+				with: {
+					merchantCoupon: true,
+				},
+			})
+
+			if (!couponForIdOrCode) return null
+
+			return couponSchema
+				.extend({
+					merchantCoupon: merchantCouponSchema,
+				})
+				.parse(couponForIdOrCode)
 		},
 		async createMerchantChargeAndPurchase(options): Promise<Purchase> {
 			const purchaseId = await client.transaction(async (trx) => {
@@ -576,13 +620,10 @@ export function mySqlDrizzleAdapter(
 								),
 							)
 							.then((res) => {
-								console.log({ res })
 								return res[0]?.coupons ?? null
 							}),
 					)
 
-					console.log({ existingBulkCoupon })
-
 					const isBulkPurchase =
 						quantity > 1 ||
 						Boolean(existingBulkCoupon) ||
@@ -637,16 +678,12 @@ export function mySqlDrizzleAdapter(
 							merchantAccountId,
 						})
 
-					console.log({ newMerchantSession })
-
 					const merchantCouponUsed = stripeCouponId
 						? await client.query.merchantCoupon.findFirst({
 								where: eq(merchantCoupon.identifier, stripeCouponId),
 							})
 						: null
 
-					console.log({ merchantCouponUsed })
-
 					const pppMerchantCoupon = appliedPPPStripeCouponId
 						? await client.query.merchantCoupon.findFirst({
 								where: and(
@@ -656,8 +693,6 @@ export function mySqlDrizzleAdapter(
 							})
 						: null
 
-					console.log({ pppMerchantCoupon })
-
 					const newPurchaseStatus =
 						merchantCouponUsed?.type === 'ppp' || pppMerchantCoupon
 							? 'Restricted'
@@ -677,8 +712,6 @@ export function mySqlDrizzleAdapter(
 						couponId: usedCouponId || null,
 					})
 
-					console.log({ newPurchase })
-
 					const oneWeekInMilliseconds = 1000 * 60 * 60 * 24 * 7
 
 					const newPurchaseUserTransfer = await client
@@ -692,8 +725,6 @@ export function mySqlDrizzleAdapter(
 							sourceUserId: userId,
 						})
 
-					console.log({ newPurchaseUserTransfer })
-
 					// const result = await Promise.all([
 					// 	newMerchantCharge,
 					// 	newPurchase,
@@ -704,8 +735,6 @@ export function mySqlDrizzleAdapter(
 					//
 					// console.log('result', { result })
 
-					console.log('inside', { purchaseId })
-
 					return purchaseId
 				} catch (error) {
 					console.error(error)
@@ -714,8 +743,6 @@ export function mySqlDrizzleAdapter(
 				}
 			})
 
-			console.log('putside', { purchaseId })
-
 			const parsedPurchase = purchaseSchema.safeParse(
 				await client.query.purchases.findFirst({
 					where: eq(purchaseTable.id, purchaseId as string),
@@ -752,7 +779,7 @@ export function mySqlDrizzleAdapter(
 				return merchantCustomer
 			}
 
-			return await this.createMerchantCustomer({
+			return await adapter.createMerchantCustomer({
 				identifier: options.identifier,
 				merchantAccountId: options.merchantAccountId,
 				userId: options.user.id,
@@ -765,10 +792,10 @@ export function mySqlDrizzleAdapter(
 			user: User
 			isNewUser: boolean
 		}> {
-			const user = await this.getUserByEmail?.(email)
+			const user = await adapter.getUserByEmail?.(email)
 
 			if (!user) {
-				const newUser = await this.createUser?.({
+				const newUser = await adapter.createUser?.({
 					id: `u_${v4()}`,
 					email,
 					name,
@@ -799,19 +826,94 @@ export function mySqlDrizzleAdapter(
 					.then((res) => res[0] ?? null),
 			)
 		},
-		getCouponWithBulkPurchases(couponId: string): Promise<
+		async getCouponWithBulkPurchases(couponId: string): Promise<
 			| (Coupon & {
-					bulkCouponPurchases: { bulkCouponId: string }[]
+					bulkPurchase?: Purchase | null
+					bulkCouponPurchases: { bulkCouponId?: string | null }[]
 			  })
 			| null
 		> {
-			throw new Error('Method not implemented.')
+			logger.debug('getCouponWithBulkPurchases', { couponId })
+			let couponData
+			try {
+				couponData =
+					(await client.query.coupon.findFirst({
+						where: eq(coupon.id, couponId),
+						with: {
+							bulkPurchase: true,
+							bulkCouponPurchases: true,
+						},
+					})) || null
+			} catch (e) {
+				console.log('getCouponWithBulkPurchases')
+				logger.error(e as Error)
+			}
+
+			if (!couponData) {
+				logger.debug('getCouponWithBulkPurchases', {
+					couponId,
+					error: 'no coupon found',
+				})
+				return null
+			}
+
+			const parsedCoupon = couponSchema
+				.merge(
+					z.object({
+						bulkCouponPurchases: z.array(purchaseSchema),
+						bulkPurchase: purchaseSchema.nullable().optional(),
+					}),
+				)
+				.nullable()
+				.safeParse(couponData)
+
+			if (!parsedCoupon.success) {
+				console.error('Error parsing coupon', couponData)
+				return null
+			}
+			return parsedCoupon.data
 		},
-		getDefaultCoupon(productIds?: string[]): Promise<{
+		async getDefaultCoupon(productIds?: string[]): Promise<{
 			defaultMerchantCoupon: MerchantCoupon
 			defaultCoupon: Coupon
 		} | null> {
-			throw new Error('Method not implemented.')
+			const activeSaleCoupon = await client.query.coupon.findFirst({
+				where: and(
+					eq(coupon.status, 1),
+					eq(coupon.default, true),
+					gte(coupon.expires, new Date()),
+					or(
+						productIds
+							? inArray(coupon.restrictedToProductId, productIds)
+							: undefined,
+						isNull(coupon.restrictedToProductId),
+					),
+				),
+				orderBy: desc(coupon.percentageDiscount),
+				with: {
+					merchantCoupon: true,
+					product: true,
+				},
+			})
+			if (activeSaleCoupon) {
+				const { restrictedToProductId } = activeSaleCoupon
+				const validForProdcutId = restrictedToProductId
+					? productIds?.includes(restrictedToProductId as string)
+					: true
+
+				const { merchantCoupon: defaultMerchantCoupon, ...defaultCoupon } =
+					activeSaleCoupon
+
+				if (validForProdcutId) {
+					return {
+						defaultMerchantCoupon: merchantCouponSchema.parse(
+							defaultMerchantCoupon,
+						),
+						defaultCoupon: couponSchema.parse(defaultCoupon),
+					}
+				}
+			}
+			return null
 		},
 		getLessonProgressCountsByDate(): Promise<
 			{
@@ -819,13 +921,141 @@ export function mySqlDrizzleAdapter(
 				completedAt: string
 			}[]
 		> {
-			throw new Error('Method not implemented.')
+			throw new Error('getLessonProgressCountsByDate Method not implemented.')
 		},
-		getLessonProgressForUser(userId: string): Promise<ResourceProgress[]> {
-			throw new Error('Method not implemented.')
+		async getLessonProgressForUser(
+			userId: string,
+		): Promise<ResourceProgress[]> {
+			const userProgress = await client.query.resourceProgress.findMany({
+				where: eq(resourceProgress.userId, userId),
+			})
+			const parsed = z.array(resourceProgressSchema).safeParse(userProgress)
+			if (!parsed.success) {
+				console.error('Error parsing user progress', userProgress)
+				return []
+			}
+			return parsed.data
+		},
+		async getModuleProgressForUser(
+			userIdOrEmail: string,
+			moduleIdOrSlug: string,
+		): Promise<ModuleProgress> {
+			const module = await client.query.contentResource.findFirst({
+				where: or(
+					eq(contentResource.id, moduleIdOrSlug),
+					eq(
+						sql`JSON_EXTRACT (${contentResource.fields}, "$.slug")`,
+						moduleIdOrSlug,
+					),
+				),
+				with: {
+					resources: {
+						orderBy: asc(contentResourceResource.position),
+					},
+				},
+			})
+
+			const parsedModule = ContentResourceSchema.parse(module)
+
+			const moduleResources =
+				await client.query.contentResourceResource.findMany({
+					where: inArray(
+						contentResourceResource.resourceOfId,
+						parsedModule.resources?.map((r) => r.resourceId) ?? [],
+					),
+					orderBy: asc(contentResourceResource.position),
+				})
+
+			const parsedModuleResources = z
+				.array(ContentResourceResourceSchema)
+				.safeParse(moduleResources)
+
+			if (!parsedModuleResources.success) {
+				console.error(
+					'Error parsing module resources',
+					parsedModuleResources.error,
+				)
+				return {
+					completedLessons: [],
+					nextResource: null,
+					percentCompleted: 0,
+					completedLessonsCount: 0,
+					totalLessonsCount: 0,
+				}
+			}
+
+			const user = await client.query.users.findFirst({
+				where: or(eq(users.id, userIdOrEmail), eq(users.email, userIdOrEmail)),
+				with: {
+					roles: true,
+				},
+			})
+
+			if (!user) {
+				console.error('User not found', userIdOrEmail)
+				return {
+					completedLessons: [],
+					nextResource: null,
+					percentCompleted: 0,
+					completedLessonsCount: 0,
+					totalLessonsCount: parsedModuleResources.data.length,
+				}
+			}
+
+			const parsedUser = userSchema.parse(user)
+
+			const userProgress = await client.query.resourceProgress.findMany({
+				where: and(
+					eq(resourceProgress.userId, parsedUser.id),
+					isNotNull(resourceProgress.completedAt),
+					inArray(
+						resourceProgress.contentResourceId,
+						parsedModuleResources.data.map((r) => r.resourceId),
+					),
+				),
+				orderBy: asc(resourceProgress.completedAt),
+			})
+
+			const nextResourceId = moduleResources.find(
+				(r) => !userProgress.find((p) => p.contentResourceId === r.resourceId),
+			)?.resourceId
+
+			const nextResource = await client.query.contentResource.findFirst({
+				where: eq(contentResource.id, nextResourceId as string),
+			})
+
+			const parsedNextResource = ContentResourceSchema.nullable()
+				.optional()
+				.default(null)
+				.parse(nextResource)
+
+			const parsedProgress = z
+				.array(resourceProgressSchema)
+				.safeParse(userProgress)
+			if (!parsedProgress.success) {
+				console.error('Error parsing user progress', parsedProgress.error)
+				return {
+					completedLessons: [],
+					nextResource: null,
+					percentCompleted: 0,
+					completedLessonsCount: 0,
+					totalLessonsCount: parsedModuleResources.data.length,
+				}
+			}
+			const percentCompleted = Math.round(
+				(parsedProgress.data.length / parsedModuleResources.data.length) * 100,
+			)
+
+			return {
+				completedLessons: parsedProgress.data,
+				nextResource: parsedNextResource,
+				percentCompleted,
+				completedLessonsCount: parsedProgress.data.length,
+				totalLessonsCount: parsedModuleResources.data.length,
+			}
 		},
 		getLessonProgresses(): Promise<ResourceProgress[]> {
-			throw new Error('Method not implemented.')
+			throw new Error('getLessonProgresses Method not implemented.')
 		},
 		async getMerchantCharge(
 			merchantChargeId: string,
@@ -833,7 +1063,6 @@ export function mySqlDrizzleAdapter(
 			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)
@@ -906,7 +1135,7 @@ export function mySqlDrizzleAdapter(
 			)
 		},
 		getPrice(productId: string): Promise<Price | null> {
-			throw new Error('Method not implemented.')
+			throw new Error('getPrice  not implemented.')
 		},
 		async getPriceForProduct(productId: string): Promise<Price | null> {
 			return priceSchema.nullable().parse(
@@ -936,7 +1165,7 @@ export function mySqlDrizzleAdapter(
 				id: newPurchaseId,
 			})
 
-			const newPurchase = await this.getPurchase(newPurchaseId)
+			const newPurchase = await adapter.getPurchase(newPurchaseId)
 
 			return purchaseSchema.parse(newPurchase)
 		},
@@ -944,20 +1173,28 @@ export function mySqlDrizzleAdapter(
 		async getPurchaseForStripeCharge(
 			stripeChargeId: string,
 		): Promise<Purchase | null> {
+			logger.debug('getPurchaseForStripeCharge', { stripeChargeId })
+
+			const chargeForPurchase = merchantChargeSchema.nullable().parse(
+				(await client.query.merchantCharge.findFirst({
+					where: eq(merchantCharge.identifier, stripeChargeId),
+				})) || null,
+			)
+
+			if (!chargeForPurchase) {
+				logger.error(new Error('No charge found for purchase'))
+				return null
+			}
+
 			const purchase = purchaseSchema.safeParse(
-				await client
-					.select()
-					.from(purchaseTable)
-					.leftJoin(
-						merchantCharge,
-						and(
-							eq(merchantCharge.identifier, stripeChargeId),
-							eq(merchantCharge.id, purchaseTable.merchantChargeId),
-						),
-					)
-					.then((res) => {
-						return res[0]?.purchases ?? null
-					}),
+				await client.query.purchases.findFirst({
+					where: eq(purchaseTable.merchantChargeId, chargeForPurchase.id),
+					with: {
+						user: true,
+						product: true,
+						bulkCoupon: true,
+					},
+				}),
 			)
 
 			if (!purchase.success) {
@@ -966,7 +1203,7 @@ export function mySqlDrizzleAdapter(
 
 			return purchase.data
 		},
-		getPurchaseUserTransferById(options: { id: string }): Promise<
+		async getPurchaseUserTransferById(options: { id: string }): Promise<
 			| (PurchaseUserTransfer & {
 					sourceUser: User
 					targetUser: User | null
@@ -974,15 +1211,51 @@ export function mySqlDrizzleAdapter(
 			  })
 			| null
 		> {
-			throw new Error('Method not implemented.')
+			const purchaseTransferData =
+				await client.query.purchaseUserTransfer.findFirst({
+					where: eq(purchaseUserTransfer.id, options.id),
+					with: {
+						sourceUser: true,
+						targetUser: true,
+						purchase: true,
+					},
+				})
+
+			return purchaseUserTransferSchema
+				.merge(
+					z.object({
+						sourceUser: userSchema,
+						targetUser: userSchema.nullable(),
+						purchase: purchaseSchema,
+					}),
+				)
+				.nullable()
+				.parse(purchaseTransferData)
 		},
-		getPurchaseWithUser(purchaseId: string): Promise<
+		async getPurchaseWithUser(purchaseId: string): Promise<
 			| (Purchase & {
 					user: User
 			  })
 			| null
 		> {
-			throw new Error('Method not implemented.')
+			const purchaseData =
+				(await client.query.purchases.findFirst({
+					where: eq(purchaseTable.id, purchaseId),
+					with: {
+						user: true,
+					},
+				})) || null
+
+			const parsedPurchase = purchaseSchema
+				.merge(z.object({ user: userSchema }))
+				.nullable()
+				.safeParse(purchaseData)
+
+			if (!parsedPurchase.success) {
+				console.error('Error parsing purchase', parsedPurchase.error)
+				return null
+			}
+			return parsedPurchase.data
 		},
 		async getPurchasesForUser(userId?: string): Promise<Purchase[]> {
 			if (!userId) {
@@ -1021,7 +1294,7 @@ export function mySqlDrizzleAdapter(
 			userId: string,
 		): Promise<{
 			purchase?: Purchase
-			existingPurchase?: Purchase & { product?: Product | null }
+			existingPurchase?: Purchase | null
 			availableUpgrades: UpgradableProduct[]
 		}> {
 			const visiblePurchaseStates = ['Valid', 'Refunded', 'Restricted']
@@ -1043,8 +1316,6 @@ export function mySqlDrizzleAdapter(
 
 			const allPurchases = parsedPurchases.success ? parsedPurchases.data : []
 
-			console.log('🦦', { allPurchases })
-
 			const thePurchase = await client.query.purchases.findFirst({
 				where: and(
 					eq(purchaseTable.id, purchaseId),
@@ -1066,8 +1337,6 @@ export function mySqlDrizzleAdapter(
 				}
 			}
 
-			console.log('🦦', { parsedPurchase: parsedPurchase.data })
-
 			const purchaseCanUpgrade = ['Valid', 'Restricted'].includes(
 				parsedPurchase.data.state || '',
 			)
@@ -1095,24 +1364,56 @@ export function mySqlDrizzleAdapter(
 				})
 			}
 
-			const existingPurchase = allPurchases.find(
-				(p) => p.product?.id === parsedPurchase.data.product?.id,
-			)
+			const existingPurchase = purchaseSchema
+				.optional()
+				.nullable()
+				.parse(
+					(await client.query.purchases.findFirst({
+						where: and(
+							eq(purchaseTable.userId, userId),
+							eq(purchaseTable.productId, parsedPurchase.data.productId),
+							inArray(purchaseTable.status, ['Valid', 'Restricted']),
+							isNull(purchaseTable.bulkCouponId),
+							not(eq(purchaseTable.id, parsedPurchase.data.id)),
+						),
+						with: {
+							user: true,
+							product: true,
+							bulkCoupon: true,
+						},
+					})) || null,
+				)
 
-			return Promise.resolve({
+			return {
 				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({
+			const user = await client.query.users
+				.findFirst({
 					where: eq(users.id, userId),
-				}),
-			)
+					with: {
+						roles: {
+							with: {
+								role: true,
+							},
+						},
+					},
+				})
+				.then(async (res) => {
+					if (res) {
+						return {
+							...res,
+							roles: res.roles.map((r) => r.role),
+						}
+					}
+				})
+
+			return userSchema.nullable().parse(user ?? null)
 		},
 		async pricesOfPurchasesTowardOneBundle({
 			userId,
@@ -1156,12 +1457,56 @@ export function mySqlDrizzleAdapter(
 
 			return z.array(priceSchema).parse(foundPrices)
 		},
-		toggleLessonProgressForUser(options: {
+		async toggleLessonProgressForUser(options: {
 			userId: string
 			lessonId?: string
-			lessonSlug?: 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) {
+				await client
+					.update(resourceProgress)
+					.set({
+						completedAt: lessonProgress.completedAt ? null : 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
 		},
 		transferPurchasesToNewUser(options: {
 			merchantCustomerId: string
@@ -1173,13 +1518,27 @@ export function mySqlDrizzleAdapter(
 			chargeId: string,
 			status: 'Valid' | 'Refunded' | 'Disputed' | 'Banned' | 'Restricted',
 		): Promise<Purchase | undefined> {
-			throw new Error('Method not implemented.')
+			throw new Error('updatePurchaseStatusForCharge Method not implemented.')
 		},
-		updatePurchaseUserTransferTransferState(options: {
+		async updatePurchaseUserTransferTransferState(options: {
 			id: string
 			transferState: PurchaseUserTransferState
 		}): Promise<PurchaseUserTransfer | null> {
-			throw new Error('Method not implemented.')
+			await client
+				.update(purchaseUserTransfer)
+				.set({
+					transferState: options.transferState,
+				})
+				.where(eq(purchaseUserTransfer.id, options.id))
+
+			const purchaseUserTransferData =
+				(await client.query.purchaseUserTransfer.findFirst({
+					where: eq(purchaseUserTransfer.id, options.id),
+				})) || null
+
+			return purchaseUserTransferSchema
+				.nullable()
+				.parse(purchaseUserTransferData)
 		},
 		addResourceToResource: async function (options) {
 			const { parentResourceId, childResourceId } = options
@@ -1571,4 +1930,6 @@ export function mySqlDrizzleAdapter(
 			return undefined
 		},
 	}
+
+	return adapter
 }