@auth/drizzle-adapter 0.3.0 → 0.3.2

package/lib/pg.js

@@ -0,0 +1,180 @@
+import { and, eq } from "drizzle-orm";
+import { timestamp, pgTable as defaultPgTableFn, text, primaryKey, integer, } from "drizzle-orm/pg-core";
+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);
+    return {
+        async createUser(data) {
+            return await client
+                .insert(users)
+                .values({ ...data, id: crypto.randomUUID() })
+                .returning()
+                .then((res) => res[0] ?? null);
+        },
+        async getUser(data) {
+            return await client
+                .select()
+                .from(users)
+                .where(eq(users.id, data))
+                .then((res) => res[0] ?? null);
+        },
+        async getUserByEmail(data) {
+            return await client
+                .select()
+                .from(users)
+                .where(eq(users.email, data))
+                .then((res) => res[0] ?? null);
+        },
+        async createSession(data) {
+            return await client
+                .insert(sessions)
+                .values(data)
+                .returning()
+                .then((res) => res[0]);
+        },
+        async getSessionAndUser(data) {
+            return await client
+                .select({
+                session: sessions,
+                user: users,
+            })
+                .from(sessions)
+                .where(eq(sessions.sessionToken, data))
+                .innerJoin(users, eq(users.id, sessions.userId))
+                .then((res) => res[0] ?? null);
+        },
+        async updateUser(data) {
+            if (!data.id) {
+                throw new Error("No user id.");
+            }
+            return await client
+                .update(users)
+                .set(data)
+                .where(eq(users.id, data.id))
+                .returning()
+                .then((res) => res[0]);
+        },
+        async updateSession(data) {
+            return await client
+                .update(sessions)
+                .set(data)
+                .where(eq(sessions.sessionToken, data.sessionToken))
+                .returning()
+                .then((res) => res[0]);
+        },
+        async linkAccount(rawAccount) {
+            const updatedAccount = await client
+                .insert(accounts)
+                .values(rawAccount)
+                .returning()
+                .then((res) => res[0]);
+            // Drizzle will return `null` for fields that are not defined.
+            // However, the return type is expecting `undefined`.
+            const account = {
+                ...updatedAccount,
+                access_token: updatedAccount.access_token ?? undefined,
+                token_type: updatedAccount.token_type ?? undefined,
+                id_token: updatedAccount.id_token ?? undefined,
+                refresh_token: updatedAccount.refresh_token ?? undefined,
+                scope: updatedAccount.scope ?? undefined,
+                expires_at: updatedAccount.expires_at ?? undefined,
+                session_state: updatedAccount.session_state ?? undefined,
+            };
+            return account;
+        },
+        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;
+        },
+        async deleteSession(sessionToken) {
+            const session = await client
+                .delete(sessions)
+                .where(eq(sessions.sessionToken, sessionToken))
+                .returning()
+                .then((res) => res[0] ?? null);
+            return session;
+        },
+        async createVerificationToken(token) {
+            return await client
+                .insert(verificationTokens)
+                .values(token)
+                .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 deleteUser(id) {
+            await client
+                .delete(users)
+                .where(eq(users.id, id))
+                .returning()
+                .then((res) => res[0] ?? null);
+        },
+        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 };
+        },
+    };
+}

package/lib/sqlite.d.ts

