@coursebuilder/adapter-drizzle 0.0.1

package/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["src/schema.ts"],"names":[],"mappings":"AAaA;;;;;GAKG;AACH,eAAO,MAAM,UAAU,0DAAiG,CAAA;AAExH,QAAA,MAAQ,KAAK,OAAE,QAAQ,OAAE,QAAQ,OAAE,eAAe,OAAE,uBAAuB,KAAkC,CAAA;AAE7G,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,eAAe,EAAE,uBAAuB,EAAE,CAAA;AAE9E,eAAO,MAAM,cAAc,KAOxB,CAAA;AAEH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuBvB,CAAA;AAED,eAAO,MAAM,oBAAoB,KAE9B,CAAA;AAEH,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuBjB,CAAA;AAED,eAAO,MAAM,cAAc,KAExB,CAAA;AAEH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwBrB,CAAA;AAED,eAAO,MAAM,kBAAkB,KAG5B,CAAA;AAEH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwB3B,CAAA;AAED,eAAO,MAAM,wBAAwB,KAMlC,CAAA;AAEH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwB3B,CAAA;AAED,eAAO,MAAM,wBAAwB,KAMlC,CAAA;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0BhC,CAAA;AAED,eAAO,MAAM,4BAA4B,KAOtC,CAAA;AAEH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyB7B,CAAA;AAED,eAAO,MAAM,0BAA0B,KAEpC,CAAA;AAEH,eAAO,MAAM,wBAAwB,KAKlC,CAAA;AAEH,eAAO,MAAM,gCAAgC,KAW1C,CAAA;AAEH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiBvC,CAAA;AAEF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuBhC,CAAA;AAED,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmCpC,CAAA;AAED,eAAO,MAAM,iCAAiC,KAa3C,CAAA;AAEH,eAAO,MAAM,iBAAiB,KAE3B,CAAA;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAc9B,CAAA"}

package/schema.js

