@coursebuilder/adapter-drizzle 0.0.1

package/src/lib/pg.ts

@@ -0,0 +1,198 @@
+import type { Adapter, AdapterAccount, AdapterSession, AdapterUser } from '@auth/core/adapters'
+import { and, eq } from 'drizzle-orm'
+import {
+  pgTable as defaultPgTableFn,
+  integer,
+  PgDatabase,
+  PgTableFn,
+  primaryKey,
+  text,
+  timestamp,
+} from 'drizzle-orm/pg-core'
+
+import { stripUndefined } from './utils.js'
+
+export function createTables(pgTable: PgTableFn) {
+  const users = pgTable('user', {
+    id: text('id').notNull().primaryKey(),
+    name: text('name'),
+    email: text('email').notNull(),
+    emailVerified: timestamp('emailVerified', { mode: 'date' }),
+    image: text('image'),
+  })
+
+  const accounts = pgTable(
+    'account',
+    {
+      userId: text('userId')
+        .notNull()
+        .references(() => users.id, { onDelete: 'cascade' }),
+      type: text('type').$type<AdapterAccount['type']>().notNull(),
+      provider: text('provider').notNull(),
+      providerAccountId: text('providerAccountId').notNull(),
+      refresh_token: text('refresh_token'),
+      access_token: text('access_token'),
+      expires_at: integer('expires_at'),
+      token_type: text('token_type'),
+      scope: text('scope'),
+      id_token: text('id_token'),
+      session_state: text('session_state'),
+    },
+    (account) => ({
+      compoundKey: primaryKey(account.provider, account.providerAccountId),
+    }),
+  )
+
+  const sessions = pgTable('session', {
+    sessionToken: text('sessionToken').notNull().primaryKey(),
+    userId: text('userId')
+      .notNull()
+      .references(() => users.id, { onDelete: 'cascade' }),
+    expires: timestamp('expires', { mode: 'date' }).notNull(),
+  })
+
+  const verificationTokens = pgTable(
+    'verificationToken',
+    {
+      identifier: text('identifier').notNull(),
+      token: text('token').notNull(),
+      expires: timestamp('expires', { mode: 'date' }).notNull(),
+    },
+    (vt) => ({
+      compoundKey: primaryKey(vt.identifier, vt.token),
+    }),
+  )
+
+  return { users, accounts, sessions, verificationTokens }
+}
+
+export type DefaultSchema = ReturnType<typeof createTables>
+
+export function pgDrizzleAdapter(client: InstanceType<typeof PgDatabase>, tableFn = defaultPgTableFn): Adapter {
+  const { users, accounts, sessions, verificationTokens } = createTables(tableFn)
+
+  return {
+    async createUser(data) {
+      return await client
+        .insert(users)
+        .values({ ...data, id: crypto.randomUUID() })
+        .returning()
+        .then((res) => (res[0] as AdapterUser) ?? null)
+    },
+    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) {
+      return await client
+        .insert(sessions)
+        .values(data)
+        .returning()
+        .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.')
+      }
+
+      return await client
+        .update(users)
+        .set(data)
+        .where(eq(users.id, data.id))
+        .returning()
+        .then((res) => res[0] as AdapterUser)
+    },
+    async updateSession(data) {
+      return await client
+        .update(sessions)
+        .set(data)
+        .where(eq(sessions.sessionToken, data.sessionToken))
+        .returning()
+        .then((res) => res[0])
+    },
+    async linkAccount(rawAccount) {
+      await client
+        .insert(accounts)
+        .values(rawAccount)
+        .returning()
+        .then((res) => res[0])
+    },
+    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
+
+      return dbAccount?.user ?? null
+    },
+    async deleteSession(sessionToken) {
+      const session = await client
+        .delete(sessions)
+        .where(eq(sessions.sessionToken, sessionToken))
+        .returning()
+        .then((res) => res[0] ?? null)
+
+      return session
+    },
+    async createVerificationToken(token) {
+      return await client
+        .insert(verificationTokens)
+        .values(token)
+        .returning()
+        .then((res) => res[0])
+    },
+    async useVerificationToken(token) {
+      try {
+        return await client
+          .delete(verificationTokens)
+          .where(and(eq(verificationTokens.identifier, token.identifier), eq(verificationTokens.token, token.token)))
+          .returning()
+          .then((res) => res[0] ?? null)
+      } catch (err) {
+        throw new Error('No verification token found.')
+      }
+    },
+    async deleteUser(id) {
+      await client
+        .delete(users)
+        .where(eq(users.id, id))
+        .returning()
+        .then((res) => res[0] ?? null)
+    },
+    async unlinkAccount(account) {
+      const { type, provider, providerAccountId, userId } = await client
+        .delete(accounts)
+        .where(and(eq(accounts.providerAccountId, account.providerAccountId), eq(accounts.provider, account.provider)))
+        .returning()
+        .then((res) => (res[0] as AdapterAccount) ?? null)
+
+      return { provider, type, providerAccountId, userId }
+    },
+  }
+}

