@auth/drizzle-adapter 0.9.0 → 1.0.0

package/lib/sqlite.js

@@ -1,82 +1,93 @@
 import { eq, and } from "drizzle-orm";
-import { integer, sqliteTable as defaultSqliteTableFn, text, primaryKey, } from "drizzle-orm/sqlite-core";
-import { stripUndefined } from "./utils.js";
-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);
+import { integer, text, primaryKey, sqliteTable, index, } from "drizzle-orm/sqlite-core";
+import { randomUUID } from "crypto";
+export const sqliteUsersTable = sqliteTable("user", {
+    id: text("id")
+        .primaryKey()
+        .$defaultFn(() => randomUUID()),
+    name: text("name"),
+    email: text("email").notNull().unique(),
+    emailVerified: integer("emailVerified", { mode: "timestamp_ms" }),
+    image: text("image"),
+});
+export const sqliteAccountsTable = sqliteTable("account", {
+    userId: text("userId")
+        .notNull()
+        .references(() => sqliteUsersTable.id, { onDelete: "cascade" }),
+    type: text("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) => ({
+    userIdIdx: index("Account_userId_index").on(account.userId),
+    compositePk: primaryKey({
+        columns: [account.provider, account.providerAccountId],
+    }),
+}));
+export const sqliteSessionsTable = sqliteTable("session", {
+    id: text("id")
+        .primaryKey()
+        .$defaultFn(() => randomUUID()),
+    sessionToken: text("sessionToken").notNull().unique(),
+    userId: text("userId")
+        .notNull()
+        .references(() => sqliteUsersTable.id, { onDelete: "cascade" }),
+    expires: integer("expires", { mode: "timestamp_ms" }).notNull(),
+}, (table) => ({
+    userIdIdx: index("Session_userId_index").on(table.userId),
+}));
+export const sqliteVerificationTokensTable = sqliteTable("verificationToken", {
+    identifier: text("identifier").notNull(),
+    token: text("token").notNull().unique(),
+    expires: integer("expires", { mode: "timestamp_ms" }).notNull(),
+}, (vt) => ({
+    compositePk: primaryKey({ columns: [vt.identifier, vt.token] }),
+}));
+export function SQLiteDrizzleAdapter(client, schema = {
+    usersTable: sqliteUsersTable,
+    accountsTable: sqliteAccountsTable,
+    sessionsTable: sqliteSessionsTable,
+    verificationTokensTable: sqliteVerificationTokensTable,
+}) {
+    const { usersTable, accountsTable, sessionsTable, verificationTokensTable } = schema;
     return {
         async createUser(data) {
-            return await client
-                .insert(users)
-                .values({ ...data, id: crypto.randomUUID() })
-                .returning()
-                .get();
+            return client.insert(usersTable).values(data).returning().get();
         },
-        async getUser(data) {
+        async getUser(userId) {
             const result = await client
                 .select()
-                .from(users)
-                .where(eq(users.id, data))
+                .from(usersTable)
+                .where(eq(usersTable.id, userId))
                 .get();
             return result ?? null;
         },
-        async getUserByEmail(data) {
+        async getUserByEmail(email) {
             const result = await client
                 .select()
-                .from(users)
-                .where(eq(users.email, data))
+                .from(usersTable)
+                .where(eq(usersTable.email, email))
                 .get();
             return result ?? null;
         },
-        createSession(data) {
-            return client.insert(sessions).values(data).returning().get();
+        async createSession(data) {
+            return await client.insert(sessionsTable).values(data).returning().get();
         },
-        async getSessionAndUser(data) {
+        async getSessionAndUser(sessionToken) {
             const result = await client
-                .select({ session: sessions, user: users })
-                .from(sessions)
-                .where(eq(sessions.sessionToken, data))
-                .innerJoin(users, eq(users.id, sessions.userId))
+                .select({
+                session: sessionsTable,
+                user: usersTable,
+            })
+                .from(sessionsTable)
+                .where(eq(sessionsTable.sessionToken, sessionToken))
+                .innerJoin(usersTable, eq(usersTable.id, sessionsTable.userId))
                 .get();
             return result ?? null;
         },
@@ -85,78 +96,68 @@ export function SQLiteDrizzleAdapter(client, tableFn = defaultSqliteTableFn) {
                 throw new Error("No user id.");
             }
             const result = await client
-                .update(users)
+                .update(usersTable)
                 .set(data)
-                .where(eq(users.id, data.id))
+                .where(eq(usersTable.id, data.id))
                 .returning()
                 .get();
-            return result ?? null;
+            if (!result) {
+                throw new Error("User not found.");
+            }
+            return result;
         },
         async updateSession(data) {
             const result = await client
-                .update(sessions)
+                .update(sessionsTable)
                 .set(data)
-                .where(eq(sessions.sessionToken, data.sessionToken))
+                .where(eq(sessionsTable.sessionToken, data.sessionToken))
                 .returning()
                 .get();
             return result ?? null;
         },
-        async linkAccount(rawAccount) {
-            return stripUndefined(await client.insert(accounts).values(rawAccount).returning().get());
+        async linkAccount(data) {
+            await client.insert(accountsTable).values(data).run();
         },
         async getUserByAccount(account) {
-            const results = await client
-                .select()
-                .from(accounts)
-                .leftJoin(users, eq(users.id, accounts.userId))
-                .where(and(eq(accounts.provider, account.provider), eq(accounts.providerAccountId, account.providerAccountId)))
+            const result = await client
+                .select({
+                account: accountsTable,
+                user: usersTable,
+            })
+                .from(accountsTable)
+                .innerJoin(usersTable, eq(accountsTable.userId, usersTable.id))
+                .where(and(eq(accountsTable.provider, account.provider), eq(accountsTable.providerAccountId, account.providerAccountId)))
                 .get();
-            if (!results) {
-                return null;
-            }
-            return Promise.resolve(results).then((results) => results.user);
+            return result?.user ?? null;
         },
         async deleteSession(sessionToken) {
-            const result = await client
-                .delete(sessions)
-                .where(eq(sessions.sessionToken, sessionToken))
+            await client
+                .delete(sessionsTable)
+                .where(eq(sessionsTable.sessionToken, sessionToken))
+                .run();
+        },
+        async createVerificationToken(data) {
+            return await client
+                .insert(verificationTokensTable)
+                .values(data)
                 .returning()
                 .get();
-            return result ?? null;
         },
-        async createVerificationToken(token) {
+        async useVerificationToken(params) {
             const result = await client
-                .insert(verificationTokens)
-                .values(token)
+                .delete(verificationTokensTable)
+                .where(and(eq(verificationTokensTable.identifier, params.identifier), eq(verificationTokensTable.token, params.token)))
                 .returning()
                 .get();
             return result ?? null;
         },
-        async useVerificationToken(token) {
-            try {
-                const result = await client
-                    .delete(verificationTokens)
-                    .where(and(eq(verificationTokens.identifier, token.identifier), eq(verificationTokens.token, token.token)))
-                    .returning()
-                    .get();
-                return result ?? null;
-            }
-            catch (err) {
-                throw new Error("No verification token found.");
-            }
-        },
         async deleteUser(id) {
-            const result = await client
-                .delete(users)
-                .where(eq(users.id, id))
-                .returning()
-                .get();
-            return result ?? null;
+            await client.delete(usersTable).where(eq(usersTable.id, id)).run();
         },
-        async unlinkAccount(account) {
+        async unlinkAccount(params) {
             await client
-                .delete(accounts)
-                .where(and(eq(accounts.providerAccountId, account.providerAccountId), eq(accounts.provider, account.provider)))
+                .delete(accountsTable)
+                .where(and(eq(accountsTable.provider, params.provider), eq(accountsTable.providerAccountId, params.providerAccountId)))
                 .run();
         },
     };

package/lib/utils.d.ts

@@ -1,26 +1,15 @@
 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;
-type NonNullableProps<T> = {
-    [P in keyof T]: null extends T[P] ? never : P;
-}[keyof T];
-export declare function stripUndefined<T>(obj: T): Pick<T, NonNullableProps<T>>;
+import type { QueryResultHKT as MySQLQueryResultHKT, PreparedQueryHKTBase } from "drizzle-orm/mysql-core";
+import type { QueryResultHKT as PostgresQueryResultHKT } from "drizzle-orm/pg-core";
+import { DefaultSQLiteSchema } from "./sqlite";
+import { DefaultPostgresSchema } from "./pg";
+import { DefaultMySqlSchema } from "./mysql";
+type AnyPostgresDatabase = PgDatabase<PostgresQueryResultHKT, any>;
+type AnyMySqlDatabase = MySqlDatabase<MySQLQueryResultHKT, PreparedQueryHKTBase, any>;
+type AnySQLiteDatabase = BaseSQLiteDatabase<"sync" | "async", any, any>;
+export type SqlFlavorOptions = AnyPostgresDatabase | AnyMySqlDatabase | AnySQLiteDatabase;
+export type DefaultSchema<Flavor> = Flavor extends AnyMySqlDatabase ? DefaultMySqlSchema : Flavor extends AnyPostgresDatabase ? DefaultPostgresSchema : Flavor extends AnySQLiteDatabase ? DefaultSQLiteSchema : never;
 export {};
 //# sourceMappingURL=utils.d.ts.map

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,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,GAC1B,aAAa,CAAC,IAAI,CAAC,GACnB,MAAM,SAAS,iBAAiB,GAC9B,aAAa,CAAC,QAAQ,CAAC,GACvB,KAAK,CAAA;AAEb,MAAM,MAAM,OAAO,CAAC,MAAM,IAAI,MAAM,SAAS,gBAAgB,GACzD,YAAY,GACZ,MAAM,SAAS,aAAa,GAC1B,SAAS,GACT,MAAM,SAAS,iBAAiB,GAC9B,aAAa,GACb,cAAc,CAAA;AAEtB,KAAK,gBAAgB,CAAC,CAAC,IAAI;KACxB,CAAC,IAAI,MAAM,CAAC,GAAG,IAAI,SAAS,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,GAAG,CAAC;CAC9C,CAAC,MAAM,CAAC,CAAC,CAAA;AAEV,wBAAgB,cAAc,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC,EAAE,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAItE"}
+{"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;AAC5D,OAAO,KAAK,EACV,cAAc,IAAI,mBAAmB,EACrC,oBAAoB,EACrB,MAAM,wBAAwB,CAAA;AAC/B,OAAO,KAAK,EAAE,cAAc,IAAI,sBAAsB,EAAE,MAAM,qBAAqB,CAAA;AACnF,OAAO,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAA;AAC9C,OAAO,EAAE,qBAAqB,EAAE,MAAM,MAAM,CAAA;AAC5C,OAAO,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAA;AAE5C,KAAK,mBAAmB,GAAG,UAAU,CAAC,sBAAsB,EAAE,GAAG,CAAC,CAAA;AAClE,KAAK,gBAAgB,GAAG,aAAa,CACnC,mBAAmB,EACnB,oBAAoB,EACpB,GAAG,CACJ,CAAA;AACD,KAAK,iBAAiB,GAAG,kBAAkB,CAAC,MAAM,GAAG,OAAO,EAAE,GAAG,EAAE,GAAG,CAAC,CAAA;AAEvE,MAAM,MAAM,gBAAgB,GACxB,mBAAmB,GACnB,gBAAgB,GAChB,iBAAiB,CAAA;AAErB,MAAM,MAAM,aAAa,CAAC,MAAM,IAAI,MAAM,SAAS,gBAAgB,GAC/D,kBAAkB,GAClB,MAAM,SAAS,mBAAmB,GAChC,qBAAqB,GACrB,MAAM,SAAS,iBAAiB,GAC9B,mBAAmB,GACnB,KAAK,CAAA"}

package/lib/utils.js

@@ -1,7 +1 @@
-export function stripUndefined(obj) {
-    const result = {};
-    for (const key in obj)
-        if (obj[key] !== undefined)
-            result[key] = obj[key];
-    return result;
-}
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@auth/drizzle-adapter",
-  "version": "0.9.0",
+  "version": "1.0.0",
   "description": "Drizzle adapter for Auth.js.",
   "homepage": "https://authjs.dev",
   "repository": "https://github.com/nextauthjs/next-auth",
@@ -19,7 +19,8 @@
   "exports": {
     ".": {
       "types": "./index.d.ts",
-      "import": "./index.js"
+      "import": "./index.js",
+      "require": "./index.js"
     }
   },
   "license": "ISC",
@@ -36,16 +37,15 @@
     "access": "public"
   },
   "dependencies": {
-    "@auth/core": "0.29.0"
+    "@auth/core": "0.30.0"
   },
   "devDependencies": {
-    "@libsql/client": "0.4.0-pre.5",
     "@types/better-sqlite3": "^7.6.4",
     "@types/uuid": "^8.3.3",
     "better-sqlite3": "^8.6.0",
-    "drizzle-kit": "^0.20.6",
-    "drizzle-orm": "^0.29.1",
-    "mysql2": "^3.2.0",
+    "drizzle-kit": "^0.20.14",
+    "drizzle-orm": "^0.30.5",
+    "mysql2": "^3.9.4",
     "postgres": "^3.3.4",
     "tsx": "^4.7.0"
   },

package/src/index.ts

@@ -2,7 +2,7 @@
  * <div style={{display: "flex", justifyContent: "space-between", alignItems: "center", padding: 16}}>
  *  <p style={{fontWeight: "normal"}}>Official <a href="https://orm.drizzle.team">Drizzle ORM</a> adapter for Auth.js / NextAuth.js.</p>
  *  <a href="https://orm.drizzle.team">
- *   <img style={{display: "block"}} src="/img/adapters/drizzle-orm.png" width="38" />
+ *   <img style={{display: "block"}} src="/img/adapters/drizzle.svg" width="38" />
  *  </a>
  * </div>
  *
@@ -16,40 +16,69 @@
  * @module @auth/drizzle-adapter
  */
 
-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 { SqlFlavorOptions, TableFn } from "./lib/utils.js"
 import { is } from "drizzle-orm"
+import { MySqlDatabase } from "drizzle-orm/mysql-core"
+import { PgDatabase } from "drizzle-orm/pg-core"
+import { BaseSQLiteDatabase } from "drizzle-orm/sqlite-core"
+import { DefaultMySqlSchema, MySqlDrizzleAdapter } from "./lib/mysql.js"
+import { DefaultPostgresSchema, PostgresDrizzleAdapter } from "./lib/pg.js"
+import { DefaultSQLiteSchema, SQLiteDrizzleAdapter } from "./lib/sqlite.js"
+import { DefaultSchema, SqlFlavorOptions } from "./lib/utils.js"
 
 import type { Adapter } from "@auth/core/adapters"
 
+export {
+  postgresUsersTable,
+  postgresAccountsTable,
+  postgresSessionsTable,
+  postgresVerificationTokensTable,
+} from "./lib/pg.js"
+export {
+  sqliteUsersTable,
+  sqliteAccountsTable,
+  sqliteSessionsTable,
+  sqliteVerificationTokensTable,
+} from "./lib/sqlite.js"
+export {
+  mysqlUsersTable,
+  mysqlAccountsTable,
+  mysqlSessionsTable,
+  mysqlVerificationTokensTable,
+} from "./lib/mysql.js"
 /**
- * Add the adapter to your `pages/api/[...nextauth].ts` next-auth configuration object.
+ * Add this adapter to your `auth.ts` Auth.js configuration object:
  *
- * ```ts title="pages/api/auth/[...nextauth].ts"
+ * ```ts title="auth.ts"
  * import NextAuth from "next-auth"
- * import GoogleProvider from "next-auth/providers/google"
+ * import Google from "next-auth/providers/google"
  * import { DrizzleAdapter } from "@auth/drizzle-adapter"
  * import { db } from "./schema"
  *
- * export default NextAuth({
+ * export const { handlers, auth } = NextAuth({
  *   adapter: DrizzleAdapter(db),
  *   providers: [
- *     GoogleProvider({
- *       clientId: process.env.GOOGLE_CLIENT_ID,
- *       clientSecret: process.env.GOOGLE_CLIENT_SECRET,
- *     }),
+ *     Google,
  *   ],
  * })
  * ```
  * 
  * :::info
- * If you're using multi-project schemas, you can pass your table function as a second argument
+ * If you want to use your own tables, you can pass them as a second argument
  * :::
+ * 
+ * ```ts title="auth.ts"
+ * import NextAuth from "next-auth"
+ * import Google from "next-auth/providers/google"
+ * import { DrizzleAdapter } from "@auth/drizzle-adapter"
+ * import { db, accounts, sessions, users, verificationTokens } from "./schema"
+ *
+ * export const { handlers, auth } = NextAuth({
+ *   adapter: DrizzleAdapter(db, { usersTable: users, accountsTable: accounts, sessionsTable: sessions, verificationTokensTable: verificationTokens }),
+ *   providers: [
+ *     Google,
+ *   ],
+ * })
+ * ```
  *
  * ## Setup
  *
@@ -71,11 +100,12 @@ import type { Adapter } from "@auth/core/adapters"
  *  integer
  * } from "drizzle-orm/pg-core"
  * import type { AdapterAccount } from '@auth/core/adapters'
+ * import { randomUUID } from "crypto"
  *
  * export const users = pgTable("user", {
- *  id: text("id").notNull().primaryKey(),
+ *  id: text("id").primaryKey().$defaultFn(() => randomUUID()),
  *  name: text("name"),
- *  email: text("email").notNull(),
+ *  email: text("email").notNull().unique(),
  *  emailVerified: timestamp("emailVerified", { mode: "date" }),
  *  image: text("image"),
  * })
@@ -86,7 +116,7 @@ import type { Adapter } from "@auth/core/adapters"
  *   userId: text("userId")
  *     .notNull()
  *     .references(() => users.id, { onDelete: "cascade" }),
- *   type: text("type").$type<AdapterAccount["type"]>().notNull(),
+ *   type: text("type").notNull(),
  *   provider: text("provider").notNull(),
  *   providerAccountId: text("providerAccountId").notNull(),
  *   refresh_token: text("refresh_token"),
@@ -98,23 +128,27 @@ import type { Adapter } from "@auth/core/adapters"
  *   session_state: text("session_state"),
  * },
  * (account) => ({
+ *   userIdIdx: index().on(account.userId),
  *   compoundKey: primaryKey({ columns: [account.provider, account.providerAccountId] }),
  * })
  * )
  *
  * export const sessions = pgTable("session", {
- *  sessionToken: text("sessionToken").notNull().primaryKey(),
+ *  id: text("id").primaryKey().$defaultFn(() => randomUUID()),
+ *  sessionToken: text("sessionToken").notNull().unique(),
  *  userId: text("userId")
  *    .notNull()
  *    .references(() => users.id, { onDelete: "cascade" }),
  *  expires: timestamp("expires", { mode: "date" }).notNull(),
- * })
+ * }, (session) => ({
+ *   userIdIdx: index().on(session.userId)
+ * }))
  *
  * export const verificationTokens = pgTable(
  *  "verificationToken",
  *  {
  *    identifier: text("identifier").notNull(),
- *    token: text("token").notNull(),
+ *    token: text("token").notNull().unique(),
  *    expires: timestamp("expires", { mode: "date" }).notNull(),
  *  },
  *  (vt) => ({
@@ -136,10 +170,10 @@ import type { Adapter } from "@auth/core/adapters"
  * import type { AdapterAccount } from "@auth/core/adapters"
  *
  * export const users = mysqlTable("user", {
- *  id: varchar("id", { length: 255 }).notNull().primaryKey(),
+ *  id: varchar("id", { length: 255 }).primaryKey().$defaultFn(() => randomUUID()),
  *  name: varchar("name", { length: 255 }),
- *  email: varchar("email", { length: 255 }).notNull(),
- *   emailVerified: timestamp("emailVerified", { mode: "date", fsp: 3 }).defaultNow(),
+ *  email: varchar("email", { length: 255 }).notNull().unique(),
+ *  emailVerified: timestamp("emailVerified", { mode: "date", fsp: 3 }),
  *  image: varchar("image", { length: 255 }),
  * })
  *
@@ -149,8 +183,8 @@ import type { Adapter } from "@auth/core/adapters"
  *    userId: varchar("userId", { length: 255 })
  *       .notNull()
  *       .references(() => users.id, { onDelete: "cascade" }),
- *    type: varchar("type", { length: 255 }).$type<AdapterAccount["type"]>().notNull(),
- *     provider: varchar("provider", { length: 255 }).notNull(),
+ *    type: varchar("type", { length: 255 }).notNull(),
+ *    provider: varchar("provider", { length: 255 }).notNull(),
  *    providerAccountId: varchar("providerAccountId", { length: 255 }).notNull(),
  *    refresh_token: varchar("refresh_token", { length: 255 }),
  *    access_token: varchar("access_token", { length: 255 }),
@@ -164,22 +198,26 @@ import type { Adapter } from "@auth/core/adapters"
  *    compoundKey: primaryKey({
         columns: [account.provider, account.providerAccountId],
       }),
+      userIdIdx: index('Account_userId_index').on(account.userId)
  * })
  * )
  *
  * export const sessions = mysqlTable("session", {
- *  sessionToken: varchar("sessionToken", { length: 255 }).notNull().primaryKey(),
+ *  id: varchar("id", { length: 255 }).primaryKey().$defaultFn(() => randomUUID()),
+ *  sessionToken: varchar("sessionToken", { length: 255 }).notNull().unique(),
  *  userId: varchar("userId", { length: 255 })
  *    .notNull()
  *    .references(() => users.id, { onDelete: "cascade" }),
  *  expires: timestamp("expires", { mode: "date" }).notNull(),
- * })
+ * }, (session) => ({
+ *  userIdIdx: index('Session_userId_index').on(session.userId)
+ * }))
  *
  * export const verificationTokens = mysqlTable(
  * "verificationToken",
  * {
  *   identifier: varchar("identifier", { length: 255 }).notNull(),
- *   token: varchar("token", { length: 255 }).notNull(),
+ *   token: varchar("token", { length: 255 }).notNull().unique(),
  *   expires: timestamp("expires", { mode: "date" }).notNull(),
  * },
  * (vt) => ({
@@ -195,9 +233,9 @@ import type { Adapter } from "@auth/core/adapters"
  * import type { AdapterAccount } from "@auth/core/adapters"
  *
  * export const users = sqliteTable("user", {
- *  id: text("id").notNull().primaryKey(),
+ *  id: text("id").primaryKey().$defaultFn(() => randomUUID()),
  *  name: text("name"),
- *  email: text("email").notNull(),
+ *  email: text("email").notNull().unique(),
  *  emailVerified: integer("emailVerified", { mode: "timestamp_ms" }),
  *  image: text("image"),
  * })
@@ -208,7 +246,7 @@ import type { Adapter } from "@auth/core/adapters"
  *    userId: text("userId")
  *      .notNull()
  *      .references(() => users.id, { onDelete: "cascade" }),
- *    type: text("type").$type<AdapterAccount["type"]>().notNull(),
+ *    type: text("type").notNull(),
  *    provider: text("provider").notNull(),
  *    providerAccountId: text("providerAccountId").notNull(),
  *    refresh_token: text("refresh_token"),
@@ -223,22 +261,26 @@ import type { Adapter } from "@auth/core/adapters"
  *    compoundKey: primaryKey({
         columns: [account.provider, account.providerAccountId],
       }),
+      userIdIdx: index('Account_userId_index').on(account.userId)
  *  })
  * )
  *
  * export const sessions = sqliteTable("session", {
- * sessionToken: text("sessionToken").notNull().primaryKey(),
+ * id: text("id").primaryKey().$defaultFn(() => randomUUID())
+ * sessionToken: text("sessionToken").notNull().unique(),
  * userId: text("userId")
  *   .notNull()
  *   .references(() => users.id, { onDelete: "cascade" }),
  * expires: integer("expires", { mode: "timestamp_ms" }).notNull(),
- * })
+ * }, (table) => ({
+ *  userIdIdx: index('Session_userId_index').on(table.userId)
+ * }))
  *
  * export const verificationTokens = sqliteTable(
  * "verificationToken",
  * {
  *   identifier: text("identifier").notNull(),
- *   token: text("token").notNull(),
+ *   token: text("token").notNull().unique(),
  *   expires: integer("expires", { mode: "timestamp_ms" }).notNull(),
  * },
  * (vt) => ({
@@ -257,14 +299,14 @@ import type { Adapter } from "@auth/core/adapters"
  **/
 export function DrizzleAdapter<SqlFlavor extends SqlFlavorOptions>(
   db: SqlFlavor,
-  table?: TableFn<SqlFlavor>
+  schema?: DefaultSchema<SqlFlavor>
 ): Adapter {
   if (is(db, MySqlDatabase)) {
-    return mySqlDrizzleAdapter(db, table as MySqlTableFn)
+    return MySqlDrizzleAdapter(db, schema as DefaultMySqlSchema)
   } else if (is(db, PgDatabase)) {
-    return pgDrizzleAdapter(db, table as PgTableFn)
+    return PostgresDrizzleAdapter(db, schema as DefaultPostgresSchema)
   } else if (is(db, BaseSQLiteDatabase)) {
-    return SQLiteDrizzleAdapter(db, table as SQLiteTableFn)
+    return SQLiteDrizzleAdapter(db, schema as DefaultSQLiteSchema)
   }
 
   throw new Error(