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

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

@@ -0,0 +1,387 @@
+import { and, desc, eq, gte, inArray, isNull, or, sql } from 'drizzle-orm'
+import { customAlphabet } from 'nanoid'
+import { v4 } from 'uuid'
+import { z } from 'zod'
+
+import type { CouponPort } from '@coursebuilder/core/ports'
+import {
+	couponSchema,
+	merchantCouponSchema,
+	purchaseSchema,
+	type Coupon,
+	type MerchantCoupon,
+	type Purchase,
+} from '@coursebuilder/core/schemas'
+import { logger as baseLogger } from '@coursebuilder/utils/logger'
+
+import type { MySqlContext } from '../context.js'
+
+const guid = customAlphabet('1234567890abcdefghijklmnopqrstuvwxyz', 5)
+
+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 coupon operations.
+ *
+ * @param context - The shared MySQL client and table set.
+ * @returns All eleven CouponPort operations.
+ *
+ * @example
+ * ```ts
+ * const couponPort = createCouponPort(context)
+ * ```
+ */
+export function createCouponPort({ client, tables }: MySqlContext): CouponPort {
+	const { coupon, merchantCoupon, purchases: purchaseTable } = tables
+
+	return {
+		incrementCouponUsedCount: async (couponId) => {
+			await client
+				.update(coupon)
+				.set({ usedCount: sql`${coupon.usedCount} + 1` })
+				.where(eq(coupon.id, couponId))
+		},
+		createMerchantCoupon: async (options) => {
+			await client.insert(merchantCoupon).values({
+				id: `mcoupon_${v4()}`,
+				identifier: options.identifier,
+				merchantAccountId: options.merchantAccountId,
+				type: options.type,
+				amountDiscount: Math.floor(options.amountDiscount),
+				status: 1,
+			})
+			return merchantCouponSchema.parse(
+				await client.query.merchantCoupon.findFirst({
+					where: eq(merchantCoupon.identifier, options.identifier),
+				}),
+			)
+		},
+		async couponForIdOrCode(options: {
+			code?: string
+			couponId?: string
+		}): Promise<(Coupon & { merchantCoupon: MerchantCoupon }) | null> {
+			if (!options.couponId && !options.code) return null
+			const couponForIdOrCode = await client.query.coupon.findFirst({
+				where: or(
+					and(
+						or(
+							options.code ? eq(coupon.code, options.code) : undefined,
+							options.couponId ? eq(coupon.id, options.couponId) : undefined,
+						),
+						gte(coupon.expires, new Date()),
+					),
+					and(
+						or(
+							options.code ? eq(coupon.code, options.code) : undefined,
+							options.couponId ? eq(coupon.id, options.couponId) : undefined,
+						),
+						isNull(coupon.expires),
+					),
+				),
+				with: {
+					merchantCoupon: true,
+				},
+			})
+
+			if (!couponForIdOrCode) return null
+
+			const parsedCoupon = couponSchema
+				.extend({
+					merchantCoupon: merchantCouponSchema,
+				})
+				.safeParse(couponForIdOrCode)
+
+			if (!parsedCoupon.success) {
+				logger.error(parsedCoupon.error, {
+					code: options.code,
+					couponId: options.couponId,
+					event: 'adapter.coupon.parse_failed',
+				})
+				return null
+			}
+
+			return parsedCoupon.data
+		},
+		async getCoupon(couponIdOrCode: string): Promise<Coupon | null> {
+			const loadedCoupon =
+				(await client.query.coupon.findFirst({
+					where: or(
+						eq(coupon.id, couponIdOrCode),
+						eq(coupon.code, couponIdOrCode),
+					),
+				})) || null
+
+			logger.debug('getCoupon', {
+				couponIdOrCode,
+				found: !!loadedCoupon,
+			})
+
+			return couponSchema.nullable().parse(loadedCoupon)
+		},
+		async getCouponWithBulkPurchases(couponId: string): Promise<
+			| (Coupon & {
+					bulkPurchases?: Purchase[] | null
+					redeemedBulkCouponPurchases: { bulkCouponId?: string | null }[]
+			  })
+			| null
+		> {
+			logger.debug('getCouponWithBulkPurchases', { couponId })
+			let couponData
+			let bulkCouponPurchases: unknown[] = []
+			try {
+				couponData =
+					(await client.query.coupon.findFirst({
+						where: eq(coupon.id, couponId),
+						with: {
+							bulkPurchases: true,
+							redeemedBulkCouponPurchases: true,
+						},
+					})) || null
+			} catch (e) {
+				logger.error(e as Error, {
+					method: 'getCouponWithBulkPurchases',
+					couponId,
+					step: 'load-coupon',
+				})
+			}
+
+			try {
+				bulkCouponPurchases = await client.query.purchases.findMany({
+					where: eq(purchaseTable.redeemedBulkCouponId, couponId),
+					with: {
+						user: true,
+					},
+				})
+				logger.debug('getCouponWithBulkPurchases.redeemed', {
+					couponId,
+					count: bulkCouponPurchases?.length ?? 0,
+				})
+			} catch (e) {
+				logger.error(e as Error, {
+					method: 'getCouponWithBulkPurchases',
+					couponId,
+					step: 'load-redeemed-purchases',
+				})
+			}
+
+			if (!couponData) {
+				logger.debug('getCouponWithBulkPurchases', {
+					couponId,
+					error: 'no coupon found',
+				})
+				return null
+			}
+
+			const couponWithBulkPurchases = {
+				...couponData,
+				redeemedBulkCouponPurchases: bulkCouponPurchases || [],
+			}
+
+			const parsedCoupon = couponSchema
+				.merge(
+					z.object({
+						redeemedBulkCouponPurchases: z.array(purchaseSchema),
+					}),
+				)
+				.nullable()
+				.safeParse(couponWithBulkPurchases)
+
+			if (!parsedCoupon.success) {
+				logger.error(parsedCoupon.error, {
+					couponId: couponData?.id ?? couponId,
+					event: 'adapter.coupon.parse_failed',
+					redeemedBulkCouponPurchasesCount: bulkCouponPurchases?.length ?? 0,
+				})
+				return null
+			}
+
+			return parsedCoupon.data
+		},
+		async getDefaultCoupon(productIds?: string[]): Promise<{
+			defaultMerchantCoupon: MerchantCoupon
+			defaultCoupon: Coupon
+		} | null> {
+			const activeSaleCoupon = await client.query.coupon.findFirst({
+				where: and(
+					eq(coupon.status, 1),
+					eq(coupon.default, true),
+					gte(coupon.expires, new Date()),
+					or(
+						productIds
+							? inArray(coupon.restrictedToProductId, productIds)
+							: undefined,
+						isNull(coupon.restrictedToProductId),
+					),
+				),
+				orderBy: desc(coupon.percentageDiscount),
+				with: {
+					merchantCoupon: true,
+					product: true,
+				},
+			})
+			if (activeSaleCoupon) {
+				const { restrictedToProductId } = activeSaleCoupon
+				const validForProdcutId = restrictedToProductId
+					? productIds?.includes(restrictedToProductId as string)
+					: true
+
+				const { merchantCoupon: defaultMerchantCoupon, ...defaultCoupon } =
+					activeSaleCoupon
+
+				if (validForProdcutId) {
+					return {
+						defaultMerchantCoupon: merchantCouponSchema.parse(
+							defaultMerchantCoupon,
+						),
+						defaultCoupon: couponSchema.parse(defaultCoupon),
+					}
+				}
+			}
+			return null
+		},
+		async getMerchantCouponsForTypeAndPercent(params: {
+			type: string
+			percentageDiscount: number
+		}): Promise<MerchantCoupon[]> {
+			return z.array(merchantCouponSchema).parse(
+				await client.query.merchantCoupon.findMany({
+					where: and(
+						eq(merchantCoupon.type, params.type),
+						eq(
+							merchantCoupon.percentageDiscount,
+							params.percentageDiscount.toString(),
+						),
+					),
+				}),
+			)
+		},
+		async getMerchantCouponForTypeAndPercent(params: {
+			type: string
+			percentageDiscount: number
+		}): Promise<MerchantCoupon | null> {
+			const foundMerchantCoupon = await client.query.merchantCoupon.findFirst({
+				where: and(
+					eq(merchantCoupon.type, params.type),
+					eq(
+						merchantCoupon.percentageDiscount,
+						params.percentageDiscount.toString(),
+					),
+				),
+			})
+
+			const parsed = merchantCouponSchema
+				.nullable()
+				.safeParse(foundMerchantCoupon)
+			if (parsed.success) {
+				return parsed.data
+			}
+
+			return null
+		},
+		async getMerchantCouponForTypeAndAmount(params: {
+			type: string
+			amountDiscount: number
+		}): Promise<MerchantCoupon | null> {
+			const foundMerchantCoupon = await client.query.merchantCoupon.findFirst({
+				where: and(
+					eq(merchantCoupon.type, params.type),
+					eq(merchantCoupon.amountDiscount, params.amountDiscount),
+				),
+			})
+
+			const parsed = merchantCouponSchema
+				.nullable()
+				.safeParse(foundMerchantCoupon)
+			if (parsed.success) {
+				return parsed.data
+			}
+
+			return null
+		},
+		async getMerchantCoupon(
+			merchantCouponId: string,
+		): Promise<MerchantCoupon | null> {
+			const foundMerchantCoupon = await client.query.merchantCoupon.findFirst({
+				where: eq(merchantCoupon.id, merchantCouponId),
+			})
+
+			const parsed = merchantCouponSchema
+				.nullable()
+				.safeParse(foundMerchantCoupon)
+			if (parsed.success) {
+				return parsed.data
+			}
+
+			return null
+		},
+		async createCoupon(input: {
+			quantity: string
+			maxUses: number
+			expires: Date | null
+			restrictedToProductId: string | null
+			percentageDiscount: string
+			status: number
+			default: boolean
+			fields: Record<string, any>
+		}) {
+			function findClosestDiscount(percentOff: number) {
+				// we want a fraction so if it is whole number, we make it fractional
+				percentOff = percentOff <= 1 ? percentOff : percentOff / 100
+				return [1, 0.95, 0.9, 0.75, 0.6, 0.5, 0.4, 0.25, 0.1].reduce((a, b) => {
+					let aDiff = Math.abs(a - percentOff)
+					let bDiff = Math.abs(b - percentOff)
+
+					if (aDiff === bDiff) {
+						// Choose largest vs smallest (> vs <)
+						return a > b ? a : b
+					} else {
+						return bDiff < aDiff ? b : a
+					}
+				})
+			}
+
+			const percentageDiscount = findClosestDiscount(
+				Number(input.percentageDiscount) * 100,
+			)
+
+			const merchantCouponResult =
+				percentageDiscount < 1
+					? await client.query.merchantCoupon.findFirst({
+							where: and(
+								eq(
+									merchantCoupon.percentageDiscount,
+									percentageDiscount.toString(),
+								),
+								eq(merchantCoupon.type, 'special'),
+							),
+						})
+					: null
+
+			if (!merchantCouponResult) {
+				return []
+			}
+
+			const codesArray: string[] = []
+			const requestedQuantity = Number(input.quantity)
+			const couponQuantity = requestedQuantity < 0 ? 1 : requestedQuantity
+
+			await client.transaction(async (trx) => {
+				// insert coupon for CouponInput quantity
+				for (let i = 0; i < couponQuantity; i++) {
+					const id = `coupon_${guid()}`
+					await trx.insert(coupon).values({
+						...input,
+						merchantCouponId: merchantCouponResult.id as string,
+						id,
+					})
+					codesArray.push(id)
+				}
+			})
+
+			return codesArray
+		},
+	}
+}

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

