@coursebuilder/adapter-drizzle 0.0.3 → 0.0.4

package/src/lib/mysql/index.ts

@@ -0,0 +1,394 @@
+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 { getAccountsSchema } from './schemas/auth/accounts'
+import { getPermissionsSchema } from './schemas/auth/permissions'
+import { getRolePermissionsSchema } from './schemas/auth/role-permissions'
+import { getRolesSchema } from './schemas/auth/roles'
+import { getSessionsSchema } from './schemas/auth/sessions'
+import { getUserPermissionsSchema } from './schemas/auth/user-permissions'
+import { getUserRolesSchema } from './schemas/auth/user-roles'
+import { 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 { getCommunicationPreferencesSchema } from './schemas/communication/communication-preferences'
+import { getContentContributionsSchema } from './schemas/content/content-contributions'
+import { getContentResourceSchema } from './schemas/content/content-resource'
+import { getContentResourceResourceSchema } from './schemas/content/content-resource-resource'
+import { getContributionTypesSchema } from './schemas/content/contribution-types'
+import { getResourceProgressSchema } from './schemas/content/resource-progress'
+
+export {
+	getAccountsSchema,
+	getSessionsSchema,
+	getUsersSchema,
+	getVerificationTokensSchema,
+	getCouponSchema,
+	getMerchantAccountSchema,
+	getMerchantChargeSchema,
+	getMerchantCouponSchema,
+	getMerchantCustomerSchema,
+	getMerchantPriceSchema,
+	getMerchantProductSchema,
+	getMerchantSessionSchema,
+	getPriceSchema,
+	getProductSchema,
+	getPurchaseSchema,
+	getPurchaseUserTransferSchema,
+	getContentResourceSchema,
+	getContentResourceResourceSchema,
+	getPermissionsSchema,
+	getRolePermissionsSchema,
+	getRolesSchema,
+	getUserPermissionsSchema,
+	getUserRolesSchema,
+	getCommunicationChannelSchema,
+	getCommunicationPreferenceTypesSchema,
+	getCommunicationPreferencesSchema,
+	getContentContributionsSchema,
+	getContributionTypesSchema,
+	getResourceProgressSchema,
+}
+
+export function createTables(mySqlTable: MySqlTableFn) {
+	return {
+		users: getUsersSchema(mySqlTable).users,
+		accounts: getAccountsSchema(mySqlTable).accounts,
+		sessions: getSessionsSchema(mySqlTable).sessions,
+		verificationTokens:
+			getVerificationTokensSchema(mySqlTable).verificationTokens,
+		contentResource: getContentResourceSchema(mySqlTable).contentResource,
+		contentResourceResource:
+			getContentResourceResourceSchema(mySqlTable).contentResourceResource,
+		purchase: getPurchaseSchema(mySqlTable).purchase,
+		price: getPriceSchema(mySqlTable).price,
+		product: getProductSchema(mySqlTable).product,
+		purchaseUserTransfer:
+			getPurchaseUserTransferSchema(mySqlTable).purchaseUserTransfer,
+		merchantSession: getMerchantSessionSchema(mySqlTable).merchantSession,
+		merchantProduct: getMerchantProductSchema(mySqlTable).merchantProduct,
+		merchantPrice: getMerchantPriceSchema(mySqlTable).merchantPrice,
+		merchantCustomer: getMerchantCustomerSchema(mySqlTable).merchantCustomer,
+		merchantCoupon: getMerchantCouponSchema(mySqlTable).merchantCoupon,
+		merchantCharge: getMerchantChargeSchema(mySqlTable).merchantCharge,
+		merchantAccount: getMerchantAccountSchema(mySqlTable).merchantAccount,
+		coupon: getCouponSchema(mySqlTable).coupon,
+	}
+}
+
+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,43 @@
+import { AdapterAccount } from '@auth/core/adapters'
+import {
+	index,
+	int,
+	MySqlTableFn,
+	primaryKey,
+	text,
+	varchar,
+} from 'drizzle-orm/mysql-core'
+
+export const getAccountsSchema = (mysqlTable: MySqlTableFn) => {
+	const accounts = 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),
+		}),
+	)
+
+	return { accounts }
+}

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