package/src/lib/sqlite.ts

@@ -0,0 +1,168 @@
+import type { Adapter, AdapterAccount } from '@auth/core/adapters'
+import { and, eq } from 'drizzle-orm'
+import {
+  BaseSQLiteDatabase,
+  sqliteTable as defaultSqliteTableFn,
+  integer,
+  primaryKey,
+  SQLiteTableFn,
+  text,
+} from 'drizzle-orm/sqlite-core'
+
+import { stripUndefined } from './utils.js'
+
+export function createTables(sqliteTable: SQLiteTableFn) {
+  const users = sqliteTable('user', {
+    id: text('id').notNull().primaryKey(),
+    name: text('name'),
+    email: text('email').notNull(),
+    emailVerified: integer('emailVerified', { mode: 'timestamp_ms' }),
+    image: text('image'),
+  })
+
+  const accounts = sqliteTable(
+    'account',
+    {
+      userId: text('userId')
+        .notNull()
+        .references(() => users.id, { onDelete: 'cascade' }),
+      type: text('type').$type<AdapterAccount['type']>().notNull(),
+      provider: text('provider').notNull(),
+      providerAccountId: text('providerAccountId').notNull(),
+      refresh_token: text('refresh_token'),
+      access_token: text('access_token'),
+      expires_at: integer('expires_at'),
+      token_type: text('token_type'),
+      scope: text('scope'),
+      id_token: text('id_token'),
+      session_state: text('session_state'),
+    },
+    (account) => ({
+      compoundKey: primaryKey(account.provider, account.providerAccountId),
+    }),
+  )
+
+  const sessions = sqliteTable('session', {
+    sessionToken: text('sessionToken').notNull().primaryKey(),
+    userId: text('userId')
+      .notNull()
+      .references(() => users.id, { onDelete: 'cascade' }),
+    expires: integer('expires', { mode: 'timestamp_ms' }).notNull(),
+  })
+
+  const verificationTokens = sqliteTable(
+    'verificationToken',
+    {
+      identifier: text('identifier').notNull(),
+      token: text('token').notNull(),
+      expires: integer('expires', { mode: 'timestamp_ms' }).notNull(),
+    },
+    (vt) => ({
+      compoundKey: primaryKey(vt.identifier, vt.token),
+    }),
+  )
+
+  return { users, accounts, sessions, verificationTokens }
+}
+
+export type DefaultSchema = ReturnType<typeof createTables>
+
+export function SQLiteDrizzleAdapter(
+  client: InstanceType<typeof BaseSQLiteDatabase>,
+  tableFn = defaultSqliteTableFn,
+): Adapter {
+  const { users, accounts, sessions, verificationTokens } = createTables(tableFn)
+
+  return {
+    async createUser(data) {
+      return client
+        .insert(users)
+        .values({ ...data, id: crypto.randomUUID() })
+        .returning()
+        .get()
+    },
+    async getUser(data) {
+      const result = await client.select().from(users).where(eq(users.id, data)).get()
+      return result ?? null
+    },
+    async getUserByEmail(data) {
+      const result = await client.select().from(users).where(eq(users.email, data)).get()
+      return result ?? null
+    },
+    createSession(data) {
+      return client.insert(sessions).values(data).returning().get()
+    },
+    async getSessionAndUser(data) {
+      const result = await client
+        .select({ session: sessions, user: users })
+        .from(sessions)
+        .where(eq(sessions.sessionToken, data))
+        .innerJoin(users, eq(users.id, sessions.userId))
+        .get()
+      return result ?? null
+    },
+    async updateUser(data) {
+      if (!data.id) {
+        throw new Error('No user id.')
+      }
+
+      const result = await client.update(users).set(data).where(eq(users.id, data.id)).returning().get()
+      return result ?? null
+    },
+    async updateSession(data) {
+      const result = await client
+        .update(sessions)
+        .set(data)
+        .where(eq(sessions.sessionToken, data.sessionToken))
+        .returning()
+        .get()
+      return result ?? null
+    },
+    async linkAccount(rawAccount) {
+      return stripUndefined(await client.insert(accounts).values(rawAccount).returning().get())
+    },
+    async getUserByAccount(account) {
+      const results = await client
+        .select()
+        .from(accounts)
+        .leftJoin(users, eq(users.id, accounts.userId))
+        .where(and(eq(accounts.provider, account.provider), eq(accounts.providerAccountId, account.providerAccountId)))
+        .get()
+
+      if (!results) {
+        return null
+      }
+      return Promise.resolve(results).then((results) => results.user)
+    },
+    async deleteSession(sessionToken) {
+      const result = await client.delete(sessions).where(eq(sessions.sessionToken, sessionToken)).returning().get()
+      return result ?? null
+    },
+    async createVerificationToken(token) {
+      const result = await client.insert(verificationTokens).values(token).returning().get()
+      return result ?? null
+    },
+    async useVerificationToken(token) {
+      try {
+        const result = await client
+          .delete(verificationTokens)
+          .where(and(eq(verificationTokens.identifier, token.identifier), eq(verificationTokens.token, token.token)))
+          .returning()
+          .get()
+        return result ?? null
+      } catch (err) {
+        throw new Error('No verification token found.')
+      }
+    },
+    async deleteUser(id) {
+      const result = await client.delete(users).where(eq(users.id, id)).returning().get()
+      return result ?? null
+    },
+    async unlinkAccount(account) {
+      await client
+        .delete(accounts)
+        .where(and(eq(accounts.providerAccountId, account.providerAccountId), eq(accounts.provider, account.provider)))
+        .run()
+    },
+  }
+}

