@coursebuilder/adapter-drizzle 1.0.0 → 1.0.2

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,
@@ -196,6 +208,11 @@ import {
 	getTagTagSchema,
 } from './schemas/content/tag-tag.js'
 import { getTagRelationsSchema, getTagSchema } from './schemas/content/tag.js'
+import { getEntitlementTypesSchema } from './schemas/entitlements/entitlement-type.js'
+import {
+	getEntitlementRelationsSchema,
+	getEntitlementsSchema,
+} from './schemas/entitlements/entitlement.js'
 import {
 	getOrganizationMembershipRolesRelationsSchema,
 	getOrganizationMembershipRolesSchema,
@@ -305,6 +322,11 @@ export function getCourseBuilderSchema(mysqlTable: MySqlTableFn) {
 			getMerchantSubscriptionRelationsSchema(mysqlTable),
 		subscription: getSubscriptionSchema(mysqlTable),
 		subscriptionRelations: getSubscriptionRelationsSchema(mysqlTable),
+		profiles: getProfilesSchema(mysqlTable),
+		profilesRelations: getProfilesRelationsSchema(mysqlTable),
+		entitlementTypes: getEntitlementTypesSchema(mysqlTable),
+		entitlements: getEntitlementsSchema(mysqlTable),
+		entitlementsRelations: getEntitlementRelationsSchema(mysqlTable),
 	} as const
 }
 
