@coursebuilder/adapter-drizzle 0.0.3 → 0.0.5

package/src/lib/mysql/index.ts

@@ -0,0 +1,424 @@
+import type { AdapterSession, AdapterUser } from '@auth/core/adapters'
+import { addSeconds, isAfter } from 'date-fns'
+import { and, eq, sql } from 'drizzle-orm'
+import {
+	mysqlTable as defaultMySqlTableFn,
+	MySqlDatabase,
+	MySqlTableFn,
+} from 'drizzle-orm/mysql-core'
+
+import { type CourseBuilderAdapter } from '@coursebuilder/core/adapters'
+import { VideoResourceSchema } from '@coursebuilder/core/schemas/video-resource'
+
+import {
+	getAccountsRelationsSchema,
+	getAccountsSchema,
+} from './schemas/auth/accounts'
+import {
+	getPermissionsRelationsSchema,
+	getPermissionsSchema,
+} from './schemas/auth/permissions'
+import {
+	getRolePermissionsRelationsSchema,
+	getRolePermissionsSchema,
+} from './schemas/auth/role-permissions'
+import { getRolesRelationsSchema, getRolesSchema } from './schemas/auth/roles'
+import {
+	getSessionRelationsSchema,
+	getSessionsSchema,
+} from './schemas/auth/sessions'
+import {
+	getUserPermissionsRelationsSchema,
+	getUserPermissionsSchema,
+} from './schemas/auth/user-permissions'
+import {
+	getUserRolesRelationsSchema,
+	getUserRolesSchema,
+} from './schemas/auth/user-roles'
+import { getUsersRelationsSchema, getUsersSchema } from './schemas/auth/users'
+import { getVerificationTokensSchema } from './schemas/auth/verification-tokens'
+import { getCouponSchema } from './schemas/commerce/coupon'
+import { getMerchantAccountSchema } from './schemas/commerce/merchant-account'
+import { getMerchantChargeSchema } from './schemas/commerce/merchant-charge'
+import { getMerchantCouponSchema } from './schemas/commerce/merchant-coupon'
+import { getMerchantCustomerSchema } from './schemas/commerce/merchant-customer'
+import { getMerchantPriceSchema } from './schemas/commerce/merchant-price'
+import { getMerchantProductSchema } from './schemas/commerce/merchant-product'
+import { getMerchantSessionSchema } from './schemas/commerce/merchant-session'
+import { getPriceSchema } from './schemas/commerce/price'
+import { getProductSchema } from './schemas/commerce/product'
+import { getPurchaseSchema } from './schemas/commerce/purchase'
+import { getPurchaseUserTransferSchema } from './schemas/commerce/purchase-user-transfer'
+import { getCommunicationChannelSchema } from './schemas/communication/communication-channel'
+import { getCommunicationPreferenceTypesSchema } from './schemas/communication/communication-preference-types'
+import {
+	getCommunicationPreferencesRelationsSchema,
+	getCommunicationPreferencesSchema,
+} from './schemas/communication/communication-preferences'
+import {
+	getContentContributionRelationsSchema,
+	getContentContributionsSchema,
+} from './schemas/content/content-contributions'
+import {
+	getContentResourceRelationsSchema,
+	getContentResourceSchema,
+} from './schemas/content/content-resource'
+import {
+	getContentResourceResourceRelationsSchema,
+	getContentResourceResourceSchema,
+} from './schemas/content/content-resource-resource'
+import {
+	getContributionTypesRelationsSchema,
+	getContributionTypesSchema,
+} from './schemas/content/contribution-types'
+import { getResourceProgressSchema } from './schemas/content/resource-progress'
+
+export function getCourseBuilderSchema(mysqlTable: MySqlTableFn) {
+	return {
+		accounts: getAccountsSchema(mysqlTable),
+		accountsRelations: getAccountsRelationsSchema(mysqlTable),
+		permissions: getPermissionsSchema(mysqlTable),
+		permissionsRelations: getPermissionsRelationsSchema(mysqlTable),
+		rolePermissions: getRolePermissionsSchema(mysqlTable),
+		rolePermissionsRelations: getRolePermissionsRelationsSchema(mysqlTable),
+		roles: getRolesSchema(mysqlTable),
+		rolesRelations: getRolesRelationsSchema(mysqlTable),
+		sessions: getSessionsSchema(mysqlTable),
+		sessionsRelations: getSessionRelationsSchema(mysqlTable),
+		userPermissions: getUserPermissionsSchema(mysqlTable),
+		userPermissionsRelations: getUserPermissionsRelationsSchema(mysqlTable),
+		userRoles: getUserRolesSchema(mysqlTable),
+		userRolesRelations: getUserRolesRelationsSchema(mysqlTable),
+		users: getUsersSchema(mysqlTable),
+		usersRelations: getUsersRelationsSchema(mysqlTable),
+		verificationTokens: getVerificationTokensSchema(mysqlTable),
+		coupon: getCouponSchema(mysqlTable),
+		merchantAccount: getMerchantAccountSchema(mysqlTable),
+		merchantCharge: getMerchantChargeSchema(mysqlTable),
+		merchantCoupon: getMerchantCouponSchema(mysqlTable),
+		merchantCustomer: getMerchantCustomerSchema(mysqlTable),
+		merchantPrice: getMerchantPriceSchema(mysqlTable),
+		merchantProduct: getMerchantProductSchema(mysqlTable),
+		merchantSession: getMerchantSessionSchema(mysqlTable),
+		price: getPriceSchema(mysqlTable),
+		product: getProductSchema(mysqlTable),
+		purchase: getPurchaseSchema(mysqlTable),
+		purchaseUserTransfer: getPurchaseUserTransferSchema(mysqlTable),
+		communicationChannel: getCommunicationChannelSchema(mysqlTable),
+		communicationPreferenceTypes:
+			getCommunicationPreferenceTypesSchema(mysqlTable),
+		communicationPreferences: getCommunicationPreferencesSchema(mysqlTable),
+		communicationPreferencesRelations:
+			getCommunicationPreferencesRelationsSchema(mysqlTable),
+		contentContributions: getContentContributionsSchema(mysqlTable),
+		contentContributionRelations:
+			getContentContributionRelationsSchema(mysqlTable),
+		contentResource: getContentResourceSchema(mysqlTable),
+		contentResourceRelations: getContentResourceRelationsSchema(mysqlTable),
+		contentResourceResource: getContentResourceResourceSchema(mysqlTable),
+		contentResourceResourceRelations:
+			getContentResourceResourceRelationsSchema(mysqlTable),
+		contributionTypes: getContributionTypesSchema(mysqlTable),
+		contributionTypesRelations: getContributionTypesRelationsSchema(mysqlTable),
+		resourceProgress: getResourceProgressSchema(mysqlTable),
+	} as const
+}
+
+export function createTables(mySqlTable: MySqlTableFn) {
+	return getCourseBuilderSchema(mySqlTable)
+}
+
+export type DefaultSchema = ReturnType<typeof createTables>
+
+export function mySqlDrizzleAdapter(
+	client: InstanceType<typeof MySqlDatabase>,
+	tableFn = defaultMySqlTableFn,
+): CourseBuilderAdapter {
+	const {
+		users,
+		accounts,
+		sessions,
+		verificationTokens,
+		contentResource,
+		contentResourceResource,
+		purchase,
+		purchaseUserTransfer,
+		coupon,
+		merchantCoupon,
+		merchantCharge,
+		merchantAccount,
+		merchantPrice,
+		merchantCustomer,
+		merchantSession,
+		merchantProduct,
+		price,
+		product,
+	} = createTables(tableFn)
+
+	return {
+		async updateContentResourceFields(options) {
+			if (!options.id) {
+				throw new Error('No content resource id.')
+			}
+
+			const currentResource = await client
+				.select()
+				.from(contentResource)
+				.where(eq(contentResource.id, options.id))
+				.then((res) => res[0])
+
+			await client
+				.update(contentResource)
+				.set({ fields: { ...currentResource.fields, ...options.fields } })
+				.where(eq(contentResource.id, options.id))
+
+			return await client
+				.select()
+				.from(contentResource)
+				.where(eq(contentResource.id, options.id))
+				.then((res) => res[0])
+		},
+		async getVideoResource(id) {
+			if (!id) {
+				throw new Error('videoResourceId is required')
+			}
+
+			const query = sql`
+    SELECT
+      id as _id,
+      CAST(updatedAt AS DATETIME) as _updatedAt,
+      CAST(createdAt AS DATETIME) as _createdAt,
+      JSON_EXTRACT (${contentResource.fields}, "$.state") AS state,
+      JSON_EXTRACT (${contentResource.fields}, "$.duration") AS duration,
+      JSON_EXTRACT (${contentResource.fields}, "$.muxPlaybackId") AS muxPlaybackId,
+      JSON_EXTRACT (${contentResource.fields}, "$.muxAssetId") AS muxAssetId,
+      JSON_EXTRACT (${contentResource.fields}, "$.transcript") AS transcript
+    FROM
+      ${contentResource}
+    WHERE
+      type = 'videoResource'
+      AND (id = ${id});
+      
+ `
+			return client
+				.execute(query)
+				.then((result: any) => {
+					const parsedResource = VideoResourceSchema.safeParse(result.rows[0])
+					return parsedResource.success ? parsedResource.data : null
+				})
+				.catch((error) => {
+					console.error(error)
+					return error
+				})
+		},
+		async createContentResource(data) {
+			const id = data.id || crypto.randomUUID()
+
+			await client.insert(contentResource).values({ ...data, id })
+
+			return await client
+				.select()
+				.from(contentResource)
+				.where(eq(contentResource.id, id))
+				.then((res) => res[0])
+		},
+		async getContentResource(data) {
+			return (
+				(await client
+					.select()
+					.from(contentResource)
+					.where(eq(contentResource.id, data))
+					.then((res) => res[0])) ?? null
+			)
+		},
+		async createUser(data) {
+			const id = crypto.randomUUID()
+
+			await client.insert(users).values({ ...data, id })
+
+			return await client
+				.select()
+				.from(users)
+				.where(eq(users.id, id))
+				.then((res) => res[0] as AdapterUser)
+		},
+		async getUser(data) {
+			return (
+				(await client
+					.select()
+					.from(users)
+					.where(eq(users.id, data))
+					.then((res) => res[0])) ?? null
+			)
+		},
+		async getUserByEmail(data) {
+			return (
+				(await client
+					.select()
+					.from(users)
+					.where(eq(users.email, data))
+					.then((res) => res[0])) ?? null
+			)
+		},
+		async createSession(data) {
+			await client.insert(sessions).values(data)
+
+			return await client
+				.select()
+				.from(sessions)
+				.where(eq(sessions.sessionToken, data.sessionToken))
+				.then((res) => res[0] as AdapterSession)
+		},
+		async getSessionAndUser(data) {
+			return (
+				(await client
+					.select({
+						session: sessions,
+						user: users,
+					})
+					.from(sessions)
+					.where(eq(sessions.sessionToken, data))
+					.innerJoin(users, eq(users.id, sessions.userId))
+					.then((res) => res[0])) ?? null
+			)
+		},
+		async updateUser(data) {
+			if (!data.id) {
+				throw new Error('No user id.')
+			}
+
+			await client.update(users).set(data).where(eq(users.id, data.id))
+
+			return await client
+				.select()
+				.from(users)
+				.where(eq(users.id, data.id))
+				.then((res) => res[0] as AdapterUser)
+		},
+		async updateSession(data) {
+			await client
+				.update(sessions)
+				.set(data)
+				.where(eq(sessions.sessionToken, data.sessionToken))
+
+			return await client
+				.select()
+				.from(sessions)
+				.where(eq(sessions.sessionToken, data.sessionToken))
+				.then((res) => res[0])
+		},
+		async linkAccount(rawAccount) {
+			await client.insert(accounts).values(rawAccount)
+		},
+		async getUserByAccount(account) {
+			const dbAccount =
+				(await client
+					.select()
+					.from(accounts)
+					.where(
+						and(
+							eq(accounts.providerAccountId, account.providerAccountId),
+							eq(accounts.provider, account.provider),
+						),
+					)
+					.leftJoin(users, eq(accounts.userId, users.id))
+					.then((res) => res[0])) ?? null
+
+			if (!dbAccount) {
+				return null
+			}
+
+			return dbAccount.user
+		},
+		async deleteSession(sessionToken) {
+			const session =
+				(await client
+					.select()
+					.from(sessions)
+					.where(eq(sessions.sessionToken, sessionToken))
+					.then((res) => res[0])) ?? null
+
+			await client
+				.delete(sessions)
+				.where(eq(sessions.sessionToken, sessionToken))
+
+			return session
+		},
+		async createVerificationToken(token) {
+			await client.insert(verificationTokens).values(token)
+
+			return await client
+				.select()
+				.from(verificationTokens)
+				.where(eq(verificationTokens.identifier, token.identifier))
+				.then((res) => res[0])
+		},
+		async useVerificationToken(token) {
+			try {
+				const deletedToken =
+					(await client
+						.select()
+						.from(verificationTokens)
+						.where(
+							and(
+								eq(verificationTokens.identifier, token.identifier),
+								eq(verificationTokens.token, token.token),
+							),
+						)
+						.then((res) => res[0])) ?? null
+
+				if (deletedToken?.createdAt) {
+					const TIMEOUT_IN_SECONDS = 90
+					const expireMultipleClicks = addSeconds(
+						deletedToken.createdAt,
+						TIMEOUT_IN_SECONDS,
+					)
+					const now = new Date()
+
+					if (isAfter(expireMultipleClicks, now)) {
+						// @ts-ignore
+						const { id: _, ...verificationToken } = token
+						return deletedToken
+					} else {
+						await client
+							.delete(verificationTokens)
+							.where(
+								and(
+									eq(verificationTokens.identifier, token.identifier),
+									eq(verificationTokens.token, token.token),
+								),
+							)
+						return deletedToken
+					}
+				}
+
+				return deletedToken
+			} catch (err) {
+				throw new Error('No verification token found.')
+			}
+		},
+		async deleteUser(id) {
+			const user = await client
+				.select()
+				.from(users)
+				.where(eq(users.id, id))
+				.then((res) => res[0] ?? null)
+
+			await client.delete(users).where(eq(users.id, id))
+
+			return user
+		},
+		async unlinkAccount(account) {
+			await client
+				.delete(accounts)
+				.where(
+					and(
+						eq(accounts.providerAccountId, account.providerAccountId),
+						eq(accounts.provider, account.provider),
+					),
+				)
+
+			return undefined
+		},
+	}
+}

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

