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

package/README.md

@@ -4,7 +4,7 @@
     <img height="64px" src="https://authjs.dev/img/logo/logo-sm.png" />
   </a>
   <a href="https://github.com/drizzle-team/drizzle-orm" target="_blank">
-    <img height="64px" src="https://pbs.twimg.com/profile_images/1598308842391179266/CtXrfLnk_400x400.jpg"/>
+    <img height="64px" src="https://authjs.dev/img/adapters/drizzle-orm.png"/>
   </a>
   <h3 align="center"><b>Drizzle ORM Adapter</b> - NextAuth.js / Auth.js</a></h3>
   <p align="center" style="align: center;">

package/index.d.ts

@@ -15,10 +15,10 @@
  *
  * @module @auth/drizzle-adapter
  */
-import { SqlFlavorOptions } from "./lib/utils";
+import { SqlFlavorOptions, TableFn } from "./lib/utils.js";
 import type { Adapter } from "@auth/core/adapters";
 /**
- * Add the adapter to your `app/api/[...nextauth]/route.js` next-auth configuration object.
+ * Add the adapter to your `pages/api/[...nextauth].ts` next-auth configuration object.
  *
  * ```ts title="pages/api/auth/[...nextauth].ts"
  * import NextAuth from "next-auth"
@@ -37,6 +37,10 @@ import type { Adapter } from "@auth/core/adapters";
  * })
  * ```
  *
+ * :::info
+ * If you're using multi-project schemas, you can pass your table function as a second argument
+ * :::
+ *
  * ## Setup
  *
  * First, create a schema that includes [the minimum requirements for a `next-auth` adapter](/reference/adapters#models). You can select your favorite SQL flavor below and copy it.
@@ -237,5 +241,5 @@ import type { Adapter } from "@auth/core/adapters";
  * ---
  *
  **/
-export declare function DrizzleAdapter<SqlFlavor extends SqlFlavorOptions>(db: SqlFlavor): Adapter;
+export declare function DrizzleAdapter<SqlFlavor extends SqlFlavorOptions>(db: SqlFlavor, table?: TableFn<SqlFlavor>): Adapter;
 //# sourceMappingURL=index.d.ts.map

package/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAKH,OAAO,EAIL,gBAAgB,EACjB,MAAM,aAAa,CAAA;AAEpB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAElD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA2NI;AACJ,wBAAgB,cAAc,CAAC,SAAS,SAAS,gBAAgB,EAC/D,EAAE,EAAE,SAAS,GACZ,OAAO,CAeT"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAQH,OAAO,EAIL,gBAAgB,EAChB,OAAO,EACR,MAAM,gBAAgB,CAAA;AAEvB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAElD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA+NI;AACJ,wBAAgB,cAAc,CAAC,SAAS,SAAS,gBAAgB,EAC/D,EAAE,EAAE,SAAS,EACb,KAAK,CAAC,EAAE,OAAO,CAAC,SAAS,CAAC,GACzB,OAAO,CAeT"}

package/index.js

@@ -15,12 +15,12 @@
  *
  * @module @auth/drizzle-adapter
  */
-import { mySqlDrizzleAdapter } from "./lib/mysql";
-import { pgDrizzleAdapter } from "./lib/pg";
-import { SQLiteDrizzleAdapter } from "./lib/sqlite";
-import { isMySqlDatabase, isPgDatabase, isSQLiteDatabase, } from "./lib/utils";
+import { mySqlDrizzleAdapter } from "./lib/mysql.js";
+import { pgDrizzleAdapter } from "./lib/pg.js";
+import { SQLiteDrizzleAdapter } from "./lib/sqlite.js";
+import { isMySqlDatabase, isPgDatabase, isSQLiteDatabase, } from "./lib/utils.js";
 /**
- * Add the adapter to your `app/api/[...nextauth]/route.js` next-auth configuration object.
+ * Add the adapter to your `pages/api/[...nextauth].ts` next-auth configuration object.
  *
  * ```ts title="pages/api/auth/[...nextauth].ts"
  * import NextAuth from "next-auth"
@@ -39,6 +39,10 @@ import { isMySqlDatabase, isPgDatabase, isSQLiteDatabase, } from "./lib/utils";
  * })
  * ```
  *
+ * :::info
+ * If you're using multi-project schemas, you can pass your table function as a second argument
+ * :::
+ *
  * ## Setup
  *
  * First, create a schema that includes [the minimum requirements for a `next-auth` adapter](/reference/adapters#models). You can select your favorite SQL flavor below and copy it.
@@ -239,16 +243,16 @@ import { isMySqlDatabase, isPgDatabase, isSQLiteDatabase, } from "./lib/utils";
  * ---
  *
  **/