@@ -342,6 +364,12 @@ export function mySqlDrizzleAdapter(
 		upgradableProducts,
 		resourceProgress,
 		comments,
+		organization: organizationTable,
+		organizationMemberships: organizationMembershipTable,
+		organizationMembershipRoles: organizationMembershipRoleTable,
+		roles: roleTable,
+		merchantSubscription: merchantSubscriptionTable,
+		subscription: subscriptionTable,
 	} = createTables(tableFn)
 
 	const adapter: CourseBuilderAdapter = {
@@ -655,6 +683,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 {
@@ -673,6 +718,7 @@ export function mySqlDrizzleAdapter(
 						upgradedFromPurchaseId,
 						country,
 						usedCouponId,
+						organizationId,
 					} = options
 
 					const existingMerchantCharge = merchantChargeSchema.nullable().parse(
@@ -761,6 +807,7 @@ export function mySqlDrizzleAdapter(
 								.update(coupon)
 								.set({
 									maxUses: (existingBulkCoupon?.maxUses || 0) + quantity,
+									...(organizationId ? { organizationId } : {}),
 								})
 								.where(eq(coupon.id, bulkCouponId))
 						} else {
@@ -778,6 +825,7 @@ export function mySqlDrizzleAdapter(
 								restrictedToProductId: productId,
 								maxUses: quantity,
 								status: 1,
+								...(organizationId ? { organizationId } : {}),
 								...(merchantCouponToUse
 									? {
 											merchantCouponId: merchantCouponToUse.id,
@@ -787,15 +835,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({
@@ -817,7 +864,7 @@ export function mySqlDrizzleAdapter(
 							? 'Restricted'
 							: 'Valid'
 
-					const newPurchase = await client.insert(purchaseTable).values({
+					await client.insert(purchaseTable).values({
 						id: purchaseId,
 						status: newPurchaseStatus,
 						userId,
@@ -829,20 +876,20 @@ export function mySqlDrizzleAdapter(
 						country,
 						upgradedFromId: upgradedFromPurchaseId || null,
 						couponId: usedCouponId || null,
+						...(organizationId ? { organizationId } : {}),
 					})
 
 					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,
+						...(organizationId ? { organizationId } : {}),
+					})
 
 					// const result = await Promise.all([
 					// 	newMerchantCharge,
@@ -1098,7 +1145,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()
@@ -1138,10 +1185,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
@@ -1471,6 +1517,7 @@ export function mySqlDrizzleAdapter(
 						...fieldsNoImage,
 						...(image?.url && { image }),
 					},
+					type: input.type,
 				})
 				.where(eq(products.id, currentProduct.id))
 
@@ -2441,11 +2488,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
@@ -2631,6 +2706,254 @@ 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 currentMembership =
+				await client.query.organizationMemberships.findFirst({
+					where: and(
+						eq(
+							organizationMembershipTable.organizationId,
+							options.organizationId,
+						),
+						eq(organizationMembershipTable.userId, options.userId),
+					),
+				})
+
+			if (currentMembership) {
+				return OrganizationMemberSchema.parse(currentMembership)
+			} else {
+				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/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'
 
@@ -16,7 +17,7 @@ export function getRolesSchema(mysqlTable: MySqlTableFn) {
 		{
 			id: varchar('id', { length: 255 }).notNull().primaryKey(),
 			organizationId: varchar('organizationId', { length: 191 }),
-			name: varchar('name', { length: 255 }).notNull().unique(),
+			name: varchar('name', { length: 255 }).notNull(),
 			description: text('description'),
 			active: boolean('active').notNull().default(true),
 			createdAt: timestamp('createdAt', {
@@ -35,6 +36,10 @@ 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,
+			),
 		}),
 	)
 }

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

@@ -15,6 +15,7 @@ import { getContentContributionsSchema } from '../content/content-contributions.
 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'
@@ -48,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)
@@ -58,7 +60,10 @@ export function getUsersRelationsSchema(mysqlTable: MySqlTableFn) {
 	const comments = getCommentsSchema(mysqlTable)
 	const userPrefs = getUserPrefsSchema(mysqlTable)
 	const organizationMemberships = getOrganizationMembershipsSchema(mysqlTable)
-	return relations(users, ({ many }) => ({
+	return relations(users, ({ many, one }) => ({
+		profiles: many(profiles, {
+			relationName: 'profiles',
+		}),
 		accounts: many(accounts, {
 			relationName: 'user',
 		}),

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

@@ -8,14 +8,12 @@ import {
 	varchar,
 } from 'drizzle-orm/mysql-core'
 
-import { getUsersSchema } from '../auth/users.js'
 import { getOrganizationsSchema } from '../org/organizations.js'
-import { getCouponSchema } from './coupon.js'
-import { getMerchantChargeSchema } from './merchant-charge.js'
-import { getMerchantSessionSchema } from './merchant-session.js'
 import { getMerchantSubscriptionSchema } from './merchant-subscription.js'
 import { getProductSchema } from './product.js'
 
+// TODO: do we add a renewal date here? probably just add that stuff to fields
+// 	even status feels out of place at the top level maybe
 export function getSubscriptionSchema(mysqlTable: MySqlTableFn) {
 	return mysqlTable(
 		'Subscription',
@@ -29,7 +27,7 @@ export function getSubscriptionSchema(mysqlTable: MySqlTableFn) {
 			merchantSubscriptionId: varchar('merchantSubscriptionId', {
 				length: 191,
 			}).notNull(),
-			status: varchar('status', { length: 191 }).default('Valid').notNull(),
+			status: varchar('status', { length: 191 }).default('active').notNull(),
 			fields: json('fields').$type<Record<string, any>>().default({}),
 		},
 		(table) => {

package/src/lib/mysql/schemas/entitlements/entitlement-type.ts

@@ -0,0 +1,21 @@
+import {
+	MySqlTableFn,
+	text,
+	uniqueIndex,
+	varchar,
+} from 'drizzle-orm/mysql-core'
+
+export function getEntitlementTypesSchema(mysqlTable: MySqlTableFn) {
+	return mysqlTable(
+		'EntitlementType',
+		{
+			id: varchar('id', { length: 191 }).notNull().primaryKey(),
+			name: varchar('name', { length: 255 }).notNull(),
+			description: text('description'),
+			// Add any type-specific config fields here
+		},
+		(table) => ({
+			uniqueName: uniqueIndex('unique_name_idx').on(table.name),
+		}),
+	)
+}