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

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

@@ -0,0 +1,274 @@
+import { and, desc, eq } from 'drizzle-orm'
+import { v4 } from 'uuid'
+
+import type { MerchantPort } from '@coursebuilder/core/ports'
+import {
+	merchantChargeSchema,
+	merchantEventsSchema,
+	merchantPriceSchema,
+	merchantProductSchema,
+	type MerchantCharge,
+	type MerchantEvents,
+	type MerchantProduct,
+	type User,
+} from '@coursebuilder/core/schemas'
+import { merchantAccountSchema } from '@coursebuilder/core/schemas/merchant-account-schema'
+import { merchantCustomerSchema } from '@coursebuilder/core/schemas/merchant-customer-schema'
+import type { MerchantCustomer } from '@coursebuilder/core/schemas/merchant-customer-schema'
+import {
+	MerchantSessionSchema,
+	type MerchantSession,
+} from '@coursebuilder/core/schemas/merchant-session'
+import { MerchantSubscriptionSchema } from '@coursebuilder/core/schemas/merchant-subscription'
+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 payment-processor mirror operations.
+ *
+ * @param context - The shared MySQL client and table set.
+ * @returns All sixteen MerchantPort operations.
+ *
+ * @example
+ * ```ts
+ * const merchantPort = createMerchantPort(context)
+ * ```
+ */
+export function createMerchantPort({
+	client,
+	tables,
+}: MySqlContext): MerchantPort {
+	const {
+		merchantAccount,
+		merchantCharge,
+		merchantCustomer,
+		merchantEvents,
+		merchantPrice,
+		merchantProduct,
+		merchantSession,
+		merchantSubscription: merchantSubscriptionTable,
+	} = tables
+
+	const merchantPort: MerchantPort = {
+		createMerchantCustomer: async (options) => {
+			await client.insert(merchantCustomer).values({
+				id: `mc_${v4()}`,
+				identifier: options.identifier,
+				merchantAccountId: options.merchantAccountId,
+				userId: options.userId,
+				status: 1,
+			})
+			return merchantCustomerSchema.parse(
+				await client.query.merchantCustomer.findFirst({
+					where: eq(merchantCustomer.identifier, options.identifier),
+				}),
+			)
+		},
+		getMerchantAccount: async (options) => {
+			return merchantAccountSchema.parse(
+				await client.query.merchantAccount.findFirst({
+					where: eq(merchantAccount.label, options.provider),
+				}),
+			)
+		},
+		getMerchantPriceForProductId: async (productId) => {
+			const merchantPriceData = await client.query.merchantPrice.findFirst({
+				where: and(
+					eq(merchantPrice.merchantProductId, productId),
+					eq(merchantPrice.status, 1),
+				),
+			})
+
+			const parsedMerchantPrice =
+				merchantPriceSchema.safeParse(merchantPriceData)
+
+			if (!parsedMerchantPrice.success) {
+				logger.error(parsedMerchantPrice.error, {
+					event: 'adapter.merchantPrice.parse_failed',
+					productId,
+				})
+				return null
+			}
+
+			return parsedMerchantPrice.data
+		},
+		getMerchantProductForProductId: async (productId) => {
+			const merchantProductData = await client.query.merchantProduct.findFirst({
+				where: eq(merchantProduct.productId, productId),
+			})
+
+			if (!merchantProductData) return null
+			return merchantProductSchema.parse(merchantProductData)
+		},
+		getMerchantCustomerForUserId: async (userId) => {
+			const merchantCustomerData =
+				await client.query.merchantCustomer.findFirst({
+					where: eq(merchantCustomer.userId, userId),
+				})
+
+			if (!merchantCustomerData) return null
+			return merchantCustomerSchema.parse(merchantCustomerData)
+		},
+		async createMerchantSession(options): Promise<MerchantSession> {
+			const id = `ms_${v4()}`
+			await client.insert(merchantSession).values({
+				id,
+				identifier: options.identifier,
+				merchantAccountId: options.merchantAccountId,
+				...(options.organizationId
+					? { organizationId: options.organizationId }
+					: {}),
+			})
+
+			return MerchantSessionSchema.parse(
+				await client.query.merchantSession.findFirst({
+					where: eq(merchantSession.id, id),
+				}),
+			)
+		},
+		async findOrCreateMerchantCustomer(options: {
+			user: User
+			identifier: string
+			merchantAccountId: string
+		}): Promise<MerchantCustomer | null> {
+			const merchantCustomer = merchantCustomerSchema
+				.nullable()
+				.optional()
+				.parse(
+					await client.query.merchantCustomer.findFirst({
+						where: (merchantCustomer, { eq }) =>
+							eq(merchantCustomer.identifier, options.identifier),
+					}),
+				)
+
+			if (merchantCustomer) {
+				return merchantCustomer
+			}
+
+			return await merchantPort.createMerchantCustomer({
+				identifier: options.identifier,
+				merchantAccountId: options.merchantAccountId,
+				userId: options.user.id,
+			})
+		},
+		async createMerchantEvent(options: {
+			merchantAccountId: string
+			identifier: string
+			payload: Record<string, any>
+		}): Promise<MerchantEvents> {
+			const eventId = `me_${v4()}`
+
+			await client.insert(merchantEvents).values({
+				id: eventId,
+				merchantAccountId: options.merchantAccountId,
+				identifier: options.identifier,
+				payload: options.payload,
+			})
+
+			const createdEvent = await client.query.merchantEvents.findFirst({
+				where: eq(merchantEvents.id, eventId),
+			})
+
+			return merchantEventsSchema.parse(createdEvent)
+		},
+		async getMerchantEventByIdentifier(
+			identifier: string,
+		): Promise<MerchantEvents | null> {
+			const event = await client.query.merchantEvents.findFirst({
+				where: eq(merchantEvents.identifier, identifier),
+			})
+
+			return event ? merchantEventsSchema.parse(event) : null
+		},
+		async getMerchantEventsByAccount(
+			merchantAccountId: string,
+		): Promise<MerchantEvents[]> {
+			const events = await client.query.merchantEvents.findMany({
+				where: eq(merchantEvents.merchantAccountId, merchantAccountId),
+				orderBy: [desc(merchantEvents.createdAt)],
+			})
+
+			return events.map((event) => merchantEventsSchema.parse(event))
+		},
+		async getMerchantCharge(
+			merchantChargeId: string,
+		): Promise<MerchantCharge | null> {
+			const mCharge = await client.query.merchantCharge.findFirst({
+				where: eq(merchantCharge.id, merchantChargeId),
+			})
+			const parsed = merchantChargeSchema.safeParse(mCharge)
+			if (!parsed.success) {
+				logger.error(parsed.error, {
+					event: 'adapter.merchantCharge.parse_failed',
+					merchantChargeId,
+				})
+				return null
+			}
+			return parsed.data
+		},
+		async getMerchantProduct(
+			stripeProductId: string,
+		): Promise<MerchantProduct | null> {
+			return merchantProductSchema.nullable().parse(
+				await client.query.merchantProduct.findFirst({
+					where: eq(merchantProduct.identifier, stripeProductId),
+				}),
+			)
+		},
+		getMerchantSubscription: async (merchantSubscriptionId: string) => {
+			return MerchantSubscriptionSchema.parse(
+				await client.query.merchantSubscription.findFirst({
+					where: eq(merchantSubscriptionTable.id, merchantSubscriptionId),
+				}),
+			)
+		},
+		createMerchantSubscription: async (options: {
+			merchantAccountId: string
+			merchantCustomerId: string
+			merchantProductId: string
+			identifier: string
+		}) => {
+			const id = crypto.randomUUID()
+			await client.insert(merchantSubscriptionTable).values({
+				...options,
+				id,
+			})
+
+			return MerchantSubscriptionSchema.parse(
+				await client.query.merchantSubscription.findFirst({
+					where: eq(merchantSubscriptionTable.id, id),
+				}),
+			)
+		},
+		updateMerchantSubscription: async (options: {
+			merchantSubscriptionId: string
+			status: string
+		}) => {
+			await client
+				.update(merchantSubscriptionTable)
+				.set({ status: Number(options.status) })
+				.where(eq(merchantSubscriptionTable.id, options.merchantSubscriptionId))
+
+			return MerchantSubscriptionSchema.parse(
+				await client.query.merchantSubscription.findFirst({
+					where: eq(
+						merchantSubscriptionTable.id,
+						options.merchantSubscriptionId,
+					),
+				}),
+			)
+		},
+		deleteMerchantSubscription: async (merchantSubscriptionId: string) => {
+			await client
+				.delete(merchantSubscriptionTable)
+				.where(eq(merchantSubscriptionTable.id, merchantSubscriptionId))
+		},
+	}
+
+	return merchantPort
+}

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