@@ -0,0 +1,225 @@
+import { BaseSQLiteDatabase, SQLiteTableFn } from "drizzle-orm/sqlite-core";
+import type { Adapter } from "@auth/core/adapters";
+export declare function createTables(sqliteTable: SQLiteTableFn): {
+    users: import("drizzle-orm/db.d-b5fdf746").ag<{
+        name: "user";
+        schema: undefined;
+        columns: {
+            id: import("drizzle-orm/sqlite-core").SQLiteText<{
+                tableName: "user";
+                enumValues: [string, ...string[]];
+                name: "id";
+                data: string;
+                driverParam: string;
+                hasDefault: false;
+                notNull: true;
+            }>;
+            name: import("drizzle-orm/sqlite-core").SQLiteText<{
+                tableName: "user";
+                name: "name";
+                data: string;
+                driverParam: string;
+                enumValues: [string, ...string[]];
+                notNull: false;
+                hasDefault: false;
+            }>;
+            email: import("drizzle-orm/sqlite-core").SQLiteText<{
+                tableName: "user";
+                enumValues: [string, ...string[]];
+                name: "email";
+                data: string;
+                driverParam: string;
+                hasDefault: false;
+                notNull: true;
+            }>;
+            emailVerified: import("drizzle-orm/sqlite-core").SQLiteTimestamp<{
+                tableName: "user";
+                name: "emailVerified";
+                data: Date;
+                driverParam: number;
+                notNull: false;
+                hasDefault: false;
+            }>;
+            image: import("drizzle-orm/sqlite-core").SQLiteText<{
+                tableName: "user";
+                name: "image";
+                data: string;
+                driverParam: string;
+                enumValues: [string, ...string[]];
+                notNull: false;
+                hasDefault: false;
+            }>;
+        };
+    }>;
+    accounts: import("drizzle-orm/db.d-b5fdf746").ag<{
+        name: "account";
+        schema: undefined;
+        columns: {
+            userId: import("drizzle-orm/sqlite-core").SQLiteText<{
+                tableName: "account";
+                enumValues: [string, ...string[]];
+                name: "userId";
+                data: string;
+                driverParam: string;
+                hasDefault: false;
+                notNull: true;
+            }>;
+            type: import("drizzle-orm/sqlite-core").SQLiteText<{
+                tableName: "account";
+                enumValues: [string, ...string[]];
+                name: "type";
+                data: "email" | "oidc" | "oauth";
+                driverParam: string;
+                hasDefault: false;
+                notNull: true;
+            }>;
+            provider: import("drizzle-orm/sqlite-core").SQLiteText<{
+                tableName: "account";
+                enumValues: [string, ...string[]];
+                name: "provider";
+                data: string;
+                driverParam: string;
+                hasDefault: false;
+                notNull: true;
+            }>;
+            providerAccountId: import("drizzle-orm/sqlite-core").SQLiteText<{
+                tableName: "account";
+                enumValues: [string, ...string[]];
+                name: "providerAccountId";
+                data: string;
+                driverParam: string;
+                hasDefault: false;
+                notNull: true;
+            }>;
+            refresh_token: import("drizzle-orm/sqlite-core").SQLiteText<{
+                tableName: "account";
+                name: "refresh_token";
+                data: string;
+                driverParam: string;
+                enumValues: [string, ...string[]];
+                notNull: false;
+                hasDefault: false;
+            }>;
+            access_token: import("drizzle-orm/sqlite-core").SQLiteText<{
+                tableName: "account";
+                name: "access_token";
+                data: string;
+                driverParam: string;
+                enumValues: [string, ...string[]];
+                notNull: false;
+                hasDefault: false;
+            }>;
+            expires_at: import("drizzle-orm/sqlite-core").SQLiteInteger<{
+                tableName: "account";
+                name: "expires_at";
+                data: number;
+                driverParam: number;
+                notNull: false;
+                hasDefault: false;
+            }>;
+            token_type: import("drizzle-orm/sqlite-core").SQLiteText<{
+                tableName: "account";
+                name: "token_type";
+                data: string;
+                driverParam: string;
+                enumValues: [string, ...string[]];
+                notNull: false;
+                hasDefault: false;
+            }>;
+            scope: import("drizzle-orm/sqlite-core").SQLiteText<{
+                tableName: "account";
+                name: "scope";
+                data: string;
+                driverParam: string;
+                enumValues: [string, ...string[]];
+                notNull: false;
+                hasDefault: false;
+            }>;
+            id_token: import("drizzle-orm/sqlite-core").SQLiteText<{
+                tableName: "account";
+                name: "id_token";
+                data: string;
+                driverParam: string;
+                enumValues: [string, ...string[]];
+                notNull: false;
+                hasDefault: false;
+            }>;
+            session_state: import("drizzle-orm/sqlite-core").SQLiteText<{
+                tableName: "account";
+                name: "session_state";
+                data: string;
+                driverParam: string;
+                enumValues: [string, ...string[]];
+                notNull: false;
+                hasDefault: false;
+            }>;
+        };
+    }>;
+    sessions: import("drizzle-orm/db.d-b5fdf746").ag<{
+        name: "session";
+        schema: undefined;
+        columns: {
+            sessionToken: import("drizzle-orm/sqlite-core").SQLiteText<{
+                tableName: "session";
+                enumValues: [string, ...string[]];
+                name: "sessionToken";
+                data: string;
+                driverParam: string;
+                hasDefault: false;
+                notNull: true;
+            }>;
+            userId: import("drizzle-orm/sqlite-core").SQLiteText<{
+                tableName: "session";
+                enumValues: [string, ...string[]];
+                name: "userId";
+                data: string;
+                driverParam: string;
+                hasDefault: false;
+                notNull: true;
+            }>;
+            expires: import("drizzle-orm/sqlite-core").SQLiteTimestamp<{
+                tableName: "session";
+                name: "expires";
+                data: Date;
+                driverParam: number;
+                hasDefault: false;
+                notNull: true;
+            }>;
+        };
+    }>;
+    verificationTokens: import("drizzle-orm/db.d-b5fdf746").ag<{
+        name: "verificationToken";
+        schema: undefined;
+        columns: {
+            identifier: import("drizzle-orm/sqlite-core").SQLiteText<{
+                tableName: "verificationToken";
+                enumValues: [string, ...string[]];
+                name: "identifier";
+                data: string;
+                driverParam: string;
+                hasDefault: false;
+                notNull: true;
+            }>;
+            token: import("drizzle-orm/sqlite-core").SQLiteText<{
+                tableName: "verificationToken";
+                enumValues: [string, ...string[]];
+                name: "token";
+                data: string;
+                driverParam: string;
+                hasDefault: false;
+                notNull: true;
+            }>;
+            expires: import("drizzle-orm/sqlite-core").SQLiteTimestamp<{
+                tableName: "verificationToken";
+                name: "expires";
+                data: Date;
+                driverParam: number;
+                hasDefault: false;
+                notNull: true;
+            }>;
+        };
+    }>;
+};
+export type DefaultSchema = ReturnType<typeof createTables>;
+export declare function SQLiteDrizzleAdapter(client: InstanceType<typeof BaseSQLiteDatabase>, tableFn?: SQLiteTableFn<undefined>): Adapter;
+//# sourceMappingURL=sqlite.d.ts.map

