@auth/drizzle-adapter 0.8.2 → 1.0.0

package/README.md

@@ -1,7 +1,7 @@
 <p align="center">
   <br/>
   <a href="https://authjs.dev" target="_blank">
-    <img height="64px" src="https://authjs.dev/img/logo/logo-sm.png" />
+    <img height="64px" src="https://authjs.dev/img/logo-sm.png" />
   </a>
   <a href="https://github.com/drizzle-team/drizzle-orm" target="_blank">
     <img height="64px" src="https://authjs.dev/img/adapters/drizzle-orm.png"/>

package/index.d.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>
  *
@@ -15,32 +15,46 @@
  *
  * @module @auth/drizzle-adapter
  */
-import { SqlFlavorOptions, TableFn } from "./lib/utils.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
  *
  * First, create a schema that includes [the minimum requirements for a `next-auth` adapter](/reference/core/adapters#models). You can select your favorite SQL flavor below and copy it.
@@ -61,11 +75,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"),
  * })
@@ -76,7 +91,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"),
@@ -88,23 +103,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) => ({
@@ -126,10 +145,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 }),
  * })
  *
@@ -139,8 +158,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 }),
@@ -154,22 +173,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) => ({
@@ -185,9 +208,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"),
  * })
@@ -198,7 +221,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"),
@@ -213,22 +236,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) => ({
@@ -245,5 +272,5 @@ import type { Adapter } from "@auth/core/adapters";
  * ---
  *
  **/
-export declare function DrizzleAdapter<SqlFlavor extends SqlFlavorOptions>(db: SqlFlavor, table?: TableFn<SqlFlavor>): Adapter;
+export declare function DrizzleAdapter<SqlFlavor extends SqlFlavorOptions>(db: SqlFlavor, schema?: DefaultSchema<SqlFlavor>): Adapter;
 //# sourceMappingURL=index.d.ts.map

package/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAQH,OAAO,EAAE,gBAAgB,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAA;AAG1D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAElD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAmOI;AACJ,wBAAgB,cAAc,CAAC,SAAS,SAAS,gBAAgB,EAC/D,EAAE,EAAE,SAAS,EACb,KAAK,CAAC,EAAE,OAAO,CAAC,SAAS,CAAC,GACzB,OAAO,CAYT"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AASH,OAAO,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAA;AAEhE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAElD,OAAO,EACL,kBAAkB,EAClB,qBAAqB,EACrB,qBAAqB,EACrB,+BAA+B,GAChC,MAAM,aAAa,CAAA;AACpB,OAAO,EACL,gBAAgB,EAChB,mBAAmB,EACnB,mBAAmB,EACnB,6BAA6B,GAC9B,MAAM,iBAAiB,CAAA;AACxB,OAAO,EACL,eAAe,EACf,kBAAkB,EAClB,kBAAkB,EAClB,4BAA4B,GAC7B,MAAM,gBAAgB,CAAA;AACvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA2PI;AACJ,wBAAgB,cAAc,CAAC,SAAS,SAAS,gBAAgB,EAC/D,EAAE,EAAE,SAAS,EACb,MAAM,CAAC,EAAE,aAAa,CAAC,SAAS,CAAC,GAChC,OAAO,CAYT"}

package/index.js

@@ -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>
  *
@@ -15,37 +15,51 @@
  *
  * @module @auth/drizzle-adapter
  */
+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 { mySqlDrizzleAdapter } from "./lib/mysql.js";
-import { pgDrizzleAdapter } from "./lib/pg.js";
+import { MySqlDrizzleAdapter } from "./lib/mysql.js";
+import { PostgresDrizzleAdapter } from "./lib/pg.js";
 import { SQLiteDrizzleAdapter } from "./lib/sqlite.js";
-import { is } from "drizzle-orm";
+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
  *
  * First, create a schema that includes [the minimum requirements for a `next-auth` adapter](/reference/core/adapters#models). You can select your favorite SQL flavor below and copy it.
@@ -66,11 +80,12 @@ import { is } from "drizzle-orm";
  *  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"),
  * })
@@ -81,7 +96,7 @@ import { is } from "drizzle-orm";
  *   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"),
@@ -93,23 +108,27 @@ import { is } from "drizzle-orm";
  *   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) => ({
@@ -131,10 +150,10 @@ import { is } from "drizzle-orm";
  * 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 }),
  * })
  *
@@ -144,8 +163,8 @@ import { is } from "drizzle-orm";
  *    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 }),
@@ -159,22 +178,26 @@ import { is } from "drizzle-orm";
  *    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) => ({
@@ -190,9 +213,9 @@ import { is } from "drizzle-orm";
  * 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"),
  * })
@@ -203,7 +226,7 @@ import { is } from "drizzle-orm";
  *    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"),
@@ -218,22 +241,26 @@ import { is } from "drizzle-orm";
  *    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) => ({
@@ -250,15 +277,15 @@ import { is } from "drizzle-orm";
  * ---
  *
  **/
-export function DrizzleAdapter(db, table) {
+export function DrizzleAdapter(db, schema) {
     if (is(db, MySqlDatabase)) {
-        return mySqlDrizzleAdapter(db, table);
+        return MySqlDrizzleAdapter(db, schema);
     }
     else if (is(db, PgDatabase)) {
-        return pgDrizzleAdapter(db, table);
+        return PostgresDrizzleAdapter(db, schema);
     }
     else if (is(db, BaseSQLiteDatabase)) {
-        return SQLiteDrizzleAdapter(db, table);
+        return SQLiteDrizzleAdapter(db, schema);
     }
     throw new Error(`Unsupported database type (${typeof db}) in Auth.js Drizzle adapter.`);
 }