@@ -0,0 +1,52 @@
+import { AdapterAccount } from '@auth/core/adapters'
+import { relations } from 'drizzle-orm'
+import {
+	index,
+	int,
+	MySqlTableFn,
+	primaryKey,
+	text,
+	varchar,
+} from 'drizzle-orm/mysql-core'
+
+import { getUsersSchema } from './users'
+
+export function getAccountsSchema(mysqlTable: MySqlTableFn) {
+	return mysqlTable(
+		'account',
+		{
+			userId: varchar('userId', { length: 255 }).notNull(),
+			type: varchar('type', { length: 255 })
+				.$type<AdapterAccount['type']>()
+				.notNull(),
+			provider: varchar('provider', { length: 255 }).notNull(),
+			providerAccountId: varchar('providerAccountId', {
+				length: 255,
+			}).notNull(),
+			refresh_token: text('refresh_token'),
+			access_token: text('access_token'),
+			oauth_token: text('oauth_token'),
+			oauth_token_secret: text('oauth_token_secret'),
+			expires_at: int('expires_at'),
+			token_type: varchar('token_type', { length: 255 }),
+			scope: varchar('scope', { length: 255 }),
+			id_token: text('id_token'),
+			session_state: varchar('session_state', { length: 255 }),
+			refresh_token_expires_in: int('refresh_token_expires_in'),
+		},
+		(account) => ({
+			pk: primaryKey({
+				columns: [account.provider, account.providerAccountId],
+			}),
+			userIdIdx: index('userId_idx').on(account.userId),
+		}),
+	)
+}
+
+export function getAccountsRelationsSchema(mysqlTable: MySqlTableFn) {
+	const accounts = getAccountsSchema(mysqlTable)
+	const users = getUsersSchema(mysqlTable)
+	return relations(accounts, ({ one }) => ({
+		user: one(users, { fields: [accounts.userId], references: [users.id] }),
+	}))
+}

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