package/lib/sqlite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite.d.ts","sourceRoot":"","sources":["../src/lib/sqlite.ts"],"names":[],"mappings":"AACA,OAAO,EAKL,kBAAkB,EAClB,aAAa,EACd,MAAM,yBAAyB,CAAA;AAEhC,OAAO,KAAK,EAAE,OAAO,EAAkB,MAAM,qBAAqB,CAAA;AAElE,wBAAgB,YAAY,CAAC,WAAW,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoDtD;AAED,MAAM,MAAM,aAAa,GAAG,UAAU,CAAC,OAAO,YAAY,CAAC,CAAA;AAE3D,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,YAAY,CAAC,OAAO,kBAAkB,CAAC,EAC/C,OAAO,2BAAuB,GAC7B,OAAO,CA2IT"}

package/lib/sqlite.js

@@ -0,0 +1,154 @@
+import { eq, and } from "drizzle-orm";
+import { integer, sqliteTable as defaultSqliteTableFn, text, primaryKey, } from "drizzle-orm/sqlite-core";
+export function createTables(sqliteTable) {
+    const users = sqliteTable("user", {
+        id: text("id").notNull().primaryKey(),
+        name: text("name"),
+        email: text("email").notNull(),
+        emailVerified: integer("emailVerified", { mode: "timestamp_ms" }),
+        image: text("image"),
+    });
+    const accounts = sqliteTable("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 = sqliteTable("session", {
+        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),
+    }));
+    return { users, accounts, sessions, verificationTokens };
+}
+export function SQLiteDrizzleAdapter(client, tableFn = defaultSqliteTableFn) {
+    const { users, accounts, sessions, verificationTokens } = createTables(tableFn);
+    return {
+        createUser(data) {
+            return client
+                .insert(users)
+                .values({ ...data, id: crypto.randomUUID() })
+                .returning()
+                .get();
+        },
+        getUser(data) {
+            return client.select().from(users).where(eq(users.id, data)).get() ?? null;
+        },
+        getUserByEmail(data) {
+            return (client.select().from(users).where(eq(users.email, data)).get() ?? null);
+        },
+        createSession(data) {
+            return client.insert(sessions).values(data).returning().get();
+        },
+        getSessionAndUser(data) {
+            return (client
+                .select({
+                session: sessions,
+                user: users,
+            })
+                .from(sessions)
+                .where(eq(sessions.sessionToken, data))
+                .innerJoin(users, eq(users.id, sessions.userId))
+                .get() ?? null);
+        },
+        updateUser(data) {
+            if (!data.id) {
+                throw new Error("No user id.");
+            }
+            return client
+                .update(users)
+                .set(data)
+                .where(eq(users.id, data.id))
+                .returning()
+                .get();
+        },
+        updateSession(data) {
+            return client
+                .update(sessions)
+                .set(data)
+                .where(eq(sessions.sessionToken, data.sessionToken))
+                .returning()
+                .get();
+        },
+        linkAccount(rawAccount) {
+            const updatedAccount = client
+                .insert(accounts)
+                .values(rawAccount)
+                .returning()
+                .get();
+            const account = {
+                ...updatedAccount,
+                type: updatedAccount.type,
+                access_token: updatedAccount.access_token ?? undefined,
+                token_type: updatedAccount.token_type ?? undefined,
+                id_token: updatedAccount.id_token ?? undefined,
+                refresh_token: updatedAccount.refresh_token ?? undefined,
+                scope: updatedAccount.scope ?? undefined,
+                expires_at: updatedAccount.expires_at ?? undefined,
+                session_state: updatedAccount.session_state ?? undefined,
+            };
+            return account;
+        },
+        getUserByAccount(account) {
+            const results = client
+                .select()
+                .from(accounts)
+                .leftJoin(users, eq(users.id, accounts.userId))
+                .where(and(eq(accounts.provider, account.provider), eq(accounts.providerAccountId, account.providerAccountId)))
+                .get();
+            return results?.user ?? null;
+        },
+        deleteSession(sessionToken) {
+            return (client
+                .delete(sessions)
+                .where(eq(sessions.sessionToken, sessionToken))
+                .returning()
+                .get() ?? null);
+        },
+        createVerificationToken(token) {
+            return client.insert(verificationTokens).values(token).returning().get();
+        },
+        useVerificationToken(token) {
+            try {
+                return (client
+                    .delete(verificationTokens)
+                    .where(and(eq(verificationTokens.identifier, token.identifier), eq(verificationTokens.token, token.token)))
+                    .returning()
+                    .get() ?? null);
+            }
+            catch (err) {
+                throw new Error("No verification token found.");
+            }
+        },
+        deleteUser(id) {
+            return client.delete(users).where(eq(users.id, id)).returning().get();
+        },
+        unlinkAccount(account) {
+            client
+                .delete(accounts)
+                .where(and(eq(accounts.providerAccountId, account.providerAccountId), eq(accounts.provider, account.provider)))
+                .run();
+            return undefined;
+        },
+    };
+}