package/src/lib/utils.ts

@@ -0,0 +1,48 @@
+import { MySqlDatabase } from 'drizzle-orm/mysql-core'
+import type { AnyMySqlTable, MySqlTableFn } from 'drizzle-orm/mysql-core'
+import { PgDatabase } from 'drizzle-orm/pg-core'
+import type { AnyPgTable, PgTableFn } from 'drizzle-orm/pg-core'
+import { BaseSQLiteDatabase } from 'drizzle-orm/sqlite-core'
+import type { AnySQLiteTable, SQLiteTableFn } from 'drizzle-orm/sqlite-core'
+
+import type { DefaultSchema as MySqlSchema } from './mysql.js'
+import type { DefaultSchema as PgSchema } from './pg.js'
+import type { DefaultSchema as SQLiteSchema } from './sqlite.js'
+
+export type AnyMySqlDatabase = MySqlDatabase<any, any>
+export type AnyPgDatabase = PgDatabase<any, any, any>
+export type AnySQLiteDatabase = BaseSQLiteDatabase<any, any, any, any>
+
+export interface MinimumSchema {
+  mysql: MySqlSchema & Record<string, AnyMySqlTable>
+  pg: PgSchema & Record<string, AnyPgTable>
+  sqlite: SQLiteSchema & Record<string, AnySQLiteTable>
+}
+
+export type SqlFlavorOptions = AnyMySqlDatabase | AnyPgDatabase | AnySQLiteDatabase
+
+export type ClientFlavors<Flavor> = Flavor extends AnyMySqlDatabase
+  ? MinimumSchema['mysql']
+  : Flavor extends AnyPgDatabase
+    ? MinimumSchema['pg']
+    : Flavor extends AnySQLiteDatabase
+      ? MinimumSchema['sqlite']
+      : never
+
+export type TableFn<Flavor> = Flavor extends AnyMySqlDatabase
+  ? MySqlTableFn
+  : Flavor extends AnyPgDatabase
+    ? PgTableFn
+    : Flavor extends AnySQLiteDatabase
+      ? SQLiteTableFn
+      : AnySQLiteTable
+
+type NonNullableProps<T> = {
+  [P in keyof T]: null extends T[P] ? never : P
+}[keyof T]
+
+export function stripUndefined<T>(obj: T): Pick<T, NonNullableProps<T>> {
+  const result = {} as T
+  for (const key in obj) if (obj[key] !== undefined) result[key] = obj[key]
+  return result
+}