@coursebuilder/adapter-drizzle 2.1.0 → 3.0.0-canary.0.0c9beb2ae

package/src/lib/mysql/ports/purchase.ts

@@ -0,0 +1,517 @@
+import { and, asc, eq, inArray, isNull, not, or } from 'drizzle-orm'
+import { v4 } from 'uuid'
+import { z } from 'zod'
+
+import type { PurchasePort } from '@coursebuilder/core/ports'
+import {
+	merchantChargeSchema,
+	purchaseSchema,
+	purchaseUserTransferSchema,
+	upgradableProductSchema,
+	userSchema,
+	type Purchase,
+	type PurchaseUserTransfer,
+	type PurchaseUserTransferState,
+	type UpgradableProduct,
+	type User,
+} from '@coursebuilder/core/schemas'
+import { logger as baseLogger } from '@coursebuilder/utils/logger'
+
+import type { MySqlContext } from '../context.js'
+
+const logger = baseLogger as unknown as {
+	debug: (message: string, attrs?: Record<string, unknown>) => void
+	error: (error: Error, attrs?: Record<string, unknown>) => void
+}
+
+type OrdinaryPurchasePort = Omit<
+	PurchasePort,
+	| 'createMerchantChargeAndPurchase'
+	| 'redeemFullPriceCoupon'
+	| 'transferPurchaseToUser'
+>
+
+function toError(error: unknown): Error {
+	return error instanceof Error ? error : new Error(String(error))
+}
+
+/**
+ * Creates the MySQL implementation of purchase persistence operations.
+ *
+ * @param context - The shared MySQL client and table set.
+ * @returns All fifteen PurchasePort operations.
+ *
+ * @example
+ * ```ts
+ * const purchasePort = createPurchasePort(context)
+ * ```
+ */
+export function createPurchasePort({
+	client,
+	tables,
+}: MySqlContext): OrdinaryPurchasePort {
+	const {
+		purchases: purchaseTable,
+		purchaseUserTransfer,
+		merchantCharge,
+		merchantCustomer,
+		merchantSession,
+		upgradableProducts,
+	} = tables
+
+	const purchasePort: OrdinaryPurchasePort = {
+		createPurchaseTransfer: async (options) => {
+			const id = `put_${v4()}`
+			await client.insert(purchaseUserTransfer).values({
+				id,
+				purchaseId: options.purchaseId,
+				sourceUserId: options.sourceUserId,
+				expiresAt: options.expiresAt,
+			})
+		},
+
+		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)
+		},
+		async getPurchasesForBulkCouponId(
+			bulkCouponId: string,
+		): Promise<(Purchase & { user: User })[]> {
+			return z.array(purchaseSchema.extend({ user: userSchema })).parse(
+				await client.query.purchases.findMany({
+					where: eq(purchaseTable.bulkCouponId, bulkCouponId),
+					with: {
+						user: true,
+					},
+				}),
+			)
+		},
+
+		async getPurchaseCountForProduct(productId: string): Promise<number> {
+			return await client.query.purchases
+				.findMany({
+					where: and(
+						eq(purchaseTable.productId, productId),
+						inArray(purchaseTable.status, ['Valid', 'Restricted']),
+					),
+				})
+				.then((res) => res.length)
+		},
+		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({
+				...options,
+				id: newPurchaseId,
+			})
+
+			const newPurchase = await purchasePort.getPurchase(newPurchaseId)
+
+			return purchaseSchema.parse(newPurchase)
+		},
+
+		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) {
+				// Expected during initial checkout processing — the merchant
+				// charge hasn't been created yet. Also expected when the
+				// payment-status-checker passes a PaymentIntent ID (pi_xxx)
+				// instead of a Charge ID (ch_xxx).
+				logger.debug('getPurchaseForStripeCharge: no matching charge', {
+					stripeChargeId,
+					idPrefix: stripeChargeId?.substring(0, 3),
+				})
+				return null
+			}
+
+			const purchase = purchaseSchema.safeParse(
+				await client.query.purchases.findFirst({
+					where: eq(purchaseTable.merchantChargeId, chargeForPurchase.id),
+					with: {
+						user: true,
+						product: true,
+						bulkCoupon: true,
+					},
+				}),
+			)
+
+			if (!purchase.success) {
+				return null
+			}
+
+			return purchase.data
+		},
+		async getPurchaseByCheckoutSessionId(
+			checkoutSessionId: string,
+		): Promise<Purchase | null> {
+			logger.debug('getPurchaseByCheckoutSessionId', { checkoutSessionId })
+
+			// Find the MerchantSession by its identifier (the Stripe checkout session ID)
+			const session = await client.query.merchantSession.findFirst({
+				where: eq(merchantSession.identifier, checkoutSessionId),
+			})
+
+			if (!session) {
+				logger.debug('getPurchaseByCheckoutSessionId: no matching session', {
+					checkoutSessionId,
+				})
+				return null
+			}
+
+			const purchase = purchaseSchema.safeParse(
+				await client.query.purchases.findFirst({
+					where: eq(purchaseTable.merchantSessionId, String(session.id)),
+					with: {
+						user: true,
+						product: true,
+						bulkCoupon: true,
+					},
+				}),
+			)
+
+			if (!purchase.success) {
+				return null
+			}
+
+			return purchase.data
+		},
+		async getPurchaseUserTransferById(options: { id: string }): Promise<
+			| (PurchaseUserTransfer & {
+					sourceUser: User
+					targetUser: User | null
+					purchase: Purchase
+			  })
+			| null
+		> {
+			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,
+						organizationId: z.string().nullable(),
+					}),
+				)
+				.nullable()
+				.parse(purchaseTransferData)
+		},
+		async getPurchaseWithUser(purchaseId: string): Promise<
+			| (Purchase & {
+					user: User
+			  })
+			| null
+		> {
+			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) {
+				logger.error(parsedPurchase.error, {
+					event: 'adapter.purchase.parse_failed',
+					purchaseId,
+				})
+				return null
+			}
+			return parsedPurchase.data
+		},
+		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.status, visiblePurchaseStates),
+				),
+				with: {
+					user: true,
+					product: true,
+					bulkCoupon: true,
+				},
+				orderBy: asc(purchaseTable.createdAt),
+			})
+
+			const parsedPurchases = z.array(purchaseSchema).safeParse(userPurchases)
+
+			if (!parsedPurchases.success) {
+				logger.error(parsedPurchases.error, {
+					event: 'adapter.purchase.list.parse_failed',
+					purchaseCount: userPurchases.length,
+					userId,
+				})
+				return []
+			}
+
+			return parsedPurchases.data
+		},
+		async getPurchaseDetails(
+			purchaseId: string,
+			userId: string,
+		): Promise<{
+			purchase?: Purchase
+			existingPurchase?: Purchase | 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 : []
+
+			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) {
+				logger.error(parsedPurchase.error, {
+					event: 'adapter.purchase.details.parse_failed',
+					purchaseId,
+					userId,
+				})
+				return {
+					availableUpgrades: [],
+				}
+			}
+
+			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 = 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 {
+				availableUpgrades: z
+					.array(upgradableProductSchema)
+					.parse(availableUpgrades),
+				existingPurchase,
+				purchase: parsedPurchase.data,
+			}
+		},
+
+		async transferPurchasesToNewUser(options: {
+			merchantCustomerId: string
+			userId: string
+		}): Promise<void> {
+			await client.transaction(async (trx) => {
+				const charges = await trx
+					.select({ id: merchantCharge.id })
+					.from(merchantCharge)
+					.where(
+						eq(merchantCharge.merchantCustomerId, options.merchantCustomerId),
+					)
+				const chargeIds = charges.map(({ id }) => id)
+				if (chargeIds.length > 0) {
+					await trx
+						.update(purchaseTable)
+						.set({ userId: options.userId })
+						.where(inArray(purchaseTable.merchantChargeId, chargeIds))
+					await trx
+						.update(merchantCharge)
+						.set({ userId: options.userId })
+						.where(inArray(merchantCharge.id, chargeIds))
+				}
+				await trx
+					.update(merchantCustomer)
+					.set({ userId: options.userId })
+					.where(eq(merchantCustomer.id, options.merchantCustomerId))
+			})
+		},
+		async updatePurchaseStatusForCharge(
+			chargeId: string,
+			status: 'Valid' | 'Refunded' | 'Disputed' | 'Banned' | 'Restricted',
+		): Promise<Purchase | undefined> {
+			try {
+				logger.debug('adapter.purchase.status_update.started', {
+					chargeId,
+					status,
+				})
+				const merchantChargeForPurchase =
+					await client.query.merchantCharge.findFirst({
+						where: or(
+							eq(merchantCharge.identifier, chargeId),
+							eq(merchantCharge.id, chargeId),
+						),
+					})
+
+				logger.debug('adapter.purchase.status_update.charge_resolved', {
+					chargeId,
+					merchantChargeId: merchantChargeForPurchase?.id ?? null,
+					merchantChargeIdentifier:
+						merchantChargeForPurchase?.identifier ?? null,
+				})
+
+				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) {
+				logger.error(toError(e), {
+					chargeId,
+					event: 'adapter.purchase.status_update.failed',
+					status,
+				})
+				throw e
+			}
+		},
+		async updatePurchaseUserTransferTransferState(options: {
+			id: string
+			transferState: PurchaseUserTransferState
+		}): Promise<PurchaseUserTransfer | null> {
+			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)
+		},
+	}
+
+	return purchasePort
+}