@@ -0,0 +1,216 @@
+import { and, eq } from 'drizzle-orm'
+import { z } from 'zod'
+
+import type { OrganizationPort } from '@coursebuilder/core/ports'
+import { OrganizationMemberSchema } from '@coursebuilder/core/schemas/organization-member'
+import { OrganizationSchema } from '@coursebuilder/core/schemas/organization-schema'
+
+import type { MySqlContext } from '../context.js'
+
+/**
+ * Creates the MySQL implementation of the organization capability port.
+ *
+ * @param context - The shared MySQL client and table set.
+ * @returns All eight organization, membership, and member-role operations.
+ *
+ * @example
+ * ```ts
+ * const organizationPort = createOrganizationPort(context)
+ * ```
+ */
+export function createOrganizationPort({
+	client,
+	tables,
+}: MySqlContext): OrganizationPort {
+	const {
+		organization: organizationTable,
+		organizationMemberships: organizationMembershipTable,
+		organizationMembershipRoles: organizationMembershipRoleTable,
+		roles: roleTable,
+	} = tables
+
+	const getOrganization: OrganizationPort['getOrganization'] = async (
+		organizationId,
+	) => {
+		return OrganizationSchema.parse(
+			await client.query.organization.findFirst({
+				where: eq(organizationTable.id, organizationId),
+			}),
+		)
+	}
+
+	const getPersonalOrganization: OrganizationPort['getPersonalOrganization'] =
+		async (userId) => {
+			return OrganizationSchema.nullable().parse(
+				(await client.query.organization.findFirst({
+					where: eq(organizationTable.personalOrganizationUserId, userId),
+				})) ?? null,
+			)
+		}
+
+	return {
+		createOrganization: async (options) => {
+			const organizationId = crypto.randomUUID()
+			await client.insert(organizationTable).values({
+				...options,
+				id: organizationId,
+			})
+
+			return getOrganization(organizationId)
+		},
+		getOrganization,
+		getPersonalOrganization,
+		createPersonalOrganization: async ({ userId, name }) => {
+			await client
+				.insert(organizationTable)
+				.values({
+					id: crypto.randomUUID(),
+					name,
+					personalOrganizationUserId: userId,
+				})
+				.onDuplicateKeyUpdate({
+					set: { personalOrganizationUserId: userId },
+				})
+
+			const organization = await getPersonalOrganization(userId)
+			if (!organization) {
+				throw new Error('Failed to create durable personal organization')
+			}
+			return organization
+		},
+		addMemberToOrganization: async (options) => {
+			const membershipWhere = options.personalOrganizationUserId
+				? eq(
+						organizationMembershipTable.personalOrganizationUserId,
+						options.personalOrganizationUserId,
+					)
+				: and(
+						eq(
+							organizationMembershipTable.organizationId,
+							options.organizationId,
+						),
+						eq(organizationMembershipTable.userId, options.userId),
+					)
+			const currentMembership =
+				await client.query.organizationMemberships.findFirst({
+					where: membershipWhere,
+					with: { organization: true, user: true },
+				})
+
+			if (!currentMembership) {
+				const insert = client.insert(organizationMembershipTable).values({
+					...options,
+					id: crypto.randomUUID(),
+				})
+				if (options.personalOrganizationUserId) {
+					await insert.onDuplicateKeyUpdate({
+						set: { userId: options.userId },
+					})
+				} else {
+					await insert
+				}
+			}
+
+			return OrganizationMemberSchema.parse(
+				await client.query.organizationMemberships.findFirst({
+					where: membershipWhere,
+					with: { organization: true, user: true },
+				}),
+			)
+		},
+		removeMemberFromOrganization: async (options) => {
+			await client
+				.delete(organizationMembershipTable)
+				.where(
+					and(
+						eq(
+							organizationMembershipTable.organizationId,
+							options.organizationId,
+						),
+						eq(organizationMembershipTable.userId, options.userId),
+					),
+				)
+		},
+		addRoleForMember: async (options) => {
+			await client
+				.insert(roleTable)
+				.values({
+					name: options.role,
+					organizationId: options.organizationId,
+					id: crypto.randomUUID(),
+				})
+				.onDuplicateKeyUpdate({ set: { name: options.role } })
+
+			const role = z.object({ id: z.string() }).parse(
+				await client.query.roles.findFirst({
+					where: and(
+						eq(roleTable.organizationId, options.organizationId),
+						eq(roleTable.name, options.role),
+					),
+				}),
+			)
+
+			await client
+				.insert(organizationMembershipRoleTable)
+				.values({
+					organizationId: options.organizationId,
+					organizationMembershipId: options.memberId,
+					roleId: role.id,
+				})
+				.onDuplicateKeyUpdate({ set: { roleId: role.id } })
+		},
+		removeRoleForMember: async (options) => {
+			const existingRole = z
+				.object({
+					id: z.string(),
+				})
+				.nullable()
+				.parse(
+					await client.query.roles.findFirst({
+						where: and(
+							eq(roleTable.organizationId, options.organizationId),
+							eq(roleTable.name, options.role),
+						),
+					}),
+				)
+
+			const roleId = existingRole?.id
+
+			if (roleId) {
+				await client
+					.delete(organizationMembershipRoleTable)
+					.where(
+						and(
+							eq(organizationMembershipRoleTable.roleId, roleId),
+							eq(
+								organizationMembershipRoleTable.organizationMembershipId,
+								options.memberId,
+							),
+						),
+					)
+			}
+		},
+		getMembershipsForUser: async (userId) => {
+			return OrganizationMemberSchema.array().parse(
+				(await client.query.organizationMemberships.findMany({
+					where: eq(organizationMembershipTable.userId, userId),
+					with: {
+						organization: true,
+						user: true,
+					},
+				})) || [],
+			)
+		},
+		getOrganizationMembers: async (organizationId) => {
+			return OrganizationMemberSchema.array().parse(
+				(await client.query.organizationMemberships.findMany({
+					where: eq(organizationMembershipTable.organizationId, organizationId),
+					with: {
+						organization: true,
+						user: true,
+					},
+				})) || [],
+			)
+		},
+	}
+}