@@ -0,0 +1,96 @@
+import { and, asc, eq, gte, isNull, or, sql } from 'drizzle-orm'
+import { z } from 'zod'
+
+import type { EntitlementPort } from '@coursebuilder/core/ports'
+import { entitlementSchema } from '@coursebuilder/core/schemas'
+import { logger as baseLogger } from '@coursebuilder/utils/logger'
+
+import type { MySqlContext } from '../context.js'
+
+const logger = baseLogger as unknown as {
+	error: (error: Error, attrs?: Record<string, unknown>) => void
+}
+
+/**
+ * Creates the MySQL implementation of entitlement lookup operations.
+ *
+ * @param context - The shared MySQL client and table set.
+ * @returns Both entitlement capability operations.
+ *
+ * @example
+ * ```ts
+ * const entitlementPort = createEntitlementPort(context)
+ * ```
+ */
+export function createEntitlementPort({
+	client,
+	tables,
+}: MySqlContext): EntitlementPort {
+	const { entitlements: entitlementTable, entitlementTypes } = tables
+
+	return {
+		async getEntitlementsForUser(params) {
+			const { userId, sourceType, entitlementType } = params
+
+			if (!userId) {
+				return []
+			}
+
+			const conditions = [eq(entitlementTable.userId, userId)]
+
+			if (sourceType) {
+				conditions.push(eq(entitlementTable.sourceType, sourceType))
+			}
+
+			if (entitlementType) {
+				conditions.push(eq(entitlementTable.entitlementType, entitlementType))
+			}
+
+			// Only return active entitlements (not deleted, not expired)
+			conditions.push(isNull(entitlementTable.deletedAt))
+			const expiresCondition = or(
+				isNull(entitlementTable.expiresAt),
+				gte(entitlementTable.expiresAt, sql`CURRENT_TIMESTAMP`),
+			)
+			if (expiresCondition) {
+				conditions.push(expiresCondition)
+			}
+
+			const userEntitlements = await client.query.entitlements.findMany({
+				where: conditions.length > 0 ? and(...conditions) : undefined,
+				orderBy: asc(entitlementTable.createdAt),
+			})
+
+			const parsedEntitlements = z
+				.array(entitlementSchema)
+				.safeParse(userEntitlements)
+
+			if (!parsedEntitlements.success) {
+				logger.error(parsedEntitlements.error, {
+					entitlementCount: userEntitlements.length,
+					entitlementType,
+					event: 'adapter.entitlement.list.parse_failed',
+					sourceType,
+					userId,
+				})
+				return []
+			}
+
+			return parsedEntitlements.data
+		},
+		async getEntitlementTypeByName(name) {
+			const entitlementType = await client.query.entitlementTypes.findFirst({
+				where: eq(entitlementTypes.name, name),
+			})
+
+			if (!entitlementType) {
+				return null
+			}
+
+			return {
+				id: String(entitlementType.id),
+				name: String(entitlementType.name),
+			}
+		},
+	}
+}

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