package/lib/utils.d.ts

@@ -0,0 +1,21 @@
+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>;
+export type AnySQLiteDatabase = BaseSQLiteDatabase<any, any, any, any>;
+export interface MinimumSchema {
+    mysql: MySqlSchema & Record<string, AnyMySqlTable>;
+    pg: PgSchema & Record<string, AnyPgTable>;
+    sqlite: SQLiteSchema & Record<string, AnySQLiteTable>;
+}
+export type SqlFlavorOptions = AnyMySqlDatabase | AnyPgDatabase | AnySQLiteDatabase;
+export type ClientFlavors<Flavor> = Flavor extends AnyMySqlDatabase ? MinimumSchema["mysql"] : Flavor extends AnyPgDatabase ? MinimumSchema["pg"] : Flavor extends AnySQLiteDatabase ? MinimumSchema["sqlite"] : never;
+export type TableFn<Flavor> = Flavor extends AnyMySqlDatabase ? MySqlTableFn : Flavor extends AnyPgDatabase ? PgTableFn : Flavor extends AnySQLiteDatabase ? SQLiteTableFn : AnySQLiteTable;
+//# sourceMappingURL=utils.d.ts.map

package/lib/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/lib/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAA;AACtD,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAA;AAChD,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAE5D,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAA;AACzE,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AAChE,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAA;AAC5E,OAAO,KAAK,EAAE,aAAa,IAAI,QAAQ,EAAE,MAAM,SAAS,CAAA;AACxD,OAAO,KAAK,EAAE,aAAa,IAAI,WAAW,EAAE,MAAM,YAAY,CAAA;AAC9D,OAAO,KAAK,EAAE,aAAa,IAAI,YAAY,EAAE,MAAM,aAAa,CAAA;AAEhE,MAAM,MAAM,gBAAgB,GAAG,aAAa,CAAC,GAAG,EAAE,GAAG,CAAC,CAAA;AACtD,MAAM,MAAM,aAAa,GAAG,UAAU,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAA;AACrD,MAAM,MAAM,iBAAiB,GAAG,kBAAkB,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAA;AAEtE,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;IAClD,EAAE,EAAE,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAA;IACzC,MAAM,EAAE,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAA;CACtD;AAED,MAAM,MAAM,gBAAgB,GACxB,gBAAgB,GAChB,aAAa,GACb,iBAAiB,CAAA;AAErB,MAAM,MAAM,aAAa,CAAC,MAAM,IAAI,MAAM,SAAS,gBAAgB,GAC/D,aAAa,CAAC,OAAO,CAAC,GACtB,MAAM,SAAS,aAAa,GAC5B,aAAa,CAAC,IAAI,CAAC,GACnB,MAAM,SAAS,iBAAiB,GAChC,aAAa,CAAC,QAAQ,CAAC,GACvB,KAAK,CAAA;AAET,MAAM,MAAM,OAAO,CAAC,MAAM,IAAI,MAAM,SAAS,gBAAgB,GACzD,YAAY,GACZ,MAAM,SAAS,aAAa,GAC5B,SAAS,GACT,MAAM,SAAS,iBAAiB,GAChC,aAAa,GACb,cAAc,CAAA"}

