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

package/src/lib/mysql/workflows/create-workshop.ts

@@ -0,0 +1,372 @@
+import slugify from '@sindresorhus/slugify'
+import { asc, eq } from 'drizzle-orm'
+
+import type {
+	CatalogPort,
+	ContentResourcePort,
+	CouponPort,
+} from '@coursebuilder/core/ports'
+import {
+	ContentResourceSchema,
+	type ContentResource,
+} from '@coursebuilder/core/schemas/content-resource-schema'
+import { logger as baseLogger } from '@coursebuilder/utils/logger'
+
+import type { MySqlContext } from '../context.js'
+import {
+	guid,
+	normalizeExpirationDate,
+} from './content-resource-workflow-utils.js'
+
+const logger = baseLogger as unknown as {
+	debug: (message: string, attrs?: Record<string, unknown>) => void
+	error: (error: Error, attrs?: Record<string, unknown>) => void
+}
+
+type CreateWorkshopOperations = Pick<CatalogPort, 'createProduct'> &
+	Pick<CouponPort, 'createCoupon'>
+
+/**
+ * Creates the private workshop creation workflow.
+ *
+ * @param context - The shared MySQL client and table set.
+ * @param operations - Narrow catalog, coupon, and content resource operations.
+ * @returns The content resource creation operation.
+ *
+ * @example
+ * ```ts
+ * const workflow = createWorkshopWorkflow(context, operations)
+ * ```
+ */
+export function createWorkshopWorkflow(
+	{ client, tables }: MySqlContext,
+	operations: CreateWorkshopOperations,
+): Pick<ContentResourcePort, 'createWorkshop'> {
+	const {
+		contentResource,
+		contentResourceResource,
+		contentResourceProduct,
+		contentResourceTag,
+	} = tables
+
+	return {
+		async createWorkshop(
+			input: {
+				workshop: {
+					title: string
+					description?: string
+					tagIds?:
+						| { id: string; fields: { label: string; name: string } }[]
+						| null
+				}
+				createProduct?: boolean
+				pricing: {
+					price?: number | null
+					quantity?: number | null
+				}
+				coupon?: {
+					enabled: boolean
+					percentageDiscount?: string
+					expires?: Date
+				}
+				structure: Array<
+					| {
+							type: 'section'
+							title: string
+							lessons: { title: string; videoResourceId?: string }[]
+					  }
+					| { type: 'lesson'; title: string; videoResourceId?: string }
+				>
+			},
+			userId: string,
+		) {
+			const hash = guid()
+			const workshopId = `workshop~${hash}`
+
+			// Transaction only handles database operations
+			const result = await client.transaction(async (tx) => {
+				// Create workshop content resource
+				await tx.insert(contentResource).values({
+					id: workshopId,
+					type: 'workshop',
+					createdById: userId,
+					fields: {
+						title: input.workshop.title,
+						description: input.workshop.description,
+						state: 'draft',
+						visibility: 'unlisted',
+						slug: slugify(`${input.workshop.title}~${hash}`),
+					},
+				})
+
+				// Fetch created workshop
+				const workshop = await tx.query.contentResource.findFirst({
+					where: eq(contentResource.id, workshopId),
+					with: {
+						resources: {
+							with: {
+								resource: {
+									with: {
+										resources: {
+											with: {
+												resource: true,
+											},
+											orderBy: asc(contentResourceResource.position),
+										},
+									},
+								},
+							},
+							orderBy: asc(contentResourceResource.position),
+						},
+					},
+				})
+
+				if (!workshop) {
+					throw new Error('Failed to create workshop')
+				}
+
+				const parsedWorkshop = ContentResourceSchema.safeParse(workshop)
+				if (!parsedWorkshop.success) {
+					throw new Error('Invalid workshop data')
+				}
+
+				// Associate tags with workshop
+				if (input.workshop.tagIds) {
+					await tx.insert(contentResourceTag).values(
+						input.workshop.tagIds.map((tag) => ({
+							contentResourceId: workshopId,
+							tagId: tag.id,
+							createdAt: new Date(),
+							updatedAt: new Date(),
+							position: 0,
+						})),
+					)
+				}
+
+				// Create sections and lessons
+				const createdSections: ContentResource[] = []
+				const createdLessons: ContentResource[] = []
+				let position = 0
+
+				for (const item of input.structure) {
+					if (item.type === 'section') {
+						// Create section
+						const sectionHash = guid()
+						const sectionId = `section~${sectionHash}`
+
+						await tx.insert(contentResource).values({
+							id: sectionId,
+							type: 'section',
+							createdById: userId,
+							fields: {
+								title: item.title,
+								state: 'draft',
+								visibility: 'unlisted',
+								slug: slugify(`${item.title}~${sectionHash}`),
+							},
+						})
+
+						// Link section to workshop
+						await tx.insert(contentResourceResource).values({
+							resourceOfId: workshopId,
+							resourceId: sectionId,
+							position,
+						})
+
+						const section = await tx.query.contentResource.findFirst({
+							where: eq(contentResource.id, sectionId),
+						})
+
+						if (section) {
+							createdSections.push(section as ContentResource)
+						}
+
+						// Create lessons in section
+						let lessonPosition = 0
+						for (const lessonData of item.lessons) {
+							const lessonHash = guid()
+							const lessonId = `lesson_${lessonHash}`
+
+							await tx.insert(contentResource).values({
+								id: lessonId,
+								type: 'lesson',
+								createdById: userId,
+								fields: {
+									title: lessonData.title,
+									state: 'draft',
+									visibility: 'unlisted',
+									slug: slugify(`${lessonData.title}~${lessonHash}`),
+									lessonType: 'lesson',
+								},
+							})
+
+							// Link video if provided
+							if (lessonData.videoResourceId) {
+								await tx.insert(contentResourceResource).values({
+									resourceOfId: lessonId,
+									resourceId: lessonData.videoResourceId,
+									position: 0,
+								})
+							}
+
+							// Link lesson to section
+							await tx.insert(contentResourceResource).values({
+								resourceOfId: sectionId,
+								resourceId: lessonId,
+								position: lessonPosition,
+							})
+
+							const lesson = await tx.query.contentResource.findFirst({
+								where: eq(contentResource.id, lessonId),
+							})
+
+							if (lesson) {
+								createdLessons.push(lesson as ContentResource)
+							}
+
+							lessonPosition++
+						}
+
+						position++
+					} else {
+						// Create top-level lesson
+						const lessonHash = guid()
+						const lessonId = `lesson_${lessonHash}`
+
+						await tx.insert(contentResource).values({
+							id: lessonId,
+							type: 'lesson',
+							createdById: userId,
+							fields: {
+								title: item.title,
+								state: 'draft',
+								visibility: 'unlisted',
+								slug: slugify(`${item.title}~${lessonHash}`),
+								lessonType: 'lesson',
+							},
+						})
+
+						// Link video if provided
+						if (item.videoResourceId) {
+							await tx.insert(contentResourceResource).values({
+								resourceOfId: lessonId,
+								resourceId: item.videoResourceId,
+								position: 0,
+							})
+						}
+
+						// Link lesson to workshop
+						await tx.insert(contentResourceResource).values({
+							resourceOfId: workshopId,
+							resourceId: lessonId,
+							position,
+						})
+
+						const lesson = await tx.query.contentResource.findFirst({
+							where: eq(contentResource.id, lessonId),
+						})
+
+						if (lesson) {
+							createdLessons.push(lesson as ContentResource)
+						}
+
+						position++
+					}
+				}
+
+				return {
+					workshop: parsedWorkshop.data,
+					sections: createdSections,
+					lessons: createdLessons,
+				}
+			})
+
+			// Handle product and coupon creation outside transaction
+			let product: any = null
+			if (
+				input.createProduct &&
+				input.pricing.price &&
+				input.pricing.price > 0
+			) {
+				try {
+					product = await operations.createProduct({
+						name: input.workshop.title,
+						price: input.pricing.price,
+						quantityAvailable: input.pricing.quantity ?? -1,
+						type: 'self-paced',
+						state: 'published',
+						visibility: 'public',
+					})
+
+					if (product) {
+						// Link product to workshop resource
+						await client.insert(contentResourceProduct).values({
+							resourceId: workshopId,
+							productId: product.id,
+							position: 0,
+							metadata: {
+								addedBy: userId,
+							},
+						})
+
+						// Create coupon if enabled
+						if (
+							input.coupon?.enabled &&
+							input.coupon.percentageDiscount &&
+							input.coupon.expires
+						) {
+							try {
+								const finalExpires = normalizeExpirationDate(
+									input.coupon.expires,
+								)
+								await operations.createCoupon({
+									percentageDiscount: input.coupon.percentageDiscount,
+									expires: finalExpires || null,
+									restrictedToProductId: product.id,
+									default: true,
+									maxUses: -1,
+									quantity: '-1',
+									status: 1,
+									fields: {},
+								})
+								logger.debug('workshop.create.coupon.success', {
+									workshopId,
+									productId: product.id,
+									userId,
+									percentageDiscount: input.coupon.percentageDiscount,
+								})
+							} catch (couponError) {
+								logger.error(
+									new Error(
+										`Failed to create coupon for workshop: ${couponError}`,
+									),
+								)
+								logger.debug('workshop.create.coupon.failed', {
+									workshopId,
+									productId: product.id,
+									userId,
+								})
+								// Don't throw - workshop creation should succeed even if coupon fails
+							}
+						}
+					}
+				} catch (productError) {
+					logger.error(
+						new Error(`Failed to create product for workshop: ${productError}`),
+					)
+					logger.debug('workshop.create.product.failed', {
+						workshopId,
+						userId,
+						price: input.pricing.price,
+					})
+					// Don't throw - workshop creation should succeed even if product fails
+				}
+			}
+
+			return {
+				...result,
+				product,
+			}
+		},
+	}
+}

