@auth/drizzle-adapter 0.9.0 → 1.0.0

package/src/lib/sqlite.ts

@@ -1,211 +1,253 @@
 import { eq, and } from "drizzle-orm"
 import {
   integer,
-  sqliteTable as defaultSqliteTableFn,
   text,
   primaryKey,
   BaseSQLiteDatabase,
-  SQLiteTableFn,
+  sqliteTable,
+  index,
+  TableConfig,
+  SQLiteTableWithColumns,
 } from "drizzle-orm/sqlite-core"
-import { stripUndefined } from "./utils.js"
 
-import type { Adapter, AdapterAccount } from "@auth/core/adapters"
+import type {
+  Adapter,
+  AdapterAccount,
+  AdapterUser,
+  AdapterSession,
+  VerificationToken,
+} from "@auth/core/adapters"
+import { randomUUID } from "crypto"
 
-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"),
-  })
+export const sqliteUsersTable = sqliteTable("user" as string, {
+  id: text("id")
+    .primaryKey()
+    .$defaultFn(() => randomUUID()),
+  name: text("name"),
+  email: text("email").notNull().unique(),
+  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),
-    })
-  )
+export const sqliteAccountsTable = sqliteTable(
+  "account" as string,
+  {
+    userId: text("userId")
+      .notNull()
+      .references(() => sqliteUsersTable.id, { onDelete: "cascade" }),
+    type: text("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) => ({
+    userIdIdx: index("Account_userId_index").on(account.userId),
+    compositePk: primaryKey({
+      columns: [account.provider, account.providerAccountId],
+    }),
+  })
+)
 