@@ -0,0 +1,318 @@
+import { boolean, index, mysqlEnum, mysqlTableCreator, primaryKey, text, timestamp, varchar, } from 'drizzle-orm/mysql-core';
+import { createMySqlTables, relations } from '@coursebuilder/adapter-drizzle';
+/**
+ * This is an example of how to use the multi-project schema feature of Drizzle ORM. Use the same
+ * database instance for multiple projects.
+ *
+ * @see https://orm.drizzle.team/docs/goodies#multi-project-schema
+ */
+export const mysqlTable = mysqlTableCreator((name) => `${process.env.NEXT_PUBLIC_APP_NAME || 'course_builder'}_${name}`);
+const { users, accounts, sessions, contentResource, contentResourceResource } = createMySqlTables(mysqlTable);
+export { users, accounts, sessions, contentResource, contentResourceResource };
+export const usersRelations = relations(users, ({ many }) => ({
+    accounts: many(accounts),
+    communicationPreferences: many(communicationPreferences),
+    userRoles: many(userRoles),
+    userPermissions: many(userPermissions),
+    contributions: many(contentContributions),
+    createdContent: many(contentResource),
+}));
+export 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),
+}));
+export const permissionsRelations = relations(permissions, ({ many }) => ({
+    rolePermissions: many(rolePermissions),
+}));
+export 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),
+}));
+export const rolesRelations = relations(roles, ({ many }) => ({
+    userRoles: many(userRoles),
+}));
+export 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),
+}));
+export const userRolesRelations = relations(userRoles, ({ one }) => ({
+    user: one(users, { fields: [userRoles.userId], references: [users.id] }),
+    role: one(roles, { fields: [userRoles.roleId], references: [roles.id] }),
+}));
+export 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),
+}));
+export const userPermissionsRelations = relations(userPermissions, ({ one }) => ({
+    user: one(users, { fields: [userPermissions.userId], references: [users.id] }),
+    permission: one(permissions, {
+        fields: [userPermissions.permissionId],
+        references: [permissions.id],
+    }),
+}));
+export 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),
+}));
+export const rolePermissionsRelations = relations(rolePermissions, ({ one }) => ({
+    role: one(roles, { fields: [rolePermissions.roleId], references: [roles.id] }),
+    permission: one(permissions, {
+        fields: [rolePermissions.permissionId],
+        references: [permissions.id],
+    }),
+}));
+export const contentContributions = mysqlTable('contentContribution', {
+    id: varchar('id', { length: 255 }).notNull().primaryKey(),
+    userId: varchar('userId', { length: 255 }).notNull(),
+    contentId: varchar('contentId', { length: 255 }).notNull(),
+    contributionTypeId: varchar('contributionTypeId', { 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,
+    }),
+}, (cc) => ({
+    userIdIdx: index('userId_idx').on(cc.userId),
+    contentIdIdx: index('contentId_idx').on(cc.contentId),
+    contributionTypeIdIdx: index('contributionTypeId_idx').on(cc.contributionTypeId),
+}));
+export const contentContributionRelations = relations(contentContributions, ({ one }) => ({
+    user: one(users, { fields: [contentContributions.userId], references: [users.id] }),
+    content: one(contentResource, { fields: [contentContributions.contentId], references: [contentResource.id] }),
+    contributionType: one(contributionTypes, {
+        fields: [contentContributions.contributionTypeId],
+        references: [contributionTypes.id],
+    }),
+}));
+export const contributionTypes = mysqlTable('contributionType', {
+    id: varchar('id', { length: 255 }).notNull().primaryKey(),
+    slug: varchar('slug', { length: 255 }).notNull().unique(),
+    name: varchar('name', { length: 255 }).notNull(),
+    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,
+    }),
+}, (ct) => ({
+    nameIdx: index('name_idx').on(ct.name),
+    slugIdx: index('slug_idx').on(ct.slug),
+}));
+export const contributionTypesRelations = relations(contributionTypes, ({ many }) => ({
+    contributions: many(contentContributions),
+}));
+export const contentResourceRelations = relations(contentResource, ({ one, many }) => ({
+    createdBy: one(users, { fields: [contentResource.createdById], references: [users.id] }),
+    contributions: many(contentContributions),
+    resources: many(contentResourceResource, { relationName: 'resource' }),
+    resourceOf: many(contentResourceResource, { relationName: 'resourceOf' }),
+}));
+export const contentResourceResourceRelations = relations(contentResourceResource, ({ one }) => ({
+    resourceOf: one(contentResource, {
+        fields: [contentResourceResource.resourceOfId],
+        references: [contentResource.id],
+        relationName: 'resourceOf',
+    }),
+    resource: one(contentResource, {
+        fields: [contentResourceResource.resourceId],
+        references: [contentResource.id],
+        relationName: 'resource',
+    }),
+}));
+export const communicationPreferenceTypes = mysqlTable('communicationPreferenceType', {
+    id: varchar('id', { length: 255 }).notNull().primaryKey(),
+    name: varchar('name', { length: 255 }).notNull(),
+    description: text('description'),
+    active: boolean('active').notNull().default(true),
+    createdAt: timestamp('createdAt', {
+        mode: 'date',
+        fsp: 3,
+    }).defaultNow(),
+    updatedAt: timestamp('updatedAt', {
+        mode: 'date',
+        fsp: 3,
+    }),
+    deletedAt: timestamp('deletedAt', {
+        mode: 'date',
+        fsp: 3,
+    }),
+});
+export const communicationChannel = mysqlTable('communicationChannel', {
+    id: varchar('id', { length: 255 }).notNull().primaryKey(),
+    name: varchar('name', { length: 255 }).notNull(),
+    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,
+    }),
+}, (cc) => ({
+    nameIdx: index('name_idx').on(cc.name),
+}));
+export const communicationPreferences = mysqlTable('communicationPreference', {
+    id: varchar('id', { length: 255 }).notNull().primaryKey(),
+    userId: varchar('userId', { length: 255 }).notNull(),
+    channelId: varchar('channelId', { length: 255 }).notNull(),
+    preferenceLevel: mysqlEnum('preferenceLevel', ['low', 'medium', 'high']).notNull().default('medium'),
+    preferenceTypeId: varchar('preferenceTypeId', { length: 255 }).notNull(),
+    active: boolean('active').notNull().default(true),
+    createdAt: timestamp('createdAt', {
+        mode: 'date',
+        fsp: 3,
+    }).defaultNow(),
+    optInAt: timestamp('optInAt', {
+        mode: 'date',
+        fsp: 3,
+    }),
+    optOutAt: timestamp('optOutAt', {
+        mode: 'date',
+        fsp: 3,
+    }),
+    updatedAt: timestamp('updatedAt', {
+        mode: 'date',
+        fsp: 3,
+    }).defaultNow(),
+    deletedAt: timestamp('deletedAt', {
+        mode: 'date',
+        fsp: 3,
+    }),
+}, (cp) => ({
+    userIdIdx: index('userId_idx').on(cp.userId),
+    preferenceTypeIdx: index('preferenceTypeId_idx').on(cp.preferenceTypeId),
+    channelIdIdx: index('channelId_idx').on(cp.channelId),
+}));
+export const communicationPreferencesRelations = relations(communicationPreferences, ({ one }) => ({
+    user: one(users, {
+        fields: [communicationPreferences.userId],
+        references: [users.id],
+    }),
+    channel: one(communicationChannel, {
+        fields: [communicationPreferences.channelId],
+        references: [communicationChannel.id],
+    }),
+    preferenceType: one(communicationPreferenceTypes, {
+        fields: [communicationPreferences.preferenceTypeId],
+        references: [communicationPreferenceTypes.id],
+    }),
+}));
+export const sessionsRelations = relations(sessions, ({ one }) => ({
+    user: one(users, { fields: [sessions.userId], references: [users.id] }),
+}));
+export const verificationTokens = mysqlTable('verificationToken', {
+    identifier: varchar('identifier', { length: 255 }).notNull(),
+    token: varchar('token', { length: 255 }).notNull(),
+    expires: timestamp('expires', { mode: 'date' }).notNull(),
+    createdAt: timestamp('createdAt', {
+        mode: 'date',
+        fsp: 3,
+    }).defaultNow(),
+}, (vt) => ({
+    pk: primaryKey({ columns: [vt.identifier, vt.token] }),
+}));

