@coursebuilder/adapter-drizzle 1.0.4 → 1.0.7

package/src/lib/mysql/index.ts

@@ -28,11 +28,15 @@ import { type CourseBuilderAdapter } from '@coursebuilder/core/adapters'
 import {
 	Coupon,
 	couponSchema,
+	Entitlement,
+	entitlementSchema,
 	MerchantCharge,
 	merchantChargeSchema,
 	MerchantCoupon,
 	merchantCouponSchema,
 	MerchantCustomer,
+	MerchantEvents,
+	merchantEventsSchema,
 	merchantPriceSchema,
 	MerchantProduct,
 	merchantProductSchema,
@@ -72,7 +76,7 @@ import { type ModuleProgress } from '@coursebuilder/core/schemas/resource-progre
 import { SubscriptionSchema } from '@coursebuilder/core/schemas/subscription'
 import { VideoResourceSchema } from '@coursebuilder/core/schemas/video-resource'
 import { PaymentsProviderConfig } from '@coursebuilder/core/types'
-import { logger } from '@coursebuilder/core/utils/logger'
+import { logger as baseLogger } from '@coursebuilder/core/utils/logger'
 import { validateCoupon } from '@coursebuilder/core/utils/validate-coupon'
 
 import {
@@ -122,6 +126,7 @@ import {
 import {
 	getUsersRelationsSchema,
 	getUsersSchema,
+	type UsersSchemaOverrides,
 } from './schemas/auth/users.js'
 import { getVerificationTokensSchema } from './schemas/auth/verification-tokens.js'
 import {
@@ -135,6 +140,10 @@ import {
 } from './schemas/commerce/merchant-charge.js'
 import { getMerchantCouponSchema } from './schemas/commerce/merchant-coupon.js'
 import { getMerchantCustomerSchema } from './schemas/commerce/merchant-customer.js'
+import {
+	getMerchantEventsRelationsSchema,
+	getMerchantEventsSchema,
+} from './schemas/commerce/merchant-events.js'
 import { getMerchantPriceSchema } from './schemas/commerce/merchant-price.js'
 import { getMerchantProductSchema } from './schemas/commerce/merchant-product.js'
 import { getMerchantSessionSchema } from './schemas/commerce/merchant-session.js'
@@ -173,6 +182,10 @@ import {
 	getCommunicationPreferencesRelationsSchema,
 	getCommunicationPreferencesSchema,
 } from './schemas/communication/communication-preferences.js'
+import {
+	getQuestionResponseRelationsSchema,
+	getQuestionResponseSchema,
+} from './schemas/communication/question-response.js'
 import {
 	getContentContributionRelationsSchema,
 	getContentContributionsSchema,
@@ -228,10 +241,60 @@ import {
 
 export const guid = customAlphabet('1234567890abcdefghijklmnopqrstuvwxyz', 5)
 
-export function getCourseBuilderSchema(mysqlTable: MySqlTableFn) {
+export const normalizeExpirationDate = (date: Date | undefined) => {
+	if (!date) return undefined
+
+	// Create a new Date object for 23:59:59 UTC on the date part of the input date
+	// The input date should be a JS Date representing 00:00:00 LA time for the chosen day.
+	// Its UTC date parts (getUTCFullYear, etc.) will give us the correct calendar day.
+	return new Date(
+		Date.UTC(
+			date.getUTCFullYear(),
+			date.getUTCMonth(), // 0-indexed
+			date.getUTCDate(),
+			23, // hours
+			59, // minutes
+			59, // seconds
+			0, // milliseconds
+		),
+	)
+}
+
+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
+	info: (message: string, attrs?: Record<string, unknown>) => void
+}
+
+export type CourseBuilderSchemaOverrides<
+	TUsers extends ReturnType<typeof getUsersSchema> = ReturnType<
+		typeof getUsersSchema
+	>,
+> = UsersSchemaOverrides<TUsers>
+
+export function getCourseBuilderSchema<
+	TUsers extends ReturnType<typeof getUsersSchema> = ReturnType<
+		typeof getUsersSchema
+	>,
+>(
+	mysqlTable: MySqlTableFn,
+	overrides: CourseBuilderSchemaOverrides<TUsers> = {},
+) {
+	const resolvedGetUsersSchema = (overrides.getUsersSchema ??
+		getUsersSchema) as (mysqlTable: MySqlTableFn) => TUsers
+	const userRelationsOverrides: UsersSchemaOverrides<TUsers> = {
+		getUsersSchema: resolvedGetUsersSchema,
+	}
 	return {
 		accounts: getAccountsSchema(mysqlTable),
-		accountsRelations: getAccountsRelationsSchema(mysqlTable),
+		accountsRelations: getAccountsRelationsSchema(
+			mysqlTable,
+			userRelationsOverrides,
+		),
 		permissions: getPermissionsSchema(mysqlTable),
 		permissionsRelations: getPermissionsRelationsSchema(mysqlTable),
 		rolePermissions: getRolePermissionsSchema(mysqlTable),
@@ -239,13 +302,22 @@ export function getCourseBuilderSchema(mysqlTable: MySqlTableFn) {
 		roles: getRolesSchema(mysqlTable),
 		rolesRelations: getRolesRelationsSchema(mysqlTable),
 		sessions: getSessionsSchema(mysqlTable),
-		sessionsRelations: getSessionRelationsSchema(mysqlTable),
+		sessionsRelations: getSessionRelationsSchema(
+			mysqlTable,
+			userRelationsOverrides,
+		),
 		userPermissions: getUserPermissionsSchema(mysqlTable),
-		userPermissionsRelations: getUserPermissionsRelationsSchema(mysqlTable),
+		userPermissionsRelations: getUserPermissionsRelationsSchema(
+			mysqlTable,
+			userRelationsOverrides,
+		),
 		userRoles: getUserRolesSchema(mysqlTable),
-		userRolesRelations: getUserRolesRelationsSchema(mysqlTable),
-		users: getUsersSchema(mysqlTable),
-		usersRelations: getUsersRelationsSchema(mysqlTable),
+		userRolesRelations: getUserRolesRelationsSchema(
+			mysqlTable,
+			userRelationsOverrides,
+		),
+		users: resolvedGetUsersSchema(mysqlTable),
+		usersRelations: getUsersRelationsSchema(mysqlTable, userRelationsOverrides),
 		verificationTokens: getVerificationTokensSchema(mysqlTable),
 		coupon: getCouponSchema(mysqlTable),
 		couponRelations: getCouponRelationsSchema(mysqlTable),
@@ -253,6 +325,8 @@ export function getCourseBuilderSchema(mysqlTable: MySqlTableFn) {
 		merchantAccount: getMerchantAccountSchema(mysqlTable),
 		merchantCharge: getMerchantChargeSchema(mysqlTable),
 		merchantChargeRelations: getMerchantChargeRelationsSchema(mysqlTable),
+		merchantEvents: getMerchantEventsSchema(mysqlTable),
+		merchantEventsRelations: getMerchantEventsRelationsSchema(mysqlTable),
 		merchantCoupon: getMerchantCouponSchema(mysqlTable),
 		merchantCustomer: getMerchantCustomerSchema(mysqlTable),
 		merchantPrice: getMerchantPriceSchema(mysqlTable),
@@ -261,24 +335,39 @@ export function getCourseBuilderSchema(mysqlTable: MySqlTableFn) {
 		prices: getPriceSchema(mysqlTable),
 		products: getProductSchema(mysqlTable),
 		purchases: getPurchaseSchema(mysqlTable),
-		purchaseRelations: getPurchaseRelationsSchema(mysqlTable),
+		purchaseRelations: getPurchaseRelationsSchema(
+			mysqlTable,
+			userRelationsOverrides,
+		),
 		purchaseUserTransfer: getPurchaseUserTransferSchema(mysqlTable),
-		purchaseUserTransferRelations:
-			getPurchaseUserTransferRelationsSchema(mysqlTable),
+		purchaseUserTransferRelations: getPurchaseUserTransferRelationsSchema(
+			mysqlTable,
+			userRelationsOverrides,
+		),
 		communicationChannel: getCommunicationChannelSchema(mysqlTable),
 		communicationPreferenceTypes:
 			getCommunicationPreferenceTypesSchema(mysqlTable),
 		communicationPreferences: getCommunicationPreferencesSchema(mysqlTable),
 		communicationPreferencesRelations:
-			getCommunicationPreferencesRelationsSchema(mysqlTable),
+			getCommunicationPreferencesRelationsSchema(
+				mysqlTable,
+				userRelationsOverrides,
+			),
 		contentContributions: getContentContributionsSchema(mysqlTable),
-		contentContributionRelations:
-			getContentContributionRelationsSchema(mysqlTable),
+		contentContributionRelations: getContentContributionRelationsSchema(
+			mysqlTable,
+			userRelationsOverrides,
+		),
 		contentResource: getContentResourceSchema(mysqlTable),
 		contentResourceVersion: getContentResourceVersionSchema(mysqlTable),
-		contentResourceVersionRelations:
-			getContentResourceVersionRelationsSchema(mysqlTable),
-		contentResourceRelations: getContentResourceRelationsSchema(mysqlTable),
+		contentResourceVersionRelations: getContentResourceVersionRelationsSchema(
+			mysqlTable,
+			userRelationsOverrides,
+		),
+		contentResourceRelations: getContentResourceRelationsSchema(
+			mysqlTable,
+			userRelationsOverrides,
+		),
 		contentResourceResource: getContentResourceResourceSchema(mysqlTable),
 		contentResourceResourceRelations:
 			getContentResourceResourceRelationsSchema(mysqlTable),
@@ -288,6 +377,11 @@ export function getCourseBuilderSchema(mysqlTable: MySqlTableFn) {
 		contributionTypes: getContributionTypesSchema(mysqlTable),
 		contributionTypesRelations: getContributionTypesRelationsSchema(mysqlTable),
 		resourceProgress: getResourceProgressSchema(mysqlTable),
+		questionResponse: getQuestionResponseSchema(mysqlTable),
+		questionResponseRelations: getQuestionResponseRelationsSchema(
+			mysqlTable,
+			userRelationsOverrides,
+		),
 		upgradableProducts: getUpgradableProductsSchema(mysqlTable),
 		upgradableProductsRelations:
 			getUpgradableProductsRelationsSchema(mysqlTable),
@@ -296,23 +390,36 @@ export function getCourseBuilderSchema(mysqlTable: MySqlTableFn) {
 			getContentResourceProductRelationsSchema(mysqlTable),
 		productRelations: getProductRelationsSchema(mysqlTable),
 		comments: getCommentsSchema(mysqlTable),
-		commentsRelations: getCommentRelationsSchema(mysqlTable),
+		commentsRelations: getCommentRelationsSchema(
+			mysqlTable,
+			userRelationsOverrides,
+		),
 		deviceVerifications: getDeviceVerificationSchema(mysqlTable),
-		deviceVerificationRelations:
-			getDeviceVerificationRelationsSchema(mysqlTable),
+		deviceVerificationRelations: getDeviceVerificationRelationsSchema(
+			mysqlTable,
+			userRelationsOverrides,
+		),
 		deviceAccessToken: getDeviceAccessTokenSchema(mysqlTable),
-		deviceAccessTokenRelations: getDeviceAccessTokenRelationsSchema(mysqlTable),
+		deviceAccessTokenRelations: getDeviceAccessTokenRelationsSchema(
+			mysqlTable,
+			userRelationsOverrides,
+		),
 		tag: getTagSchema(mysqlTable),
 		tagRelations: getTagRelationsSchema(mysqlTable),
 		tagTag: getTagTagSchema(mysqlTable),
 		tagTagRelations: getTagTagRelationsSchema(mysqlTable),
 		userPrefs: getUserPrefsSchema(mysqlTable),
-		userPrefsRelations: getUserPrefsRelationsSchema(mysqlTable),
+		userPrefsRelations: getUserPrefsRelationsSchema(
+			mysqlTable,
+			userRelationsOverrides,
+		),
 		organization: getOrganizationsSchema(mysqlTable),
 		organizationRelations: getOrganizationsRelationsSchema(mysqlTable),
 		organizationMemberships: getOrganizationMembershipsSchema(mysqlTable),
-		organizationMembershipRelations:
-			getOrganizationMembershipsRelationsSchema(mysqlTable),
+		organizationMembershipRelations: getOrganizationMembershipsRelationsSchema(
+			mysqlTable,
+			userRelationsOverrides,
+		),
 		organizationMembershipRoles:
 			getOrganizationMembershipRolesSchema(mysqlTable),
 		organizationMembershipRolesRelations:
@@ -323,10 +430,16 @@ export function getCourseBuilderSchema(mysqlTable: MySqlTableFn) {
 		subscription: getSubscriptionSchema(mysqlTable),
 		subscriptionRelations: getSubscriptionRelationsSchema(mysqlTable),
 		profiles: getProfilesSchema(mysqlTable),
-		profilesRelations: getProfilesRelationsSchema(mysqlTable),
+		profilesRelations: getProfilesRelationsSchema(
+			mysqlTable,
+			userRelationsOverrides,
+		),
 		entitlementTypes: getEntitlementTypesSchema(mysqlTable),
 		entitlements: getEntitlementsSchema(mysqlTable),
-		entitlementsRelations: getEntitlementRelationsSchema(mysqlTable),
+		entitlementsRelations: getEntitlementRelationsSchema(
+			mysqlTable,
+			userRelationsOverrides,
+		),
 	} as const
 }
 
@@ -349,12 +462,14 @@ export function mySqlDrizzleAdapter(
 		contentResource,
 		contentResourceResource,
 		contentResourceProduct,
+		contentResourceTag,
 		purchases: purchaseTable,
 		purchaseUserTransfer,
 		coupon,
 		merchantCoupon,
 		merchantCharge,
 		merchantAccount,
+		merchantEvents,
 		merchantPrice,
 		merchantCustomer,
 		merchantSession,
@@ -370,6 +485,8 @@ export function mySqlDrizzleAdapter(
 		roles: roleTable,
 		merchantSubscription: merchantSubscriptionTable,
 		subscription: subscriptionTable,
+		entitlements: entitlementTable,
+		entitlementTypes,
 	} = createTables(tableFn)
 
 	const adapter: CourseBuilderAdapter = {
@@ -420,7 +537,13 @@ export function mySqlDrizzleAdapter(
 
 				if (existingPurchases.length > 0) {
 					const errorMessage = `already-purchased-${email}`
-					console.error(errorMessage)
+					logger.info('adapter.coupon.redeem.already_purchased', {
+						couponId: coupon.id,
+						currentUserId,
+						email,
+						productId,
+						userId: user.id,
+					})
 					return {
 						error: {
 							message: errorMessage,
@@ -510,6 +633,21 @@ export function mySqlDrizzleAdapter(
 				}),
 			)
 		},
+		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),
+				}),
+			)
+		},
 		getMerchantAccount: async (options) => {
 			return merchantAccountSchema.parse(
 				await client.query.merchantAccount.findFirst({
@@ -529,10 +667,10 @@ export function mySqlDrizzleAdapter(
 				merchantPriceSchema.safeParse(merchantPriceData)
 
 			if (!parsedMerchantPrice.success) {
-				console.error(
-					'Error parsing merchant price',
-					JSON.stringify(parsedMerchantPrice.error),
-				)
+				logger.error(parsedMerchantPrice.error, {
+					event: 'adapter.merchantPrice.parse_failed',
+					productId,
+				})
 				return null
 			}
 
@@ -638,7 +776,11 @@ export function mySqlDrizzleAdapter(
 				resourceProgressSchema.safeParse(lessonProgress)
 
 			if (!parsedLessonProgress.success) {
-				console.error('Error parsing lesson progress', lessonProgress)
+				logger.error(parsedLessonProgress.error, {
+					event: 'adapter.lessonProgress.parse_failed',
+					lessonId: options.lessonId,
+					userId: options.userId,
+				})
 				return null
 			}
 
@@ -680,10 +822,11 @@ export function mySqlDrizzleAdapter(
 				.safeParse(couponForIdOrCode)
 
 			if (!parsedCoupon.success) {
-				console.error(
-					'Error parsing coupon',
-					JSON.stringify(parsedCoupon.error),
-				)
+				logger.error(parsedCoupon.error, {
+					code: options.code,
+					couponId: options.couponId,
+					event: 'adapter.coupon.parse_failed',
+				})
 				return null
 			}
 
@@ -817,15 +960,35 @@ export function mySqlDrizzleAdapter(
 								})
 								.where(eq(coupon.id, bulkCouponId))
 						} else {
-							const merchantCouponToUse = stripeCouponId
+							// Try to find merchant coupon by stripeCouponId first
+							let merchantCouponToUse = stripeCouponId
 								? merchantCouponSchema.nullable().parse(
-										await client.query.merchantCoupon.findFirst({
+										(await client.query.merchantCoupon.findFirst({
 											where: eq(merchantCoupon.identifier, stripeCouponId),
-										}),
+										})) || null,
 									)
 								: null
 
-							couponToUpdate = await client.insert(coupon).values({
+							// 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 client.query.coupon.findFirst({
+										where: eq(coupon.id, usedCouponId),
+									})) || null,
+								)
+
+								// Then get the merchant coupon
+								if (usedCoupon?.merchantCouponId) {
+									merchantCouponToUse = merchantCouponSchema.nullable().parse(
+										(await client.query.merchantCoupon.findFirst({
+											where: eq(merchantCoupon.id, usedCoupon.merchantCouponId),
+										})) || null,
+									)
+								}
+							}
+
+							const bulkCouponValues = {
 								id: bulkCouponId as string,
 								percentageDiscount: '1.0',
 								restrictedToProductId: productId,
@@ -837,7 +1000,11 @@ export function mySqlDrizzleAdapter(
 											merchantCouponId: merchantCouponToUse.id,
 										}
 									: {}),
-							})
+							}
+
+							couponToUpdate = await client
+								.insert(coupon)
+								.values(bulkCouponValues)
 						}
 					}
 
@@ -909,7 +1076,14 @@ export function mySqlDrizzleAdapter(
 
 					return purchaseId
 				} catch (error) {
-					console.error(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
 				}
@@ -922,11 +1096,12 @@ export function mySqlDrizzleAdapter(
 			)
 
 			if (!parsedPurchase.success) {
-				console.error(
-					'Error parsing purchase',
-					parsedPurchase,
-					JSON.stringify(parsedPurchase, null, 2),
-				)
+				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')
 			}
 
@@ -957,6 +1132,45 @@ export function mySqlDrizzleAdapter(
 				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 findOrCreateUser(
 			email: string,
 			name?: string | null,
@@ -973,10 +1187,13 @@ export function mySqlDrizzleAdapter(
 					name,
 					emailVerified: null,
 				})
-				console.log('newUser', { newUser })
 				if (!newUser) {
 					throw new Error('Could not create user')
 				}
+				logger.info('adapter.user.created', {
+					email,
+					userId: newUser.id,
+				})
 				return {
 					user: newUser as User,
 					isNewUser: true,
@@ -997,7 +1214,10 @@ export function mySqlDrizzleAdapter(
 					),
 				})) || null
 
-			logger.debug('loadedCoupon', { loadedCoupon })
+			logger.debug('getCoupon', {
+				couponIdOrCode,
+				found: !!loadedCoupon,
+			})
 
 			return couponSchema.nullable().parse(loadedCoupon)
 		},
@@ -1022,7 +1242,7 @@ export function mySqlDrizzleAdapter(
 		> {
 			logger.debug('getCouponWithBulkPurchases', { couponId })
 			let couponData
-			let bulkCouponPurchases
+			let bulkCouponPurchases: unknown[] = []
 			try {
 				couponData =
 					(await client.query.coupon.findFirst({
@@ -1033,8 +1253,11 @@ export function mySqlDrizzleAdapter(
 						},
 					})) || null
 			} catch (e) {
-				console.log('getCouponWithBulkPurchases')
-				logger.error(e as Error)
+				logger.error(e as Error, {
+					method: 'getCouponWithBulkPurchases',
+					couponId,
+					step: 'load-coupon',
+				})
 			}
 
 			try {
@@ -1044,10 +1267,16 @@ export function mySqlDrizzleAdapter(
 						user: true,
 					},
 				})
-				console.log('purchases with redeemedBulkCouponId', bulkCouponPurchases)
+				logger.debug('getCouponWithBulkPurchases.redeemed', {
+					couponId,
+					count: bulkCouponPurchases?.length ?? 0,
+				})
 			} catch (e) {
-				console.log('getCouponWithBulkPurchases')
-				logger.error(e as Error)
+				logger.error(e as Error, {
+					method: 'getCouponWithBulkPurchases',
+					couponId,
+					step: 'load-redeemed-purchases',
+				})
 			}
 
 			if (!couponData) {
@@ -1073,11 +1302,11 @@ export function mySqlDrizzleAdapter(
 				.safeParse(couponWithBulkPurchases)
 
 			if (!parsedCoupon.success) {
-				console.error(
-					'Error parsing coupon',
-					JSON.stringify(parsedCoupon.error),
-					couponData,
-				)
+				logger.error(parsedCoupon.error, {
+					couponId: couponData?.id ?? couponId,
+					event: 'adapter.coupon.parse_failed',
+					redeemedBulkCouponPurchasesCount: bulkCouponPurchases?.length ?? 0,
+				})
 				return null
 			}
 
@@ -1141,7 +1370,10 @@ export function mySqlDrizzleAdapter(
 			})
 			const parsed = z.array(resourceProgressSchema).safeParse(userProgress)
 			if (!parsed.success) {
-				console.error('Error parsing user progress', userProgress)
+				logger.error(parsed.error, {
+					event: 'adapter.userProgress.parse_failed',
+					userId,
+				})
 				return []
 			}
 			return parsed.data
@@ -1172,41 +1404,63 @@ export function mySqlDrizzleAdapter(
 					.transform((val) => (val ? new Date(val) : null)),
 			})
 
-			// Execute the optimized query
+			// Execute the optimized query - create a flattened, properly ordered list
 			const results: any = await client.execute(sql`
-        SELECT
-						cr.id AS resource_id,
+				WITH RECURSIVE workshop AS (
+					SELECT id, fields->>'$.slug' AS slug
+					FROM ${contentResource}
+					WHERE id = ${moduleIdOrSlug} OR fields->>'$.slug' = ${moduleIdOrSlug}
+				),
+				-- Get all workshop resources with their positions
+				workshop_structure AS (
+					SELECT
+						w.id AS workshop_id,
+						crr.resourceId,
+						crr.position AS position,
 						cr.type AS resource_type,
 						cr.fields->>'$.slug' AS resource_slug,
-						rp.completedAt AS completed_at
-				FROM
-						(SELECT id, fields->>'$.slug' AS slug
-						 FROM ${contentResource}
-						 WHERE id = ${moduleIdOrSlug}
-								OR fields->>'$.slug' = ${moduleIdOrSlug}) AS w
-				LEFT JOIN
-						(SELECT
-								crr.resourceOfId AS workshop_id,
-								crr.resourceId,
-								crr.position
-						 FROM ${contentResourceResource} crr) AS tlr ON w.id = tlr.workshop_id
-				LEFT JOIN ${contentResource} sections ON sections.id = tlr.resourceId AND sections.type = 'section'
-				LEFT JOIN
-						(SELECT
-								crr.resourceOfId AS section_id,
-								crr.resourceId AS resource_id,
-								crr.position AS position_in_section,
-								section_crr.position AS section_position
-						 FROM ${contentResourceResource} crr
-						 JOIN ${contentResourceResource} section_crr ON crr.resourceOfId = section_crr.resourceId) AS sr
-				ON sr.section_id = sections.id
-				JOIN ${contentResource} cr ON cr.id = COALESCE(sr.resource_id, tlr.resourceId)
-				LEFT JOIN ${resourceProgress} rp ON rp.resourceId = cr.id
-						AND rp.userId = ${user.id}
-				WHERE
-						cr.type IN ('lesson', 'exercise', 'post')
-
-    `)
+						cr.id AS resource_content_id
+					FROM workshop w
+					JOIN ${contentResourceResource} crr ON w.id = crr.resourceOfId
+					JOIN ${contentResource} cr ON crr.resourceId = cr.id
+					ORDER BY crr.position
+				),
+				-- Recursively expand sections and maintain global ordering
+				expanded_resources AS (
+					-- Base case: direct lessons/posts from workshop
+					SELECT
+						workshop_id,
+						position * 1000 AS global_order, -- Multiply by 1000 to leave room for section items
+						resource_content_id AS resource_id,
+						resource_type,
+						resource_slug
+					FROM workshop_structure
+					WHERE resource_type IN ('lesson', 'post')
+					UNION ALL
+					-- Recursive case: lessons within sections
+					SELECT
+						ws.workshop_id,
+						ws.position * 1000 + crr.position AS global_order, -- Section position * 1000 + lesson position
+						cr.id AS resource_id,
+						cr.type AS resource_type,
+						cr.fields->>'$.slug' AS resource_slug
+					FROM workshop_structure ws
+					JOIN ${contentResourceResource} crr ON ws.resource_content_id = crr.resourceOfId
+					JOIN ${contentResource} cr ON crr.resourceId = cr.id
+					WHERE ws.resource_type = 'section'
+					AND cr.type IN ('lesson', 'post')
+				)
+				SELECT
+					er.resource_id,
+					er.resource_type,
+					er.resource_slug,
+					rp.completedAt AS completed_at,
+					er.global_order
+				FROM expanded_resources er
+				LEFT JOIN ${resourceProgress} rp ON rp.resourceId = er.resource_id
+					AND rp.userId = ${user.id}
+				ORDER BY er.global_order ASC
+			`)
 			// Process the results
 			const completedLessons: ResourceProgress[] = []
 			let nextResource: Partial<ContentResource> | null = null
@@ -1216,7 +1470,11 @@ export function mySqlDrizzleAdapter(
 			const parsedRows = z.array(ResultRowSchema).safeParse(results.rows)
 
 			if (!parsedRows.success) {
-				console.error('Error parsing rows', parsedRows.error)
+				logger.error(parsedRows.error, {
+					event: 'adapter.moduleProgress.rows.parse_failed',
+					moduleIdOrSlug,
+					userId: user.id,
+				})
 				return {
 					completedLessons: [],
 					nextResource: null,
@@ -1270,7 +1528,10 @@ export function mySqlDrizzleAdapter(
 			})
 			const parsed = merchantChargeSchema.safeParse(mCharge)
 			if (!parsed.success) {
-				console.info('Error parsing merchantCharge', mCharge)
+				logger.error(parsed.error, {
+					event: 'adapter.merchantCharge.parse_failed',
+					merchantChargeId,
+				})
 				return null
 			}
 			return parsed.data
@@ -1314,6 +1575,26 @@ export function mySqlDrizzleAdapter(
 
 			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> {
@@ -1445,26 +1726,56 @@ export function mySqlDrizzleAdapter(
 				currentProduct.price.unitAmount.toString() !==
 				input.price?.unitAmount.toString()
 
-			if (priceChanged) {
-				const currentMerchantPrice = merchantPriceSchema.nullish().parse(
-					await client.query.merchantPrice.findFirst({
-						where: (merchantPrice, { eq, and }) =>
-							and(
-								eq(merchantPrice.merchantProductId, merchantProduct.id),
-								eq(merchantPrice.status, 1),
-							),
-					}),
-				)
+			// 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`)
-				}
+			if (!currentMerchantPrice || !currentMerchantPrice.identifier) {
+				throw new Error(`Merchant price not found`)
+			}
 
-				const currentStripePrice = await paymentProvider.getPrice(
-					currentMerchantPrice.identifier,
-				)
+			const currentStripePrice = await paymentProvider.getPrice(
+				currentMerchantPrice.identifier,
+			)
 
-				const newStripePrice = await paymentProvider.createPrice({
+			// 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',
@@ -1472,8 +1783,26 @@ export function mySqlDrizzleAdapter(
 						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,
 				})
@@ -1568,6 +1897,16 @@ export function mySqlDrizzleAdapter(
 					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,
+					}),
 				},
 			}
 
@@ -1600,6 +1939,10 @@ export function mySqlDrizzleAdapter(
 				metadata: {
 					slug: product?.fields?.slug || null,
 				},
+				// Membership products get recurring billing
+				...(input.type === 'membership' && {
+					recurring: { interval: input.billingInterval || 'year' },
+				}),
 			})
 
 			const newMerchantProductId = `mproduct_${v4()}`
@@ -1662,16 +2005,20 @@ export function mySqlDrizzleAdapter(
 				})
 				const parsedProduct = productSchema.safeParse(productData)
 				if (!parsedProduct.success) {
-					console.error(
-						'Error parsing product',
-						JSON.stringify(parsedProduct.error),
-						JSON.stringify(productData),
-					)
+					logger.error(parsedProduct.error, {
+						event: 'adapter.product.parse_failed',
+						productId: productData?.id,
+						productSlugOrId,
+					})
 					return null
 				}
 				return parsedProduct.data
 			} catch (e) {
-				console.log('getProduct error', e)
+				logger.error(toError(e), {
+					event: 'adapter.product.lookup.failed',
+					productSlugOrId,
+					withResources,
+				})
 				return null
 			}
 		},