package/src/lib/mysql/workflows/redeem-full-price-coupon.ts

@@ -0,0 +1,179 @@
+import { and, eq } from 'drizzle-orm'
+import { v4 } from 'uuid'
+
+import type {
+	CouponPort,
+	IdentityPort,
+	OrganizationPort,
+	PurchasePort,
+} from '@coursebuilder/core/ports'
+import { logger } from '@coursebuilder/utils/logger'
+import { validateCoupon } from '@coursebuilder/commerce/validate-coupon'
+
+import type { MySqlContext } from '../context.js'
+
+type RedeemFullPriceCouponOperations = Pick<
+	CouponPort,
+	'getCouponWithBulkPurchases' | 'incrementCouponUsedCount'
+> &
+	Pick<IdentityPort, 'findOrCreateUser' | 'getUserById'> &
+	Pick<OrganizationPort, 'getMembershipsForUser'> &
+	Pick<
+		PurchasePort,
+		| 'createPurchase'
+		| 'createPurchaseTransfer'
+		| 'getExistingNonBulkValidPurchasesOfProduct'
+		| 'getPurchase'
+	>
+
+const normalizeLearnerEmail = (email: string) =>
+	email.trim().toLowerCase().replace(/\s+/g, '+')
+
+/**
+ * Creates the private full-price coupon redemption workflow.
+ *
+ * @param context - The shared MySQL client and table set.
+ * @param operations - Narrow identity, organization, purchase, and coupon operations.
+ * @returns The purchase-owned coupon redemption operation.
+ *
+ * @example
+ * ```ts
+ * const workflow = createRedeemFullPriceCouponWorkflow(context, operations)
+ * ```
+ */
+export function createRedeemFullPriceCouponWorkflow(
+	{ client, tables }: MySqlContext,
+	operations: RedeemFullPriceCouponOperations,
+): Pick<PurchasePort, 'redeemFullPriceCoupon'> {
+	const { purchases: purchaseTable } = tables
+
+	return {
+		async redeemFullPriceCoupon(options) {
+			const {
+				email: baseEmail,
+				couponId,
+				productIds,
+				currentUserId,
+				redeemingProductId,
+			} = options
+			const email = normalizeLearnerEmail(String(baseEmail))
+
+			const coupon = await operations.getCouponWithBulkPurchases(couponId)
+
+			const productId =
+				(coupon && (coupon.restrictedToProductId as string)) ||
+				redeemingProductId
+
+			if (!productId) throw new Error(`unable-to-find-any-product-id`)
+
+			const couponValidation = validateCoupon(coupon, productIds)
+
+			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.maxUses > 1)
+
+				const { user } = await operations.findOrCreateUser(email)
+
+				if (!user) throw new Error(`unable-to-create-user-${email}`)
+
+				const currentUser = currentUserId
+					? await operations.getUserById(currentUserId)
+					: null
+
+				const redeemingForCurrentUser = currentUser?.id === user.id
+
+				if (bulkCouponRedemption) {
+					const existingValidRedemption =
+						await client.query.purchases.findFirst({
+							where: and(
+								eq(purchaseTable.redeemedBulkCouponId, coupon.id),
+								eq(purchaseTable.userId, user.id),
+								eq(purchaseTable.status, 'Valid'),
+							),
+						})
+
+					if (existingValidRedemption) {
+						logger.info('adapter.coupon.redeem.duplicate_team_seat', {
+							couponId: coupon.id,
+							currentUserId,
+							email,
+							productId,
+							purchaseId: existingValidRedemption.id,
+							userId: user.id,
+						})
+						return {
+							error: {
+								message: 'team-seat-redemption-already-claimed',
+							},
+							redeemingForCurrentUser,
+							purchase: null,
+						}
+					}
+				}
+
+				// To prevent double-purchasing, check if this user already has a
+				// Purchase record for this product that is valid and wasn't a bulk
+				// coupon purchase.
+				const existingPurchases =
+					await operations.getExistingNonBulkValidPurchasesOfProduct({
+						userId: user.id,
+						productId,
+					})
+
+				if (existingPurchases.length > 0) {
+					const errorMessage = `already-purchased-${email}`
+					logger.info('adapter.coupon.redeem.already_purchased', {
+						couponId: coupon.id,
+						currentUserId,
+						email,
+						productId,
+						userId: user.id,
+					})
+					return {
+						error: {
+							message: errorMessage,
+						},
+						redeemingForCurrentUser,
+						purchase: null,
+					}
+					throw new Error(errorMessage)
+				}
+
+				const purchaseId = `purchase-${v4()}`
+				const userMemberships = await operations.getMembershipsForUser(user.id)
+				const organizationId =
+					coupon.organizationId ||
+					userMemberships.find((m) => m.organization.name?.includes(user.email))
+						?.organizationId // safer way to make sure we are using personal organization
+
+				await operations.createPurchase({
+					id: purchaseId,
+					userId: user.id,
+					couponId: bulkCouponRedemption ? null : coupon.id,
+					redeemedBulkCouponId: bulkCouponRedemption ? coupon.id : null,
+					productId,
+					totalAmount: '0',
+					organizationId,
+					metadata: {
+						couponUsedId: bulkCouponRedemption ? null : coupon.id,
+					},
+				})
+
+				const newPurchase = await operations.getPurchase(purchaseId)
+
+				await operations.incrementCouponUsedCount(coupon.id)
+
+				await operations.createPurchaseTransfer({
+					sourceUserId: user.id,
+					purchaseId: purchaseId,
+					expiresAt: new Date(Date.now() + 1000 * 60 * 60 * 24 * 7),
+				})
+
+				return { purchase: newPurchase, redeemingForCurrentUser }
+			}
+
+			return null
+		},
+	}
+}