package/lib/utils.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@auth/drizzle-adapter",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "Drizzle adapter for Auth.js.",
   "homepage": "https://authjs.dev",
   "repository": "https://github.com/nextauthjs/next-auth",
@@ -11,8 +11,8 @@
   "type": "module",
   "types": "./index.d.ts",
   "files": [
-    "*.js",
     "*.d.ts*",
+    "*.js",
     "lib",
     "src"
   ],
@@ -36,7 +36,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@auth/core": "0.10.3"
+    "@auth/core": "0.12.0"
   },
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.4",

package/src/index.ts

@@ -16,19 +16,14 @@
  * @module @auth/drizzle-adapter
  */
 
-import { MySqlTableFn } from "drizzle-orm/mysql-core/index.js"
-import { PgTableFn } from "drizzle-orm/pg-core/index.js"
-import { SQLiteTableFn } from "drizzle-orm/sqlite-core/index.js"
+import { MySqlDatabase, MySqlTableFn } from "drizzle-orm/mysql-core"
+import { PgDatabase, PgTableFn } from "drizzle-orm/pg-core"
+import { BaseSQLiteDatabase, SQLiteTableFn } from "drizzle-orm/sqlite-core"
 import { mySqlDrizzleAdapter } from "./lib/mysql.js"
 import { pgDrizzleAdapter } from "./lib/pg.js"
 import { SQLiteDrizzleAdapter } from "./lib/sqlite.js"
-import {
-  isMySqlDatabase,
-  isPgDatabase,
-  isSQLiteDatabase,
-  SqlFlavorOptions,
-  TableFn,
-} from "./lib/utils.js"
+import { SqlFlavorOptions, TableFn } from "./lib/utils.js"
+import { is } from "drizzle-orm"
 
 import type { Adapter } from "@auth/core/adapters"
 
@@ -260,18 +255,15 @@ export function DrizzleAdapter<SqlFlavor extends SqlFlavorOptions>(
   db: SqlFlavor,
   table?: TableFn<SqlFlavor>
 ): Adapter {
-  if (isMySqlDatabase(db)) {
-    // We need to cast to unknown since the type overlaps (PScale is MySQL based)
+  if (is(db, MySqlDatabase)) {
     return mySqlDrizzleAdapter(db, table as MySqlTableFn)
-  }
-
-  if (isPgDatabase(db)) {
+  } else if (is(db, PgDatabase)) {
     return pgDrizzleAdapter(db, table as PgTableFn)
-  }
-
-  if (isSQLiteDatabase(db)) {
+  } else if (is(db, BaseSQLiteDatabase)) {
     return SQLiteDrizzleAdapter(db, table as SQLiteTableFn)
   }
 
-  throw new Error("Unsupported database type in Auth.js Drizzle adapter.")
+  throw new Error(
+    `Unsupported database type (${typeof db}) in Auth.js Drizzle adapter.`
+  )
 }