@@ -0,0 +1,44 @@
+import { relations } from 'drizzle-orm'
+import {
+	boolean,
+	index,
+	MySqlTableFn,
+	text,
+	timestamp,
+	varchar,
+} from 'drizzle-orm/mysql-core'
+
+import { getRolePermissionsSchema } from './role-permissions'
+
+export function getPermissionsSchema(mysqlTable: MySqlTableFn) {
+	return mysqlTable(
+		'permission',
+		{
+			id: varchar('id', { length: 255 }).notNull().primaryKey(),
+			name: varchar('name', { length: 255 }).notNull().unique(),
+			description: text('description'),
+			active: boolean('active').notNull().default(true),
+			createdAt: timestamp('createdAt', {
+				mode: 'date',
+				fsp: 3,
+			}).defaultNow(),
+			updatedAt: timestamp('updatedAt', {
+				mode: 'date',
+				fsp: 3,
+			}).defaultNow(),
+			deletedAt: timestamp('deletedAt', {
+				mode: 'date',
+				fsp: 3,
+			}),
+		},
+		(permission) => ({
+			nameIdx: index('name_idx').on(permission.name),
+		}),
+	)
+}
+
+export function getPermissionsRelationsSchema(mysqlTable: MySqlTableFn) {
+	return relations(getPermissionsSchema(mysqlTable), ({ many }) => ({
+		rolePermissions: many(getRolePermissionsSchema(mysqlTable)),
+	}))
+}

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

