@auth/drizzle-adapter 0.1.0 → 0.2.1

package/src/lib/mysql.ts

@@ -2,75 +2,87 @@ import { and, eq } from "drizzle-orm"
 import {
   int,
   timestamp,
-  mysqlTable,
+  mysqlTable as defaultMySqlTableFn,
   primaryKey,
   varchar,
+  MySqlTableFn,
 } from "drizzle-orm/mysql-core"
 
 import type { Adapter, AdapterAccount } from "@auth/core/adapters"
 import type { MySql2Database } from "drizzle-orm/mysql2"
 
-export const users = mysqlTable("users", {
-  id: varchar("id", { length: 255 }).notNull().primaryKey(),
-  name: varchar("name", { length: 255 }),
-  email: varchar("email", { length: 255 }).notNull(),
-  emailVerified: timestamp("emailVerified", {
-    mode: "date",
-    fsp: 3,
-  }).defaultNow(),
-  image: varchar("image", { length: 255 }),
-})
-
-export const accounts = mysqlTable(
-  "accounts",
-  {
+export function createTables(mySqlTable: MySqlTableFn) {
+  const users = mySqlTable("users", {
+    id: varchar("id", { length: 255 }).notNull().primaryKey(),
+    name: varchar("name", { length: 255 }),
+    email: varchar("email", { length: 255 }).notNull(),
+    emailVerified: timestamp("emailVerified", {
+      mode: "date",
+      fsp: 3,
+    }).defaultNow(),
+    image: varchar("image", { length: 255 }),
+  })
+
+  const accounts = mySqlTable(
+    "accounts",
+    {
+      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) => ({
+      compoundKey: primaryKey(account.provider, account.providerAccountId),
+    })
+  )
+
+  const sessions = mySqlTable("sessions", {
+    sessionToken: varchar("sessionToken", { length: 255 })
+      .notNull()
+      .primaryKey(),
     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) => ({
-    compoundKey: primaryKey(account.provider, account.providerAccountId),
-  })
-)
-
-export const sessions = mysqlTable("sessions", {
-  sessionToken: varchar("sessionToken", { length: 255 }).notNull().primaryKey(),
-  userId: varchar("userId", { length: 255 })
-    .notNull()
-    .references(() => users.id, { onDelete: "cascade" }),
-  expires: timestamp("expires", { mode: "date" }).notNull(),
-})
-
-export const verificationTokens = mysqlTable(
-  "verificationToken",
-  {
-    identifier: varchar("identifier", { length: 255 }).notNull(),
-    token: varchar("token", { length: 255 }).notNull(),
     expires: timestamp("expires", { mode: "date" }).notNull(),
-  },
-  (vt) => ({
-    compoundKey: primaryKey(vt.identifier, vt.token),
   })
-)
 
-export const schema = { users, accounts, sessions, verificationTokens }
-export type DefaultSchema = typeof schema
+  const verificationTokens = mySqlTable(
+    "verificationToken",
+    {
+      identifier: varchar("identifier", { length: 255 }).notNull(),
+      token: varchar("token", { length: 255 }).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 mySqlDrizzleAdapter(
-  client: MySql2Database<Record<string, never>>
+  client: MySql2Database<Record<string, never>>,
+  tableFn = defaultMySqlTableFn
 ): Adapter {
+  const { users, accounts, sessions, verificationTokens } =
+    createTables(tableFn)
+
   return {
     async createUser(data) {
       const id = crypto.randomUUID()

package/src/lib/pg.ts

@@ -1,71 +1,79 @@
 import { and, eq } from "drizzle-orm"
 import {
   timestamp,
-  pgTable,
+  pgTable as defaultPgTableFn,
   text,
   primaryKey,
   integer,
+  PgTableFn,
 } from "drizzle-orm/pg-core"
 
 import type { PostgresJsDatabase } from "drizzle-orm/postgres-js"
 import type { Adapter, AdapterAccount } from "@auth/core/adapters"
 
-export const users = pgTable("users", {
-  id: text("id").notNull().primaryKey(),
-  name: text("name"),
-  email: text("email").notNull(),
-  emailVerified: timestamp("emailVerified", { mode: "date" }),
-  image: text("image"),
-})
-
-export const accounts = pgTable(
-  "accounts",
-  {
+export function createTables(pgTable: PgTableFn) {
+  const users = pgTable("users", {
+    id: text("id").notNull().primaryKey(),
+    name: text("name"),
+    email: text("email").notNull(),
+    emailVerified: timestamp("emailVerified", { mode: "date" }),
+    image: text("image"),
+  })
+
+  const accounts = pgTable(
+    "accounts",
+    {
+      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("sessions", {
+    sessionToken: text("sessionToken").notNull().primaryKey(),
     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 sessions = pgTable("sessions", {
-  sessionToken: text("sessionToken").notNull().primaryKey(),
-  userId: text("userId")
-    .notNull()
-    .references(() => users.id, { onDelete: "cascade" }),
-  expires: timestamp("expires", { mode: "date" }).notNull(),
-})
-
-export 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),
   })
-)
 
-export const schema = { users, accounts, sessions, verificationTokens }
-export type DefaultSchema = typeof schema
+  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: PostgresJsDatabase<Record<string, never>>
+  client: PostgresJsDatabase<Record<string, never>>,
+  tableFn = defaultPgTableFn
 ): Adapter {
+  const { users, accounts, sessions, verificationTokens } =
+    createTables(tableFn)
+
   return {
     async createUser(data) {
       return await client

package/src/lib/sqlite.ts

@@ -1,70 +1,78 @@
 import { eq, and } from "drizzle-orm"
 import {
   integer,
-  sqliteTable,
+  sqliteTable as defaultSqliteTableFn,
   text,
   primaryKey,
   BaseSQLiteDatabase,
+  SQLiteTableFn,
 } from "drizzle-orm/sqlite-core"
 
 import type { Adapter, AdapterAccount } from "@auth/core/adapters"
 
-export const users = sqliteTable("users", {
-  id: text("id").notNull().primaryKey(),
-  name: text("name"),
-  email: text("email").notNull(),
-  emailVerified: integer("emailVerified", { mode: "timestamp_ms" }),
-  image: text("image"),
-})
+export function createTables(sqliteTable: SQLiteTableFn) {
+  const users = sqliteTable("users", {
+    id: text("id").notNull().primaryKey(),
+    name: text("name"),
+    email: text("email").notNull(),
+    emailVerified: integer("emailVerified", { mode: "timestamp_ms" }),
+    image: text("image"),
+  })
+
+  const accounts = sqliteTable(
+    "accounts",
+    {
+      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 accounts = sqliteTable(
-  "accounts",
-  {
+  const sessions = sqliteTable("sessions", {
+    sessionToken: text("sessionToken").notNull().primaryKey(),
     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),
+    expires: integer("expires", { mode: "timestamp_ms" }).notNull(),
   })
-)
 
-export const sessions = sqliteTable("sessions", {
-  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),
+    })
+  )
 
-export 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 const schema = { users, accounts, sessions, verificationTokens }
-export type DefaultSchema = typeof schema
+export type DefaultSchema = ReturnType<typeof createTables>
 
 export function SQLiteDrizzleAdapter(
-  client: BaseSQLiteDatabase<any, any>
+  client: BaseSQLiteDatabase<any, any>,
+  tableFn = defaultSqliteTableFn
 ): Adapter {
+  const { users, accounts, sessions, verificationTokens } =
+    createTables(tableFn)
+
   return {
     createUser(data) {
       return client

package/src/lib/utils.ts

@@ -2,9 +2,9 @@ import { MySqlDatabase } from "drizzle-orm/mysql-core"
 import { PgDatabase } from "drizzle-orm/pg-core"
 import { BaseSQLiteDatabase } from "drizzle-orm/sqlite-core"
 
-import type { AnyMySqlTable } from "drizzle-orm/mysql-core"
-import type { AnyPgTable } from "drizzle-orm/pg-core"
-import type { AnySQLiteTable } 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"
@@ -32,6 +32,14 @@ export type ClientFlavors<Flavor> = Flavor extends AnyMySqlDatabase
   ? MinimumSchema["sqlite"]
   : never
 
+export type TableFn<Flavor> = Flavor extends AnyMySqlDatabase
+  ? MySqlTableFn
+  : Flavor extends AnyPgDatabase
+  ? PgTableFn
+  : Flavor extends AnySQLiteDatabase
+  ? SQLiteTableFn
+  : AnySQLiteTable
+
 export function isMySqlDatabase(
   db: any
 ): db is MySqlDatabase<any, any, any, any> {