@@ -1742,11 +2089,14 @@ export function mySqlDrizzleAdapter(
 			)
 
 			if (!chargeForPurchase) {
-				logger.error(
-					new Error(
-						`No charge found for purchase: Stripe Charge ID: ${stripeChargeId}`,
-					),
-				)
+				// Expected during initial checkout processing — the merchant
+				// charge hasn't been created yet. Also expected when the
+				// payment-status-checker passes a PaymentIntent ID (pi_xxx)
+				// instead of a Charge ID (ch_xxx).
+				logger.debug('getPurchaseForStripeCharge: no matching charge', {
+					stripeChargeId,
+					idPrefix: stripeChargeId?.substring(0, 3),
+				})
 				return null
 			}
 
@@ -1767,6 +2117,40 @@ export function mySqlDrizzleAdapter(
 
 			return purchase.data
 		},
+		async getPurchaseByCheckoutSessionId(
+			checkoutSessionId: string,
+		): Promise<Purchase | null> {
+			logger.debug('getPurchaseByCheckoutSessionId', { checkoutSessionId })
+
+			// Find the MerchantSession by its identifier (the Stripe checkout session ID)
+			const session = await client.query.merchantSession.findFirst({
+				where: eq(merchantSession.identifier, checkoutSessionId),
+			})
+
+			if (!session) {
+				logger.debug('getPurchaseByCheckoutSessionId: no matching session', {
+					checkoutSessionId,
+				})
+				return null
+			}
+
+			const purchase = purchaseSchema.safeParse(
+				await client.query.purchases.findFirst({
+					where: eq(purchaseTable.merchantSessionId, String(session.id)),
+					with: {
+						user: true,
+						product: true,
+						bulkCoupon: true,
+					},
+				}),
+			)
+
+			if (!purchase.success) {
+				return null
+			}
+
+			return purchase.data
+		},
 		async getPurchaseUserTransferById(options: { id: string }): Promise<
 			| (PurchaseUserTransfer & {
 					sourceUser: User
@@ -1817,7 +2201,10 @@ export function mySqlDrizzleAdapter(
 				.safeParse(purchaseData)
 
 			if (!parsedPurchase.success) {
-				console.error('Error parsing purchase', parsedPurchase.error)
+				logger.error(parsedPurchase.error, {
+					event: 'adapter.purchase.parse_failed',
+					purchaseId,
+				})
 				return null
 			}
 			return parsedPurchase.data
@@ -1845,15 +2232,85 @@ export function mySqlDrizzleAdapter(
 			const parsedPurchases = z.array(purchaseSchema).safeParse(userPurchases)
 
 			if (!parsedPurchases.success) {
-				console.error(
-					'Error parsing purchases',
-					JSON.stringify(parsedPurchases.error),
-				)
+				logger.error(parsedPurchases.error, {
+					event: 'adapter.purchase.list.parse_failed',
+					purchaseCount: userPurchases.length,
+					userId,
+				})
 				return []
 			}
 
 			return parsedPurchases.data
 		},
+		async getEntitlementsForUser(params: {
+			userId: string
+			sourceType?: string
+			entitlementType?: string
+		}): Promise<Entitlement[]> {
+			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: string,
+		): Promise<{ id: string; name: string } | null> {
+			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),
+			}
+		},
 		async getPurchaseDetails(
 			purchaseId: string,
 			userId: string,
@@ -1896,7 +2353,11 @@ export function mySqlDrizzleAdapter(
 			const parsedPurchase = purchaseSchema.safeParse(thePurchase)
 
 			if (!parsedPurchase.success) {
-				console.error('Error parsing purchase', parsedPurchase)
+				logger.error(parsedPurchase.error, {
+					event: 'adapter.purchase.details.parse_failed',
+					purchaseId,
+					userId,
+				})
 				return {
 					availableUpgrades: [],
 				}
@@ -2095,7 +2556,11 @@ export function mySqlDrizzleAdapter(
 				resourceProgressSchema.safeParse(lessonProgress)
 
 			if (!parsedLessonProgress.success) {
-				console.error('Error parsing lesson progress', lessonProgress)
+				logger.error(parsedLessonProgress.error, {
+					event: 'adapter.lessonProgress.parse_failed',
+					lessonId: options.lessonId,
+					userId: options.userId,
+				})
 				return null
 			}
 
@@ -2206,7 +2671,10 @@ export function mySqlDrizzleAdapter(
 			status: 'Valid' | 'Refunded' | 'Disputed' | 'Banned' | 'Restricted',
 		): Promise<Purchase | undefined> {
 			try {
-				console.log('updatePurchaseStatusForCharge', { chargeId, status })
+				logger.debug('adapter.purchase.status_update.started', {
+					chargeId,
+					status,
+				})
 				const merchantChargeForPurchase =
 					await client.query.merchantCharge.findFirst({
 						where: or(
@@ -2215,7 +2683,12 @@ export function mySqlDrizzleAdapter(
 						),
 					})
 
-				console.log('merchantChargeForPurchase', { merchantChargeForPurchase })
+				logger.debug('adapter.purchase.status_update.charge_resolved', {
+					chargeId,
+					merchantChargeId: merchantChargeForPurchase?.id ?? null,
+					merchantChargeIdentifier:
+						merchantChargeForPurchase?.identifier ?? null,
+				})
 
 				const parsedMerchantChargeForPurchase = merchantChargeSchema.parse(
 					merchantChargeForPurchase,
@@ -2248,7 +2721,11 @@ export function mySqlDrizzleAdapter(
 					throw new Error(`no-purchase-found-for-charge ${chargeId}`)
 				}
 			} catch (e) {
-				console.log('error updating purchase status', e)
+				logger.error(toError(e), {
+					chargeId,
+					event: 'adapter.purchase.status_update.failed',
+					status,
+				})
 				throw e
 			}
 		},
@@ -2383,7 +2860,10 @@ export function mySqlDrizzleAdapter(
 			const parsedResource = ContentResourceSchema.safeParse(resource)
 
 			if (!parsedResource.success) {
-				console.error('Error parsing resource', resource)
+				logger.error(parsedResource.error, {
+					event: 'adapter.contentResource.parse_failed',
+					resourceId: options.id,
+				})
 				return null
 			}
 
@@ -2418,10 +2898,63 @@ export function mySqlDrizzleAdapter(
 					return parsedResource.success ? parsedResource.data : null
 				})
 				.catch((error) => {
-					console.error(error)
+					logger.error(toError(error), {
+						event: 'adapter.videoResource.lookup.failed',
+						resourceId: id,
+					})
 					throw error
 				})
 		},
+		async getParentResourceOfVideoResource(
+			videoResourceId: string,
+		): Promise<ContentResource | null> {
+			if (!videoResourceId) {
+				return null
+			}
+
+			// Use a SQL query to find the parent post or lesson of this video resource
+			const results = await client
+				.select()
+				.from(contentResource)
+				.innerJoin(
+					contentResourceResource,
+					eq(contentResourceResource.resourceOfId, contentResource.id),
+				)
+				.where(
+					and(
+						eq(contentResourceResource.resourceId, videoResourceId),
+						or(
+							eq(contentResource.type, 'post'),
+							eq(contentResource.type, 'lesson'),
+						),
+					),
+				)
+				.limit(1)
+
+			if (!results || results.length === 0) {
+				return null
+			}
+
+			const resourceData = results[0]?.ContentResource
+
+			if (!resourceData) {
+				return null
+			}
+
+			// Fetch the full resource with relationships
+			const fullResource = await client.query.contentResource.findFirst({
+				where: eq(contentResource.id, resourceData.id),
+				with: {
+					resources: true,
+				},
+			})
+
+			if (!fullResource) {
+				return null
+			}
+
+			return ContentResourceSchema.parse(fullResource)
+		},
 		async createContentResource(data) {
 			const id = data.id || crypto.randomUUID()
 
@@ -2451,7 +2984,11 @@ export function mySqlDrizzleAdapter(
 			const parsedResource = ContentResourceSchema.safeParse(resource)
 
 			if (!parsedResource.success) {
-				console.error('Error parsing resource', resource)
+				logger.error(parsedResource.error, {
+					event: 'adapter.contentResource.parse_failed',
+					resourceId: id,
+					resourceType: data.type,
+				})
 				throw new Error('Error parsing resource')
 			}
 
@@ -2496,32 +3033,1216 @@ export function mySqlDrizzleAdapter(
 			const parsedResource = ContentResourceSchema.safeParse(resource)
 
 			if (!parsedResource.success) {
-				console.error('Error parsing resource', resource)
+				logger.error(parsedResource.error, {
+					event: 'adapter.contentResource.parse_failed',
+					resourceId: resource?.id,
+					resourceIdOrSlug: data,
+				})
 				return null
 			}
 
 			return parsedResource.data
 		},
-		async createUser(data) {
-			try {
-				const id = crypto.randomUUID()
+		async getEvent(
+			eventIdOrSlug: string,
+			options?: {
+				withResources?: boolean
+				withTags?: boolean
+				withProducts?: boolean
+				withPricing?: boolean
+			},
+		): Promise<ContentResource | null> {
+			const {
+				withResources = false,
+				withTags = false,
+				withProducts = false,
+				withPricing = false,
+			} = options || {}
 
-				await client.insert(users).values({ ...data, id })
+			const eventQuery = await client.query.contentResource.findFirst({
+				where: and(
+					or(
+						eq(contentResource.type, 'event'),
+						eq(contentResource.type, 'event-series'),
+					),
+					or(
+						eq(contentResource.id, eventIdOrSlug),
+						eq(
+							sql`JSON_EXTRACT (${contentResource.fields}, "$.slug")`,
+							eventIdOrSlug,
+						),
+					),
+				),
+				with: {
+					...(withResources && {
+						resources: {
+							with: { resource: true },
+							orderBy: asc(contentResourceResource.position),
+						},
+					}),
+					...(withTags && {
+						tags: {
+							with: { tag: true },
+							orderBy: asc(contentResourceTag.position),
+						},
+					}),
+					...(withProducts && {
+						resourceProducts: {
+							with: {
+								product: {
+									...(withPricing && {
+										with: { price: true },
+									}),
+								},
+							},
+						},
+					}),
+				},
+			})
 
-				// creating a personal organization for the user
-				// every user gets an organization of their very own
-				const personalOrganization = await adapter.createOrganization({
-					name: `Personal (${data.email})`,
+			const parsedEvent = ContentResourceSchema.safeParse(eventQuery)
+			if (!parsedEvent.success) {
+				logger.debug('Error parsing event', {
+					eventQuery,
+					error: parsedEvent.error,
 				})
+				return null
+			}
 
-				if (!personalOrganization) {
-					throw new Error('Failed to create personal organization')
-				}
+			return parsedEvent.data
+		},
+		async addResourceToProduct(options: {
+			resource: ContentResource
+			productId: string
+			userId: string
+		}) {
+			const { resource, productId, userId } = options
+			const product = await adapter.getProduct(productId)
 
-				const membership = await adapter.addMemberToOrganization({
-					organizationId: personalOrganization.id,
-					userId: id,
-					invitedById: id,
+			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
+			)
+		},
+		async createEvent(
+			input: {
+				type: 'event'
+				fields: {
+					title: string
+					startsAt?: Date | null | undefined
+					endsAt?: Date | null | undefined
+					description?: string | null | undefined
+					price?: number | null | undefined
+					quantity?: number | null | undefined
+					state?: string | null | undefined
+					visibility?: string | null | undefined
+					slug?: string | null | undefined
+					tagIds?:
+						| { id: string; fields: Record<string, any> }[]
+						| null
+						| undefined
+				}
+				coupon?: {
+					enabled: boolean
+					percentageDiscount: string
+					expires: Date
+				}
+			},
+			userId: string,
+		) {
+			const hash = guid()
+			const newEventId = slugify(`${input.type}~${hash}`)
+
+			const newEvent = {
+				id: newEventId,
+				type: 'event',
+				fields: {
+					title: input.fields.title,
+					state: 'draft',
+					visibility: 'public',
+					slug: slugify(`${input.fields.title}~${hash}`),
+					description: input.fields.description,
+					startsAt: input.fields.startsAt,
+					endsAt: input.fields.endsAt,
+				},
+				createdById: userId,
+			}
+
+			await client.insert(contentResource).values(newEvent)
+			const event = await adapter.getEvent(newEventId, {
+				withResources: true,
+				withTags: true,
+				withProducts: true,
+				withPricing: true,
+			})
+
+			const parsedEvent = ContentResourceSchema.safeParse(event)
+
+			if (!parsedEvent.success) {
+				logger.error(new Error('Error parsing event resource'))
+				throw new Error('Error parsing event resource')
+			}
+
+			// if price is provided, create a product and associate it with the event
+			if (input.fields.price && input.fields.price > 0) {
+				try {
+					const product = await adapter.createProduct({
+						name: input.fields.title,
+						price: input.fields.price,
+						quantityAvailable: input.fields.quantity ?? -1,
+						type: 'live',
+						state: 'published',
+						visibility: 'public',
+					})
+					if (product) {
+						const resourceProduct = await adapter.addResourceToProduct({
+							resource: parsedEvent.data,
+							productId: product.id,
+							userId,
+						})
+						if (!resourceProduct) {
+							logger.error(new Error('Failed to add resource to product'))
+							logger.debug('event.addResourceToProduct.failed', {
+								eventId: newEventId,
+								productId: product.id,
+								userId,
+							})
+						} else {
+							logger.debug('event.addResourceToProduct.success', {
+								eventId: newEventId,
+								productId: product.id,
+								userId,
+							})
+						}
+						// Create coupon if enabled
+						if (
+							input.coupon?.enabled &&
+							input.coupon.percentageDiscount &&
+							input.coupon.expires
+						) {
+							try {
+								const finalExpires = normalizeExpirationDate(
+									input.coupon.expires,
+								)
+								const couponInput = {
+									quantity: '1',
+									maxUses: -1,
+									expires: finalExpires || null,
+									restrictedToProductId: product.id,
+									percentageDiscount: input.coupon.percentageDiscount,
+									status: 1,
+									default: true,
+									fields: {
+										bypassSoldOut: false,
+									},
+								}
+								await adapter.createCoupon(couponInput)
+								logger.debug('event.create.coupon.success', {
+									eventId: newEventId,
+									productId: product.id,
+									userId,
+									percentageDiscount: input.coupon.percentageDiscount,
+								})
+							} catch (couponError) {
+								logger.error(
+									new Error(
+										`Failed to create coupon for event: ${couponError}`,
+									),
+								)
+								logger.debug('event.create.coupon.failed', {
+									eventId: newEventId,
+									productId: product.id,
+									userId,
+								})
+								// Don't throw here - event creation should succeed even if coupon fails
+							}
+						}
+					} else {
+						logger.error(new Error('Failed to create product'))
+						logger.debug('event.create.product.failed', {
+							eventId: newEventId,
+							userId,
+							price: input.fields.price,
+						})
+					}
+				} catch (error) {
+					logger.error(
+						new Error(`Error creating and associating product: ${error}`),
+					)
+					logger.debug('event.create.product.failed', {
+						eventId: newEventId,
+						userId,
+						price: input.fields.price,
+					})
+				}
+			}
+
+			// if we provide tagIds, we need to associate them with the event
+			if (input.fields.tagIds) {
+				try {
+					await client.insert(contentResourceTag).values(
+						input.fields.tagIds.map((tag) => ({
+							contentResourceId: newEventId,
+							tagId: tag.id,
+							createdAt: new Date(),
+							updatedAt: new Date(),
+							position: 0,
+						})),
+					)
+					logger.debug('event.create.tags.success', {
+						eventId: newEventId,
+						userId,
+						tagIds: input.fields.tagIds,
+					})
+				} catch (error) {
+					logger.error(new Error(`Error associating tags with event: ${error}`))
+					logger.debug('event.create.tags.failed', {
+						eventId: newEventId,
+						userId,
+						tagIds: input.fields.tagIds,
+					})
+				}
+			}
+
+			return parsedEvent.data
+		},
+		async createEventSeries(
+			input: {
+				eventSeries: {
+					type: 'event-series'
+					fields: {
+						title: string
+						description?: string | undefined
+						tagIds?:
+							| { id: string; fields: { label: string; name: string } }[]
+							| null
+							| undefined
+					}
+					sharedFields: {
+						price: number | null | undefined
+						quantity: number | null | undefined
+					}
+				}
+				childEvents: Array<{
+					type: 'event'
+					fields: {
+						title: string
+						startsAt: Date | null | undefined
+						endsAt: Date | null | undefined
+						description?: string | undefined
+						tagIds?:
+							| { id: string; fields: { label: string; name: string } }[]
+							| null
+							| undefined
+					}
+				}>
+				coupon?:
+					| {
+							enabled: boolean
+							expires?: Date | undefined
+							percentageDiscount?: string | undefined
+					  }
+					| undefined
+			},
+			userId: string,
+		) {
+			const { eventSeries: eventSeriesInput, childEvents: childEventsInput } =
+				input
+
+			if (childEventsInput.length === 0) {
+				throw new Error('At least one event is required')
+			}
+
+			// Execute all database operations within a transaction
+			const result = await client.transaction(async (tx) => {
+				// Step 1: Create the event series resource
+				const eventSeriesHash = guid()
+				const eventSeriesResourceId = slugify(`event-series~${eventSeriesHash}`)
+
+				const newEventSeries = {
+					id: eventSeriesResourceId,
+					type: 'event-series',
+					fields: {
+						...eventSeriesInput.fields,
+						title: eventSeriesInput.fields.title,
+						state: 'draft',
+						visibility: 'public',
+						slug: slugify(
+							`${eventSeriesInput.fields.title}~${eventSeriesHash}`,
+						),
+					},
+					createdById: userId,
+				}
+
+				await tx.insert(contentResource).values(newEventSeries)
+
+				// Fetch the created event series with relations
+				const eventSeriesResource = await tx.query.contentResource.findFirst({
+					where: eq(contentResource.id, eventSeriesResourceId),
+					with: {
+						resources: {
+							with: {
+								resource: {
+									with: {
+										resources: {
+											with: {
+												resource: true,
+											},
+											orderBy: asc(contentResourceResource.position),
+										},
+									},
+								},
+							},
+							orderBy: asc(contentResourceResource.position),
+						},
+						tags: {
+							with: {
+								tag: true,
+							},
+							orderBy: asc(contentResourceTag.position),
+						},
+						resourceProducts: {
+							with: {
+								product: {
+									with: {
+										price: true,
+									},
+								},
+							},
+						},
+					},
+				})
+
+				const parsedEventSeries =
+					ContentResourceSchema.safeParse(eventSeriesResource)
+				if (!parsedEventSeries.success) {
+					throw new Error('Error parsing event series resource')
+				}
+
+				// Step 2: Associate tags with event series
+				if (eventSeriesInput.fields.tagIds) {
+					await tx.insert(contentResourceTag).values(
+						eventSeriesInput.fields.tagIds.map((tag) => ({
+							contentResourceId: eventSeriesResourceId,
+							tagId: tag.id,
+							createdAt: new Date(),
+							updatedAt: new Date(),
+							position: 0,
+						})),
+					)
+				}
+
+				// Step 3: Create child events and associate them
+				const createdChildEvents = []
+
+				for (let i = 0; i < childEventsInput.length; i++) {
+					const childEventInput = childEventsInput[i]
+
+					if (!childEventInput) {
+						throw new Error(`Child event input is required`)
+					}
+
+					// Create child event
+					const childEventHash = guid()
+					const childEventResourceId = slugify(`event~${childEventHash}`)
+
+					const newChildEvent = {
+						id: childEventResourceId,
+						type: 'event',
+						fields: {
+							title: childEventInput.fields.title,
+							startsAt: childEventInput.fields.startsAt,
+							endsAt: childEventInput.fields.endsAt,
+							description: childEventInput.fields.description,
+							state: 'draft',
+							visibility: 'public',
+							slug: slugify(
+								`${childEventInput.fields.title}~${childEventHash}`,
+							),
+							// No price/quantity - they're on the event series
+							price: null,
+							quantity: null,
+						},
+						createdById: userId,
+					}
+
+					await tx.insert(contentResource).values(newChildEvent)
+
+					// Fetch the created child event with relations
+					const childEventResource = await tx.query.contentResource.findFirst({
+						where: eq(contentResource.id, childEventResourceId),
+						with: {
+							resources: {
+								with: {
+									resource: {
+										with: {
+											resources: {
+												with: {
+													resource: true,
+												},
+												orderBy: asc(contentResourceResource.position),
+											},
+										},
+									},
+								},
+								orderBy: asc(contentResourceResource.position),
+							},
+							tags: {
+								with: {
+									tag: true,
+								},
+								orderBy: asc(contentResourceTag.position),
+							},
+							resourceProducts: {
+								with: {
+									product: {
+										with: {
+											price: true,
+										},
+									},
+								},
+							},
+						},
+					})
+
+					const parsedChildEvent =
+						ContentResourceSchema.safeParse(childEventResource)
+					if (!parsedChildEvent.success) {
+						throw new Error(`Error parsing child event resource ${i + 1}`)
+					}
+
+					// Associate tags with child event
+					if (childEventInput.fields.tagIds) {
+						await tx.insert(contentResourceTag).values(
+							childEventInput.fields.tagIds.map((tag) => ({
+								contentResourceId: childEventResourceId,
+								tagId: tag.id,
+								createdAt: new Date(),
+								updatedAt: new Date(),
+								position: 0,
+							})),
+						)
+					}
+
+					// Associate child event with event series
+					await tx.insert(contentResourceResource).values({
+						resourceOfId: eventSeriesResourceId,
+						resourceId: childEventResourceId,
+						position: i,
+					})
+
+					createdChildEvents.push(parsedChildEvent.data)
+				}
+
+				return {
+					eventSeries: parsedEventSeries.data,
+					childEvents: createdChildEvents,
+				}
+			})
+
+			const { eventSeries, childEvents } = result
+
+			// Step 4: Handle product creation outside transaction
+			if (
+				eventSeriesInput.sharedFields.price &&
+				eventSeriesInput.sharedFields.price > 0
+			) {
+				try {
+					const product = await adapter.createProduct({
+						name: eventSeriesInput.fields.title,
+						price: eventSeriesInput.sharedFields.price,
+						quantityAvailable: eventSeriesInput.sharedFields.quantity ?? -1,
+						type: 'live',
+						state: 'published',
+						visibility: 'public',
+					})
+					if (product) {
+						await adapter.addResourceToProduct({
+							resource: eventSeries,
+							productId: product.id,
+							userId,
+						})
+
+						// Create coupon if enabled
+						if (
+							input.coupon?.enabled &&
+							input.coupon.percentageDiscount &&
+							input.coupon.expires
+						) {
+							try {
+								let finalExpires = input.coupon.expires
+								if (finalExpires instanceof Date) {
+									finalExpires = new Date(
+										Date.UTC(
+											finalExpires.getUTCFullYear(),
+											finalExpires.getUTCMonth(),
+											finalExpires.getUTCDate(),
+											23,
+											59,
+											59,
+											0,
+										),
+									)
+								}
+								const couponInput = {
+									quantity: '1',
+									maxUses: 1,
+									expires: finalExpires,
+									restrictedToProductId: product.id,
+									percentageDiscount: input.coupon.percentageDiscount,
+									status: 1,
+									default: true,
+									fields: {},
+								}
+								await adapter.createCoupon(couponInput)
+								logger.debug('event.series.coupon.success', {
+									eventSeriesId: eventSeries.id,
+									productId: product.id,
+									userId,
+									percentageDiscount: input.coupon.percentageDiscount,
+								})
+							} catch (couponError) {
+								logger.error(
+									new Error(
+										`Error creating coupon for event series: ${couponError}`,
+									),
+								)
+								logger.debug('event.series.coupon.failed', {
+									eventSeriesId: eventSeries.id,
+									productId: product.id,
+									userId,
+								})
+								// Don't throw here - event series creation should succeed even if coupon fails
+							}
+						}
+					} else {
+						logger.error(new Error('Failed to create product'))
+						logger.debug('event.series.product.failed', {
+							eventSeriesId: eventSeries.id,
+							userId,
+							price: eventSeriesInput.sharedFields.price,
+						})
+					}
+				} catch (error) {
+					logger.error(
+						new Error(`Error creating and associating product: ${error}`),
+					)
+					logger.debug('event.series.product.creation.failed', {
+						eventSeriesId: eventSeries.id,
+						userId,
+					})
+					// Note: We don't throw here since the core data is already committed
+				}
+			}
+
+			return { eventSeries, childEvents }
+		},
+		async createCohort(
+			input: {
+				cohort: {
+					title: string
+					description?: string
+					tagIds?:
+						| { id: string; fields: { label: string; name: string } }[]
+						| null
+				}
+				dates: {
+					start: Date
+					end: Date
+				}
+				createProduct?: boolean
+				pricing: {
+					price?: number | null
+				}
+				coupon?: {
+					enabled: boolean
+					percentageDiscount?: string
+					expires?: Date
+				}
+				workshops: { id: string }[]
+			},
+			userId: string,
+		) {
+			const hash = guid()
+			const cohortId = `cohort~${hash}`
+
+			// Transaction only handles database operations
+			const cohort = await client.transaction(async (tx) => {
+				// Create cohort content resource
+				await tx.insert(contentResource).values({
+					id: cohortId,
+					type: 'cohort',
+					createdById: userId,
+					fields: {
+						title: input.cohort.title,
+						description: input.cohort.description,
+						state: 'draft',
+						visibility: 'unlisted',
+						slug: slugify(`${input.cohort.title}~${hash}`),
+						startsAt: input.dates.start,
+						endsAt: input.dates.end,
+					},
+				})
+
+				// Fetch created cohort
+				const cohort = await tx.query.contentResource.findFirst({
+					where: eq(contentResource.id, cohortId),
+					with: {
+						resources: {
+							with: {
+								resource: true,
+							},
+							orderBy: asc(contentResourceResource.position),
+						},
+					},
+				})
+
+				if (!cohort) {
+					throw new Error('Failed to create cohort')
+				}
+
+				const parsedCohort = ContentResourceSchema.safeParse(cohort)
+				if (!parsedCohort.success) {
+					throw new Error('Invalid cohort data')
+				}
+
+				// Associate tags with cohort
+				if (input.cohort.tagIds) {
+					await tx.insert(contentResourceTag).values(
+						input.cohort.tagIds.map((tag) => ({
+							contentResourceId: cohortId,
+							tagId: tag.id,
+							createdAt: new Date(),
+							updatedAt: new Date(),
+							position: 0,
+						})),
+					)
+				}
+
+				// Link workshops to cohort
+				let position = 0
+				for (const workshop of input.workshops) {
+					await tx.insert(contentResourceResource).values({
+						resourceOfId: cohortId,
+						resourceId: workshop.id,
+						position,
+					})
+					position++
+				}
+
+				return parsedCohort.data
+			})
+
+			// Handle product and coupon creation outside transaction
+			let product: any = null
+			if (
+				input.createProduct &&
+				input.pricing.price &&
+				input.pricing.price > 0
+			) {
+				try {
+					product = await adapter.createProduct({
+						name: input.cohort.title,
+						price: input.pricing.price,
+						quantityAvailable: -1,
+						type: 'cohort',
+						state: 'published',
+						visibility: 'public',
+						openEnrollment: new Date().toISOString(),
+						closeEnrollment: input.dates.start.toISOString(),
+					})
+
+					if (product) {
+						// Link product to cohort resource
+						await client.insert(contentResourceProduct).values({
+							resourceId: cohortId,
+							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 adapter.createCoupon({
+									percentageDiscount: input.coupon.percentageDiscount,
+									expires: finalExpires || null,
+									restrictedToProductId: product.id,
+									default: true,
+									maxUses: -1,
+									quantity: '-1',
+									status: 1,
+									fields: {},
+								})
+								logger.debug('cohort.create.coupon.success', {
+									cohortId,
+									productId: product.id,
+									userId,
+									percentageDiscount: input.coupon.percentageDiscount,
+								})
+							} catch (couponError) {
+								logger.error(
+									new Error(
+										`Failed to create coupon for cohort: ${couponError}`,
+									),
+								)
+								logger.debug('cohort.create.coupon.failed', {
+									cohortId,
+									productId: product.id,
+									userId,
+								})
+								// Don't throw - cohort creation should succeed even if coupon fails
+							}
+						}
+					}
+				} catch (productError) {
+					logger.error(
+						new Error(`Failed to create product for cohort: ${productError}`),
+					)
+					logger.debug('cohort.create.product.failed', {
+						cohortId,
+						userId,
+						price: input.pricing.price,
+					})
+					// Don't throw - cohort creation should succeed even if product fails
+				}
+			}
+
+			return {
+				cohort,
+				product,
+			}
+		},
+		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 adapter.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 adapter.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,
+			}
+		},
+		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[] = []
+			await client.transaction(async (trx) => {
+				// insert coupon for CouponInput quantity
+				for (let i = 0; i < Number(input.quantity); i++) {
+					const id = `coupon_${guid()}`
+					await trx.insert(coupon).values({
+						...input,
+						merchantCouponId: merchantCouponResult.id as string,
+						id,
+					})
+					codesArray.push(id)
+				}
+			})
+
+			return codesArray
+		},
+		async createUser(data) {
+			const id = crypto.randomUUID()
+			try {
+				await client.insert(users).values({ ...data, id })
+
+				// creating a personal organization for the user
+				// every user gets an organization of their very own
+				const personalOrganization = await adapter.createOrganization({
+					name: `Personal (${data.email})`,
+				})
+
+				if (!personalOrganization) {
+					throw new Error('Failed to create personal organization')
+				}
+
+				const membership = await adapter.addMemberToOrganization({
+					organizationId: personalOrganization.id,
+					userId: id,
+					invitedById: id,
 				})
 
 				if (!membership) {
@@ -2542,7 +4263,11 @@ export function mySqlDrizzleAdapter(
 
 				return user
 			} catch (error) {
-				console.error(error)
+				logger.error(toError(error), {
+					email: data.email,
+					event: 'adapter.user.create.failed',
+					userId: id,
+				})
 				throw error
 			}
 		},
@@ -2978,6 +4703,15 @@ export function mySqlDrizzleAdapter(
 
 			return subscriptionParsed.data
 		},
+		updateSubscriptionStatus: async (
+			subscriptionId: string,
+			status: string,
+		) => {
+			await client
+				.update(subscriptionTable)
+				.set({ status })
+				.where(eq(subscriptionTable.id, subscriptionId))
+		},
 	}
 
 	return adapter