@@ -0,0 +1,56 @@
+import { relations } from 'drizzle-orm'
+import {
+	boolean,
+	index,
+	MySqlTableFn,
+	primaryKey,
+	timestamp,
+	varchar,
+} from 'drizzle-orm/mysql-core'
+
+import { getPermissionsSchema } from './permissions'
+import { getRolesSchema } from './roles'
+
+export function getRolePermissionsSchema(mysqlTable: MySqlTableFn) {
+	return mysqlTable(
+		'rolePermission',
+		{
+			roleId: varchar('roleId', { length: 255 }).notNull(),
+			permissionId: varchar('permissionId', { length: 255 }).notNull(),
+			active: boolean('active').notNull().default(true),
+			createdAt: timestamp('createdAt', {
+				mode: 'date',
+				fsp: 3,
+			}).defaultNow(),
+			updatedAt: timestamp('updatedAt', {
+				mode: 'date',
+				fsp: 3,
+			}).defaultNow(),
+			deletedAt: timestamp('deletedAt', {
+				mode: 'date',
+				fsp: 3,
+			}),
+		},
+		(rp) => ({
+			pk: primaryKey({ columns: [rp.roleId, rp.permissionId] }),
+			roleIdIdx: index('roleId_idx').on(rp.roleId),
+			permissionIdIdx: index('permissionId_idx').on(rp.permissionId),
+		}),
+	)
+}
+
+export function getRolePermissionsRelationsSchema(mysqlTable: MySqlTableFn) {
+	const permissions = getPermissionsSchema(mysqlTable)
+	const roles = getRolesSchema(mysqlTable)
+	const rolePermissions = getRolePermissionsSchema(mysqlTable)
+	return relations(rolePermissions, ({ one }) => ({
+		role: one(roles, {
+			fields: [rolePermissions.roleId],
+			references: [roles.id],
+		}),
+		permission: one(permissions, {
+			fields: [rolePermissions.permissionId],
+			references: [permissions.id],
+		}),
+	}))
+}

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