package/src/index.ts

@@ -0,0 +1,28 @@
+import { is } from 'drizzle-orm'
+import { MySqlDatabase, MySqlTableFn } from 'drizzle-orm/mysql-core'
+import { PgDatabase, PgTableFn } from 'drizzle-orm/pg-core'
+import { BaseSQLiteDatabase, SQLiteTableFn } from 'drizzle-orm/sqlite-core'
+
+import { createTables as createMySqlTables, mySqlDrizzleAdapter } from './lib/mysql.js'
+import { pgDrizzleAdapter } from './lib/pg.js'
+import { SQLiteDrizzleAdapter } from './lib/sqlite.js'
+import { SqlFlavorOptions, TableFn } from './lib/utils.js'
+
+type NO_IT_AINT = any
+
+export function DrizzleAdapter<SqlFlavor extends SqlFlavorOptions>(
+  db: SqlFlavor,
+  table?: TableFn<SqlFlavor>,
+): NO_IT_AINT {
+  if (is(db, MySqlDatabase)) {
+    return mySqlDrizzleAdapter(db, table as MySqlTableFn)
+  } else if (is(db, PgDatabase)) {
+    return pgDrizzleAdapter(db, table as PgTableFn)
+  } else if (is(db, BaseSQLiteDatabase)) {
+    return SQLiteDrizzleAdapter(db, table as SQLiteTableFn)
+  }
+
+  throw new Error(`Unsupported database type (${typeof db}) in Auth.js Drizzle adapter.`)
+}
+
+export { createMySqlTables }

package/src/lib/mysql.ts

