@auth/drizzle-adapter 0.8.2 → 1.0.0

package/lib/mysql.js

@@ -1,189 +1,181 @@
 import { and, eq } from "drizzle-orm";
-import { int, timestamp, mysqlTable as defaultMySqlTableFn, primaryKey, varchar, } from "drizzle-orm/mysql-core";
-export function createTables(mySqlTable) {
-    const users = mySqlTable("user", {
-        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("account", {
-        userId: varchar("userId", { length: 255 })
-            .notNull()
-            .references(() => users.id, { onDelete: "cascade" }),
-        type: varchar("type", { length: 255 })
-            .$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("session", {
-        sessionToken: varchar("sessionToken", { length: 255 })
-            .notNull()
-            .primaryKey(),
-        userId: varchar("userId", { length: 255 })
-            .notNull()
-            .references(() => users.id, { onDelete: "cascade" }),
-        expires: timestamp("expires", { mode: "date" }).notNull(),
-    });
-    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 function mySqlDrizzleAdapter(client, tableFn = defaultMySqlTableFn) {
-    const { users, accounts, sessions, verificationTokens } = createTables(tableFn);
+import { int, timestamp, primaryKey, varchar, mysqlTable, index, } from "drizzle-orm/mysql-core";
+import { randomUUID } from "crypto";
+export const mysqlUsersTable = mysqlTable("user", {
+    id: varchar("id", { length: 255 })
+        .primaryKey()
+        .$defaultFn(() => randomUUID()),
+    name: varchar("name", { length: 255 }),
+    email: varchar("email", { length: 255 }).notNull().unique(),
+    emailVerified: timestamp("emailVerified", { mode: "date", fsp: 3 }),
+    image: varchar("image", { length: 255 }),
+});
+export const mysqlAccountsTable = mysqlTable("account", {
+    userId: varchar("userId", { length: 255 })
+        .notNull()
+        .references(() => mysqlUsersTable.id, { onDelete: "cascade" }),
+    type: varchar("type", { length: 255 }).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: 2048 }),
+    session_state: varchar("session_state", { length: 255 }),
+}, (account) => ({
+    compositePk: primaryKey({
+        columns: [account.provider, account.providerAccountId],
+    }),
+    userIdIdx: index("Account_userId_index").on(account.userId),
+}));
+export const mysqlSessionsTable = mysqlTable("session", {
+    id: varchar("id", { length: 255 })
+        .primaryKey()
+        .$defaultFn(() => randomUUID()),
+    sessionToken: varchar("sessionToken", { length: 255 }).notNull().unique(),
+    userId: varchar("userId", { length: 255 })
+        .notNull()
+        .references(() => mysqlUsersTable.id, { onDelete: "cascade" }),
+    expires: timestamp("expires", { mode: "date" }).notNull(),
+}, (session) => ({
+    userIdIdx: index("Session_userId_index").on(session.userId),
+}));
+export const mysqlVerificationTokensTable = mysqlTable("verificationToken", {
+    identifier: varchar("identifier", { length: 255 }).notNull(),
+    token: varchar("token", { length: 255 }).notNull().unique(),
+    expires: timestamp("expires", { mode: "date" }).notNull(),
+}, (vt) => ({
+    compositePk: primaryKey({ columns: [vt.identifier, vt.token] }),
+}));
+export function MySqlDrizzleAdapter(client, schema = {
+    usersTable: mysqlUsersTable,
+    accountsTable: mysqlAccountsTable,
+    sessionsTable: mysqlSessionsTable,
+    verificationTokensTable: mysqlVerificationTokensTable,
+}) {
+    const { usersTable, accountsTable, sessionsTable, verificationTokensTable } = schema;
     return {
         async createUser(data) {
-            const id = crypto.randomUUID();
-            await client.insert(users).values({ ...data, id });
-            return await client
+            const id = randomUUID();
+            await client.insert(usersTable).values({ ...data, id });
+            return client
                 .select()
-                .from(users)
-                .where(eq(users.id, id))
+                .from(usersTable)
+                .where(eq(usersTable.id, id))
                 .then((res) => res[0]);
         },
-        async getUser(data) {
-            const thing = (await client
+        async getUser(userId) {
+            return client
                 .select()
-                .from(users)
-                .where(eq(users.id, data))
-                .then((res) => res[0])) ?? null;
-            return thing;
+                .from(usersTable)
+                .where(eq(usersTable.id, userId))
+                .then((res) => (res.length > 0 ? res[0] : null));
         },
-        async getUserByEmail(data) {
-            const user = (await client
+        async getUserByEmail(email) {
+            return client
                 .select()
-                .from(users)
-                .where(eq(users.email, data))
-                .then((res) => res[0])) ?? null;
-            return user;
+                .from(usersTable)
+                .where(eq(usersTable.email, email))
+                .then((res) => (res.length > 0 ? res[0] : null));
         },
         async createSession(data) {
-            await client.insert(sessions).values(data);
-            return await client
+            const id = randomUUID();
+            await client.insert(sessionsTable).values({ ...data, id });
+            return client
                 .select()
-                .from(sessions)
-                .where(eq(sessions.sessionToken, data.sessionToken))
+                .from(sessionsTable)
+                .where(eq(sessionsTable.id, id))
                 .then((res) => res[0]);
         },
-        async getSessionAndUser(data) {
-            const sessionAndUser = (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;
-            return sessionAndUser;
+                .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.");
             }
-            await client.update(users).set(data).where(eq(users.id, data.id));
-            return await client
+            await client
+                .update(usersTable)
+                .set(data)
+                .where(eq(usersTable.id, data.id));
+            const [result] = await client
                 .select()
-                .from(users)
-                .where(eq(users.id, data.id))
-                .then((res) => res[0]);
+                .from(usersTable)
+                .where(eq(usersTable.id, data.id));
+            if (!result) {
+                throw new Error("No user found.");
+            }
+            return result;
         },
         async updateSession(data) {
             await client
-                .update(sessions)
+                .update(sessionsTable)
                 .set(data)
-                .where(eq(sessions.sessionToken, data.sessionToken));
-            return await client
+                .where(eq(sessionsTable.sessionToken, data.sessionToken));
+            return client
                 .select()
-                .from(sessions)
-                .where(eq(sessions.sessionToken, data.sessionToken))
+                .from(sessionsTable)
+                .where(eq(sessionsTable.sessionToken, data.sessionToken))
                 .then((res) => res[0]);
         },
-        async linkAccount(rawAccount) {
-            await client.insert(accounts).values(rawAccount);
+        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;
-            if (!dbAccount) {
-                return null;
-            }
-            return dbAccount.user;
+            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
-                .select()
-                .from(sessions)
-                .where(eq(sessions.sessionToken, sessionToken))
-                .then((res) => res[0])) ?? null;
             await client
-                .delete(sessions)
-                .where(eq(sessions.sessionToken, sessionToken));
-            return session;
+                .delete(sessionsTable)
+                .where(eq(sessionsTable.sessionToken, sessionToken));
         },
-        async createVerificationToken(token) {
-            await client.insert(verificationTokens).values(token);
-            return await client
+        async createVerificationToken(data) {
+            await client.insert(verificationTokensTable).values(data);
+            return client
                 .select()
-                .from(verificationTokens)
-                .where(eq(verificationTokens.identifier, token.identifier))
+                .from(verificationTokensTable)
+                .where(eq(verificationTokensTable.identifier, data.identifier))
                 .then((res) => res[0]);
         },
-        async useVerificationToken(token) {
-            try {
-                const deletedToken = (await client
-                    .select()
-                    .from(verificationTokens)
-                    .where(and(eq(verificationTokens.identifier, token.identifier), eq(verificationTokens.token, token.token)))
-                    .then((res) => res[0])) ?? null;
+        async useVerificationToken(params) {
+            const deletedToken = await client
+                .select()
+                .from(verificationTokensTable)
+                .where(and(eq(verificationTokensTable.identifier, params.identifier), eq(verificationTokensTable.token, params.token)))
+                .then((res) => (res.length > 0 ? res[0] : null));
+            if (deletedToken) {
                 await client
-                    .delete(verificationTokens)
-                    .where(and(eq(verificationTokens.identifier, token.identifier), eq(verificationTokens.token, token.token)));
-                return deletedToken;
-            }
-            catch (err) {
-                throw new Error("No verification token found.");
+                    .delete(verificationTokensTable)
+                    .where(and(eq(verificationTokensTable.identifier, params.identifier), eq(verificationTokensTable.token, params.token)));
             }
+            return deletedToken;
         },
         async deleteUser(id) {
-            const user = await client
-                .select()
-                .from(users)
-                .where(eq(users.id, id))
-                .then((res) => res[0] ?? null);
-            await client.delete(users).where(eq(users.id, id));
-            return user;
+            await client.delete(usersTable).where(eq(usersTable.id, id));
         },
-        async unlinkAccount(account) {
+        async unlinkAccount(params) {
             await client
-                .delete(accounts)
-                .where(and(eq(accounts.providerAccountId, account.providerAccountId), eq(accounts.provider, account.provider)));
-            return undefined;
+                .delete(accountsTable)
+                .where(and(eq(accountsTable.provider, params.provider), eq(accountsTable.providerAccountId, params.providerAccountId)));
         },
     };
 }