-export function DrizzleAdapter(db) {
+export function DrizzleAdapter(db, table) {
     if (isMySqlDatabase(db)) {
         // We need to cast to unknown since the type overlaps (PScale is MySQL based)
-        return mySqlDrizzleAdapter(db);
+        return mySqlDrizzleAdapter(db, table);
     }
     if (isPgDatabase(db)) {
-        return pgDrizzleAdapter(db);
+        return pgDrizzleAdapter(db, table);
     }
     if (isSQLiteDatabase(db)) {
-        return SQLiteDrizzleAdapter(db);
+        return SQLiteDrizzleAdapter(db, table);
     }
     throw new Error("Unsupported database type in Auth.js Drizzle adapter.");
 }

package/lib/mysql.d.ts

@@ -1,2 +1,226 @@
-export type DefaultSchema = typeof schema;
+import { MySqlTableFn } from "drizzle-orm/mysql-core";
+import type { Adapter } from "@auth/core/adapters";
+import type { MySql2Database } from "drizzle-orm/mysql2";
+export declare function createTables(mySqlTable: MySqlTableFn): {
+    users: import("drizzle-orm/select.types.d-b947a018").aw<{
+        name: "users";
+        schema: undefined;
+        columns: {
+            id: import("drizzle-orm/mysql-core").MySqlVarChar<{
+                tableName: "users";
+                enumValues: [string, ...string[]];
+                name: "id";
+                data: string;
+                driverParam: string | number;
+                hasDefault: false;
+                notNull: true;
+            }>;
+            name: import("drizzle-orm/mysql-core").MySqlVarChar<{
+                tableName: "users";
+                name: "name";
+                data: string;
+                driverParam: string | number;
+                enumValues: [string, ...string[]];
+                notNull: false;
+                hasDefault: false;
+            }>;
+            email: import("drizzle-orm/mysql-core").MySqlVarChar<{
+                tableName: "users";
+                enumValues: [string, ...string[]];
+                name: "email";
+                data: string;
+                driverParam: string | number;
+                hasDefault: false;
+                notNull: true;
+            }>;
+            emailVerified: import("drizzle-orm/mysql-core").MySqlTimestamp<{
+                tableName: "users";
+                name: "emailVerified";
+                data: Date;
+                driverParam: string | number;
+                notNull: false;
+                hasDefault: true;
+            }>;
+            image: import("drizzle-orm/mysql-core").MySqlVarChar<{
+                tableName: "users";
+                name: "image";
+                data: string;
+                driverParam: string | number;
+                enumValues: [string, ...string[]];
+                notNull: false;
+                hasDefault: false;
+            }>;
+        };
+    }>;
+    accounts: import("drizzle-orm/select.types.d-b947a018").aw<{
+        name: "accounts";
+        schema: undefined;
+        columns: {
+            userId: import("drizzle-orm/mysql-core").MySqlVarChar<{
+                tableName: "accounts";
+                enumValues: [string, ...string[]];
+                name: "userId";
+                data: string;
+                driverParam: string | number;
+                hasDefault: false;
+                notNull: true;
+            }>;
+            type: import("drizzle-orm/mysql-core").MySqlVarChar<{
+                tableName: "accounts";
+                enumValues: [string, ...string[]];
+                name: "type";
+                data: "email" | "oidc" | "oauth";
+                driverParam: string | number;
+                hasDefault: false;
+                notNull: true;
+            }>;
+            provider: import("drizzle-orm/mysql-core").MySqlVarChar<{
+                tableName: "accounts";
+                enumValues: [string, ...string[]];
+                name: "provider";
+                data: string;
+                driverParam: string | number;
+                hasDefault: false;
+                notNull: true;
+            }>;
+            providerAccountId: import("drizzle-orm/mysql-core").MySqlVarChar<{
+                tableName: "accounts";
+                enumValues: [string, ...string[]];
+                name: "providerAccountId";
+                data: string;
+                driverParam: string | number;
+                hasDefault: false;
+                notNull: true;
+            }>;
+            refresh_token: import("drizzle-orm/mysql-core").MySqlVarChar<{
+                tableName: "accounts";
+                name: "refresh_token";
+                data: string;
+                driverParam: string | number;
+                enumValues: [string, ...string[]];
+                notNull: false;
+                hasDefault: false;
+            }>;
+            access_token: import("drizzle-orm/mysql-core").MySqlVarChar<{
+                tableName: "accounts";
+                name: "access_token";
+                data: string;
+                driverParam: string | number;
+                enumValues: [string, ...string[]];
+                notNull: false;
+                hasDefault: false;
+            }>;
+            expires_at: import("drizzle-orm/mysql-core").MySqlInt<{
+                tableName: "accounts";
+                name: "expires_at";
+                data: number;
+                driverParam: string | number;
+                notNull: false;
+                hasDefault: false;
+            }>;
+            token_type: import("drizzle-orm/mysql-core").MySqlVarChar<{
+                tableName: "accounts";
+                name: "token_type";
+                data: string;
+                driverParam: string | number;
+                enumValues: [string, ...string[]];
+                notNull: false;
+                hasDefault: false;
+            }>;
+            scope: import("drizzle-orm/mysql-core").MySqlVarChar<{
+                tableName: "accounts";
+                name: "scope";
+                data: string;
+                driverParam: string | number;
+                enumValues: [string, ...string[]];
+                notNull: false;
+                hasDefault: false;
+            }>;
+            id_token: import("drizzle-orm/mysql-core").MySqlVarChar<{
+                tableName: "accounts";
+                name: "id_token";
+                data: string;
+                driverParam: string | number;
+                enumValues: [string, ...string[]];
+                notNull: false;
+                hasDefault: false;
+            }>;
+            session_state: import("drizzle-orm/mysql-core").MySqlVarChar<{
+                tableName: "accounts";
+                name: "session_state";
+                data: string;
+                driverParam: string | number;
+                enumValues: [string, ...string[]];
+                notNull: false;
+                hasDefault: false;
+            }>;
+        };
+    }>;
+    sessions: import("drizzle-orm/select.types.d-b947a018").aw<{
+        name: "sessions";
+        schema: undefined;
+        columns: {
+            sessionToken: import("drizzle-orm/mysql-core").MySqlVarChar<{
+                tableName: "sessions";
+                enumValues: [string, ...string[]];
+                name: "sessionToken";
+                data: string;
+                driverParam: string | number;
+                hasDefault: false;
+                notNull: true;
+            }>;
+            userId: import("drizzle-orm/mysql-core").MySqlVarChar<{
+                tableName: "sessions";
+                enumValues: [string, ...string[]];
+                name: "userId";
+                data: string;
+                driverParam: string | number;
+                hasDefault: false;
+                notNull: true;
+            }>;
+            expires: import("drizzle-orm/mysql-core").MySqlTimestamp<{
+                tableName: "sessions";
+                name: "expires";
+                data: Date;
+                driverParam: string | number;
+                hasDefault: false;
+                notNull: true;
+            }>;
+        };
+    }>;
+    verificationTokens: import("drizzle-orm/select.types.d-b947a018").aw<{
+        name: "verificationToken";
+        schema: undefined;
+        columns: {
+            identifier: import("drizzle-orm/mysql-core").MySqlVarChar<{
+                tableName: "verificationToken";
+                enumValues: [string, ...string[]];
+                name: "identifier";
+                data: string;
+                driverParam: string | number;
+                hasDefault: false;
+                notNull: true;
+            }>;
+            token: import("drizzle-orm/mysql-core").MySqlVarChar<{
+                tableName: "verificationToken";
+                enumValues: [string, ...string[]];
+                name: "token";
+                data: string;
+                driverParam: string | number;
+                hasDefault: false;
+                notNull: true;
+            }>;
+            expires: import("drizzle-orm/mysql-core").MySqlTimestamp<{
+                tableName: "verificationToken";
+                name: "expires";
+                data: Date;
+                driverParam: string | number;
+                hasDefault: false;
+                notNull: true;
+            }>;
+        };
+    }>;
+};
+export type DefaultSchema = ReturnType<typeof createTables>;
+export declare function mySqlDrizzleAdapter(client: MySql2Database<Record<string, never>>, tableFn?: MySqlTableFn<undefined>): Adapter;
 //# sourceMappingURL=mysql.d.ts.map

package/lib/mysql.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mysql.d.ts","sourceRoot":"","sources":["../src/lib/mysql.ts"],"names":[],"mappings":"AAwEA,MAAM,MAAM,aAAa,GAAG,OAAO,MAAM,CAAA"}
+{"version":3,"file":"mysql.d.ts","sourceRoot":"","sources":["../src/lib/mysql.ts"],"names":[],"mappings":"AACA,OAAO,EAML,YAAY,EACb,MAAM,wBAAwB,CAAA;AAE/B,OAAO,KAAK,EAAE,OAAO,EAAkB,MAAM,qBAAqB,CAAA;AAClE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA;AAExD,wBAAgB,YAAY,CAAC,UAAU,EAAE,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6DpD;AAED,MAAM,MAAM,aAAa,GAAG,UAAU,CAAC,OAAO,YAAY,CAAC,CAAA;AAE3D,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,cAAc,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,EAC7C,OAAO,0BAAsB,GAC5B,OAAO,CAyLT"}

package/lib/mysql.js

@@ -1,58 +1,59 @@
 import { and, eq } from "drizzle-orm";
-import { int, timestamp, mysqlTable, primaryKey, varchar, } from "drizzle-orm/mysql-core";
-/** @internal */
-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 }),
-});
-/** @internal */
-export const accounts = mysqlTable("accounts", {
-    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),
-}));
-/** @internal */
-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(),
-});
-/** @internal */
-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),
-}));
-/** @internal */
-export const schema = { users, accounts, sessions, verificationTokens };
-/** @internal */
-export function mySqlDrizzleAdapter(client) {
+import { int, timestamp, mysqlTable as defaultMySqlTableFn, primaryKey, varchar, } from "drizzle-orm/mysql-core";
+export function createTables(mySqlTable) {
+    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()
+            .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" }),
+        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);
     return {
-        createUser: async (data) => {
+        async createUser(data) {
             const id = crypto.randomUUID();
             await client.insert(users).values({ ...data, id });
             return await client
@@ -61,7 +62,7 @@ export function mySqlDrizzleAdapter(client) {
                 .where(eq(users.id, id))
                 .then((res) => res[0]);
         },
-        getUser: async (data) => {
+        async getUser(data) {
             const thing = (await client
                 .select()
                 .from(users)
@@ -69,7 +70,7 @@ export function mySqlDrizzleAdapter(client) {
                 .then((res) => res[0])) ?? null;
             return thing;
         },
-        getUserByEmail: async (data) => {
+        async getUserByEmail(data) {
             const user = (await client
                 .select()
                 .from(users)
@@ -77,7 +78,7 @@ export function mySqlDrizzleAdapter(client) {
                 .then((res) => res[0])) ?? null;
             return user;
         },
-        createSession: async (data) => {
+        async createSession(data) {
             await client.insert(sessions).values(data);
             return await client
                 .select()
@@ -85,7 +86,7 @@ export function mySqlDrizzleAdapter(client) {
                 .where(eq(sessions.sessionToken, data.sessionToken))
                 .then((res) => res[0]);
         },
-        getSessionAndUser: async (data) => {
+        async getSessionAndUser(data) {
             const sessionAndUser = (await client
                 .select({
                 session: sessions,
@@ -97,7 +98,7 @@ export function mySqlDrizzleAdapter(client) {
                 .then((res) => res[0])) ?? null;
             return sessionAndUser;
         },
-        updateUser: async (data) => {
+        async updateUser(data) {
             if (!data.id) {
                 throw new Error("No user id.");
             }
@@ -108,7 +109,7 @@ export function mySqlDrizzleAdapter(client) {
                 .where(eq(users.id, data.id))
                 .then((res) => res[0]);
         },
-        updateSession: async (data) => {
+        async updateSession(data) {
             await client
                 .update(sessions)
                 .set(data)
@@ -119,13 +120,13 @@ export function mySqlDrizzleAdapter(client) {
                 .where(eq(sessions.sessionToken, data.sessionToken))
                 .then((res) => res[0]);
         },
-        linkAccount: async (rawAccount) => {
+        async linkAccount(rawAccount) {
             await client
                 .insert(accounts)
                 .values(rawAccount)
                 .then((res) => res[0]);
         },
-        getUserByAccount: async (account) => {
+        async getUserByAccount(account) {
             const dbAccount = (await client
                 .select()
                 .from(accounts)
@@ -137,7 +138,7 @@ export function mySqlDrizzleAdapter(client) {
             }
             return dbAccount.users;
         },
-        deleteSession: async (sessionToken) => {
+        async deleteSession(sessionToken) {
             const session = (await client
                 .select()
                 .from(sessions)
@@ -148,7 +149,7 @@ export function mySqlDrizzleAdapter(client) {
                 .where(eq(sessions.sessionToken, sessionToken));
             return session;
         },
-        createVerificationToken: async (token) => {
+        async createVerificationToken(token) {
             await client.insert(verificationTokens).values(token);
             return await client
                 .select()
@@ -156,7 +157,7 @@ export function mySqlDrizzleAdapter(client) {
                 .where(eq(verificationTokens.identifier, token.identifier))
                 .then((res) => res[0]);
         },
-        useVerificationToken: async (token) => {
+        async useVerificationToken(token) {
             try {
                 const deletedToken = (await client
                     .select()
@@ -172,7 +173,7 @@ export function mySqlDrizzleAdapter(client) {
                 throw new Error("No verification token found.");
             }
         },
-        deleteUser: async (id) => {
+        async deleteUser(id) {
             const user = await client
                 .select()
                 .from(users)
@@ -181,7 +182,7 @@ export function mySqlDrizzleAdapter(client) {
             await client.delete(users).where(eq(users.id, id));
             return user;
         },
-        unlinkAccount: async (account) => {
+        async unlinkAccount(account) {
             await client
                 .delete(accounts)
                 .where(and(eq(accounts.providerAccountId, account.providerAccountId), eq(accounts.provider, account.provider)));