package/src/lib/mysql/ports/subscription.ts

@@ -0,0 +1,93 @@
+import { eq } from 'drizzle-orm'
+
+import type { SubscriptionPort } from '@coursebuilder/core/ports'
+import { MerchantSubscriptionSchema } from '@coursebuilder/core/schemas/merchant-subscription'
+import { SubscriptionSchema } from '@coursebuilder/core/schemas/subscription'
+
+import type { MySqlContext } from '../context.js'
+
+/**
+ * Creates the MySQL implementation of product-level subscription operations.
+ *
+ * @param context - The shared MySQL client and table set.
+ * @returns All three SubscriptionPort operations.
+ *
+ * @example
+ * ```ts
+ * const subscriptionPort = createSubscriptionPort(context)
+ * ```
+ */
+export function createSubscriptionPort({
+	client,
+	tables,
+}: MySqlContext): SubscriptionPort {
+	const {
+		merchantSubscription: merchantSubscriptionTable,
+		subscription: subscriptionTable,
+	} = tables
+
+	return {
+		createSubscription: async (options: {
+			organizationId: string
+			merchantSubscriptionId: string
+			productId: string
+		}) => {
+			const id = `sub_${crypto.randomUUID()}`
+			await client.insert(subscriptionTable).values({
+				...options,
+				id,
+			})
+
+			return SubscriptionSchema.parse(
+				await client.query.subscription.findFirst({
+					where: eq(subscriptionTable.id, id),
+					with: {
+						product: true,
+					},
+				}),
+			)
+		},
+		getSubscriptionForStripeId: async (stripeSubscriptionId: string) => {
+			const merchantSubscriptionParsed = MerchantSubscriptionSchema.safeParse(
+				await client.query.merchantSubscription.findFirst({
+					where: eq(merchantSubscriptionTable.identifier, stripeSubscriptionId),
+				}),
+			)
+
+			if (!merchantSubscriptionParsed.success) {
+				throw new Error(
+					`No merchant subscription found for stripe id ${stripeSubscriptionId} ${merchantSubscriptionParsed.error}`,
+				)
+			}
+
+			const subscriptionParsed = SubscriptionSchema.safeParse(
+				await client.query.subscription.findFirst({
+					where: eq(
+						subscriptionTable.merchantSubscriptionId,
+						merchantSubscriptionParsed.data.id,
+					),
+					with: {
+						product: true,
+					},
+				}),
+			)
+
+			if (!subscriptionParsed.success) {
+				throw new Error(
+					`No subscription found for merchant subscription ${merchantSubscriptionParsed.data.id} ${subscriptionParsed.error}`,
+				)
+			}
+
+			return subscriptionParsed.data
+		},
+		updateSubscriptionStatus: async (
+			subscriptionId: string,
+			status: string,
+		) => {
+			await client
+				.update(subscriptionTable)
+				.set({ status })
+				.where(eq(subscriptionTable.id, subscriptionId))
+		},
+	}
+}