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

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

@@ -0,0 +1,610 @@
+import slugify from '@sindresorhus/slugify'
+import { and, eq, inArray, or, sql } from 'drizzle-orm'
+import { customAlphabet } from 'nanoid'
+import { v4 } from 'uuid'
+import { z } from 'zod'
+
+import type { CatalogPort } from '@coursebuilder/core/ports'
+import {
+	merchantPriceSchema,
+	merchantProductSchema,
+	priceSchema,
+	productSchema,
+	upgradableProductSchema,
+	type NewProduct,
+	type Price,
+	type Product,
+	type Purchase,
+} from '@coursebuilder/core/schemas'
+import {
+	ContentResourceProductSchema,
+	ContentResourceSchema,
+	type ContentResource,
+} from '@coursebuilder/core/schemas/content-resource-schema'
+import { merchantAccountSchema } from '@coursebuilder/core/schemas/merchant-account-schema'
+import type { PaymentsProviderConfig } from '@coursebuilder/core/types'
+import { logger as baseLogger } from '@coursebuilder/utils/logger'
+
+import type { MySqlContext } from '../context.js'
+
+const guid = customAlphabet('1234567890abcdefghijklmnopqrstuvwxyz', 5)
+
+function toError(error: unknown) {
+	return error instanceof Error ? error : new Error(String(error))
+}
+
+const logger = baseLogger as unknown as {
+	debug: (message: string, attrs?: Record<string, unknown>) => void
+	error: (error: Error, attrs?: Record<string, unknown>) => void
+}
+
+/**
+ * Creates the MySQL implementation of catalog and pricing operations.
+ *
+ * @param context - The shared MySQL client and table set.
+ * @param paymentProvider - Optional provider used by product write operations.
+ * @returns All eleven CatalogPort operations.
+ *
+ * @example
+ * ```ts
+ * const catalogPort = createCatalogPort(context, paymentProvider)
+ * ```
+ */
+export function createCatalogPort(
+	{ client, tables }: MySqlContext,
+	paymentProvider?: PaymentsProviderConfig,
+): CatalogPort {
+	const {
+		contentResource,
+		contentResourceProduct,
+		merchantAccount,
+		merchantPrice,
+		merchantProduct,
+		prices,
+		products,
+		purchases: purchaseTable,
+		upgradableProducts,
+	} = tables
+
+	const getProduct: CatalogPort['getProduct'] = async (
+		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) {
+				logger.error(parsedProduct.error, {
+					event: 'adapter.product.parse_failed',
+					productId: productData?.id,
+					productSlugOrId,
+				})
+				return null
+			}
+			return parsedProduct.data
+		} catch (e) {
+			logger.error(toError(e), {
+				event: 'adapter.product.lookup.failed',
+				productSlugOrId,
+				withResources,
+			})
+			return null
+		}
+	}
+
+	return {
+		getProduct,
+		getUpgradableProducts: async (options) => {
+			const { upgradableFromId, upgradableToId } = options
+			return z.array(upgradableProductSchema).parse(
+				await client.query.upgradableProducts.findMany({
+					where: and(
+						eq(upgradableProducts.upgradableFromId, upgradableFromId),
+						eq(upgradableProducts.upgradableToId, upgradableToId),
+					),
+				}),
+			)
+		},
+		async availableUpgradesForProduct(
+			purchases: any,
+			productId: string,
+		): Promise<any[]> {
+			const previousPurchaseProductIds = purchases.map(
+				({ productId }: Purchase) => productId,
+			)
+
+			if (previousPurchaseProductIds.length > 0) {
+				return client.query.upgradableProducts.findMany({
+					where: and(
+						eq(upgradableProducts.upgradableToId, productId),
+						inArray(
+							upgradableProducts.upgradableFromId,
+							previousPurchaseProductIds,
+						),
+					),
+				})
+			}
+			return []
+		},
+		async getPrice(productId: string): Promise<Price | null> {
+			return priceSchema.nullable().parse(
+				await client.query.prices.findFirst({
+					where: eq(prices.productId, productId),
+				}),
+			)
+		},
+		async getPriceForProduct(productId: string): Promise<Price | null> {
+			return priceSchema.nullable().parse(
+				await client.query.prices.findFirst({
+					where: eq(prices.productId, productId),
+				}),
+			)
+		},
+		async archiveProduct(productId) {
+			if (!paymentProvider) throw new Error('Payment provider not found')
+			const product = await 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: eq(merchantPrice.priceId, product.price.id),
+				}),
+			)
+
+			if (!currentMerchantPrice || !currentMerchantPrice.identifier) {
+				throw new Error(`Merchant price not found for id (${productId})`)
+			}
+
+			await paymentProvider.updatePrice(currentMerchantPrice.identifier, {
+				active: false,
+			})
+
+			return getProduct(productId)
+		},
+		async updateProduct(input: Product) {
+			if (!paymentProvider) throw new Error('Payment provider not found')
+			const currentProduct = await 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()
+
+			// Get current merchant price and Stripe price to check if it needs updating
+			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,
+			)
+
+			// Check if type changed to/from membership (requires Stripe price recreation)
+			const membershipTypeChanged =
+				currentProduct.type !== input.type &&
+				(input.type === 'membership' || currentProduct.type === 'membership')
+
+			// Check if billing interval changed for membership products
+			const billingIntervalChanged =
+				input.type === 'membership' &&
+				currentProduct.type === 'membership' &&
+				currentProduct.fields?.billingInterval !== input.fields?.billingInterval
+
+			// Check if Stripe price recurring status doesn't match expected state for input type:
+			// - membership products require recurring=true
+			// - non-membership products require recurring=false (null/undefined)
+			const isMembership = input.type === 'membership'
+			const stripePriceMismatch =
+				isMembership !== !!currentStripePrice.recurring
+
+			// Need to recreate price if: price changed, type changed to/from membership,
+			// billing interval changed, or Stripe price doesn't match expected recurring status
+			const needsPriceRecreation =
+				priceChanged ||
+				membershipTypeChanged ||
+				billingIntervalChanged ||
+				stripePriceMismatch
+
+			if (needsPriceRecreation) {
+				// Get billing interval from input or default to 'year'
+				const billingInterval = input.fields?.billingInterval || 'year'
+
+				const priceParams = {
+					product: stripeProduct.id,
+					unit_amount: Math.floor(Number(input.price?.unitAmount || 0) * 100),
+					currency: 'usd',
+					metadata: {
+						slug: input.fields.slug,
+					},
+					active: true,
+					// Membership products get recurring billing
+					...(input.type === 'membership' && {
+						recurring: { interval: billingInterval },
+					}),
+				}
+
+				logger.debug('adapter.product.price_recreation.started', {
+					billingInterval,
+					currency: priceParams.currency,
+					currentMerchantPriceId: currentMerchantPrice.id,
+					isMembership: input.type === 'membership',
+					merchantProductId: merchantProduct.id,
+					productId: input.id,
+					productSlug: input.fields.slug,
+					stripeProductId: stripeProduct.id,
+					unitAmount: priceParams.unit_amount,
+				})
+
+				const newStripePrice = await paymentProvider.createPrice(priceParams)
+
+				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 }),
+					},
+					type: input.type,
+				})
+				.where(eq(products.id, currentProduct.id))
+
+			return 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: input.type || 'self-paced',
+				quantityAvailable: input.quantityAvailable,
+				fields: {
+					state: input.state || 'draft',
+					visibility: input.visibility || 'unlisted',
+					slug: slugify(`${input.name}-${hash}`),
+					...(input.openEnrollment && { openEnrollment: input.openEnrollment }),
+					...(input.closeEnrollment && {
+						closeEnrollment: input.closeEnrollment,
+					}),
+					...(typeof input.availableAfterDays === 'number' && {
+						availableAfterDays: input.availableAfterDays,
+					}),
+					...(typeof input.accessDurationDays === 'number' && {
+						accessDurationDays: input.accessDurationDays,
+					}),
+				},
+			}
+
+			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 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,
+				},
+				// Membership products get recurring billing
+				...(input.type === 'membership' && {
+					recurring: { interval: input.billingInterval || 'year' },
+				}),
+			})
+
+			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 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 pricesOfPurchasesTowardOneBundle({
+			userId,
+			bundleId,
+		}: {
+			userId: string | undefined
+			bundleId: string
+		}): Promise<Price[]> {
+			if (userId === undefined) return []
+
+			const canUpgradeProducts = await client.query.upgradableProducts.findMany(
+				{
+					where: eq(upgradableProducts.upgradableToId, bundleId),
+				},
+			)
+
+			const upgradableFrom = z.array(z.string()).parse(
+				canUpgradeProducts.map((product) => {
+					return product.upgradableFromId
+				}),
+			)
+
+			const purchases = await client.query.purchases.findMany({
+				where: and(
+					eq(purchaseTable.userId, userId),
+					inArray(purchaseTable.productId, upgradableFrom),
+				),
+			})
+
+			const productsPurchased = z.array(z.string()).parse(
+				purchases.map((purchase) => {
+					return purchase.productId
+				}),
+			)
+
+			if (productsPurchased.length === 0) return []
+
+			const foundPrices = await client.query.prices.findMany({
+				where: inArray(prices.productId, productsPurchased),
+			})
+
+			return z.array(priceSchema).parse(foundPrices)
+		},
+		async addResourceToProduct(options: {
+			resource: ContentResource
+			productId: string
+			userId: string
+		}) {
+			const { resource, productId, userId } = options
+			const product = await getProduct(productId)
+
+			if (!product) {
+				throw new Error(`Product not found for id (${productId})`)
+			}
+
+			await client.insert(contentResourceProduct).values({
+				resourceId: resource.id,
+				productId,
+				position: product.resources?.length || 0,
+				metadata: {
+					addedBy: userId,
+				},
+			})
+
+			const resourceProduct =
+				await client.query.contentResourceProduct.findFirst({
+					where: eq(contentResourceProduct.resourceId, resource.id),
+					with: {
+						resource: true,
+						product: true,
+					},
+				})
+
+			return (
+				ContentResourceProductSchema.safeParse(resourceProduct).data || null
+			)
+		},
+	}
+}