@@ -0,0 +1,46 @@
+import { relations } from 'drizzle-orm'
+import {
+	boolean,
+	index,
+	MySqlTableFn,
+	text,
+	timestamp,
+	varchar,
+} from 'drizzle-orm/mysql-core'
+
+import { getUserRolesSchema } from './user-roles'
+
+export function getRolesSchema(mysqlTable: MySqlTableFn) {
+	return mysqlTable(
+		'role',
+		{
+			id: varchar('id', { length: 255 }).notNull().primaryKey(),
+			name: varchar('name', { length: 255 }).notNull().unique(),
+			description: text('description'),
+			active: boolean('active').notNull().default(true),
+			createdAt: timestamp('createdAt', {
+				mode: 'date',
+				fsp: 3,
+			}).defaultNow(),
+			updatedAt: timestamp('updatedAt', {
+				mode: 'date',
+				fsp: 3,
+			}).defaultNow(),
+			deletedAt: timestamp('deletedAt', {
+				mode: 'date',
+				fsp: 3,
+			}),
+		},
+		(role) => ({
+			nameIdx: index('name_idx').on(role.name),
+		}),
+	)
+}
+
+export function getRolesRelationsSchema(mysqlTable: MySqlTableFn) {
+	const roles = getRolesSchema(mysqlTable)
+	const userRoles = getUserRolesSchema(mysqlTable)
+	return relations(roles, ({ many }) => ({
+		userRoles: many(userRoles),
+	}))
+}

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