package/src/lib/mysql/workflows/transfer-purchase-to-user.ts

@@ -0,0 +1,142 @@
+import { eq } from 'drizzle-orm'
+import { v4 } from 'uuid'
+
+import type { PurchasePort } from '@coursebuilder/core/ports'
+import { merchantChargeSchema, userSchema } from '@coursebuilder/core/schemas'
+import { merchantCustomerSchema } from '@coursebuilder/core/schemas/merchant-customer-schema'
+import type { PaymentsProviderConfig } from '@coursebuilder/core/types'
+
+import type { MySqlContext } from '../context.js'
+
+type TransferPurchaseToUserOperations = Pick<
+	PurchasePort,
+	'getPurchaseUserTransferById'
+>
+
+/**
+ * Creates the private purchase transfer workflow.
+ *
+ * @param context - The shared MySQL client and table set.
+ * @param paymentProvider - The configured external payment provider.
+ * @param operations - Narrow purchase, merchant, and identity operations.
+ * @returns The purchase-owned user transfer operation.
+ *
+ * @example
+ * ```ts
+ * const workflow = createTransferPurchaseToUserWorkflow(
+ * 	context,
+ * 	paymentProvider,
+ * 	operations,
+ * )
+ * ```
+ */
+export function createTransferPurchaseToUserWorkflow(
+	{ client, tables }: MySqlContext,
+	paymentProvider: PaymentsProviderConfig | undefined,
+	operations: TransferPurchaseToUserOperations,
+): Pick<PurchasePort, 'transferPurchaseToUser'> {
+	const {
+		users,
+		purchases: purchaseTable,
+		purchaseUserTransfer,
+		merchantCharge,
+		merchantCustomer,
+	} = tables
+
+	return {
+		transferPurchaseToUser: async (options: {
+			purchaseId: string
+			targetUserId: string
+			sourceUserId: string
+		}) => {
+			const { purchaseId, targetUserId, sourceUserId } = options
+			const transferId = `put_${v4()}`
+
+			await client.transaction(async (trx) => {
+				const purchase = await trx
+					.select()
+					.from(purchaseTable)
+					.where(eq(purchaseTable.id, purchaseId))
+					.for('update')
+					.then((rows) => rows[0])
+
+				if (!purchase) throw new Error('No purchase found')
+				if (purchase.userId !== sourceUserId)
+					throw new Error('Invalid source user')
+
+				await trx
+					.update(purchaseTable)
+					.set({ userId: targetUserId })
+					.where(eq(purchaseTable.id, purchase.id))
+
+				await trx.insert(purchaseUserTransfer).values({
+					id: transferId,
+					purchaseId: purchase.id,
+					sourceUserId: sourceUserId,
+					targetUserId: targetUserId,
+					transferState: 'COMPLETED',
+					completedAt: new Date(),
+				})
+
+				if (paymentProvider && purchase.merchantChargeId) {
+					await trx
+						.update(merchantCharge)
+						.set({
+							userId: targetUserId,
+						})
+						.where(eq(merchantCharge.id, purchase.merchantChargeId))
+
+					const updatedMerchantCharge = merchantChargeSchema.parse(
+						await trx.query.merchantCharge.findFirst({
+							where: eq(merchantCharge.id, purchase.merchantChargeId),
+						}),
+					)
+
+					await trx
+						.update(merchantCustomer)
+						.set({ userId: targetUserId })
+						.where(
+							eq(merchantCustomer.id, updatedMerchantCharge.merchantCustomerId),
+						)
+
+					const updatedMerchantCustomer = merchantCustomerSchema.parse(
+						await trx.query.merchantCustomer.findFirst({
+							where: eq(
+								merchantCustomer.id,
+								updatedMerchantCharge.merchantCustomerId,
+							),
+						}),
+					)
+
+					const targetUser = userSchema.parse(
+						await trx.query.users.findFirst({
+							where: eq(users.id, targetUserId),
+						}),
+					)
+
+					const sourceUser = userSchema.parse(
+						await trx.query.users.findFirst({
+							where: eq(users.id, sourceUserId),
+						}),
+					)
+
+					await paymentProvider.updateCustomer(
+						updatedMerchantCustomer.identifier,
+						{
+							email: targetUser.email,
+							name: targetUser.name || sourceUser.name || '',
+							metadata: {
+								transferId,
+								transferredFrom: sourceUser.email,
+								transferredOn: new Date().toISOString(),
+							},
+						},
+					)
+				}
+			})
+			return await operations.getPurchaseUserTransferById({
+				id: transferId,
+			})
+		},
+	}
+}