@coursebuilder/adapter-drizzle 0.5.2 → 1.0.1

package/src/lib/mysql/index.ts

@@ -61,7 +61,15 @@ import {
 } from '@coursebuilder/core/schemas/content-resource-schema'
 import { merchantAccountSchema } from '@coursebuilder/core/schemas/merchant-account-schema'
 import { merchantCustomerSchema } from '@coursebuilder/core/schemas/merchant-customer-schema'
+import {
+	MerchantSession,
+	MerchantSessionSchema,
+} from '@coursebuilder/core/schemas/merchant-session'
+import { MerchantSubscriptionSchema } from '@coursebuilder/core/schemas/merchant-subscription'
+import { OrganizationMemberSchema } from '@coursebuilder/core/schemas/organization-member'
+import { OrganizationSchema } from '@coursebuilder/core/schemas/organization-schema'
 import { type ModuleProgress } from '@coursebuilder/core/schemas/resource-progress-schema'
+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'
@@ -83,6 +91,10 @@ import {
 	getPermissionsRelationsSchema,
 	getPermissionsSchema,
 } from './schemas/auth/permissions.js'
+import {
+	getProfilesRelationsSchema,
+	getProfilesSchema,
+} from './schemas/auth/profiles.js'
 import {
 	getRolePermissionsRelationsSchema,
 	getRolePermissionsSchema,
@@ -126,6 +138,10 @@ import { getMerchantCustomerSchema } from './schemas/commerce/merchant-customer.
 import { getMerchantPriceSchema } from './schemas/commerce/merchant-price.js'
 import { getMerchantProductSchema } from './schemas/commerce/merchant-product.js'
 import { getMerchantSessionSchema } from './schemas/commerce/merchant-session.js'
+import {
+	getMerchantSubscriptionRelationsSchema,
+	getMerchantSubscriptionSchema,
+} from './schemas/commerce/merchant-subscription.js'
 import { getPriceSchema } from './schemas/commerce/price.js'
 import {
 	getProductRelationsSchema,
@@ -139,6 +155,10 @@ import {
 	getPurchaseRelationsSchema,
 	getPurchaseSchema,
 } from './schemas/commerce/purchase.js'
+import {
+	getSubscriptionRelationsSchema,
+	getSubscriptionSchema,
+} from './schemas/commerce/subscription.js'
 import {
 	getUpgradableProductsRelationsSchema,
 	getUpgradableProductsSchema,
@@ -188,6 +208,18 @@ import {
 	getTagTagSchema,
 } from './schemas/content/tag-tag.js'
 import { getTagRelationsSchema, getTagSchema } from './schemas/content/tag.js'
+import {
+	getOrganizationMembershipRolesRelationsSchema,
+	getOrganizationMembershipRolesSchema,
+} from './schemas/org/organization-membership-roles.js'
+import {
+	getOrganizationMembershipsRelationsSchema,
+	getOrganizationMembershipsSchema,
+} from './schemas/org/organization-memberships.js'
+import {
+	getOrganizationsRelationsSchema,
+	getOrganizationsSchema,
+} from './schemas/org/organizations.js'
 
 export const guid = customAlphabet('1234567890abcdefghijklmnopqrstuvwxyz', 5)
 
@@ -271,6 +303,22 @@ export function getCourseBuilderSchema(mysqlTable: MySqlTableFn) {
 		tagTagRelations: getTagTagRelationsSchema(mysqlTable),
 		userPrefs: getUserPrefsSchema(mysqlTable),
 		userPrefsRelations: getUserPrefsRelationsSchema(mysqlTable),
+		organization: getOrganizationsSchema(mysqlTable),
+		organizationRelations: getOrganizationsRelationsSchema(mysqlTable),
+		organizationMemberships: getOrganizationMembershipsSchema(mysqlTable),
+		organizationMembershipRelations:
+			getOrganizationMembershipsRelationsSchema(mysqlTable),
+		organizationMembershipRoles:
+			getOrganizationMembershipRolesSchema(mysqlTable),
+		organizationMembershipRolesRelations:
+			getOrganizationMembershipRolesRelationsSchema(mysqlTable),
+		merchantSubscription: getMerchantSubscriptionSchema(mysqlTable),
+		merchantSubscriptionRelations:
+			getMerchantSubscriptionRelationsSchema(mysqlTable),
+		subscription: getSubscriptionSchema(mysqlTable),
+		subscriptionRelations: getSubscriptionRelationsSchema(mysqlTable),
+		profiles: getProfilesSchema(mysqlTable),
+		profilesRelations: getProfilesRelationsSchema(mysqlTable),
 	} as const
 }
 
@@ -308,6 +356,12 @@ export function mySqlDrizzleAdapter(
 		upgradableProducts,
 		resourceProgress,
 		comments,
+		organization: organizationTable,
+		organizationMemberships: organizationMembershipTable,
+		organizationMembershipRoles: organizationMembershipRoleTable,
+		roles: roleTable,
+		merchantSubscription: merchantSubscriptionTable,
+		subscription: subscriptionTable,
 	} = createTables(tableFn)
 
 	const adapter: CourseBuilderAdapter = {
@@ -621,6 +675,23 @@ export function mySqlDrizzleAdapter(
 
 			return parsedCoupon.data
 		},
+		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 createMerchantChargeAndPurchase(options): Promise<Purchase> {
 			const purchaseId = await client.transaction(async (trx) => {
 				try {
@@ -753,15 +824,14 @@ export function mySqlDrizzleAdapter(
 						}
 					}
 
+					// create a new merchant session
 					const merchantSessionId = `ms_${v4()}`
 
-					const newMerchantSession = await client
-						.insert(merchantSession)
-						.values({
-							id: merchantSessionId,
-							identifier: checkoutSessionId,
-							merchantAccountId,
-						})
+					await client.insert(merchantSession).values({
+						id: merchantSessionId,
+						identifier: checkoutSessionId,
+						merchantAccountId,
+					})
 
 					const merchantCouponUsed = stripeCouponId
 						? await client.query.merchantCoupon.findFirst({
@@ -783,7 +853,7 @@ export function mySqlDrizzleAdapter(
 							? 'Restricted'
 							: 'Valid'
 
-					const newPurchase = await client.insert(purchaseTable).values({
+					await client.insert(purchaseTable).values({
 						id: purchaseId,
 						status: newPurchaseStatus,
 						userId,
@@ -799,16 +869,14 @@ export function mySqlDrizzleAdapter(
 
 					const oneWeekInMilliseconds = 1000 * 60 * 60 * 24 * 7
 
-					const newPurchaseUserTransfer = await client
-						.insert(purchaseUserTransfer)
-						.values({
-							id: `put_${v4()}`,
-							purchaseId: purchaseId as string,
-							expiresAt: existingPurchase
-								? new Date()
-								: new Date(Date.now() + oneWeekInMilliseconds),
-							sourceUserId: userId,
-						})
+					await client.insert(purchaseUserTransfer).values({
+						id: `put_${v4()}`,
+						purchaseId: purchaseId as string,
+						expiresAt: existingPurchase
+							? new Date()
+							: new Date(Date.now() + oneWeekInMilliseconds),
+						sourceUserId: userId,
+					})
 
 					// const result = await Promise.all([
 					// 	newMerchantCharge,
@@ -1064,7 +1132,7 @@ export function mySqlDrizzleAdapter(
 
 			const ResultRowSchema = z.object({
 				resource_id: z.string(),
-				resource_type: z.enum(['lesson', 'exercise']),
+				resource_type: z.enum(['lesson', 'exercise', 'post']),
 				resource_slug: z.string().nullable(),
 				completed_at: z
 					.string()
@@ -1104,10 +1172,9 @@ export function mySqlDrizzleAdapter(
 				LEFT JOIN ${resourceProgress} rp ON rp.resourceId = cr.id
 						AND rp.userId = ${user.id}
 				WHERE
-						cr.type IN ('lesson', 'exercise')
+						cr.type IN ('lesson', 'exercise', 'post')
 
     `)
-
 			// Process the results
 			const completedLessons: ResourceProgress[] = []
 			let nextResource: Partial<ContentResource> | null = null
@@ -2407,11 +2474,39 @@ export function mySqlDrizzleAdapter(
 
 				await client.insert(users).values({ ...data, id })
 
-				return await client
-					.select()
-					.from(users)
-					.where(eq(users.id, id))
-					.then((res) => res[0] as AdapterUser)
+				// 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) {
+					throw new Error('Failed to add user to personal organization')
+				}
+
+				await adapter.addRoleForMember({
+					organizationId: personalOrganization.id,
+					memberId: membership.id,
+					role: 'owner',
+				})
+
+				const user = await adapter.getUser?.(id)
+
+				if (!user) {
+					throw new Error('Failed to get user')
+				}
+
+				return user
 			} catch (error) {
 				console.error(error)
 				throw error
@@ -2597,6 +2692,239 @@ export function mySqlDrizzleAdapter(
 
 			return undefined
 		},
+		createOrganization: async (options: { name: string }) => {
+			const organizationId = crypto.randomUUID()
+			await client.insert(organizationTable).values({
+				...options,
+				id: organizationId,
+			})
+
+			return adapter.getOrganization(organizationId)
+		},
+		getOrganization: async (organizationId: string) => {
+			return OrganizationSchema.parse(
+				await client.query.organization.findFirst({
+					where: eq(organizationTable.id, organizationId),
+				}),
+			)
+		},
+		addMemberToOrganization: async (options: {
+			organizationId: string
+			userId: string
+			invitedById: string
+		}) => {
+			const id = crypto.randomUUID()
+			await client.insert(organizationMembershipTable).values({
+				...options,
+				id,
+			})
+
+			return OrganizationMemberSchema.parse(
+				await client.query.organizationMemberships.findFirst({
+					where: eq(organizationMembershipTable.id, id),
+					with: {
+						organization: true,
+						user: true,
+					},
+				}),
+			)
+		},
+		removeMemberFromOrganization: async (options: {
+			organizationId: string
+			userId: string
+		}) => {
+			await client
+				.delete(organizationMembershipTable)
+				.where(
+					and(
+						eq(
+							organizationMembershipTable.organizationId,
+							options.organizationId,
+						),
+						eq(organizationMembershipTable.userId, options.userId),
+					),
+				)
+		},
+		addRoleForMember: async (options: {
+			organizationId: string
+			memberId: string
+			role: string
+		}) => {
+			const existingRole = z
+				.object({
+					id: z.string(),
+				})
+				.nullish()
+				.parse(
+					await client.query.roles.findFirst({
+						where: and(
+							eq(roleTable.organizationId, options.organizationId),
+							eq(roleTable.name, options.role),
+						),
+					}),
+				)
+
+			const roleId = existingRole?.id || crypto.randomUUID()
+
+			if (!existingRole) {
+				await client.insert(roleTable).values({
+					name: options.role,
+					organizationId: options.organizationId,
+					id: roleId,
+				})
+			}
+
+			const currentOrgMembershipRole =
+				await client.query.organizationMembershipRoles.findFirst({
+					where: and(
+						eq(
+							organizationMembershipRoleTable.organizationMembershipId,
+							options.memberId,
+						),
+						eq(organizationMembershipRoleTable.roleId, roleId),
+					),
+				})
+
+			if (!currentOrgMembershipRole) {
+				await client.insert(organizationMembershipRoleTable).values({
+					organizationId: options.organizationId,
+					organizationMembershipId: options.memberId,
+					roleId,
+				})
+			}
+		},
+		removeRoleForMember: async (options: {
+			organizationId: string
+			memberId: string
+			role: string
+		}) => {
+			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(eq(organizationMembershipRoleTable.roleId, roleId))
+			}
+		},
+		getMembershipsForUser: async (userId: string) => {
+			return OrganizationMemberSchema.array().parse(
+				(await client.query.organizationMemberships.findMany({
+					where: eq(organizationMembershipTable.userId, userId),
+					with: {
+						organization: true,
+						user: true,
+					},
+				})) || [],
+			)
+		},
+		getOrganizationMembers: async (organizationId: string) => {
+			return OrganizationMemberSchema.array().parse(
+				(await client.query.organizationMemberships.findMany({
+					where: eq(organizationMembershipTable.organizationId, organizationId),
+				})) || [],
+			)
+		},
+		createSubscription: async (options: {
+			organizationId: string
+			merchantSubscriptionId: string
+			productId: string
+		}) => {
+			const id = `sub_${crypto.randomUUID()}`
+			await client.insert(subscriptionTable).values({
+				...options,
+				id,
+			})
+
+			return SubscriptionSchema.parse(
+				await client.query.subscription.findFirst({
+					where: eq(subscriptionTable.id, id),
+					with: {
+						product: true,
+					},
+				}),
+			)
+		},
+		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
+		}) => {
+			throw new Error('Not implemented')
+		},
+		deleteMerchantSubscription: async (merchantSubscriptionId: string) => {
+			throw new Error('Not implemented')
+		},
+		getSubscriptionForStripeId: async (stripeSubscriptionId: string) => {
+			const merchantSubscriptionParsed = MerchantSubscriptionSchema.safeParse(
+				await client.query.merchantSubscription.findFirst({
+					where: eq(merchantSubscriptionTable.identifier, stripeSubscriptionId),
+				}),
+			)
+
+			if (!merchantSubscriptionParsed.success) {
+				throw new Error(
+					`No merchant subscription found for stripe id ${stripeSubscriptionId} ${merchantSubscriptionParsed.error}`,
+				)
+			}
+
+			const subscriptionParsed = SubscriptionSchema.safeParse(
+				await client.query.subscription.findFirst({
+					where: eq(
+						subscriptionTable.merchantSubscriptionId,
+						merchantSubscriptionParsed.data.id,
+					),
+					with: {
+						product: true,
+					},
+				}),
+			)
+
+			if (!subscriptionParsed.success) {
+				throw new Error(
+					`No subscription found for merchant subscription ${merchantSubscriptionParsed.data.id} ${subscriptionParsed.error}`,
+				)
+			}
+
+			return subscriptionParsed.data
+		},
 	}
 
 	return adapter

package/src/lib/mysql/schemas/auth/device-access-token.ts

@@ -15,6 +15,9 @@ export function getDeviceAccessTokenSchema(mysqlTable: MySqlTableFn) {
 		{
 			token: varchar('token', { length: 191 }).notNull(),
 			userId: varchar('userId', { length: 191 }).notNull(),
+			organizationMembershipId: varchar('organizationMembershipId', {
+				length: 191,
+			}),
 			createdAt: timestamp('createdAt', {
 				mode: 'date',
 				fsp: 3,

package/src/lib/mysql/schemas/auth/profiles.ts

@@ -0,0 +1,50 @@
+import { relations, sql } from 'drizzle-orm'
+import {
+	index,
+	json,
+	MySqlTableFn,
+	timestamp,
+	uniqueIndex,
+	varchar,
+} from 'drizzle-orm/mysql-core'
+
+import { getUsersSchema } from './users.js'
+
+export function getProfilesSchema(mysqlTable: MySqlTableFn) {
+	return mysqlTable(
+		'Profile',
+		{
+			id: varchar('id', { length: 255 }).notNull().primaryKey(),
+			userId: varchar('userId', { length: 255 }).notNull(),
+			type: varchar('type', { length: 255 }).notNull(),
+			fields: json('fields').$type<Record<string, any>>().default({}),
+			createdAt: timestamp('createdAt', {
+				mode: 'date',
+				fsp: 3,
+			}).default(sql`CURRENT_TIMESTAMP(3)`),
+			updatedAt: timestamp('updatedAt', {
+				mode: 'date',
+				fsp: 3,
+			}).default(sql`CURRENT_TIMESTAMP(3)`),
+		},
+		(profile) => ({
+			userIdIdx: index('userId_idx').on(profile.userId),
+			uniqueUserType: uniqueIndex('unique_user_type_idx').on(
+				profile.userId,
+				profile.type,
+			),
+		}),
+	)
+}
+
+export function getProfilesRelationsSchema(mysqlTable: MySqlTableFn) {
+	const profiles = getProfilesSchema(mysqlTable)
+	const users = getUsersSchema(mysqlTable)
+	return relations(profiles, ({ one }) => ({
+		user: one(users, {
+			fields: [profiles.userId],
+			references: [users.id],
+			relationName: 'profiles',
+		}),
+	}))
+}

package/src/lib/mysql/schemas/auth/roles.ts

@@ -5,6 +5,7 @@ import {
 	MySqlTableFn,
 	text,
 	timestamp,
+	uniqueIndex,
 	varchar,
 } from 'drizzle-orm/mysql-core'
 
@@ -15,7 +16,8 @@ export function getRolesSchema(mysqlTable: MySqlTableFn) {
 		'Role',
 		{
 			id: varchar('id', { length: 255 }).notNull().primaryKey(),
-			name: varchar('name', { length: 255 }).notNull().unique(),
+			organizationId: varchar('organizationId', { length: 191 }),
+			name: varchar('name', { length: 255 }).notNull(),
 			description: text('description'),
 			active: boolean('active').notNull().default(true),
 			createdAt: timestamp('createdAt', {
@@ -33,6 +35,11 @@ export function getRolesSchema(mysqlTable: MySqlTableFn) {
 		},
 		(role) => ({
 			nameIdx: index('name_idx').on(role.name),
+			organizationIdIdx: index('organizationId_idx').on(role.organizationId),
+			uniqueNamePerOrg: uniqueIndex('unique_name_per_org').on(
+				role.organizationId,
+				role.name,
+			),
 		}),
 	)
 }
@@ -40,6 +47,7 @@ export function getRolesSchema(mysqlTable: MySqlTableFn) {
 export function getRolesRelationsSchema(mysqlTable: MySqlTableFn) {
 	const roles = getRolesSchema(mysqlTable)
 	const userRoles = getUserRolesSchema(mysqlTable)
+
 	return relations(roles, ({ many }) => ({
 		userRoles: many(userRoles, { relationName: 'role' }),
 	}))

package/src/lib/mysql/schemas/auth/user-permissions.ts

@@ -16,6 +16,7 @@ export function getUserPermissionsSchema(mysqlTable: MySqlTableFn) {
 		'UserPermission',
 		{
 			userId: varchar('userId', { length: 255 }).notNull(),
+			organizationId: varchar('organizationId', { length: 191 }),
 			permissionId: varchar('permissionId', { length: 255 }).notNull(),
 			active: boolean('active').notNull().default(true),
 			createdAt: timestamp('createdAt', {
@@ -35,6 +36,7 @@ export function getUserPermissionsSchema(mysqlTable: MySqlTableFn) {
 			pk: primaryKey({ columns: [up.userId, up.permissionId] }),
 			userIdIdx: index('userId_idx').on(up.userId),
 			permissionIdIdx: index('permissionId_idx').on(up.permissionId),
+			organizationIdIdx: index('organizationId_idx').on(up.organizationId),
 		}),
 	)
 }

package/src/lib/mysql/schemas/auth/user-prefs.ts

@@ -16,6 +16,7 @@ export function getUserPrefsSchema(mysqlTable: MySqlTableFn) {
 		'UserPrefs',
 		{
 			id: varchar('id', { length: 191 }).notNull(),
+			organizationId: varchar('organizationId', { length: 191 }),
 			type: varchar('type', { length: 191 }).default('Global').notNull(),
 			userId: varchar('userId', { length: 255 }).notNull(),
 			fields: json('fields').$type<Record<string, any>>().default({}),
@@ -35,6 +36,7 @@ export function getUserPrefsSchema(mysqlTable: MySqlTableFn) {
 		(crr) => ({
 			pk: primaryKey({ columns: [crr.id] }),
 			crrUserIdIdKey: index('crr_userIdId_idx').on(crr.userId),
+			organizationIdIdx: index('organizationId_idx').on(crr.organizationId),
 		}),
 	)
 }

package/src/lib/mysql/schemas/auth/user-roles.ts

@@ -18,6 +18,7 @@ export function getUserRolesSchema(mysqlTable: MySqlTableFn) {
 			userId: varchar('userId', { length: 255 }).notNull(),
 			roleId: varchar('roleId', { length: 255 }).notNull(),
 			active: boolean('active').notNull().default(true),
+			organizationId: varchar('organizationId', { length: 191 }),
 			createdAt: timestamp('createdAt', {
 				mode: 'date',
 				fsp: 3,
@@ -35,6 +36,7 @@ export function getUserRolesSchema(mysqlTable: MySqlTableFn) {
 			pk: primaryKey({ columns: [ur.userId, ur.roleId] }),
 			userIdIdx: index('userId_idx').on(ur.userId),
 			roleIdIdx: index('roleId_idx').on(ur.roleId),
+			organizationIdIdx: index('organizationId_idx').on(ur.organizationId),
 		}),
 	)
 }

package/src/lib/mysql/schemas/auth/users.ts

@@ -13,7 +13,9 @@ import { getCommentsSchema } from '../communication/comment.js'
 import { getCommunicationPreferencesSchema } from '../communication/communication-preferences.js'
 import { getContentContributionsSchema } from '../content/content-contributions.js'
 import { getContentResourceSchema } from '../content/content-resource.js'
+import { getOrganizationMembershipsSchema } from '../org/organization-memberships.js'
 import { getAccountsSchema } from './accounts.js'
+import { getProfilesSchema } from './profiles.js'
 import { getUserPermissionsSchema } from './user-permissions.js'
 import { getUserPrefsSchema } from './user-prefs.js'
 import { getUserRolesSchema } from './user-roles.js'
@@ -47,6 +49,7 @@ export function getUsersSchema(mysqlTable: MySqlTableFn) {
 
 export function getUsersRelationsSchema(mysqlTable: MySqlTableFn) {
 	const users = getUsersSchema(mysqlTable)
+	const profiles = getProfilesSchema(mysqlTable)
 	const accounts = getAccountsSchema(mysqlTable)
 	const communicationPreferences = getCommunicationPreferencesSchema(mysqlTable)
 	const userRoles = getUserRolesSchema(mysqlTable)
@@ -56,7 +59,11 @@ export function getUsersRelationsSchema(mysqlTable: MySqlTableFn) {
 	const purchases = getPurchaseSchema(mysqlTable)
 	const comments = getCommentsSchema(mysqlTable)
 	const userPrefs = getUserPrefsSchema(mysqlTable)
-	return relations(users, ({ many }) => ({
+	const organizationMemberships = getOrganizationMembershipsSchema(mysqlTable)
+	return relations(users, ({ many, one }) => ({
+		profiles: many(profiles, {
+			relationName: 'profiles',
+		}),
 		accounts: many(accounts, {
 			relationName: 'user',
 		}),
@@ -84,5 +91,8 @@ export function getUsersRelationsSchema(mysqlTable: MySqlTableFn) {
 		prefs: many(userPrefs, {
 			relationName: 'user',
 		}),
+		organizationMemberships: many(organizationMemberships, {
+			relationName: 'user',
+		}),
 	}))
 }

package/src/lib/mysql/schemas/commerce/coupon.ts

@@ -21,6 +21,7 @@ export function getCouponSchema(mysqlTable: MySqlTableFn) {
 		'Coupon',
 		{
 			id: varchar('id', { length: 191 }).notNull(),
+			organizationId: varchar('organizationId', { length: 191 }),
 			code: varchar('code', { length: 191 }),
 			createdAt: timestamp('createdAt', { mode: 'date', fsp: 3 })
 				.default(sql`CURRENT_TIMESTAMP(3)`)
@@ -46,6 +47,7 @@ export function getCouponSchema(mysqlTable: MySqlTableFn) {
 				),
 				couponId: primaryKey({ columns: [table.id], name: 'Coupon_id' }),
 				couponCodeKey: unique('Coupon_code_key').on(table.code),
+				organizationIdIdx: index('organizationId_idx').on(table.organizationId),
 			}
 		},
 	)