@@ -0,0 +1,344 @@
+import type { AdapterAccount, AdapterSession, AdapterUser } from '@auth/core/adapters'
+import { addSeconds, isAfter } from 'date-fns'
+import { and, eq, sql } from 'drizzle-orm'
+import {
+  mysqlTable as defaultMySqlTableFn,
+  double,
+  index,
+  int,
+  json,
+  MySqlDatabase,
+  mysqlEnum,
+  MySqlTableFn,
+  primaryKey,
+  timestamp,
+  varchar,
+} from 'drizzle-orm/mysql-core'
+
+import { CourseBuilderAdapter } from '@coursebuilder/core/adapters'
+
+export function createTables(mySqlTable: MySqlTableFn) {
+  const users = mySqlTable('user', {
+    id: varchar('id', { length: 255 }).notNull().primaryKey(),
+    name: varchar('name', { length: 255 }),
+    email: varchar('email', { length: 255 }).notNull(),
+    role: mysqlEnum('role', ['user', 'admin']).default('user'),
+    emailVerified: timestamp('emailVerified', {
+      mode: 'date',
+      fsp: 3,
+    }).defaultNow(),
+    image: varchar('image', { length: 255 }),
+  })
+
+  const accounts = mySqlTable(
+    'account',
+    {
+      userId: varchar('userId', { length: 255 })
+        .notNull()
+        .references(() => users.id, { onDelete: 'cascade' }),
+      type: varchar('type', { length: 255 }).$type<AdapterAccount['type']>().notNull(),
+      provider: varchar('provider', { length: 255 }).notNull(),
+      providerAccountId: varchar('providerAccountId', {
+        length: 255,
+      }).notNull(),
+      refresh_token: varchar('refresh_token', { length: 255 }),
+      access_token: varchar('access_token', { length: 255 }),
+      expires_at: int('expires_at'),
+      token_type: varchar('token_type', { length: 255 }),
+      scope: varchar('scope', { length: 255 }),
+      id_token: varchar('id_token', { length: 255 }),
+      session_state: varchar('session_state', { length: 255 }),
+    },
+    (account) => ({
+      pk: primaryKey({ columns: [account.provider, account.providerAccountId] }),
+      userIdIdx: index('userId_idx').on(account.userId),
+    }),
+  )
+
+  const sessions = mySqlTable(
+    'session',
+    {
+      sessionToken: varchar('sessionToken', { length: 255 }).notNull().primaryKey(),
+      userId: varchar('userId', { length: 255 })
+        .notNull()
+        .references(() => users.id, { onDelete: 'cascade' }),
+      expires: timestamp('expires', { mode: 'date' }).notNull(),
+    },
+    (session) => ({
+      userIdIdx: index('userId_idx').on(session.userId),
+    }),
+  )
+
+  const verificationTokens = mySqlTable(
+    'verificationToken',
+    {
+      identifier: varchar('identifier', { length: 255 }).notNull(),
+      token: varchar('token', { length: 255 }).notNull(),
+      expires: timestamp('expires', { mode: 'date' }).notNull(),
+      createdAt: timestamp('createdAt', {
+        mode: 'date',
+        fsp: 3,
+      }).default(sql`CURRENT_TIMESTAMP(3)`),
+    },
+    (vt) => ({
+      pk: primaryKey({ columns: [vt.identifier, vt.token] }),
+    }),
+  )
+
+  const contentResource = mySqlTable(
+    'contentResource',
+    {
+      id: varchar('id', { length: 255 }).notNull().primaryKey(),
+      type: varchar('type', { length: 255 }).notNull(),
+      createdById: varchar('createdById', { length: 255 }).notNull(),
+      fields: json('fields').$type<Record<string, any>>().default({}),
+      createdAt: timestamp('createdAt', {
+        mode: 'date',
+        fsp: 3,
+      }).defaultNow(),
+      updatedAt: timestamp('updatedAt', {
+        mode: 'date',
+        fsp: 3,
+      }).defaultNow(),
+      deletedAt: timestamp('deletedAt', {
+        mode: 'date',
+        fsp: 3,
+      }),
+    },
+    (cm) => ({
+      typeIdx: index('type_idx').on(cm.type),
+      createdByIdx: index('createdById_idx').on(cm.createdById),
+      createdAtIdx: index('createdAt_idx').on(cm.createdAt),
+    }),
+  )
+
+  const contentResourceResource = mySqlTable(
+    'contentResourceResource',
+    {
+      resourceOfId: varchar('resourceOfId', { length: 255 }).notNull(),
+      resourceId: varchar('resourceId', { length: 255 }).notNull(),
+      position: double('position').notNull().default(0),
+      metadata: json('fields').$type<Record<string, any>>().default({}),
+      createdAt: timestamp('createdAt', {
+        mode: 'date',
+        fsp: 3,
+      }).defaultNow(),
+      updatedAt: timestamp('updatedAt', {
+        mode: 'date',
+        fsp: 3,
+      }).defaultNow(),
+      deletedAt: timestamp('deletedAt', {
+        mode: 'date',
+        fsp: 3,
+      }),
+    },
+    (crr) => ({
+      pk: primaryKey({ columns: [crr.resourceOfId, crr.resourceId] }),
+      contentResourceIdIdx: index('contentResourceId_idx').on(crr.resourceOfId),
+      resourceIdIdx: index('resourceId_idx').on(crr.resourceId),
+    }),
+  )
+
+  return { users, accounts, sessions, verificationTokens, contentResource, contentResourceResource }
+}
+
+export type DefaultSchema = ReturnType<typeof createTables>
+
+export function mySqlDrizzleAdapter(
+  client: InstanceType<typeof MySqlDatabase>,
+  tableFn = defaultMySqlTableFn,
+): CourseBuilderAdapter {
+  const { users, accounts, sessions, verificationTokens, contentResource } = createTables(tableFn)
+
+  return {
+    async createContentResource(data) {
+      const 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) {
+      const thing =
+        (await client
+          .select()
+          .from(contentResource)
+          .where(eq(contentResource.id, data))
+          .then((res) => res[0])) ?? null
+
+      return thing
+    },
+    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) {
+      const thing =
+        (await client
+          .select()
+          .from(users)
+          .where(eq(users.id, data))
+          .then((res) => res[0])) ?? null
+
+      return thing
+    },
+    async getUserByEmail(data) {
+      const user =
+        (await client
+          .select()
+          .from(users)
+          .where(eq(users.email, data))
+          .then((res) => res[0])) ?? null
+
+      return user
+    },
+    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) {
+      const sessionAndUser =
+        (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
+
+      return sessionAndUser
+    },
+    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
+    },
+  }
+}