@auth/drizzle-adapter 0.3.0 → 0.3.2

package/index.d.ts.map

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAQH,OAAO,EAAE,gBAAgB,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAA;AAG1D,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,CAYT"}

package/index.js

@@ -15,10 +15,13 @@
  *
  * @module @auth/drizzle-adapter
  */
+import { MySqlDatabase } from "drizzle-orm/mysql-core";
+import { PgDatabase } from "drizzle-orm/pg-core";
+import { BaseSQLiteDatabase } 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, } from "./lib/utils.js";
+import { is } from "drizzle-orm";
 /**
  * Add the adapter to your `pages/api/[...nextauth].ts` next-auth configuration object.
  *
@@ -244,15 +247,14 @@ import { isMySqlDatabase, isPgDatabase, isSQLiteDatabase, } from "./lib/utils.js
  *
  **/
 export function DrizzleAdapter(db, table) {
-    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);
     }
-    if (isPgDatabase(db)) {
+    else if (is(db, PgDatabase)) {
         return pgDrizzleAdapter(db, table);
     }
-    if (isSQLiteDatabase(db)) {
+    else if (is(db, BaseSQLiteDatabase)) {
         return SQLiteDrizzleAdapter(db, table);
     }
-    throw new Error("Unsupported database type in Auth.js Drizzle adapter.");
+    throw new Error(`Unsupported database type (${typeof db}) in Auth.js Drizzle adapter.`);
 }

package/lib/mysql.d.ts

@@ -0,0 +1,225 @@
+import { MySqlTableFn, MySqlDatabase } from "drizzle-orm/mysql-core";
+import type { Adapter } from "@auth/core/adapters";
+export declare function createTables(mySqlTable: MySqlTableFn): {
+    users: import("drizzle-orm/select.types.d-b947a018").aw<{
+        name: "user";
+        schema: undefined;
+        columns: {
+            id: import("drizzle-orm/mysql-core").MySqlVarChar<{
+                tableName: "user";
+                enumValues: [string, ...string[]];
+                name: "id";
+                data: string;
+                driverParam: string | number;
+                hasDefault: false;
+                notNull: true;
+            }>;
+            name: import("drizzle-orm/mysql-core").MySqlVarChar<{
+                tableName: "user";
+                name: "name";
+                data: string;
+                driverParam: string | number;
+                enumValues: [string, ...string[]];
+                notNull: false;
+                hasDefault: false;
+            }>;
+            email: import("drizzle-orm/mysql-core").MySqlVarChar<{
+                tableName: "user";
+                enumValues: [string, ...string[]];
+                name: "email";
+                data: string;
+                driverParam: string | number;
+                hasDefault: false;
+                notNull: true;
+            }>;
+            emailVerified: import("drizzle-orm/mysql-core").MySqlTimestamp<{
+                tableName: "user";
+                name: "emailVerified";
+                data: Date;
+                driverParam: string | number;
+                notNull: false;
+                hasDefault: true;
+            }>;
+            image: import("drizzle-orm/mysql-core").MySqlVarChar<{
+                tableName: "user";
+                name: "image";
+                data: string;
+                driverParam: string | number;
+                enumValues: [string, ...string[]];
+                notNull: false;
+                hasDefault: false;
+            }>;
+        };
+    }>;
+    accounts: import("drizzle-orm/select.types.d-b947a018").aw<{
+        name: "account";
+        schema: undefined;
+        columns: {
+            userId: import("drizzle-orm/mysql-core").MySqlVarChar<{
+                tableName: "account";
+                enumValues: [string, ...string[]];
+                name: "userId";
+                data: string;
+                driverParam: string | number;
+                hasDefault: false;
+                notNull: true;
+            }>;
+            type: import("drizzle-orm/mysql-core").MySqlVarChar<{
+                tableName: "account";
+                enumValues: [string, ...string[]];
+                name: "type";
+                data: "email" | "oidc" | "oauth";
+                driverParam: string | number;
+                hasDefault: false;
+                notNull: true;
+            }>;
+            provider: import("drizzle-orm/mysql-core").MySqlVarChar<{
+                tableName: "account";
+                enumValues: [string, ...string[]];
+                name: "provider";
+                data: string;
+                driverParam: string | number;
+                hasDefault: false;
+                notNull: true;
+            }>;
+            providerAccountId: import("drizzle-orm/mysql-core").MySqlVarChar<{
+                tableName: "account";
+                enumValues: [string, ...string[]];
+                name: "providerAccountId";
+                data: string;
+                driverParam: string | number;
+                hasDefault: false;
+                notNull: true;
+            }>;
+            refresh_token: import("drizzle-orm/mysql-core").MySqlVarChar<{
+                tableName: "account";
+                name: "refresh_token";
+                data: string;
+                driverParam: string | number;
+                enumValues: [string, ...string[]];
+                notNull: false;
+                hasDefault: false;
+            }>;
+            access_token: import("drizzle-orm/mysql-core").MySqlVarChar<{
+                tableName: "account";
+                name: "access_token";
+                data: string;
+                driverParam: string | number;
+                enumValues: [string, ...string[]];
+                notNull: false;
+                hasDefault: false;
+            }>;
+            expires_at: import("drizzle-orm/mysql-core").MySqlInt<{
+                tableName: "account";
+                name: "expires_at";
+                data: number;
+                driverParam: string | number;
+                notNull: false;
+                hasDefault: false;
+            }>;
+            token_type: import("drizzle-orm/mysql-core").MySqlVarChar<{
+                tableName: "account";
+                name: "token_type";
+                data: string;
+                driverParam: string | number;
+                enumValues: [string, ...string[]];
+                notNull: false;
+                hasDefault: false;
+            }>;
+            scope: import("drizzle-orm/mysql-core").MySqlVarChar<{
+                tableName: "account";
+                name: "scope";
+                data: string;
+                driverParam: string | number;
+                enumValues: [string, ...string[]];
+                notNull: false;
+                hasDefault: false;
+            }>;
+            id_token: import("drizzle-orm/mysql-core").MySqlVarChar<{
+                tableName: "account";
+                name: "id_token";
+                data: string;
+                driverParam: string | number;
+                enumValues: [string, ...string[]];
+                notNull: false;
+                hasDefault: false;
+            }>;
+            session_state: import("drizzle-orm/mysql-core").MySqlVarChar<{
+                tableName: "account";
+                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: "session";
+        schema: undefined;
+        columns: {
+            sessionToken: import("drizzle-orm/mysql-core").MySqlVarChar<{
+                tableName: "session";
+                enumValues: [string, ...string[]];
+                name: "sessionToken";
+                data: string;
+                driverParam: string | number;
+                hasDefault: false;
+                notNull: true;
+            }>;
+            userId: import("drizzle-orm/mysql-core").MySqlVarChar<{
+                tableName: "session";
+                enumValues: [string, ...string[]];
+                name: "userId";
+                data: string;
+                driverParam: string | number;
+                hasDefault: false;
+                notNull: true;
+            }>;
+            expires: import("drizzle-orm/mysql-core").MySqlTimestamp<{
+                tableName: "session";
+                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: InstanceType<typeof MySqlDatabase>, tableFn?: MySqlTableFn<undefined>): Adapter;
+//# sourceMappingURL=mysql.d.ts.map

package/lib/mysql.d.ts.map

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

package/lib/mysql.js

@@ -0,0 +1,189 @@
+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);
+    return {
+        async createUser(data) {
+            const id = crypto.randomUUID();
+            await client.insert(users).values({ ...data, id });
+            return await client
+                .select()
+                .from(users)
+                .where(eq(users.id, id))
+                .then((res) => res[0]);
+        },
+        async getUser(data) {
+            const thing = (await client
+                .select()
+                .from(users)
+                .where(eq(users.id, data))
+                .then((res) => res[0])) ?? null;
+            return thing;
+        },
+        async getUserByEmail(data) {
+            const user = (await client
+                .select()
+                .from(users)
+                .where(eq(users.email, data))
+                .then((res) => res[0])) ?? null;
+            return user;
+        },
+        async createSession(data) {
+            await client.insert(sessions).values(data);
+            return await client
+                .select()
+                .from(sessions)
+                .where(eq(sessions.sessionToken, data.sessionToken))
+                .then((res) => res[0]);
+        },
+        async getSessionAndUser(data) {
+            const sessionAndUser = (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;
+            return sessionAndUser;
+        },
+        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
+                .select()
+                .from(users)
+                .where(eq(users.id, data.id))
+                .then((res) => res[0]);
+        },
+        async updateSession(data) {
+            await client
+                .update(sessions)
+                .set(data)
+                .where(eq(sessions.sessionToken, data.sessionToken));
+            return await client
+                .select()
+                .from(sessions)
+                .where(eq(sessions.sessionToken, data.sessionToken))
+                .then((res) => res[0]);
+        },
+        async linkAccount(rawAccount) {
+            await client.insert(accounts).values(rawAccount);
+        },
+        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
+                .select()
+                .from(sessions)
+                .where(eq(sessions.sessionToken, sessionToken))
+                .then((res) => res[0])) ?? null;
+            await client
+                .delete(sessions)
+                .where(eq(sessions.sessionToken, sessionToken));
+            return session;
+        },
+        async createVerificationToken(token) {
+            await client.insert(verificationTokens).values(token);
+            return await client
+                .select()
+                .from(verificationTokens)
+                .where(eq(verificationTokens.identifier, token.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;
+                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.");
+            }
+        },
+        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;
+        },
+        async unlinkAccount(account) {
+            await client
+                .delete(accounts)
+                .where(and(eq(accounts.providerAccountId, account.providerAccountId), eq(accounts.provider, account.provider)));
+            return undefined;
+        },
+    };
+}

package/lib/pg.d.ts

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

package/lib/pg.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pg.d.ts","sourceRoot":"","sources":["../src/lib/pg.ts"],"names":[],"mappings":"AACA,OAAO,EAML,SAAS,EACT,UAAU,EACX,MAAM,qBAAqB,CAAA;AAE5B,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,YAAY,CAAC,OAAO,UAAU,CAAC,EACvC,OAAO,uBAAmB,GACzB,OAAO,CAgKT"}