@coursebuilder/adapter-drizzle 0.0.6 → 0.1.0

package/src/lib/mysql/index.ts

@@ -1,13 +1,40 @@
 import type { AdapterSession, AdapterUser } from '@auth/core/adapters'
 import { addSeconds, isAfter } from 'date-fns'
-import { and, eq, sql } from 'drizzle-orm'
+import { and, asc, eq, inArray, not, notInArray, or, sql } from 'drizzle-orm'
 import {
 	mysqlTable as defaultMySqlTableFn,
 	MySqlDatabase,
 	MySqlTableFn,
 } from 'drizzle-orm/mysql-core'
+import { v4 } from 'uuid'
+import { z } from 'zod'
 
 import { type CourseBuilderAdapter } from '@coursebuilder/core/adapters'
+import {
+	Coupon,
+	couponSchema,
+	MerchantCharge,
+	merchantChargeSchema,
+	MerchantCoupon,
+	merchantCouponSchema,
+	MerchantCustomer,
+	MerchantProduct,
+	Price,
+	Product,
+	Purchase,
+	purchaseSchema,
+	PurchaseUserTransfer,
+	PurchaseUserTransferState,
+	ResourceProgress,
+	UpgradableProduct,
+	upgradableProductSchema,
+	User,
+	userSchema,
+} from '@coursebuilder/core/schemas'
+import {
+	ContentResourceResourceSchema,
+	ContentResourceSchema,
+} from '@coursebuilder/core/schemas/content-resource-schema'
 import { VideoResourceSchema } from '@coursebuilder/core/schemas/video-resource'
 
 import {
@@ -54,7 +81,14 @@ import { getMerchantSessionSchema } from './schemas/commerce/merchant-session.js
 import { getPriceSchema } from './schemas/commerce/price.js'
 import { getProductSchema } from './schemas/commerce/product.js'
 import { getPurchaseUserTransferSchema } from './schemas/commerce/purchase-user-transfer.js'
-import { getPurchaseSchema } from './schemas/commerce/purchase.js'
+import {
+	getPurchaseRelationsSchema,
+	getPurchaseSchema,
+} from './schemas/commerce/purchase.js'
+import {
+	getUpgradableProductsRelationsSchema,
+	getUpgradableProductsSchema,
+} from './schemas/commerce/upgradable-products.js'
 import { getCommunicationChannelSchema } from './schemas/communication/communication-channel.js'
 import { getCommunicationPreferenceTypesSchema } from './schemas/communication/communication-preference-types.js'
 import {
@@ -106,9 +140,10 @@ export function getCourseBuilderSchema(mysqlTable: MySqlTableFn) {
 		merchantPrice: getMerchantPriceSchema(mysqlTable),
 		merchantProduct: getMerchantProductSchema(mysqlTable),
 		merchantSession: getMerchantSessionSchema(mysqlTable),
-		price: getPriceSchema(mysqlTable),
-		product: getProductSchema(mysqlTable),
-		purchase: getPurchaseSchema(mysqlTable),
+		prices: getPriceSchema(mysqlTable),
+		products: getProductSchema(mysqlTable),
+		purchases: getPurchaseSchema(mysqlTable),
+		purchaseRelations: getPurchaseRelationsSchema(mysqlTable),
 		purchaseUserTransfer: getPurchaseUserTransferSchema(mysqlTable),
 		communicationChannel: getCommunicationChannelSchema(mysqlTable),
 		communicationPreferenceTypes:
@@ -127,6 +162,9 @@ export function getCourseBuilderSchema(mysqlTable: MySqlTableFn) {
 		contributionTypes: getContributionTypesSchema(mysqlTable),
 		contributionTypesRelations: getContributionTypesRelationsSchema(mysqlTable),
 		resourceProgress: getResourceProgressSchema(mysqlTable),
+		upgradableProducts: getUpgradableProductsSchema(mysqlTable),
+		upgradableProductsRelations:
+			getUpgradableProductsRelationsSchema(mysqlTable),
 	} as const
 }
 
@@ -139,7 +177,7 @@ export type DefaultSchema = ReturnType<typeof createTables>
 export function mySqlDrizzleAdapter(
 	client: InstanceType<typeof MySqlDatabase>,
 	tableFn = defaultMySqlTableFn,
-): CourseBuilderAdapter {
+): CourseBuilderAdapter<typeof MySqlDatabase> {
 	const {
 		users,
 		accounts,
@@ -147,7 +185,7 @@ export function mySqlDrizzleAdapter(
 		verificationTokens,
 		contentResource,
 		contentResourceResource,
-		purchase,
+		purchases: purchaseTable,
 		purchaseUserTransfer,
 		coupon,
 		merchantCoupon,
@@ -157,11 +195,551 @@ export function mySqlDrizzleAdapter(
 		merchantCustomer,
 		merchantSession,
 		merchantProduct,
-		price,
-		product,
+		prices,
+		products,
+		upgradableProducts,
 	} = createTables(tableFn)
 
 	return {
+		client,
+		availableUpgradesForProduct(
+			purchases: any,
+			productId: string,
+		): Promise<
+			{
+				upgradableTo: { id: string; name: string }
+				upgradableFrom: { id: string; name: string }
+			}[]
+		> {
+			throw new Error('Method not implemented.')
+		},
+		clearLessonProgressForUser(options: {
+			userId: string
+			lessons: { id: string; slug: string }[]
+		}): Promise<void> {
+			throw new Error('Method not implemented.')
+		},
+		completeLessonProgressForUser(options: {
+			userId: string
+			lessonId?: string
+		}): Promise<ResourceProgress | null> {
+			throw new Error('Method not implemented.')
+		},
+		couponForIdOrCode(options: {
+			code?: string
+			couponId?: string
+		}): Promise<(Coupon & { merchantCoupon: MerchantCoupon }) | null> {
+			throw new Error('Method not implemented.')
+		},
+		async createMerchantChargeAndPurchase(options): Promise<Purchase> {
+			const purchaseId = await client.transaction(async (trx) => {
+				try {
+					const {
+						userId,
+						stripeChargeId,
+						stripeCouponId,
+						merchantAccountId,
+						merchantProductId,
+						merchantCustomerId,
+						productId,
+						stripeChargeAmount,
+						quantity = 1,
+						checkoutSessionId,
+						appliedPPPStripeCouponId,
+						upgradedFromPurchaseId,
+						country,
+						usedCouponId,
+					} = options
+
+					const existingMerchantCharge = merchantChargeSchema.nullable().parse(
+						(await client.query.merchantCharge.findFirst({
+							where: eq(merchantCharge.identifier, stripeChargeId),
+						})) || null,
+					)
+
+					const existingPurchaseForCharge = existingMerchantCharge
+						? await client.query.purchase.findFirst({
+								where: eq(
+									purchaseTable.merchantChargeId,
+									existingMerchantCharge.id,
+								),
+								with: {
+									user: true,
+									product: true,
+									bulkCoupon: true,
+								},
+							})
+						: null
+
+					if (existingPurchaseForCharge) {
+						return purchaseSchema.parse(existingPurchaseForCharge)
+					}
+
+					const merchantChargeId = v4()
+					const purchaseId = v4()
+
+					const newMerchantCharge = trx.insert(merchantCharge).values({
+						id: merchantChargeId,
+						userId,
+						identifier: stripeChargeId,
+						merchantAccountId,
+						merchantProductId,
+						merchantCustomerId,
+					})
+
+					const existingPurchase = purchaseSchema.nullable().parse(
+						(await client.query.purchases.findFirst({
+							where: and(
+								eq(purchaseTable.productId, productId),
+								eq(purchaseTable.userId, userId),
+								inArray(purchaseTable.status, ['Valid', 'Restricted']),
+							),
+						})) || null,
+					)
+
+					const existingBulkCoupon = couponSchema.nullable().parse(
+						await client
+							.select()
+							.from(coupon)
+							.leftJoin(
+								purchaseTable,
+								and(
+									eq(coupon.id, purchaseTable.bulkCouponId),
+									eq(purchaseTable.userId, userId),
+								),
+							)
+							.then((res) => res[0] ?? null),
+					)
+
+					const isBulkPurchase =
+						quantity > 1 ||
+						Boolean(existingBulkCoupon) ||
+						options.bulk ||
+						Boolean(existingPurchase?.status === 'Valid')
+
+					let bulkCouponId: string | null = null
+					let couponToUpdate = null
+
+					if (isBulkPurchase) {
+						bulkCouponId =
+							existingBulkCoupon !== null ? existingBulkCoupon.id : v4()
+
+						if (existingBulkCoupon !== null) {
+							couponToUpdate = trx
+								.update(coupon)
+								.set({
+									maxUses: (existingBulkCoupon?.maxUses || 0) + quantity,
+								})
+								.where(eq(coupon.id, bulkCouponId))
+						} else {
+							const merchantCouponToUse = stripeCouponId
+								? merchantCouponSchema.nullable().parse(
+										await client.query.merchantCoupon.findFirst({
+											where: eq(merchantCoupon.identifier, stripeCouponId),
+										}),
+									)
+								: null
+
+							couponToUpdate = await trx.insert(coupon).values({
+								id: bulkCouponId as string,
+								percentageDiscount: '1.0',
+								restrictedToProductId: productId,
+								maxUses: quantity,
+								status: 1,
+								...(merchantCouponToUse
+									? {
+											merchantCouponId: merchantCouponToUse.id,
+										}
+									: {}),
+							})
+						}
+					}
+
+					const merchantSessionId = v4()
+
+					const newMerchantSession = trx.insert(merchantSession).values({
+						id: merchantSessionId,
+						identifier: checkoutSessionId,
+						merchantAccountId,
+					})
+
+					const merchantCouponUsed = stripeCouponId
+						? await client.query.merchantCoupon.findFirst({
+								where: eq(merchantCoupon.identifier, stripeCouponId),
+							})
+						: null
+
+					const pppMerchantCoupon = appliedPPPStripeCouponId
+						? await client.query.merchantCoupon.findFirst({
+								where: and(
+									eq(merchantCoupon.identifier, appliedPPPStripeCouponId),
+									eq(merchantCoupon.type, 'ppp'),
+								),
+							})
+						: null
+
+					const newPurchaseStatus =
+						merchantCouponUsed?.type === 'ppp' || pppMerchantCoupon
+							? 'Restricted'
+							: 'Valid'
+
+					const newPurchase = trx.insert(purchaseTable).values({
+						id: purchaseId,
+						status: newPurchaseStatus,
+						userId,
+						productId,
+						merchantChargeId,
+						totalAmount: (stripeChargeAmount / 100).toFixed(),
+						bulkCouponId,
+						merchantSessionId,
+						country,
+						upgradedFromId: upgradedFromPurchaseId || null,
+						couponId: usedCouponId || null,
+					})
+
+					const oneWeekInMilliseconds = 1000 * 60 * 60 * 24 * 7
+
+					const newPurchaseUserTransfer = trx
+						.insert(purchaseUserTransfer)
+						.values({
+							id: v4(),
+							purchaseId: purchaseId as string,
+							expiresAt: existingPurchase
+								? new Date()
+								: new Date(Date.now() + oneWeekInMilliseconds),
+							sourceUserId: userId,
+						})
+
+					await Promise.all([
+						newMerchantCharge,
+						newPurchase,
+						newPurchaseUserTransfer,
+						newMerchantSession,
+						...(couponToUpdate ? [couponToUpdate] : []),
+					])
+
+					return purchaseId
+				} catch (error) {
+					console.error(error)
+					trx.rollback()
+					throw error
+				}
+			})
+
+			return purchaseSchema.parse(
+				await client.query.purchases.findFirst({
+					where: eq(purchaseTable.id, purchaseId as string),
+				}),
+			)
+		},
+		findOrCreateMerchantCustomer(options: {
+			user: User
+			identifier: string
+			merchantAccountId: string
+		}): Promise<MerchantCustomer | null> {
+			throw new Error('Method not implemented.')
+		},
+		findOrCreateUser(
+			email: string,
+			name?: string | null,
+		): Promise<{
+			user: User
+			isNewUser: boolean
+		}> {
+			throw new Error('Method not implemented.')
+		},
+		getCoupon(couponIdOrCode: string): Promise<Coupon | null> {
+			throw new Error('Method not implemented.')
+		},
+		getCouponWithBulkPurchases(couponId: string): Promise<
+			| (Coupon & {
+					bulkCouponPurchases: { bulkCouponId: string }[]
+			  })
+			| null
+		> {
+			throw new Error('Method not implemented.')
+		},
+		getDefaultCoupon(productIds?: string[]): Promise<{
+			defaultMerchantCoupon: MerchantCoupon
+			defaultCoupon: Coupon
+		} | null> {
+			throw new Error('Method not implemented.')
+		},
+		getLessonProgressCountsByDate(): Promise<
+			{
+				count: number
+				completedAt: string
+			}[]
+		> {
+			throw new Error('Method not implemented.')
+		},
+		getLessonProgressForUser(userId: string): Promise<ResourceProgress[]> {
+			throw new Error('Method not implemented.')
+		},
+		getLessonProgresses(): Promise<ResourceProgress[]> {
+			throw new Error('Method not implemented.')
+		},
+		getMerchantCharge(
+			merchantChargeId: string,
+		): Promise<MerchantCharge | null> {
+			throw new Error('Method not implemented.')
+		},
+		getMerchantCoupon(
+			merchantCouponId: string,
+		): Promise<MerchantCoupon | null> {
+			throw new Error('Method not implemented.')
+		},
+		getMerchantProduct(
+			stripeProductId: string,
+		): Promise<MerchantProduct | null> {
+			throw new Error('Method not implemented.')
+		},
+		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 getPurchase(purchaseId: string): Promise<Purchase | null> {
+			const purchase = await client.query.purchases.findFirst({
+				where: eq(purchaseTable.id, purchaseId),
+			})
+
+			return purchase ? purchaseSchema.parse(purchase) : null
+		},
+		async createPurchase(options): Promise<Purchase> {
+			const newPurchaseId = options.id || `purchase-${v4()}`
+			await client.insert(purchaseTable).values({
+				state: 'Valid',
+				...options,
+				id: newPurchaseId,
+			})
+
+			const newPurchase = await this.getPurchase(newPurchaseId)
+
+			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> {
+			const purchase = purchaseSchema.safeParse(
+				await client
+					.select()
+					.from(purchaseTable)
+					.leftJoin(
+						merchantCharge,
+						and(
+							eq(merchantCharge.identifier, stripeChargeId),
+							eq(merchantCharge.id, purchaseTable.merchantChargeId),
+						),
+					)
+					.then((res) => res[0] ?? null),
+			)
+
+			if (!purchase.success) {
+				return null
+			}
+
+			return purchase.data
+		},
+		getPurchaseUserTransferById(options: { id: string }): Promise<
+			| (PurchaseUserTransfer & {
+					sourceUser: User
+					targetUser: User | null
+					purchase: Purchase
+			  })
+			| null
+		> {
+			throw new Error('Method not implemented.')
+		},
+		getPurchaseWithUser(purchaseId: string): Promise<
+			| (Purchase & {
+					user: User
+			  })
+			| null
+		> {
+			throw new Error('Method not implemented.')
+		},
+		async getPurchasesForUser(userId?: string): Promise<Purchase[]> {
+			if (!userId) {
+				return []
+			}
+
+			const visiblePurchaseStates = ['Valid', 'Refunded', 'Restricted']
+
+			const userPurchases = await client.query.purchases.findMany({
+				where: and(
+					eq(purchaseTable.userId, userId),
+					inArray(purchaseTable.state, visiblePurchaseStates),
+				),
+				with: {
+					user: true,
+					product: true,
+					bulkCoupon: true,
+				},
+				orderBy: asc(purchaseTable.createdAt),
+			})
+
+			const parsedPurchases = z.array(purchaseSchema).safeParse(userPurchases)
+
+			if (!parsedPurchases.success) {
+				console.error('Error parsing purchases', parsedPurchases)
+				return []
+			}
+
+			return parsedPurchases.data
+		},
+		async getUserById(userId: string): Promise<User | null> {
+			return userSchema.nullable().parse(
+				await client.query.users.findFirst({
+					where: eq(users.id, userId),
+				}),
+			)
+		},
+		pricesOfPurchasesTowardOneBundle(options: {
+			userId: string | undefined
+			bundleId: string
+		}): Promise<Price[]> {
+			throw new Error('Method not implemented.')
+		},
+		toggleLessonProgressForUser(options: {
+			userId: string
+			lessonId?: string
+			lessonSlug?: string
+		}): Promise<ResourceProgress | null> {
+			throw new Error('Method not implemented.')
+		},
+		transferPurchasesToNewUser(options: {
+			merchantCustomerId: string
+			userId: string
+		}): Promise<unknown> {
+			throw new Error('Method not implemented.')
+		},
+		updatePurchaseStatusForCharge(
+			chargeId: string,
+			status: 'Valid' | 'Refunded' | 'Disputed' | 'Banned' | 'Restricted',
+		): Promise<Purchase | undefined> {
+			throw new Error('Method not implemented.')
+		},
+		updatePurchaseUserTransferTransferState(options: {
+			id: string
+			transferState: PurchaseUserTransferState
+		}): Promise<PurchaseUserTransfer | null> {
+			throw new Error('Method not implemented.')
+		},
+		addResourceToResource: async function (options) {
+			const { parentResourceId, childResourceId } = options
+
+			const parentResourceData = await client.query.contentResource.findFirst({
+				where: or(
+					eq(
+						sql`JSON_EXTRACT (${contentResource.fields}, "$.slug")`,
+						parentResourceId,
+					),
+					eq(contentResource.id, parentResourceId),
+				),
+				with: {
+					resources: true,
+				},
+			})
+
+			const parentResource = ContentResourceSchema.parse(parentResourceData)
+
+			await client.insert(contentResourceResource).values({
+				resourceOfId: parentResource.id,
+				resourceId: childResourceId,
+				position: parentResource.resources?.length || 0,
+			})
+
+			const resourceJoin = client.query.contentResourceResource.findFirst({
+				where: and(
+					eq(contentResourceResource.resourceOfId, parentResourceId),
+					eq(contentResourceResource.resourceId, childResourceId),
+				),
+				with: {
+					resource: true,
+				},
+			})
+
+			const parsedResourceJoin =
+				ContentResourceResourceSchema.safeParse(resourceJoin)
+			if (!parsedResourceJoin.success) {
+				return null
+			}
+
+			return parsedResourceJoin.data
+		},
 		async updateContentResourceFields(options) {
 			if (!options.id) {
 				throw new Error('No content resource id.')
@@ -178,11 +756,35 @@ export function mySqlDrizzleAdapter(
 				.set({ fields: { ...currentResource.fields, ...options.fields } })
 				.where(eq(contentResource.id, options.id))
 
-			return await client
-				.select()
-				.from(contentResource)
-				.where(eq(contentResource.id, options.id))
-				.then((res) => res[0])
+			const resource = await client.query.contentResource.findFirst({
+				where: eq(contentResource.id, options.id),
+				with: {
+					resources: {
+						with: {
+							resource: {
+								with: {
+									resources: {
+										with: {
+											resource: true,
+										},
+										orderBy: asc(contentResourceResource.position),
+									},
+								},
+							},
+						},
+						orderBy: asc(contentResourceResource.position),
+					},
+				},
+			})
+
+			const parsedResource = ContentResourceSchema.safeParse(resource)
+
+			if (!parsedResource.success) {
+				console.error('Error parsing resource', resource)
+				return null
+			}
+
+			return parsedResource.data
 		},
 		async getVideoResource(id) {
 			if (!id) {
@@ -214,7 +816,7 @@ export function mySqlDrizzleAdapter(
 				})
 				.catch((error) => {
 					console.error(error)
-					return error
+					throw error
 				})
 		},
 		async createContentResource(data) {
@@ -222,31 +824,83 @@ export function mySqlDrizzleAdapter(
 
 			await client.insert(contentResource).values({ ...data, id })
 
-			return await client
-				.select()
-				.from(contentResource)
-				.where(eq(contentResource.id, id))
-				.then((res) => res[0])
+			const resource = await client.query.contentResource.findFirst({
+				where: eq(contentResource.id, id),
+				with: {
+					resources: {
+						with: {
+							resource: {
+								with: {
+									resources: {
+										with: {
+											resource: true,
+										},
+										orderBy: asc(contentResourceResource.position),
+									},
+								},
+							},
+						},
+						orderBy: asc(contentResourceResource.position),
+					},
+				},
+			})
+
+			const parsedResource = ContentResourceSchema.safeParse(resource)
+
+			if (!parsedResource.success) {
+				console.error('Error parsing resource', resource)
+				throw new Error('Error parsing resource')
+			}
+
+			return parsedResource.data
 		},
 		async getContentResource(data) {
-			return (
-				(await client
-					.select()
-					.from(contentResource)
-					.where(eq(contentResource.id, data))
-					.then((res) => res[0])) ?? null
-			)
+			const resource = await client.query.contentResource.findFirst({
+				where: eq(contentResource.id, data),
+				with: {
+					resources: {
+						with: {
+							resource: {
+								with: {
+									resources: {
+										with: {
+											resource: true,
+										},
+										orderBy: asc(contentResourceResource.position),
+									},
+								},
+							},
+						},
+						orderBy: asc(contentResourceResource.position),
+					},
+				},
+			})
+
+			const parsedResource = ContentResourceSchema.safeParse(resource)
+
+			if (!parsedResource.success) {
+				console.error('Error parsing resource', resource)
+				return null
+			}
+
+			return parsedResource.data
 		},
 		async createUser(data) {
-			const id = crypto.randomUUID()
+			console.log(data)
+			try {
+				const id = crypto.randomUUID()
 
-			await client.insert(users).values({ ...data, id })
+				await client.insert(users).values({ ...data, id })
 
-			return await client
-				.select()
-				.from(users)
-				.where(eq(users.id, id))
-				.then((res) => res[0] as AdapterUser)
+				return await client
+					.select()
+					.from(users)
+					.where(eq(users.id, id))
+					.then((res) => res[0] as AdapterUser)
+			} catch (error) {
+				console.error(error)
+				throw error
+			}
 		},
 		async getUser(data) {
 			return (