@auth/drizzle-adapter 0.1.0 → 0.2.0

package/lib/pg.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pg.d.ts","sourceRoot":"","sources":["../src/lib/pg.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AACjE,OAAO,KAAK,EAAE,OAAO,EAAkB,MAAM,qBAAqB,CAAA;AAElE,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMhB,CAAA;AAEF,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoBpB,CAAA;AAED,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMnB,CAAA;AAEF,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAU9B,CAAA;AAED,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAoD,CAAA;AACvE,MAAM,MAAM,aAAa,GAAG,OAAO,MAAM,CAAA;AAEzC,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,kBAAkB,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,GAChD,OAAO,CA6JT"}
+{"version":3,"file":"pg.d.ts","sourceRoot":"","sources":["../src/lib/pg.ts"],"names":[],"mappings":"AACA,OAAO,EAML,SAAS,EACV,MAAM,qBAAqB,CAAA;AAE5B,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AACjE,OAAO,KAAK,EAAE,OAAO,EAAkB,MAAM,qBAAqB,CAAA;AAElE,wBAAgB,YAAY,CAAC,OAAO,EAAE,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoD9C;AAED,MAAM,MAAM,aAAa,GAAG,UAAU,CAAC,OAAO,YAAY,CAAC,CAAA;AAE3D,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,kBAAkB,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,EACjD,OAAO,uBAAmB,GACzB,OAAO,CAgKT"}

package/lib/pg.js

@@ -1,45 +1,48 @@
 import { and, eq } from "drizzle-orm";
-import { timestamp, pgTable, text, primaryKey, integer, } from "drizzle-orm/pg-core";
-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"),
-});
-export const accounts = pgTable("accounts", {
-    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),
-}));
-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(),
-});
-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),
-}));
-export const schema = { users, accounts, sessions, verificationTokens };
-export function pgDrizzleAdapter(client) {
+import { timestamp, pgTable as defaultPgTableFn, text, primaryKey, integer, } from "drizzle-orm/pg-core";
+export function createTables(pgTable) {
+    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().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" }),
+        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

package/lib/sqlite.d.ts

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

package/lib/sqlite.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sqlite.d.ts","sourceRoot":"","sources":["../src/lib/sqlite.ts"],"names":[],"mappings":"AACA,OAAO,EAKL,kBAAkB,EACnB,MAAM,yBAAyB,CAAA;AAEhC,OAAO,KAAK,EAAE,OAAO,EAAkB,MAAM,qBAAqB,CAAA;AAElE,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMhB,CAAA;AAEF,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoBpB,CAAA;AAED,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMnB,CAAA;AAEF,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAU9B,CAAA;AAED,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAoD,CAAA;AACvE,MAAM,MAAM,aAAa,GAAG,OAAO,MAAM,CAAA;AAEzC,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,kBAAkB,CAAC,GAAG,EAAE,GAAG,CAAC,GACnC,OAAO,CAwIT"}
+{"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,kBAAkB,CAAC,GAAG,EAAE,GAAG,CAAC,EACpC,OAAO,2BAAuB,GAC7B,OAAO,CA2IT"}

package/lib/sqlite.js

@@ -1,45 +1,48 @@
 import { eq, and } from "drizzle-orm";
-import { integer, sqliteTable, text, primaryKey, } from "drizzle-orm/sqlite-core";
-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"),
-});
-export const accounts = sqliteTable("accounts", {
-    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),
-}));
-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(),
-});
-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),
-}));
-export const schema = { users, accounts, sessions, verificationTokens };
-export function SQLiteDrizzleAdapter(client) {
+import { integer, sqliteTable as defaultSqliteTableFn, text, primaryKey, } from "drizzle-orm/sqlite-core";
+export function createTables(sqliteTable) {
+    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().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("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),
+    }));
+    return { users, accounts, sessions, verificationTokens };
+}
+export function SQLiteDrizzleAdapter(client, tableFn = defaultSqliteTableFn) {
+    const { users, accounts, sessions, verificationTokens } = createTables(tableFn);
     return {
         createUser(data) {
             return client

package/lib/utils.d.ts

@@ -1,9 +1,9 @@
 import { MySqlDatabase } from "drizzle-orm/mysql-core";
 import { PgDatabase } from "drizzle-orm/pg-core";
 import { BaseSQLiteDatabase } from "drizzle-orm/sqlite-core";
-import type { AnyMySqlTable } from "drizzle-orm/mysql-core";
-import type { AnyPgTable } from "drizzle-orm/pg-core";
-import type { AnySQLiteTable } 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";
@@ -17,6 +17,7 @@ export interface MinimumSchema {
 }
 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 ? AnySQLiteTable : SQLiteTableFn;
 export declare function isMySqlDatabase(db: any): db is MySqlDatabase<any, any, any, any>;
 export declare function isPgDatabase(db: any): db is PgDatabase<any, any, any>;
 export declare function isSQLiteDatabase(db: any): db is AnySQLiteDatabase;

package/lib/utils.d.ts.map

@@ -1 +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,MAAM,wBAAwB,CAAA;AAC3D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAA;AACrD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAA;AAC7D,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,wBAAgB,eAAe,CAC7B,EAAE,EAAE,GAAG,GACN,EAAE,IAAI,aAAa,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAEzC;AAED,wBAAgB,YAAY,CAAC,EAAE,EAAE,GAAG,GAAG,EAAE,IAAI,UAAU,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAErE;AAED,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,GAAG,GAAG,EAAE,IAAI,iBAAiB,CAEjE"}
+{"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,cAAc,GACd,aAAa,CAAA;AAEjB,wBAAgB,eAAe,CAC7B,EAAE,EAAE,GAAG,GACN,EAAE,IAAI,aAAa,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAEzC;AAED,wBAAgB,YAAY,CAAC,EAAE,EAAE,GAAG,GAAG,EAAE,IAAI,UAAU,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAErE;AAED,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,GAAG,GAAG,EAAE,IAAI,iBAAiB,CAEjE"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@auth/drizzle-adapter",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Drizzle adapter for Auth.js.",
   "homepage": "https://authjs.dev",
   "repository": "https://github.com/nextauthjs/next-auth",

package/src/index.ts

@@ -16,6 +16,9 @@
  * @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 { mySqlDrizzleAdapter } from "./lib/mysql.js"
 import { pgDrizzleAdapter } from "./lib/pg.js"
 import { SQLiteDrizzleAdapter } from "./lib/sqlite.js"
@@ -24,12 +27,13 @@ import {
   isPgDatabase,
   isSQLiteDatabase,
   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"
@@ -47,6 +51,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
  *
@@ -249,19 +257,20 @@ import type { Adapter } from "@auth/core/adapters"
  *
  **/
 export function DrizzleAdapter<SqlFlavor extends SqlFlavorOptions>(
-  db: SqlFlavor
+  db: SqlFlavor,
+  table?: TableFn<SqlFlavor>
 ): Adapter {
   if (isMySqlDatabase(db)) {
     // We need to cast to unknown since the type overlaps (PScale is MySQL based)
-    return mySqlDrizzleAdapter(db)
+    return mySqlDrizzleAdapter(db, table as MySqlTableFn)
   }
 
   if (isPgDatabase(db)) {
-    return pgDrizzleAdapter(db)
+    return pgDrizzleAdapter(db, table as PgTableFn)
   }
 
   if (isSQLiteDatabase(db)) {
-    return SQLiteDrizzleAdapter(db)
+    return SQLiteDrizzleAdapter(db, table as SQLiteTableFn)
   }
 
   throw new Error("Unsupported database type in Auth.js Drizzle adapter.")