@@ -0,0 +1,160 @@
+import { and, eq } from 'drizzle-orm'
+import { v4 } from 'uuid'
+
+import type { IdentityPort } from '@coursebuilder/core/ports'
+import { userSchema, 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 {
+	error: (error: Error, attrs?: Record<string, unknown>) => void
+	info: (message: string, attrs?: Record<string, unknown>) => void
+}
+
+function toError(error: unknown) {
+	return error instanceof Error ? error : new Error(String(error))
+}
+
+/**
+ * Creates the MySQL implementation of Course Builder identity persistence.
+ *
+ * @param context - The shared MySQL client and table set.
+ * @returns User and external-identity-link operations.
+ *
+ * @example
+ * ```ts
+ * const identity = createIdentityPort(context)
+ * ```
+ */
+export function createIdentityPort({
+	client,
+	tables,
+}: MySqlContext): Required<IdentityPort> {
+	const { accounts, users, verificationTokens } = tables
+
+	const getUser: NonNullable<IdentityPort['getUser']> = async (data) =>
+		(await client
+			.select()
+			.from(users)
+			.where(eq(users.id, data))
+			.then((res) => res[0])) ?? null
+
+	const getUserByEmail: NonNullable<IdentityPort['getUserByEmail']> = async (
+		data,
+	) =>
+		(await client
+			.select()
+			.from(users)
+			.where(eq(users.email, data))
+			.then((res) => res[0])) ?? null
+
+	const createUser: NonNullable<IdentityPort['createUser']> = async (data) => {
+		const id = crypto.randomUUID()
+		try {
+			await client.insert(users).values({ ...data, id })
+
+			const user = await getUser(id)
+			if (!user) throw new Error('Failed to get user')
+			return user
+		} catch (error) {
+			logger.error(toError(error), {
+				email: data.email,
+				event: 'adapter.user.create.failed',
+				userId: id,
+			})
+			throw error
+		}
+	}
+
+	return {
+		createUser,
+		getUser,
+		getUserByEmail,
+		updateUser: async (data) => {
+			if (!data.id) throw new Error('No user id.')
+			await client.update(users).set(data).where(eq(users.id, data.id))
+			return await client
+				.select()
+				.from(users)
+				.where(eq(users.id, data.id))
+				.then((res) => res[0])
+		},
+		linkAccount: async (rawAccount) => {
+			await client.insert(accounts).values(rawAccount)
+		},
+		getUserByAccount: async (account) => {
+			const dbAccount =
+				(await client
+					.select()
+					.from(accounts)
+					.where(
+						and(
+							eq(accounts.providerAccountId, account.providerAccountId),
+							eq(accounts.provider, account.provider),
+						),
+					)
+					.leftJoin(users, eq(accounts.userId, users.id))
+					.then((res) => res[0])) ?? null
+			return dbAccount?.User ?? null
+		},
+		unlinkAccount: async (account) => {
+			await client
+				.delete(accounts)
+				.where(
+					and(
+						eq(accounts.providerAccountId, account.providerAccountId),
+						eq(accounts.provider, account.provider),
+					),
+				)
+			return undefined
+		},
+		createVerificationToken: async (token) => {
+			await client.insert(verificationTokens).values(token)
+			return await client
+				.select()
+				.from(verificationTokens)
+				.where(eq(verificationTokens.identifier, token.identifier))
+				.then((res) => res[0])
+		},
+		findOrCreateUser: async (email, name) => {
+			const user = await getUserByEmail(email)
+			if (!user) {
+				const newUser = await createUser({
+					id: `u_${v4()}`,
+					email,
+					name,
+					emailVerified: null,
+				})
+				logger.info('adapter.user.created', { email, userId: newUser.id })
+				return { user: newUser as User, isNewUser: true }
+			}
+			return { user: user as User, isNewUser: false }
+		},
+		getUserWithPurchasersByEmail: async (email) =>
+			client.query.users.findFirst({
+				where: eq(users.email, email.trim().toLowerCase()),
+				with: {
+					roles: { with: { role: true } },
+					purchases: {
+						with: {
+							bulkCoupon: true,
+							merchantCharge: true,
+							product: { columns: { id: true, name: true, key: true } },
+						},
+					},
+				},
+			}),
+		getUserById: async (userId) => {
+			const user = await client.query.users
+				.findFirst({
+					where: eq(users.id, userId),
+					with: { roles: { with: { role: true } } },
+				})
+				.then(async (res) =>
+					res ? { ...res, roles: res.roles.map((r) => r.role) } : undefined,
+				)
+			return userSchema.nullable().parse(user ?? null)
+		},
+	}
+}