@coursebuilder/adapter-drizzle 0.5.0 → 0.5.1

package/src/lib/mysql/index.ts

@@ -1,4 +1,5 @@
 import type { AdapterSession, AdapterUser } from '@auth/core/adapters'
+import slugify from '@sindresorhus/slugify'
 import { addSeconds, isAfter } from 'date-fns'
 import {
 	and,
@@ -19,6 +20,7 @@ import {
 	MySqlDatabase,
 	MySqlTableFn,
 } from 'drizzle-orm/mysql-core'
+import { customAlphabet } from 'nanoid'
 import { v4 } from 'uuid'
 import { z } from 'zod'
 
@@ -34,6 +36,7 @@ import {
 	merchantPriceSchema,
 	MerchantProduct,
 	merchantProductSchema,
+	NewProduct,
 	Price,
 	priceSchema,
 	Product,
@@ -51,15 +54,16 @@ import {
 	userSchema,
 } from '@coursebuilder/core/schemas'
 import {
+	ContentResourceProductSchema,
 	ContentResourceResourceSchema,
 	ContentResourceSchema,
 	type ContentResource,
-	type ContentResourceResource,
 } 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 { PaymentsProviderConfig } from '@coursebuilder/core/types'
 import { logger } from '@coursebuilder/core/utils/logger'
 import { validateCoupon } from '@coursebuilder/core/utils/validate-coupon'
 
@@ -172,6 +176,8 @@ import {
 import { getLessonProgressSchema } from './schemas/content/lesson-progress.js'
 import { getResourceProgressSchema } from './schemas/content/resource-progress.js'
 
+export const guid = customAlphabet('1234567890abcdefghijklmnopqrstuvwxyz', 5)
+
 export function getCourseBuilderSchema(mysqlTable: MySqlTableFn) {
 	return {
 		accounts: getAccountsSchema(mysqlTable),
@@ -254,6 +260,7 @@ export type DefaultSchema = ReturnType<typeof createTables>
 export function mySqlDrizzleAdapter(
 	client: InstanceType<typeof MySqlDatabase>,
 	tableFn = defaultMySqlTableFn,
+	paymentProvider?: PaymentsProviderConfig,
 ): CourseBuilderAdapter<typeof MySqlDatabase> {
 	const {
 		users,
@@ -262,6 +269,7 @@ export function mySqlDrizzleAdapter(
 		verificationTokens,
 		contentResource,
 		contentResourceResource,
+		contentResourceProduct,
 		purchases: purchaseTable,
 		purchaseUserTransfer,
 		coupon,
@@ -304,7 +312,7 @@ 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.bulkPurchase?.bulkCouponId)
+				const bulkCouponRedemption = Boolean(coupon.maxUses > 1)
 
 				const { user } = await adapter.findOrCreateUser(email)
 
@@ -325,8 +333,18 @@ export function mySqlDrizzleAdapter(
 						productId,
 					})
 
-				if (existingPurchases.length > 0)
-					throw new Error(`already-purchased-${email}`)
+				if (existingPurchases.length > 0) {
+					const errorMessage = `already-purchased-${email}`
+					console.error(errorMessage)
+					return {
+						error: {
+							message: errorMessage,
+						},
+						redeemingForCurrentUser,
+						purchase: null,
+					}
+					throw new Error(errorMessage)
+				}
 
 				const purchaseId = `purchase-${v4()}`
 
@@ -410,7 +428,10 @@ export function mySqlDrizzleAdapter(
 		},
 		getMerchantPriceForProductId: async (productId) => {
 			const merchantPriceData = await client.query.merchantPrice.findFirst({
-				where: eq(merchantPrice.merchantProductId, productId),
+				where: and(
+					eq(merchantPrice.merchantProductId, productId),
+					eq(merchantPrice.status, 1),
+				),
 			})
 
 			const parsedMerchantPrice =
@@ -463,7 +484,7 @@ export function mySqlDrizzleAdapter(
 			)
 
 			if (previousPurchaseProductIds.length > 0) {
-				return await client.query.upgradableProducts.findMany({
+				return client.query.upgradableProducts.findMany({
 					where: and(
 						eq(upgradableProducts.upgradableToId, productId),
 						inArray(
@@ -871,20 +892,21 @@ export function mySqlDrizzleAdapter(
 		},
 		async getCouponWithBulkPurchases(couponId: string): Promise<
 			| (Coupon & {
-					bulkPurchase?: Purchase | null
-					bulkCouponPurchases: { bulkCouponId?: string | null }[]
+					bulkPurchases?: Purchase[] | null
+					redeemedBulkCouponPurchases: { bulkCouponId?: string | null }[]
 			  })
 			| null
 		> {
 			logger.debug('getCouponWithBulkPurchases', { couponId })
 			let couponData
+			let bulkCouponPurchases
 			try {
 				couponData =
 					(await client.query.coupon.findFirst({
 						where: eq(coupon.id, couponId),
 						with: {
-							bulkPurchase: true,
-							bulkCouponPurchases: true,
+							bulkPurchases: true,
+							redeemedBulkCouponPurchases: true,
 						},
 					})) || null
 			} catch (e) {
@@ -892,6 +914,19 @@ export function mySqlDrizzleAdapter(
 				logger.error(e as Error)
 			}
 
+			try {
+				bulkCouponPurchases = await client.query.purchases.findMany({
+					where: eq(purchaseTable.redeemedBulkCouponId, couponId),
+					with: {
+						user: true,
+					},
+				})
+				console.log('purchases with redeemedBulkCouponId', bulkCouponPurchases)
+			} catch (e) {
+				console.log('getCouponWithBulkPurchases')
+				logger.error(e as Error)
+			}
+
 			if (!couponData) {
 				logger.debug('getCouponWithBulkPurchases', {
 					couponId,
@@ -900,20 +935,29 @@ export function mySqlDrizzleAdapter(
 				return null
 			}
 
+			const couponWithBulkPurchases = {
+				...couponData,
+				redeemedBulkCouponPurchases: bulkCouponPurchases || [],
+			}
+
 			const parsedCoupon = couponSchema
 				.merge(
 					z.object({
-						bulkCouponPurchases: z.array(purchaseSchema),
-						bulkPurchase: purchaseSchema.nullable().optional(),
+						redeemedBulkCouponPurchases: z.array(purchaseSchema),
 					}),
 				)
 				.nullable()
-				.safeParse(couponData)
+				.safeParse(couponWithBulkPurchases)
 
 			if (!parsedCoupon.success) {
-				console.error('Error parsing coupon', couponData)
+				console.error(
+					'Error parsing coupon',
+					JSON.stringify(parsedCoupon.error),
+					couponData,
+				)
 				return null
 			}
+
 			return parsedCoupon.data
 		},
 		async getDefaultCoupon(productIds?: string[]): Promise<{
@@ -982,189 +1026,114 @@ export function mySqlDrizzleAdapter(
 		async getModuleProgressForUser(
 			userIdOrEmail: string,
 			moduleIdOrSlug: string,
-		): Promise<ModuleProgress> {
-			const ALLOWED_MODULE_RESOURCE_TYPES = ['lesson', 'exercise', 'solution']
-			const COUNTABLE_MODULE_RESOURCE_TYPES = ['lesson', 'exercise']
-
-			const module = await client.query.contentResource.findFirst({
-				where: or(
-					eq(contentResource.id, moduleIdOrSlug),
-					eq(
-						sql`JSON_EXTRACT (${contentResource.fields}, "$.slug")`,
-						moduleIdOrSlug,
-					),
-				),
-				with: {
-					resources: {
-						with: {
-							resource: {
-								with: {
-									resources: {
-										with: {
-											resource: {
-												with: {
-													resources: {
-														with: {
-															resource: true,
-														},
-													},
-												},
-											},
-										},
-										orderBy: asc(contentResourceResource.position),
-									},
-								},
-							},
-						},
-						orderBy: asc(contentResourceResource.position),
-					},
+		): Promise<ModuleProgress | null> {
+			// First, get the user ID
+			const user = await client.query.users.findFirst({
+				where: or(eq(users.id, userIdOrEmail), eq(users.email, userIdOrEmail)),
+				columns: {
+					id: true,
 				},
 			})
 
-			const parsedModule = ContentResourceSchema.parse(module)
-
-			function flattenResources(
-				resources: ContentResourceResource[],
-			): ContentResource[] {
-				const result: ContentResource[] = []
-
-				function recurse(resources: ContentResourceResource[]) {
-					for (const nestedResource of resources) {
-						const resource = nestedResource.resource
-						result.push(resource)
-						if (resource.resources) {
-							recurse(resource.resources)
-						}
-					}
-				}
-
-				recurse(resources)
-				return result
+			if (!user) {
+				return null
 			}
 
-			const allResources =
-				parsedModule?.resources && flattenResources(parsedModule.resources)
-			const filteredResources = allResources?.filter((resource) => {
-				return ALLOWED_MODULE_RESOURCE_TYPES.includes(resource.type)
+			const ResultRowSchema = z.object({
+				resource_id: z.string(),
+				resource_type: z.enum(['lesson', 'exercise']),
+				resource_slug: z.string().nullable(),
+				completed_at: z
+					.string()
+					.nullable()
+					.transform((val) => (val ? new Date(val) : null)),
 			})
 
-			const parsedResources = z
-				.array(ContentResourceSchema)
-				.safeParse(filteredResources)
-
-			if (!parsedResources.success) {
-				console.error('Error parsing module resources', parsedResources.error)
+			// Execute the optimized query
+			const results: any = await client.execute(sql`
+        SELECT
+						cr.id AS resource_id,
+						cr.type AS resource_type,
+						cr.fields->>'$.slug' AS resource_slug,
+						rp.completedAt AS completed_at
+				FROM
+						(SELECT id, fields->>'$.slug' AS slug
+						 FROM ${contentResource}
+						 WHERE id = ${moduleIdOrSlug}
+								OR fields->>'$.slug' = ${moduleIdOrSlug}) AS w
+				LEFT JOIN
+						(SELECT
+								crr.resourceOfId AS workshop_id,
+								crr.resourceId,
+								crr.position
+						 FROM ${contentResourceResource} crr) AS tlr ON w.id = tlr.workshop_id
+				LEFT JOIN ${contentResource} sections ON sections.id = tlr.resourceId AND sections.type = 'section'
+				LEFT JOIN
+						(SELECT
+								crr.resourceOfId AS section_id,
+								crr.resourceId AS resource_id,
+								crr.position AS position_in_section,
+								section_crr.position AS section_position
+						 FROM ${contentResourceResource} crr
+						 JOIN ${contentResourceResource} section_crr ON crr.resourceOfId = section_crr.resourceId) AS sr
+				ON sr.section_id = sections.id
+				JOIN ${contentResource} cr ON cr.id = COALESCE(sr.resource_id, tlr.resourceId)
+				LEFT JOIN ${resourceProgress} rp ON rp.resourceId = cr.id
+						AND rp.userId = ${user.id}
+				WHERE
+						cr.type IN ('lesson', 'exercise')
+
+    `)
+
+			// Process the results
+			const completedLessons: ResourceProgress[] = []
+			let nextResource: Partial<ContentResource> | null = null
+			let completedLessonsCount = 0
+			let totalLessonsCount = results.rows.length
+
+			const parsedRows = z.array(ResultRowSchema).safeParse(results.rows)
+
+			if (!parsedRows.success) {
+				console.error('Error parsing rows', parsedRows.error)
 				return {
 					completedLessons: [],
 					nextResource: null,
 					percentCompleted: 0,
 					completedLessonsCount: 0,
-					totalLessonsCount: 0,
+					totalLessonsCount,
 				}
 			}
 
-			const progressResources = parsedResources.data.filter((r) => {
-				return COUNTABLE_MODULE_RESOURCE_TYPES.includes(r.type)
-			})
-
-			const totalLessonsCount = progressResources.length
-
-			const user = await client.query.users
-				.findFirst({
-					where: or(
-						eq(users.id, userIdOrEmail),
-						eq(users.email, userIdOrEmail),
-					),
-					with: {
-						roles: {
-							with: {
-								role: true,
-							},
+			for (const row of parsedRows.data) {
+				if (row.completed_at) {
+					completedLessonsCount++
+					completedLessons.push({
+						userId: user.id as string,
+						resourceId: row.resource_id,
+						completedAt: new Date(row.completed_at),
+						// Add other fields as needed
+					})
+				} else if (!nextResource) {
+					nextResource = {
+						id: row.resource_id,
+						type: row.resource_type,
+						fields: {
+							slug: row.resource_slug,
 						},
-					},
-				})
-				.then(async (res) => {
-					if (res) {
-						return {
-							...res,
-							roles: res.roles.map((r) => r.role),
-						}
 					}
-				})
-
-			if (!user) {
-				console.error('User not found', userIdOrEmail)
-				return {
-					completedLessons: [],
-					nextResource: null,
-					percentCompleted: 0,
-					completedLessonsCount: 0,
-					totalLessonsCount,
-				}
-			}
-
-			const parsedUser = userSchema.safeParse(user)
-
-			if (!parsedUser.success) {
-				console.error('Error parsing user', parsedUser.error)
-				return {
-					completedLessons: [],
-					nextResource: null,
-					percentCompleted: 0,
-					completedLessonsCount: 0,
-					totalLessonsCount,
 				}
 			}
 
-			const userProgress = await client.query.resourceProgress.findMany({
-				where: and(
-					eq(resourceProgress.userId, parsedUser.data.id),
-					isNotNull(resourceProgress.completedAt),
-					inArray(
-						resourceProgress.resourceId,
-						progressResources.map((r) => r.id),
-					),
-				),
-				orderBy: asc(resourceProgress.completedAt),
-			})
-
-			const nextResourceId = parsedResources.data
-				.filter((r) => {
-					return COUNTABLE_MODULE_RESOURCE_TYPES.includes(r.type)
-				})
-				.find((r) => !userProgress.find((p) => p.resourceId === r.id))?.id
-
-			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,
-				}
-			}
-			const percentCompleted = Math.round(
-				(parsedProgress.data.length / parsedResources.data.length) * 100,
-			)
+			const percentCompleted =
+				totalLessonsCount > 0
+					? Math.ceil((completedLessonsCount / totalLessonsCount) * 100)
+					: 0
 
 			return {
-				completedLessons: parsedProgress.data,
-				nextResource: parsedNextResource,
+				completedLessons,
+				nextResource,
 				percentCompleted,
-				completedLessonsCount: parsedProgress.data.length,
+				completedLessonsCount,
 				totalLessonsCount,
 			}
 		},
@@ -1179,7 +1148,7 @@ export function mySqlDrizzleAdapter(
 			})
 			const parsed = merchantChargeSchema.safeParse(mCharge)
 			if (!parsed.success) {
-				console.error('Error parsing merchantCharge', mCharge)
+				console.info('Error parsing merchantCharge', mCharge)
 				return null
 			}
 			return parsed.data
@@ -1258,12 +1227,356 @@ export function mySqlDrizzleAdapter(
 				}),
 			)
 		},
-		async getProduct(productId: string): Promise<Product | null> {
-			return productSchema.nullable().parse(
-				await client.query.products.findFirst({
-					where: eq(products.id, productId),
+		async archiveProduct(productId) {
+			if (!paymentProvider) throw new Error('Payment provider not found')
+			const product = await adapter.getProduct(productId)
+
+			if (!product) {
+				throw new Error(`Product not found for id (${productId})`)
+			}
+
+			if (!product.price) {
+				throw new Error(`Product has no price`)
+			}
+
+			await client
+				.update(products)
+				.set({ status: 0, name: `${product.name} (Archived)` })
+				.where(eq(products.id, productId))
+
+			await client
+				.update(prices)
+				.set({ status: 0, nickname: `${product.name} (Archived)` })
+				.where(eq(prices.productId, productId))
+
+			await client
+				.update(merchantProduct)
+				.set({ status: 0 })
+				.where(eq(merchantProduct.productId, productId))
+
+			await client
+				.update(merchantPrice)
+				.set({ status: 0 })
+				.where(eq(merchantPrice.priceId, product.price.id))
+
+			const currentMerchantProduct = merchantProductSchema.nullish().parse(
+				await client.query.merchantProduct.findFirst({
+					where: eq(merchantProduct.productId, productId),
+				}),
+			)
+
+			if (!currentMerchantProduct || !currentMerchantProduct.identifier) {
+				throw new Error(`Merchant product not found for id (${productId})`)
+			}
+
+			await paymentProvider.updateProduct(currentMerchantProduct.identifier, {
+				active: false,
+			})
+
+			const currentMerchantPrice = merchantPriceSchema.nullish().parse(
+				await client.query.merchantPrice.findFirst({
+					where: and(
+						eq(merchantPrice.priceId, product.price.id),
+						eq(merchantPrice.status, 1),
+					),
+				}),
+			)
+
+			if (!currentMerchantPrice || !currentMerchantPrice.identifier) {
+				throw new Error(`Merchant price not found for id (${productId})`)
+			}
+
+			await paymentProvider.updatePrice(currentMerchantPrice.identifier, {
+				active: false,
+			})
+
+			return adapter.getProduct(productId)
+		},
+		async updateProduct(input: Product) {
+			if (!paymentProvider) throw new Error('Payment provider not found')
+			const currentProduct = await adapter.getProduct(input.id)
+			if (!currentProduct) {
+				throw new Error(`Product not found`)
+			}
+			if (!currentProduct.price) {
+				throw new Error(`Product has no price`)
+			}
+
+			const merchantProduct = merchantProductSchema.nullish().parse(
+				await client.query.merchantProduct.findFirst({
+					where: (merchantProduct, { eq }) =>
+						eq(merchantProduct.productId, input.id),
+				}),
+			)
+
+			if (!merchantProduct || !merchantProduct.identifier) {
+				throw new Error(`Merchant product not found`)
+			}
+
+			// TODO: handle upgrades
+
+			const stripeProduct = await paymentProvider.getProduct(
+				merchantProduct.identifier,
+			)
+
+			const priceChanged =
+				currentProduct.price.unitAmount.toString() !==
+				input.price?.unitAmount.toString()
+
+			if (priceChanged) {
+				const currentMerchantPrice = merchantPriceSchema.nullish().parse(
+					await client.query.merchantPrice.findFirst({
+						where: (merchantPrice, { eq, and }) =>
+							and(
+								eq(merchantPrice.merchantProductId, merchantProduct.id),
+								eq(merchantPrice.status, 1),
+							),
+					}),
+				)
+
+				if (!currentMerchantPrice || !currentMerchantPrice.identifier) {
+					throw new Error(`Merchant price not found`)
+				}
+
+				const currentStripePrice = await paymentProvider.getPrice(
+					currentMerchantPrice.identifier,
+				)
+
+				const newStripePrice = await paymentProvider.createPrice({
+					product: stripeProduct.id,
+					unit_amount: Math.floor(Number(input.price?.unitAmount || 0) * 100),
+					currency: 'usd',
+					metadata: {
+						slug: input.fields.slug,
+					},
+					active: true,
+				})
+
+				await paymentProvider.updateProduct(stripeProduct.id, {
+					default_price: newStripePrice.id,
+				})
+
+				const newMerchantPriceId = `mprice_${v4()}`
+				await client.insert(merchantPrice).values({
+					id: newMerchantPriceId,
+					merchantProductId: merchantProduct.id,
+					merchantAccountId: merchantProduct.merchantAccountId,
+					priceId: currentProduct.price.id,
+					status: 1,
+					identifier: newStripePrice.id,
+				})
+
+				if (currentMerchantPrice) {
+					await client
+						.update(merchantPrice)
+						.set({
+							status: 0,
+						})
+						.where(eq(merchantPrice.id, currentMerchantPrice.id))
+				}
+
+				await client
+					.update(prices)
+					.set({
+						unitAmount: Math.floor(
+							Number(input.price?.unitAmount || 0),
+						).toString(),
+						nickname: input.name,
+					})
+					.where(eq(prices.id, currentProduct.price.id))
+
+				if (currentStripePrice) {
+					await paymentProvider.updatePrice(currentStripePrice.id, {
+						active: false,
+					})
+				}
+			}
+
+			await paymentProvider.updateProduct(stripeProduct.id, {
+				name: input.name,
+				active: true,
+				images: input.fields.image?.url ? [input.fields.image.url] : undefined,
+				description: input.fields.description || '',
+				metadata: {
+					slug: input.fields.slug,
+				},
+			})
+
+			const { image, ...fieldsNoImage } = input.fields
+
+			await client
+				.update(products)
+				.set({
+					name: input.name,
+					quantityAvailable: input.quantityAvailable,
+					status: 1,
+					fields: {
+						...fieldsNoImage,
+						...(image?.url && { image }),
+					},
+				})
+				.where(eq(products.id, currentProduct.id))
+
+			return adapter.getProduct(currentProduct.id)
+		},
+		async createProduct(input: NewProduct) {
+			if (!paymentProvider) throw new Error('Payment provider not found')
+			const merchantAccount = merchantAccountSchema.nullish().parse(
+				await client.query.merchantAccount.findFirst({
+					where: (merchantAccount, { eq }) =>
+						eq(merchantAccount.label, 'stripe'),
 				}),
 			)
+
+			if (!merchantAccount) {
+				throw new Error('Merchant account not found')
+			}
+
+			const hash = guid()
+			const newProductId = slugify(`product-${hash}`)
+
+			const newProduct = {
+				id: newProductId,
+				name: input.name,
+				status: 1,
+				type: 'self-paced',
+				quantityAvailable: input.quantityAvailable,
+				fields: {
+					state: 'draft',
+					visibility: 'unlisted',
+					slug: slugify(`${input.name}-${hash}`),
+				},
+			}
+
+			await client.insert(products).values(newProduct)
+
+			const priceHash = guid()
+			const newPriceId = `price-${priceHash}`
+
+			await client.insert(prices).values({
+				id: newPriceId,
+				productId: newProductId,
+				unitAmount: input.price.toString(),
+				status: 1,
+			})
+
+			const product = await adapter.getProduct(newProductId)
+
+			const stripeProduct = await paymentProvider.createProduct({
+				name: input.name,
+				metadata: {
+					slug: product?.fields?.slug || null,
+				},
+			})
+
+			const stripePrice = await paymentProvider.createPrice({
+				product: stripeProduct.id,
+				unit_amount: Math.floor(Number(input.price) * 100),
+				currency: 'usd',
+				nickname: input.name,
+				metadata: {
+					slug: product?.fields?.slug || null,
+				},
+			})
+
+			const newMerchantProductId = `mproduct_${v4()}`
+
+			await client.insert(merchantProduct).values({
+				id: newMerchantProductId,
+				merchantAccountId: merchantAccount.id,
+				productId: newProductId,
+				identifier: stripeProduct.id,
+				status: 1,
+			})
+
+			const newMerchantPriceId = `mprice_${v4()}`
+			await client.insert(merchantPrice).values({
+				id: newMerchantPriceId,
+				merchantAccountId: merchantAccount.id,
+				merchantProductId: newMerchantProductId,
+				priceId: newPriceId,
+				identifier: stripePrice.id,
+				status: 1,
+			})
+
+			// TODO: handle upgrades
+
+			return product
+		},
+		async getProduct(
+			productSlugOrId?: string,
+			withResources: boolean = true,
+		): Promise<Product | null> {
+			if (!productSlugOrId) {
+				return null
+			}
+
+			try {
+				const productData = await client.query.products.findFirst({
+					where: and(
+						or(
+							eq(
+								sql`JSON_EXTRACT (${products.fields}, "$.slug")`,
+								`${productSlugOrId}`,
+							),
+							eq(products.id, productSlugOrId),
+						),
+					),
+					with: {
+						price: true,
+						...(withResources && {
+							resources: {
+								with: {
+									resource: {
+										with: {
+											resources: true,
+										},
+									},
+								},
+							},
+						}),
+					},
+				})
+				const parsedProduct = productSchema.safeParse(productData)
+				if (!parsedProduct.success) {
+					console.error(
+						'Error parsing product',
+						JSON.stringify(parsedProduct.error),
+						JSON.stringify(productData),
+					)
+					return null
+				}
+				return parsedProduct.data
+			} catch (e) {
+				console.log('getProduct error', e)
+				return null
+			}
+		},
+		async getProductResources(
+			productId: string,
+		): Promise<ContentResource[] | null> {
+			const contentResourceProductsForProduct = z
+				.array(ContentResourceProductSchema)
+				.nullable()
+				.parse(
+					await client.query.contentResourceProduct.findMany({
+						where: eq(contentResourceProduct.productId, productId),
+					}),
+				)
+
+			if (!contentResourceProductsForProduct) {
+				return null
+			} else {
+				const contentResources = z.array(ContentResourceSchema).parse(
+					await client.query.contentResource.findMany({
+						where: inArray(
+							contentResource.id,
+							contentResourceProductsForProduct.map((crp) => crp.resourceId),
+						),
+					}),
+				)
+				return contentResources
+			}
 		},
 		async getPurchaseCountForProduct(productId: string): Promise<number> {
 			return await client.query.purchases
@@ -1306,7 +1619,11 @@ export function mySqlDrizzleAdapter(
 			)
 
 			if (!chargeForPurchase) {
-				logger.error(new Error('No charge found for purchase'))
+				logger.error(
+					new Error(
+						`No charge found for purchase: Stripe Charge ID: ${stripeChargeId}`,
+					),
+				)
 				return null
 			}
 
@@ -1516,6 +1833,34 @@ export function mySqlDrizzleAdapter(
 				purchase: parsedPurchase.data,
 			}
 		},
+		async getUserWithPurchasersByEmail(email: string): Promise<any | null> {
+			const user = await client.query.users.findFirst({
+				where: eq(users.email, email.trim().toLowerCase()),
+				with: {
+					// merchantCustomer: true,
+					roles: {
+						with: {
+							role: true,
+						},
+					},
+					purchases: {
+						with: {
+							bulkCoupon: true,
+							merchantCharge: true,
+							product: {
+								columns: {
+									id: true,
+									name: true,
+									key: true,
+								},
+							},
+						},
+					},
+				},
+			})
+
+			return user
+		},
 		async getUserById(userId: string): Promise<User | null> {
 			const user = await client.query.users
 				.findFirst({
@@ -1638,11 +1983,56 @@ export function mySqlDrizzleAdapter(
 		}): Promise<unknown> {
 			throw new Error('Method not implemented.')
 		},
-		updatePurchaseStatusForCharge(
+		async updatePurchaseStatusForCharge(
 			chargeId: string,
 			status: 'Valid' | 'Refunded' | 'Disputed' | 'Banned' | 'Restricted',
 		): Promise<Purchase | undefined> {
-			throw new Error('updatePurchaseStatusForCharge Method not implemented.')
+			try {
+				console.log('updatePurchaseStatusForCharge', { chargeId, status })
+				const merchantChargeForPurchase =
+					await client.query.merchantCharge.findFirst({
+						where: or(
+							eq(merchantCharge.identifier, chargeId),
+							eq(merchantCharge.id, chargeId),
+						),
+					})
+
+				console.log('merchantChargeForPurchase', { merchantChargeForPurchase })
+
+				const parsedMerchantChargeForPurchase = merchantChargeSchema.parse(
+					merchantChargeForPurchase,
+				)
+
+				if (!parsedMerchantChargeForPurchase)
+					throw new Error(`no-charge-found-for-purchase ${chargeId}`)
+
+				const purchase = await client.query.purchases.findFirst({
+					where: eq(
+						purchaseTable.merchantChargeId,
+						parsedMerchantChargeForPurchase.id,
+					),
+				})
+
+				const parsedPurchase = purchaseSchema.nullable().parse(purchase)
+
+				if (parsedPurchase) {
+					await client
+						.update(purchaseTable)
+						.set({ status: status })
+						.where(eq(purchaseTable.id, parsedPurchase.id))
+
+					const newPurchase = await client.query.purchases.findFirst({
+						where: eq(purchaseTable.id, parsedPurchase.id),
+					})
+
+					return purchaseSchema.optional().parse(newPurchase)
+				} else {
+					throw new Error(`no-purchase-found-for-charge ${chargeId}`)
+				}
+			} catch (e) {
+				console.log('error updating purchase status', e)
+				throw e
+			}
 		},
 		async updatePurchaseUserTransferTransferState(options: {
 			id: string
@@ -1706,6 +2096,35 @@ export function mySqlDrizzleAdapter(
 
 			return parsedResourceJoin.data
 		},
+		async removeResourceFromResource(options) {
+			const { childResourceId, parentResourceId } = options
+
+			const resourceJoin = await client.query.contentResourceResource.findFirst(
+				{
+					where: and(
+						eq(contentResourceResource.resourceOfId, parentResourceId),
+						eq(contentResourceResource.resourceId, childResourceId),
+					),
+				},
+			)
+
+			const parsedResourceJoin =
+				ContentResourceResourceSchema.safeParse(resourceJoin)
+			if (!parsedResourceJoin.success) {
+				return null
+			}
+
+			await client
+				.delete(contentResourceResource)
+				.where(
+					and(
+						eq(contentResourceResource.resourceOfId, parentResourceId),
+						eq(contentResourceResource.resourceId, childResourceId),
+					),
+				)
+
+			return parsedResourceJoin.data.resource
+		},
 		async updateContentResourceFields(options) {
 			if (!options.id) {
 				throw new Error('No content resource id.')