@@ -0,0 +1,37 @@
+import {
+	boolean,
+	index,
+	MySqlTableFn,
+	text,
+	timestamp,
+	varchar,
+} from 'drizzle-orm/mysql-core'
+
+export const getPermissionsSchema = (mysqlTable: MySqlTableFn) => {
+	const permissions = 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),
+		}),
+	)
+
+	return { permissions }
+}

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

@@ -0,0 +1,38 @@
+import {
+	boolean,
+	index,
+	MySqlTableFn,
+	primaryKey,
+	timestamp,
+	varchar,
+} from 'drizzle-orm/mysql-core'
+
+export const getRolePermissionsSchema = (mysqlTable: MySqlTableFn) => {
+	const rolePermissions = 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),
+		}),
+	)
+
+	return { rolePermissions }
+}

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

@@ -0,0 +1,37 @@
+import {
+	boolean,
+	index,
+	MySqlTableFn,
+	text,
+	timestamp,
+	varchar,
+} from 'drizzle-orm/mysql-core'
+
+export const getRolesSchema = (mysqlTable: MySqlTableFn) => {
+	const roles = 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),
+		}),
+	)
+
+	return { roles }
+}

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

@@ -0,0 +1,19 @@
+import { index, MySqlTableFn, timestamp, varchar } from 'drizzle-orm/mysql-core'
+
+export const getSessionsSchema = (mysqlTable: MySqlTableFn) => {
+	const sessions = 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),
+		}),
+	)
+
+	return { sessions }
+}

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

@@ -0,0 +1,38 @@
+import {
+	boolean,
+	index,
+	MySqlTableFn,
+	primaryKey,
+	timestamp,
+	varchar,
+} from 'drizzle-orm/mysql-core'
+
+export const getUserPermissionsSchema = (mysqlTable: MySqlTableFn) => {
+	const userPermissions = 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),
+		}),
+	)
+
+	return { userPermissions }
+}

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

@@ -0,0 +1,38 @@
+import {
+	boolean,
+	index,
+	MySqlTableFn,
+	primaryKey,
+	timestamp,
+	varchar,
+} from 'drizzle-orm/mysql-core'
+
+export const getUserRolesSchema = (mysqlTable: MySqlTableFn) => {
+	const userRoles = mysqlTable(
+		'userRole',
+		{
+			userId: varchar('userId', { length: 255 }).notNull(),
+			roleId: varchar('roleId', { 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,
+			}),
+		},
+		(ur) => ({
+			pk: primaryKey({ columns: [ur.userId, ur.roleId] }),
+			userIdIdx: index('userId_idx').on(ur.userId),
+			roleIdIdx: index('roleId_idx').on(ur.roleId),
+		}),
+	)
+
+	return { userRoles }
+}

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

@@ -0,0 +1,35 @@
+import { sql } from 'drizzle-orm'
+import {
+	index,
+	mysqlEnum,
+	MySqlTableFn,
+	timestamp,
+	varchar,
+} from 'drizzle-orm/mysql-core'
+
+export function getUsersSchema(mysqlTable: MySqlTableFn) {
+	const users = mysqlTable(
+		'user',
+		{
+			id: varchar('id', { length: 255 }).notNull().primaryKey(),
+			name: varchar('name', { length: 255 }),
+			role: mysqlEnum('role', ['user', 'admin']).default('user'),
+			email: varchar('email', { length: 255 }).notNull().unique(),
+			emailVerified: timestamp('emailVerified', {
+				mode: 'date',
+				fsp: 3,
+			}),
+			image: varchar('image', { length: 255 }),
+			createdAt: timestamp('createdAt', {
+				mode: 'date',
+				fsp: 3,
+			}).default(sql`CURRENT_TIMESTAMP(3)`),
+		},
+		(user) => ({
+			emailIdx: index('email_idx').on(user.email),
+			roleIdx: index('role_idx').on(user.role),
+		}),
+	)
+
+	return { users }
+}