@auth/drizzle-adapter 0.0.0-manual.ffc00566 → 0.2.0

package/src/lib/pg.ts

@@ -1,106 +1,109 @@
+import { and, eq } from "drizzle-orm"
 import {
   timestamp,
-  pgTable,
+  pgTable as defaultPgTableFn,
   text,
   primaryKey,
   integer,
+  PgTableFn,
 } from "drizzle-orm/pg-core"
-import { PostgresJsDatabase } from "drizzle-orm/postgres-js"
-import { Adapter, AdapterAccount } from "@auth/core/adapters"
-import { and, eq } from "drizzle-orm"
 
-/** @internal */
-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"),
-})
-
-/** @internal */
-export const accounts = pgTable(
-  "accounts",
-  {
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js"
+import type { Adapter, AdapterAccount } from "@auth/core/adapters"
+
+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),
-  })
-)
-
-/** @internal */
-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(),
-})
-
-/** @internal */
-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),
   })
-)
 
-/** @internal */
-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>
 
-/** @internal */
 export function pgDrizzleAdapter(
-  client: PostgresJsDatabase<Record<string, never>>
+  client: PostgresJsDatabase<Record<string, never>>,
+  tableFn = defaultPgTableFn
 ): Adapter {
+  const { users, accounts, sessions, verificationTokens } =
+    createTables(tableFn)
+
   return {
-    createUser: async (data) => {
+    async createUser(data) {
       return await client
         .insert(users)
         .values({ ...data, id: crypto.randomUUID() })
         .returning()
         .then((res) => res[0] ?? null)
     },
-    getUser: async (data) => {
+    async getUser(data) {
       return await client
         .select()
         .from(users)
         .where(eq(users.id, data))
         .then((res) => res[0] ?? null)
     },
-    getUserByEmail: async (data) => {
+    async getUserByEmail(data) {
       return await client
         .select()
         .from(users)
         .where(eq(users.email, data))
         .then((res) => res[0] ?? null)
     },
-    createSession: async (data) => {
+    async createSession(data) {
       return await client
         .insert(sessions)
         .values(data)
         .returning()
         .then((res) => res[0])
     },
-    getSessionAndUser: async (data) => {
+    async getSessionAndUser(data) {
       return await client
         .select({
           session: sessions,
@@ -111,7 +114,7 @@ export function pgDrizzleAdapter(
         .innerJoin(users, eq(users.id, sessions.userId))
         .then((res) => res[0] ?? null)
     },
-    updateUser: async (data) => {
+    async updateUser(data) {
       if (!data.id) {
         throw new Error("No user id.")
       }
@@ -123,7 +126,7 @@ export function pgDrizzleAdapter(
         .returning()
         .then((res) => res[0])
     },
-    updateSession: async (data) => {
+    async updateSession(data) {
       return await client
         .update(sessions)
         .set(data)
@@ -131,7 +134,7 @@ export function pgDrizzleAdapter(
         .returning()
         .then((res) => res[0])
     },
-    linkAccount: async (rawAccount) => {
+    async linkAccount(rawAccount) {
       const updatedAccount = await client
         .insert(accounts)
         .values(rawAccount)
@@ -153,7 +156,7 @@ export function pgDrizzleAdapter(
 
       return account
     },
-    getUserByAccount: async (account) => {
+    async getUserByAccount(account) {
       const dbAccount =
         (await client
           .select()
@@ -173,7 +176,7 @@ export function pgDrizzleAdapter(
 
       return dbAccount.users
     },
-    deleteSession: async (sessionToken) => {
+    async deleteSession(sessionToken) {
       const session = await client
         .delete(sessions)
         .where(eq(sessions.sessionToken, sessionToken))
@@ -182,14 +185,14 @@ export function pgDrizzleAdapter(
 
       return session
     },
-    createVerificationToken: async (token) => {
+    async createVerificationToken(token) {
       return await client
         .insert(verificationTokens)
         .values(token)
         .returning()
         .then((res) => res[0])
     },
-    useVerificationToken: async (token) => {
+    async useVerificationToken(token) {
       try {
         return await client
           .delete(verificationTokens)
@@ -205,14 +208,14 @@ export function pgDrizzleAdapter(
         throw new Error("No verification token found.")
       }
     },
-    deleteUser: async (id) => {
+    async deleteUser(id) {
       await client
         .delete(users)
         .where(eq(users.id, id))
         .returning()
         .then((res) => res[0] ?? null)
     },
-    unlinkAccount: async (account) => {
+    async unlinkAccount(account) {
       const { type, provider, providerAccountId, userId } = await client
         .delete(accounts)
         .where(

package/src/lib/sqlite.ts

@@ -1,95 +1,98 @@
+import { eq, and } from "drizzle-orm"
 import {
   integer,
-  sqliteTable,
+  sqliteTable as defaultSqliteTableFn,
   text,
   primaryKey,
   BaseSQLiteDatabase,
+  SQLiteTableFn,
 } from "drizzle-orm/sqlite-core"
-import { Adapter, AdapterAccount } from "@auth/core/adapters"
-import { eq, and } from "drizzle-orm"
 
-/** @internal */
-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"),
-})
+import type { Adapter, AdapterAccount } from "@auth/core/adapters"
+
+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),
+    })
+  )
 
-/** @internal */
-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(),
   })
-)
 
-/** @internal */
-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),
+    })
+  )
 
-/** @internal */
-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 }
+}
 
-/** @internal */
-export const schema = { users, accounts, sessions, verificationTokens }
-export type DefaultSchema = typeof schema
+export type DefaultSchema = ReturnType<typeof createTables>
 
-/** @internal */
 export function SQLiteDrizzleAdapter(
-  client: BaseSQLiteDatabase<any, any>
+  client: BaseSQLiteDatabase<any, any>,
+  tableFn = defaultSqliteTableFn
 ): Adapter {
+  const { users, accounts, sessions, verificationTokens } =
+    createTables(tableFn)
+
   return {
-    createUser: (data) => {
+    createUser(data) {
       return client
         .insert(users)
         .values({ ...data, id: crypto.randomUUID() })
         .returning()
         .get()
     },
-    getUser: (data) => {
+    getUser(data) {
       return client.select().from(users).where(eq(users.id, data)).get() ?? null
     },
-    getUserByEmail: (data) => {
+    getUserByEmail(data) {
       return (
         client.select().from(users).where(eq(users.email, data)).get() ?? null
       )
     },
-    createSession: (data) => {
+    createSession(data) {
       return client.insert(sessions).values(data).returning().get()
     },
-    getSessionAndUser: (data) => {
+    getSessionAndUser(data) {
       return (
         client
           .select({
@@ -102,7 +105,7 @@ export function SQLiteDrizzleAdapter(
           .get() ?? null
       )
     },
-    updateUser: (data) => {
+    updateUser(data) {
       if (!data.id) {
         throw new Error("No user id.")
       }
@@ -114,7 +117,7 @@ export function SQLiteDrizzleAdapter(
         .returning()
         .get()
     },
-    updateSession: (data) => {
+    updateSession(data) {
       return client
         .update(sessions)
         .set(data)
@@ -122,7 +125,7 @@ export function SQLiteDrizzleAdapter(
         .returning()
         .get()
     },
-    linkAccount: (rawAccount) => {
+    linkAccount(rawAccount) {
       const updatedAccount = client
         .insert(accounts)
         .values(rawAccount)
@@ -143,7 +146,7 @@ export function SQLiteDrizzleAdapter(
 
       return account
     },
-    getUserByAccount: (account) => {
+    getUserByAccount(account) {
       const results = client
         .select()
         .from(accounts)
@@ -158,7 +161,7 @@ export function SQLiteDrizzleAdapter(
 
       return results?.users ?? null
     },
-    deleteSession: (sessionToken) => {
+    deleteSession(sessionToken) {
       return (
         client
           .delete(sessions)
@@ -167,10 +170,10 @@ export function SQLiteDrizzleAdapter(
           .get() ?? null
       )
     },
-    createVerificationToken: (token) => {
+    createVerificationToken(token) {
       return client.insert(verificationTokens).values(token).returning().get()
     },
-    useVerificationToken: (token) => {
+    useVerificationToken(token) {
       try {
         return (
           client
@@ -188,10 +191,10 @@ export function SQLiteDrizzleAdapter(
         throw new Error("No verification token found.")
       }
     },
-    deleteUser: (id) => {
+    deleteUser(id) {
       return client.delete(users).where(eq(users.id, id)).returning().get()
     },
-    unlinkAccount: (account) => {
+    unlinkAccount(account) {
       client
         .delete(accounts)
         .where(

package/src/lib/utils.ts

@@ -1,9 +1,13 @@
-import { AnyMySqlTable, MySqlDatabase } from "drizzle-orm/mysql-core"
-import { AnyPgTable, PgDatabase } from "drizzle-orm/pg-core"
-import { AnySQLiteTable, BaseSQLiteDatabase } from "drizzle-orm/sqlite-core"
-import { DefaultSchema as PgSchema } from "./pg"
-import { DefaultSchema as MySqlSchema } from "./mysql"
-import { DefaultSchema as SQLiteSchema } from "./sqlite"
+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>
@@ -28,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
+  ? AnySQLiteTable
+  : SQLiteTableFn
+
 export function isMySqlDatabase(
   db: any
 ): db is MySqlDatabase<any, any, any, any> {