-  const sessions = sqliteTable("session", {
-    sessionToken: text("sessionToken").notNull().primaryKey(),
+export const sqliteSessionsTable = sqliteTable(
+  "session" as string,
+  {
+    id: text("id")
+      .primaryKey()
+      .$defaultFn(() => randomUUID()),
+    sessionToken: text("sessionToken").notNull().unique(),
     userId: text("userId")
       .notNull()
-      .references(() => users.id, { onDelete: "cascade" }),
+      .references(() => sqliteUsersTable.id, { onDelete: "cascade" }),
     expires: integer("expires", { mode: "timestamp_ms" }).notNull(),
+  },
+  (table) => ({
+    userIdIdx: index("Session_userId_index").on(table.userId),
   })
+)
 
-  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 const sqliteVerificationTokensTable = sqliteTable(
+  "verificationToken" as string,
+  {
+    identifier: text("identifier").notNull(),
+    token: text("token").notNull().unique(),
+    expires: integer("expires", { mode: "timestamp_ms" }).notNull(),
+  },
+  (vt) => ({
+    compositePk: primaryKey({ columns: [vt.identifier, vt.token] }),
+  })
+)
 
 export function SQLiteDrizzleAdapter(
-  client: InstanceType<typeof BaseSQLiteDatabase>,
-  tableFn = defaultSqliteTableFn
+  client: BaseSQLiteDatabase<"sync" | "async", any, any>,
+  schema: DefaultSQLiteSchema = {
+    usersTable: sqliteUsersTable,
+    accountsTable: sqliteAccountsTable,
+    sessionsTable: sqliteSessionsTable,
+    verificationTokensTable: sqliteVerificationTokensTable,
+  }
 ): Adapter {
-  const { users, accounts, sessions, verificationTokens } =
-    createTables(tableFn)
+  const { usersTable, accountsTable, sessionsTable, verificationTokensTable } =
+    schema
 
   return {
-    async createUser(data) {
-      return await client
-        .insert(users)
-        .values({ ...data, id: crypto.randomUUID() })
-        .returning()
-        .get()
+    async createUser(data: Omit<AdapterUser, "id">) {
+      return client.insert(usersTable).values(data).returning().get()
     },
-    async getUser(data) {
+    async getUser(userId: string) {
       const result = await client
         .select()
-        .from(users)
-        .where(eq(users.id, data))
+        .from(usersTable)
+        .where(eq(usersTable.id, userId))
         .get()
+
       return result ?? null
     },
-    async getUserByEmail(data) {
+    async getUserByEmail(email: string) {
       const result = await client
         .select()
-        .from(users)
-        .where(eq(users.email, data))
+        .from(usersTable)
+        .where(eq(usersTable.email, email))
         .get()
+
       return result ?? null
     },
-    createSession(data) {
-      return client.insert(sessions).values(data).returning().get()
+    async createSession(data: {
+      sessionToken: string
+      userId: string
+      expires: Date
+    }) {
+      return await client.insert(sessionsTable).values(data).returning().get()
     },
-    async getSessionAndUser(data) {
+    async getSessionAndUser(sessionToken: string) {
       const result = await client
-        .select({ session: sessions, user: users })
-        .from(sessions)
-        .where(eq(sessions.sessionToken, data))
-        .innerJoin(users, eq(users.id, sessions.userId))
+        .select({
+          session: sessionsTable,
+          user: usersTable,
+        })
+        .from(sessionsTable)
+        .where(eq(sessionsTable.sessionToken, sessionToken))
+        .innerJoin(usersTable, eq(usersTable.id, sessionsTable.userId))
         .get()
+
       return result ?? null
     },
-    async updateUser(data) {
+    async updateUser(data: Partial<AdapterUser> & Pick<AdapterUser, "id">) {
       if (!data.id) {
         throw new Error("No user id.")
       }
 
       const result = await client
-        .update(users)
+        .update(usersTable)
         .set(data)
-        .where(eq(users.id, data.id))
+        .where(eq(usersTable.id, data.id))
         .returning()
         .get()
-      return result ?? null
+
+      if (!result) {
+        throw new Error("User not found.")
+      }
+
+      return result
     },
-    async updateSession(data) {
+    async updateSession(
+      data: Partial<AdapterSession> & Pick<AdapterSession, "sessionToken">
+    ) {
       const result = await client
-        .update(sessions)
+        .update(sessionsTable)
         .set(data)
-        .where(eq(sessions.sessionToken, data.sessionToken))
+        .where(eq(sessionsTable.sessionToken, data.sessionToken))
         .returning()
         .get()
+
       return result ?? null
     },
-    async linkAccount(rawAccount) {
-      return stripUndefined(
-        await client.insert(accounts).values(rawAccount).returning().get()
-      )
+    async linkAccount(data: AdapterAccount) {
+      await client.insert(accountsTable).values(data).run()
     },
-    async getUserByAccount(account) {
-      const results = await client
-        .select()
-        .from(accounts)
-        .leftJoin(users, eq(users.id, accounts.userId))
+    async getUserByAccount(
+      account: Pick<AdapterAccount, "provider" | "providerAccountId">
+    ) {
+      const result = await client
+        .select({
+          account: accountsTable,
+          user: usersTable,
+        })
+        .from(accountsTable)
+        .innerJoin(usersTable, eq(accountsTable.userId, usersTable.id))
         .where(
           and(
-            eq(accounts.provider, account.provider),
-            eq(accounts.providerAccountId, account.providerAccountId)
+            eq(accountsTable.provider, account.provider),
+            eq(accountsTable.providerAccountId, account.providerAccountId)
           )
         )
         .get()
 
-      if (!results) {
-        return null
-      }
-      return Promise.resolve(results).then((results) => results.user)
+      return result?.user ?? null
     },
-    async deleteSession(sessionToken) {
-      const result = await client
-        .delete(sessions)
-        .where(eq(sessions.sessionToken, sessionToken))
-        .returning()
-        .get()
-      return result ?? null
+    async deleteSession(sessionToken: string) {
+      await client
+        .delete(sessionsTable)
+        .where(eq(sessionsTable.sessionToken, sessionToken))
+        .run()
     },
-    async createVerificationToken(token) {
-      const result = await client
-        .insert(verificationTokens)
-        .values(token)
+    async createVerificationToken(data: VerificationToken) {
+      return await client
+        .insert(verificationTokensTable)
+        .values(data)
         .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) {
+    async useVerificationToken(params: { identifier: string; token: string }) {
       const result = await client
-        .delete(users)
-        .where(eq(users.id, id))
+        .delete(verificationTokensTable)
+        .where(
+          and(
+            eq(verificationTokensTable.identifier, params.identifier),
+            eq(verificationTokensTable.token, params.token)
+          )
+        )
         .returning()
         .get()
+
       return result ?? null
     },
-    async unlinkAccount(account) {
+    async deleteUser(id: string) {
+      await client.delete(usersTable).where(eq(usersTable.id, id)).run()
+    },
+    async unlinkAccount(
+      params: Pick<AdapterAccount, "provider" | "providerAccountId">
+    ) {
       await client
-        .delete(accounts)
+        .delete(accountsTable)
         .where(
           and(
-            eq(accounts.providerAccountId, account.providerAccountId),
-            eq(accounts.provider, account.provider)
+            eq(accountsTable.provider, params.provider),
+            eq(accountsTable.providerAccountId, params.providerAccountId)
           )
         )
         .run()
     },
   }
 }
+
+export type SQLiteTableFn<T extends TableConfig> = SQLiteTableWithColumns<{
+  name: T["name"]
+  columns: T["columns"]
+  dialect: T["dialect"]
+  schema: string | undefined
+}>
+
+export type DefaultSQLiteSchema = {
+  usersTable: SQLiteTableFn<(typeof sqliteUsersTable)["_"]["config"]>
+  accountsTable: SQLiteTableFn<(typeof sqliteAccountsTable)["_"]["config"]>
+  sessionsTable: SQLiteTableFn<(typeof sqliteSessionsTable)["_"]["config"]>
+  verificationTokensTable: SQLiteTableFn<
+    (typeof sqliteVerificationTokensTable)["_"]["config"]
+  >
+}

package/src/lib/utils.ts

@@ -1,51 +1,32 @@
 import { MySqlDatabase } from "drizzle-orm/mysql-core"
 import { PgDatabase } from "drizzle-orm/pg-core"
 import { BaseSQLiteDatabase } from "drizzle-orm/sqlite-core"
-
-import type { AnyMySqlTable, MySqlTableFn } from "drizzle-orm/mysql-core"
-import type { AnyPgTable, PgTableFn } from "drizzle-orm/pg-core"
-import type { AnySQLiteTable, SQLiteTableFn } from "drizzle-orm/sqlite-core"
-import type { DefaultSchema as PgSchema } from "./pg.js"
-import type { DefaultSchema as MySqlSchema } from "./mysql.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>
-}
+import type {
+  QueryResultHKT as MySQLQueryResultHKT,
+  PreparedQueryHKTBase,
+} from "drizzle-orm/mysql-core"
+import type { QueryResultHKT as PostgresQueryResultHKT } from "drizzle-orm/pg-core"
+import { DefaultSQLiteSchema } from "./sqlite"
+import { DefaultPostgresSchema } from "./pg"
+import { DefaultMySqlSchema } from "./mysql"
+
+type AnyPostgresDatabase = PgDatabase<PostgresQueryResultHKT, any>
+type AnyMySqlDatabase = MySqlDatabase<
+  MySQLQueryResultHKT,
+  PreparedQueryHKTBase,
+  any
+>
+type AnySQLiteDatabase = BaseSQLiteDatabase<"sync" | "async", any, any>
 
 export type SqlFlavorOptions =
+  | AnyPostgresDatabase
   | AnyMySqlDatabase
-  | AnyPgDatabase
   | AnySQLiteDatabase
 
-export type ClientFlavors<Flavor> = Flavor extends AnyMySqlDatabase
-  ? MinimumSchema["mysql"]
-  : Flavor extends AnyPgDatabase
-    ? MinimumSchema["pg"]
+export type DefaultSchema<Flavor> = Flavor extends AnyMySqlDatabase
+  ? DefaultMySqlSchema
+  : Flavor extends AnyPostgresDatabase
+    ? DefaultPostgresSchema
     : Flavor extends AnySQLiteDatabase
-      ? MinimumSchema["sqlite"]
+      ? DefaultSQLiteSchema
       : 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
-}