@@ -0,0 +1,28 @@
+import { relations } from 'drizzle-orm'
+import { index, MySqlTableFn, timestamp, varchar } from 'drizzle-orm/mysql-core'
+
+import { getUsersSchema } from './users'
+
+export function getSessionsSchema(mysqlTable: MySqlTableFn) {
+	return mysqlTable(
+		'session',
+		{
+			sessionToken: varchar('sessionToken', { length: 255 })
+				.notNull()
+				.primaryKey(),
+			userId: varchar('userId', { length: 255 }).notNull(),
+			expires: timestamp('expires', { mode: 'date' }).notNull(),
+		},
+		(session) => ({
+			userIdIdx: index('userId_idx').on(session.userId),
+		}),
+	)
+}
+
+export function getSessionRelationsSchema(mysqlTable: MySqlTableFn) {
+	const sessions = getSessionsSchema(mysqlTable)
+	const users = getUsersSchema(mysqlTable)
+	return relations(sessions, ({ one }) => ({
+		user: one(users, { fields: [sessions.userId], references: [users.id] }),
+	}))
+}

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

@@ -0,0 +1,56 @@
+import { relations } from 'drizzle-orm'
+import {
+	boolean,
+	index,
+	MySqlTableFn,
+	primaryKey,
+	timestamp,
+	varchar,
+} from 'drizzle-orm/mysql-core'
+
+import { getPermissionsSchema } from './permissions'
+import { getUsersSchema } from './users'
+
+export function getUserPermissionsSchema(mysqlTable: MySqlTableFn) {
+	return mysqlTable(
+		'userPermission',
+		{
+			userId: varchar('userId', { length: 255 }).notNull(),
+			permissionId: varchar('permissionId', { length: 255 }).notNull(),
+			active: boolean('active').notNull().default(true),
+			createdAt: timestamp('createdAt', {
+				mode: 'date',
+				fsp: 3,
+			}).defaultNow(),
+			updatedAt: timestamp('updatedAt', {
+				mode: 'date',
+				fsp: 3,
+			}).defaultNow(),
+			deletedAt: timestamp('deletedAt', {
+				mode: 'date',
+				fsp: 3,
+			}),
+		},
+		(up) => ({
+			pk: primaryKey({ columns: [up.userId, up.permissionId] }),
+			userIdIdx: index('userId_idx').on(up.userId),
+			permissionIdIdx: index('permissionId_idx').on(up.permissionId),
+		}),
+	)
+}
+
+export function getUserPermissionsRelationsSchema(mysqlTable: MySqlTableFn) {
+	const userPermissions = getUserPermissionsSchema(mysqlTable)
+	const users = getUsersSchema(mysqlTable)
+	const permissions = getPermissionsSchema(mysqlTable)
+	return relations(userPermissions, ({ one }) => ({
+		user: one(users, {
+			fields: [userPermissions.userId],
+			references: [users.id],
+		}),
+		permission: one(permissions, {
+			fields: [userPermissions.permissionId],
+			references: [permissions.id],
+		}),
+	}))
+}