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

package/src/lib/mysql/workflows/create-merchant-charge-and-purchase.ts

@@ -0,0 +1,365 @@
+import { and, eq, inArray } from 'drizzle-orm'
+import { v4 } from 'uuid'
+
+import type { PurchasePort } from '@coursebuilder/core/ports'
+import {
+	parseAndExpandPurchaseBenefitTransport,
+	PURCHASE_BENEFIT_METADATA_KEY,
+} from '@coursebuilder/commerce/purchase-benefit-transport'
+import {
+	couponSchema,
+	merchantChargeSchema,
+	merchantCouponSchema,
+	purchaseSchema,
+	type Purchase,
+} from '@coursebuilder/core/schemas'
+import { logger as baseLogger } from '@coursebuilder/utils/logger'
+
+import type { MySqlContext } from '../context.js'
+
+function toError(error: unknown) {
+	return error instanceof Error ? error : new Error(String(error))
+}
+
+const logger = baseLogger as unknown as {
+	error: (error: Error, attrs?: Record<string, unknown>) => void
+	info: (message: string, attrs?: Record<string, unknown>) => void
+}
+
+type PurchaseBenefitExpansion = ReturnType<
+	typeof parseAndExpandPurchaseBenefitTransport
+> | null
+
+function mergePurchaseBenefitFields(
+	fields: Record<string, any>,
+	expansion: PurchaseBenefitExpansion,
+) {
+	if (!expansion) return fields
+
+	return {
+		...fields,
+		...(expansion.success
+			? { purchaseBenefits: expansion.benefits }
+			: { purchaseBenefitsReview: expansion.review }),
+	}
+}
+
+/**
+ * Creates the private merchant charge and purchase workflow.
+ *
+ * @param context - The shared MySQL client and table set.
+ * @returns The purchase-owned merchant charge creation operation.
+ *
+ * @example
+ * ```ts
+ * const workflow = createMerchantChargeAndPurchaseWorkflow(context)
+ * ```
+ */
+export function createMerchantChargeAndPurchaseWorkflow({
+	client,
+	tables,
+}: MySqlContext): Pick<PurchasePort, 'createMerchantChargeAndPurchase'> {
+	const {
+		purchases: purchaseTable,
+		purchaseUserTransfer,
+		coupon,
+		merchantCoupon,
+		merchantCharge,
+		merchantSession,
+	} = tables
+
+	return {
+		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,
+						organizationId,
+						attributionSnapshot,
+					} = options
+
+					const existingMerchantCharge = merchantChargeSchema.nullable().parse(
+						(await trx.query.merchantCharge.findFirst({
+							where: eq(merchantCharge.identifier, stripeChargeId),
+						})) || null,
+					)
+
+					const existingPurchaseForCharge = existingMerchantCharge
+						? await trx.query.purchases.findFirst({
+								where: eq(
+									purchaseTable.merchantChargeId,
+									existingMerchantCharge.id,
+								),
+								with: {
+									user: true,
+									product: true,
+									bulkCoupon: true,
+								},
+							})
+						: null
+
+					if (existingPurchaseForCharge) {
+						return existingPurchaseForCharge.id
+					}
+
+					const merchantChargeId = `mc_${v4()}`
+					const purchaseId = `purch_${v4()}`
+
+					const newMerchantCharge = await trx.insert(merchantCharge).values({
+						id: merchantChargeId,
+						userId,
+						identifier: stripeChargeId,
+						merchantAccountId,
+						merchantProductId,
+						merchantCustomerId,
+					})
+
+					const existingPurchase = purchaseSchema.nullable().parse(
+						(await trx.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 trx
+							.select()
+							.from(coupon)
+							.leftJoin(
+								purchaseTable,
+								and(
+									eq(coupon.id, purchaseTable.bulkCouponId),
+									eq(purchaseTable.userId, userId),
+								),
+							)
+							.where(
+								and(
+									eq(coupon.restrictedToProductId, productId),
+									eq(purchaseTable.userId, userId),
+									eq(purchaseTable.status, 'Valid'),
+								),
+							)
+							.then((res) => {
+								return res[0]?.Coupon ?? null
+							}),
+					)
+
+					const isBulkPurchase =
+						quantity > 1 || Boolean(existingBulkCoupon) || Boolean(options.bulk)
+
+					let bulkCouponId: string | null = null
+					let couponToUpdate = null
+					const purchaseBenefitsTransport =
+						options.purchaseBenefitsTransport?.trim() || undefined
+					const purchaseBenefitExpansion = purchaseBenefitsTransport
+						? parseAndExpandPurchaseBenefitTransport({
+								transport: purchaseBenefitsTransport,
+								appliesTo: isBulkPurchase ? 'redeemed_team_seat' : 'buyer',
+							})
+						: null
+
+					if (purchaseBenefitExpansion && !purchaseBenefitExpansion.success) {
+						logger.info('purchase_benefits.transport.needs_review', {
+							checkoutSessionId,
+							event: 'purchase_benefits.transport.needs_review',
+							metadataKey: PURCHASE_BENEFIT_METADATA_KEY,
+							productId,
+							stripeChargeId,
+							userId,
+							errors: purchaseBenefitExpansion.review.errors,
+						})
+					}
+
+					if (isBulkPurchase) {
+						bulkCouponId =
+							existingBulkCoupon !== null ? existingBulkCoupon.id : v4()
+
+						if (existingBulkCoupon !== null) {
+							const existingCouponFields = existingBulkCoupon.fields ?? {}
+							couponToUpdate = await trx
+								.update(coupon)
+								.set({
+									maxUses: (existingBulkCoupon?.maxUses || 0) + quantity,
+									fields: mergePurchaseBenefitFields(
+										existingCouponFields,
+										purchaseBenefitExpansion,
+									),
+									...(organizationId ? { organizationId } : {}),
+								})
+								.where(eq(coupon.id, bulkCouponId as string))
+						} else {
+							// Try to find merchant coupon by stripeCouponId first
+							let merchantCouponToUse = stripeCouponId
+								? merchantCouponSchema.nullable().parse(
+										(await trx.query.merchantCoupon.findFirst({
+											where: eq(merchantCoupon.identifier, stripeCouponId),
+										})) || null,
+									)
+								: null
+
+							// Fallback: If not found, try to find via usedCouponId from checkout session metadata
+							if (!merchantCouponToUse && usedCouponId) {
+								// First get the coupon record to find its merchantCouponId
+								const usedCoupon = couponSchema.nullable().parse(
+									(await trx.query.coupon.findFirst({
+										where: eq(coupon.id, usedCouponId),
+									})) || null,
+								)
+
+								// Then get the merchant coupon
+								if (usedCoupon?.merchantCouponId) {
+									merchantCouponToUse = merchantCouponSchema.nullable().parse(
+										(await trx.query.merchantCoupon.findFirst({
+											where: eq(merchantCoupon.id, usedCoupon.merchantCouponId),
+										})) || null,
+									)
+								}
+							}
+
+							const bulkCouponValues = {
+								id: bulkCouponId as string,
+								percentageDiscount: '1.0',
+								restrictedToProductId: productId,
+								maxUses: quantity,
+								status: 1,
+								fields: mergePurchaseBenefitFields(
+									{},
+									purchaseBenefitExpansion,
+								),
+								...(organizationId ? { organizationId } : {}),
+								...(merchantCouponToUse
+									? {
+											merchantCouponId: merchantCouponToUse.id,
+										}
+									: {}),
+							}
+
+							couponToUpdate = await trx.insert(coupon).values(bulkCouponValues)
+						}
+					}
+
+					// create a new merchant session
+					const merchantSessionId = `ms_${v4()}`
+
+					await trx.insert(merchantSession).values({
+						id: merchantSessionId,
+						identifier: checkoutSessionId,
+						merchantAccountId,
+					})
+
+					const merchantCouponUsed = stripeCouponId
+						? await trx.query.merchantCoupon.findFirst({
+								where: eq(merchantCoupon.identifier, stripeCouponId),
+							})
+						: null
+
+					const pppMerchantCoupon = appliedPPPStripeCouponId
+						? await trx.query.merchantCoupon.findFirst({
+								where: and(
+									eq(merchantCoupon.identifier, appliedPPPStripeCouponId),
+									eq(merchantCoupon.type, 'ppp'),
+								),
+							})
+						: null
+
+					const newPurchaseStatus =
+						merchantCouponUsed?.type === 'ppp' || pppMerchantCoupon
+							? 'Restricted'
+							: 'Valid'
+
+					await trx.insert(purchaseTable).values({
+						id: purchaseId,
+						status: newPurchaseStatus,
+						userId,
+						productId,
+						merchantChargeId,
+						totalAmount: (stripeChargeAmount / 100).toFixed(),
+						bulkCouponId,
+						merchantSessionId,
+						country,
+						fields: {
+							...(!isBulkPurchase
+								? mergePurchaseBenefitFields({}, purchaseBenefitExpansion)
+								: {}),
+							...(attributionSnapshot
+								? { attribution: attributionSnapshot }
+								: {}),
+						},
+						upgradedFromId: upgradedFromPurchaseId || null,
+						couponId: usedCouponId || null,
+						...(organizationId ? { organizationId } : {}),
+					})
+
+					const oneWeekInMilliseconds = 1000 * 60 * 60 * 24 * 7
+
+					await trx.insert(purchaseUserTransfer).values({
+						id: `put_${v4()}`,
+						purchaseId: purchaseId as string,
+						expiresAt: existingPurchase
+							? new Date()
+							: new Date(Date.now() + oneWeekInMilliseconds),
+						sourceUserId: userId,
+						...(organizationId ? { organizationId } : {}),
+					})
+
+					// const result = await Promise.all([
+					// 	newMerchantCharge,
+					// 	newPurchase,
+					// 	newPurchaseUserTransfer,
+					// 	newMerchantSession,
+					// 	...(couponToUpdate ? [couponToUpdate] : []),
+					// ])
+					//
+					// console.log('result', { result })
+
+					return purchaseId
+				} catch (error) {
+					logger.error(toError(error), {
+						checkoutSessionId: options.checkoutSessionId,
+						event: 'adapter.purchase.create.failed',
+						organizationId: options.organizationId,
+						productId: options.productId,
+						stripeChargeId: options.stripeChargeId,
+						userId: options.userId,
+					})
+					trx.rollback()
+					throw error
+				}
+			})
+
+			const parsedPurchase = purchaseSchema.safeParse(
+				await client.query.purchases.findFirst({
+					where: eq(purchaseTable.id, purchaseId as string),
+				}),
+			)
+
+			if (!parsedPurchase.success) {
+				logger.error(parsedPurchase.error, {
+					event: 'adapter.purchase.parse_failed',
+					productId: options.productId,
+					purchaseId: purchaseId as string,
+					userId: options.userId,
+				})
+				throw new Error('Error parsing purchase')
+			}
+
+			return parsedPurchase.data
+		},
+	}
+}