@auth/drizzle-adapter 0.9.0 → 1.0.0

package/lib/pg.js

@@ -1,165 +1,170 @@
 import { and, eq } from "drizzle-orm";
-import { timestamp, pgTable as defaultPgTableFn, text, primaryKey, integer, } from "drizzle-orm/pg-core";
-import { stripUndefined } from "./utils.js";
-export function createTables(pgTable) {
-    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().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 function pgDrizzleAdapter(client, tableFn = defaultPgTableFn) {
-    const { users, accounts, sessions, verificationTokens } = createTables(tableFn);
+import { timestamp, text, primaryKey, integer, pgTable, index, } from "drizzle-orm/pg-core";
+import { randomUUID } from "crypto";
+export const postgresUsersTable = pgTable("user", {
+    id: text("id")
+        .primaryKey()
+        .$defaultFn(() => randomUUID()),
+    name: text("name"),
+    email: text("email").notNull().unique(),
+    emailVerified: timestamp("emailVerified", { mode: "date" }),
+    image: text("image"),
+});
+export const postgresAccountsTable = pgTable("account", {
+    userId: text("userId")
+        .notNull()
+        .references(() => postgresUsersTable.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"),
+}, (table) => {
+    return {
+        userIdIdx: index().on(table.userId),
+        compositePk: primaryKey({
+            columns: [table.provider, table.providerAccountId],
+        }),
+    };
+});
+export const postgresSessionsTable = pgTable("session", {
+    id: text("id")
+        .primaryKey()
+        .$defaultFn(() => randomUUID()),
+    sessionToken: text("sessionToken").notNull().unique(),
+    userId: text("userId")
+        .notNull()
+        .references(() => postgresUsersTable.id, { onDelete: "cascade" }),
+    expires: timestamp("expires", { mode: "date" }).notNull(),
+}, (table) => {
+    return {
+        userIdIdx: index().on(table.userId),
+    };
+});
+export const postgresVerificationTokensTable = pgTable("verificationToken", {
+    identifier: text("identifier").notNull(),
+    token: text("token").notNull().unique(),
+    expires: timestamp("expires", { mode: "date" }).notNull(),
+}, (table) => {
+    return {
+        compositePk: primaryKey({ columns: [table.identifier, table.token] }),
+    };
+});
+export function PostgresDrizzleAdapter(client, schema = {
+    usersTable: postgresUsersTable,
+    accountsTable: postgresAccountsTable,
+    sessionsTable: postgresSessionsTable,
+    verificationTokensTable: postgresVerificationTokensTable,
+}) {
+    const { usersTable, accountsTable, sessionsTable, verificationTokensTable } = schema;
     return {
         async createUser(data) {
-            return await client
-                .insert(users)
-                .values({ ...data, id: crypto.randomUUID() })
+            return client
+                .insert(usersTable)
+                .values(data)
                 .returning()
-                .then((res) => res[0] ?? null);
+                .then((res) => res[0]);
         },
-        async getUser(data) {
-            return await client
+        async getUser(userId) {
+            return client
                 .select()
-                .from(users)
-                .where(eq(users.id, data))
-                .then((res) => res[0] ?? null);
+                .from(usersTable)
+                .where(eq(usersTable.id, userId))
+                .then((res) => (res.length > 0 ? res[0] : null));
         },
-        async getUserByEmail(data) {
-            return await client
+        async getUserByEmail(email) {
+            return client
                 .select()
-                .from(users)
-                .where(eq(users.email, data))
-                .then((res) => res[0] ?? null);
+                .from(usersTable)
+                .where(eq(usersTable.email, email))
+                .then((res) => (res.length > 0 ? res[0] : null));
         },
         async createSession(data) {
-            return await client
-                .insert(sessions)
+            return client
+                .insert(sessionsTable)
                 .values(data)
                 .returning()
                 .then((res) => res[0]);
         },
-        async getSessionAndUser(data) {
-            return await client
+        async getSessionAndUser(sessionToken) {
+            return client
                 .select({
-                session: sessions,
-                user: users,
+                session: sessionsTable,
+                user: usersTable,
             })
-                .from(sessions)
-                .where(eq(sessions.sessionToken, data))
-                .innerJoin(users, eq(users.id, sessions.userId))
-                .then((res) => res[0] ?? null);
+                .from(sessionsTable)
+                .where(eq(sessionsTable.sessionToken, sessionToken))
+                .innerJoin(usersTable, eq(usersTable.id, sessionsTable.userId))
+                .then((res) => (res.length > 0 ? res[0] : null));
         },
         async updateUser(data) {
             if (!data.id) {
                 throw new Error("No user id.");
             }
-            return await client
-                .update(users)
+            const [result] = await client
+                .update(usersTable)
                 .set(data)
-                .where(eq(users.id, data.id))
-                .returning()
-                .then((res) => res[0]);
+                .where(eq(usersTable.id, data.id))
+                .returning();
+            if (!result) {
+                throw new Error("No user found.");
+            }
+            return result;
         },
         async updateSession(data) {
-            return await client
-                .update(sessions)
+            return client
+                .update(sessionsTable)
                 .set(data)
-                .where(eq(sessions.sessionToken, data.sessionToken))
+                .where(eq(sessionsTable.sessionToken, data.sessionToken))
                 .returning()
                 .then((res) => res[0]);
         },
-        async linkAccount(rawAccount) {
-            return stripUndefined(await client
-                .insert(accounts)
-                .values(rawAccount)
-                .returning()
-                .then((res) => res[0]));
+        async linkAccount(data) {
+            await client.insert(accountsTable).values(data);
         },
         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;
+            const result = await client
+                .select({
+                account: accountsTable,
+                user: usersTable,
+            })
+                .from(accountsTable)
+                .innerJoin(usersTable, eq(accountsTable.userId, usersTable.id))
+                .where(and(eq(accountsTable.provider, account.provider), eq(accountsTable.providerAccountId, account.providerAccountId)))
+                .then((res) => res[0]);
+            return result?.user ?? null;
         },
         async deleteSession(sessionToken) {
-            const session = await client
-                .delete(sessions)
-                .where(eq(sessions.sessionToken, sessionToken))
-                .returning()
-                .then((res) => res[0] ?? null);
-            return session;
+            await client
+                .delete(sessionsTable)
+                .where(eq(sessionsTable.sessionToken, sessionToken));
         },
-        async createVerificationToken(token) {
-            return await client
-                .insert(verificationTokens)
-                .values(token)
+        async createVerificationToken(data) {
+            return client
+                .insert(verificationTokensTable)
+                .values(data)
                 .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 useVerificationToken(params) {
+            return client
+                .delete(verificationTokensTable)
+                .where(and(eq(verificationTokensTable.identifier, params.identifier), eq(verificationTokensTable.token, params.token)))
+                .returning()
+                .then((res) => (res.length > 0 ? res[0] : null));
         },
         async deleteUser(id) {
-            await client
-                .delete(users)
-                .where(eq(users.id, id))
-                .returning()
-                .then((res) => res[0] ?? null);
+            await client.delete(usersTable).where(eq(usersTable.id, id));
         },
-        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] ?? null);
-            return { provider, type, providerAccountId, userId };
+        async unlinkAccount(params) {
+            await client
+                .delete(accountsTable)
+                .where(and(eq(accountsTable.provider, params.provider), eq(accountsTable.providerAccountId, params.providerAccountId)));
         },
     };
 }