@auth/drizzle-adapter 1.0.1 → 1.2.0

package/src/index.ts

@@ -1,6 +1,6 @@
 /**
  * <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>
+ *  <p>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.svg" width="38" />
  *  </a>
@@ -26,251 +26,7 @@ import { DefaultSQLiteSchema, SQLiteDrizzleAdapter } from "./lib/sqlite.js"
 import { DefaultSchema, SqlFlavorOptions } from "./lib/utils.js"
 
 import type { Adapter } from "@auth/core/adapters"
-/**
- * Create db instance and pass it to adapter. Add this adapter to your `auth.ts` Auth.js configuration object:
- *
- * ```ts title="auth.ts"
- * import NextAuth from "next-auth"
- * import Google from "next-auth/providers/google"
- * import { DrizzleAdapter } from "@auth/drizzle-adapter"
- * import { db } from "./db.ts"
- *
- * export const { handlers, auth } = NextAuth({
- *   adapter: DrizzleAdapter(db),
- *   providers: [
- *     Google,
- *   ],
- * })
- * ```
- * 
- * Follow the Drizzle documentation for [PostgreSQL setup](https://orm.drizzle.team/docs/get-started-postgresql), [MySQL setup](https://orm.drizzle.team/docs/get-started-mysql) and [SQLite setup](https://orm.drizzle.team/docs/get-started-sqlite).
- * 
- * :::info
- * If you want to use your own tables, you can pass them as a second argument. If you add non-nullable columns, make sure to provide a default value or rewrite functions to handle the missing values.
- * :::
- * 
- * ```ts title="auth.ts"
- * import NextAuth from "next-auth"
- * import Google from "next-auth/providers/google"
- * import { DrizzleAdapter } from "@auth/drizzle-adapter"
- * import { accounts, sessions, users, verificationTokens } from "./schema"
- * import { db } from "./db.ts"
- *
- * 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.
- * Additionally, you may extend the schema from the minimum requirements to suit your needs.
- *
- * - [Postgres](#postgres)
- * - [MySQL](#mysql)
- * - [SQLite](#sqlite)
- *
- * ### Postgres
 
- * ```ts title="schema.ts"
- * import {
- *   timestamp,
- *   pgTable,
- *   text,
- *   primaryKey,
- *  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").primaryKey().$defaultFn(() => randomUUID()),
- *  name: text("name"),
- *  email: text("email").notNull(),
- *  emailVerified: timestamp("emailVerified", { mode: "date" }),
- *  image: text("image"),
- * })
- *
- * export const accounts = pgTable(
- * "account",
- * {
- *   userId: text("userId")
- *     .notNull()
- *     .references(() => users.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) => ({
- *   compoundKey: primaryKey({ columns: [account.provider, account.providerAccountId] }),
- * })
- * )
- *
- * export const sessions = pgTable("session", {
- *  sessionToken: text("sessionToken").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({ columns: [vt.identifier, vt.token] }),
- *  })
- * )
- * ```
- *
- * ### MySQL
- *
- *  In MySQL, there's no `returning` clause, so in the `createUser` function, we first insert a new user and then search by `email` to get the user's data. To make the search faster, we suggest adding an index to the `email` column.
- * 
- * ```ts title="schema.ts"
- * import {
- *  int,
- *  timestamp,
- *  mysqlTable,
- *  primaryKey,
- *  varchar,
- * } from "drizzle-orm/mysql-core"
- * import type { AdapterAccount } from "@auth/core/adapters"
- *
- * export const users = mysqlTable("user", {
- *  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 }),
- *  image: varchar("image", { length: 255 }),
- * })
- *
- * export const accounts = mysqlTable(
- *  "account",
- *   {
- *     userId: varchar("userId", { length: 255 })
- *        .notNull()
- *        .references(() => users.id, { onDelete: "cascade" }),
- *     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 }),
- *     expires_at: int("expires_at"),
- *     token_type: varchar("token_type", { length: 255 }),
- *     scope: varchar("scope", { length: 255 }),
- *     id_token: varchar("id_token", { length: 2048 }),
- *     session_state: varchar("session_state", { length: 255 }),
- *   },
- *   (account) => ({
- *     compoundKey: primaryKey({
-         columns: [account.provider, account.providerAccountId],
-       })
- *   })
- * )
- *
- * export const sessions = mysqlTable("session", {
- *  sessionToken: varchar("sessionToken", { length: 255 }).primaryKey(),
- *  userId: varchar("userId", { length: 255 })
- *    .notNull()
- *    .references(() => users.id, { onDelete: "cascade" }),
- *  expires: timestamp("expires", { mode: "date" }).notNull(),
- * })
- *
- * export 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({ columns: [vt.identifier, vt.token] }),
- *  })
- * )
- * ```
- *
- * ### SQLite
- *
- * ```ts title="schema.ts"
- * import { integer, sqliteTable, text, primaryKey } from "drizzle-orm/sqlite-core"
- * import type { AdapterAccount } from "@auth/core/adapters"
- *
- * export const users = sqliteTable("user", {
- *  id: text("id").primaryKey().$defaultFn(() => randomUUID()),
- *  name: text("name"),
- *  email: text("email").notNull(),
- *  emailVerified: integer("emailVerified", { mode: "timestamp_ms" }),
- *  image: text("image"),
- * })
- *
- * export const accounts = sqliteTable(
- *  "account",
- *  {
- *    userId: text("userId")
- *      .notNull()
- *      .references(() => users.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) => ({
- *    compoundKey: primaryKey({
-        columns: [account.provider, account.providerAccountId],
-      })
- *  })
- * )
- *
- * export const sessions = sqliteTable("session", {
- *  sessionToken: text("sessionToken").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({ columns: [vt.identifier, vt.token] }),
- *  })
- * )
- * ```
- *
- * ## Migrating your database
- * With your schema now described in your code, you'll need to migrate your database to your schema.
- *
- * For full documentation on how to run migrations with Drizzle, [visit the Drizzle documentation](https://orm.drizzle.team/kit-docs/overview#running-migrations) or check how to apply changes directly to the database with [push command](https://orm.drizzle.team/kit-docs/overview#prototyping-with-db-push).
- *
- * ---
- *
- **/
 export function DrizzleAdapter<SqlFlavor extends SqlFlavorOptions>(
   db: SqlFlavor,
   schema?: DefaultSchema<SqlFlavor>

package/src/lib/mysql.ts

@@ -2,99 +2,158 @@ import { and, eq, getTableColumns } from "drizzle-orm"
 import {
   MySqlColumn,
   MySqlDatabase,
-  MySqlTableWithColumns,
-  PreparedQueryHKTBase,
-  QueryResultHKT,
+  boolean,
   int,
   mysqlTable,
   primaryKey,
   timestamp,
   varchar,
+  QueryResultHKT,
+  PreparedQueryHKTBase,
+  MySqlTableWithColumns,
 } from "drizzle-orm/mysql-core"
 
 import type {
   Adapter,
   AdapterAccount,
+  AdapterAccountType,
   AdapterSession,
   AdapterUser,
   VerificationToken,
+  AdapterAuthenticator,
 } from "@auth/core/adapters"
 
-export const mysqlUsersTable = mysqlTable("user", {
-  id: varchar("id", { length: 255 })
-    .primaryKey()
-    .$defaultFn(() => crypto.randomUUID()),
-  name: varchar("name", { length: 255 }),
-  email: varchar("email", { length: 255 }).notNull(),
-  emailVerified: timestamp("emailVerified", { mode: "date", fsp: 3 }),
-  image: varchar("image", { length: 255 }),
-}) satisfies DefaultMySqlUsersTable
-
-export const mysqlAccountsTable = mysqlTable(
-  "account",
-  {
-    userId: varchar("userId", { length: 255 })
-      .notNull()
-      .references(() => mysqlUsersTable.id, { onDelete: "cascade" }),
-    type: varchar("type", { length: 255 })
-      .$type<AdapterAccount["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: 2048 }),
-    session_state: varchar("session_state", { length: 255 }),
-  },
-  (account) => ({
-    compositePk: primaryKey({
-      columns: [account.provider, account.providerAccountId],
-    }),
-  })
-) satisfies DefaultMySqlAccountsTable
-
-export const mysqlSessionsTable = mysqlTable("session", {
-  sessionToken: varchar("sessionToken", { length: 255 }).primaryKey(),
-  userId: varchar("userId", { length: 255 })
-    .notNull()
-    .references(() => mysqlUsersTable.id, { onDelete: "cascade" }),
-  expires: timestamp("expires", { mode: "date" }).notNull(),
-}) satisfies DefaultMySqlSessionsTable
-
-export const mysqlVerificationTokensTable = mysqlTable(
-  "verificationToken",
-  {
-    identifier: varchar("identifier", { length: 255 }).notNull(),
-    token: varchar("token", { length: 255 }).notNull(),
-    expires: timestamp("expires", { mode: "date" }).notNull(),
-  },
-  (vt) => ({
-    compositePk: primaryKey({ columns: [vt.identifier, vt.token] }),
-  })
-) satisfies DefaultMySqlVerificationTokenTable
+export function defineTables(
+  schema: Partial<DefaultMySqlSchema> = {}
+): Required<DefaultMySqlSchema> {
+  const usersTable =
+    schema.usersTable ??
+    (mysqlTable("user", {
+      id: varchar("id", { length: 255 })
+        .primaryKey()
+        .$defaultFn(() => crypto.randomUUID()),
+      name: varchar("name", { length: 255 }),
+      email: varchar("email", { length: 255 }).notNull(),
+      emailVerified: timestamp("emailVerified", { mode: "date", fsp: 3 }),
+      image: varchar("image", { length: 255 }),
+    }) satisfies DefaultMySqlUsersTable)
+
+  const accountsTable =
+    schema.accountsTable ??
+    (mysqlTable(
+      "account",
+      {
+        userId: varchar("userId", { length: 255 })
+          .notNull()
+          .references(() => usersTable.id, { onDelete: "cascade" }),
+        type: varchar("type", { length: 255 })
+          .$type<AdapterAccountType>()
+          .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: 2048 }),
+        session_state: varchar("session_state", { length: 255 }),
+      },
+      (account) => ({
+        compositePk: primaryKey({
+          columns: [account.provider, account.providerAccountId],
+        }),
+      })
+    ) satisfies DefaultMySqlAccountsTable)
+
+  const sessionsTable =
+    schema.sessionsTable ??
+    (mysqlTable("session", {
+      sessionToken: varchar("sessionToken", { length: 255 }).primaryKey(),
+      userId: varchar("userId", { length: 255 })
+        .notNull()
+        .references(() => usersTable.id, { onDelete: "cascade" }),
+      expires: timestamp("expires", { mode: "date" }).notNull(),
+    }) satisfies DefaultMySqlSessionsTable)
+
+  const verificationTokensTable =
+    schema.verificationTokensTable ??
+    (mysqlTable(
+      "verificationToken",
+      {
+        identifier: varchar("identifier", { length: 255 }).notNull(),
+        token: varchar("token", { length: 255 }).notNull(),
+        expires: timestamp("expires", { mode: "date" }).notNull(),
+      },
+      (verficationToken) => ({
+        compositePk: primaryKey({
+          columns: [verficationToken.identifier, verficationToken.token],
+        }),
+      })
+    ) satisfies DefaultMySqlVerificationTokenTable)
+
+  const authenticatorsTable =
+    schema.authenticatorsTable ??
+    (mysqlTable(
+      "authenticator",
+      {
+        credentialID: varchar("credentialID", { length: 255 })
+          .notNull()
+          .unique(),
+        userId: varchar("userId", { length: 255 })
+          .notNull()
+          .references(() => usersTable.id, { onDelete: "cascade" }),
+        providerAccountId: varchar("providerAccountId", {
+          length: 255,
+        }).notNull(),
+        credentialPublicKey: varchar("credentialPublicKey", {
+          length: 255,
+        }).notNull(),
+        counter: int("counter").notNull(),
+        credentialDeviceType: varchar("credentialDeviceType", {
+          length: 255,
+        }).notNull(),
+        credentialBackedUp: boolean("credentialBackedUp").notNull(),
+        transports: varchar("transports", { length: 255 }),
+      },
+      (authenticator) => ({
+        compositePk: primaryKey({
+          columns: [authenticator.userId, authenticator.credentialID],
+        }),
+      })
+    ) satisfies DefaultMySqlAuthenticatorTable)
+
+  return {
+    usersTable,
+    accountsTable,
+    sessionsTable,
+    verificationTokensTable,
+    authenticatorsTable,
+  }
+}
 
 export function MySqlDrizzleAdapter(
   client: MySqlDatabase<QueryResultHKT, PreparedQueryHKTBase, any>,
-  schema: DefaultMySqlSchema = {
-    usersTable: mysqlUsersTable,
-    accountsTable: mysqlAccountsTable,
-    sessionsTable: mysqlSessionsTable,
-    verificationTokensTable: mysqlVerificationTokensTable,
-  }
+  schema?: DefaultMySqlSchema
 ): Adapter {
-  const { usersTable, accountsTable, sessionsTable, verificationTokensTable } =
-    schema
+  const {
+    usersTable,
+    accountsTable,
+    sessionsTable,
+    verificationTokensTable,
+    authenticatorsTable,
+  } = defineTables(schema)
 
   return {
     async createUser(data: AdapterUser) {
+      const { id, ...insertData } = data
       const hasDefaultId = getTableColumns(usersTable)["id"]["hasDefault"]
 
       await client
         .insert(usersTable)
-        .values(hasDefaultId ? data : { ...data, id: crypto.randomUUID() })
+        .values(hasDefaultId ? insertData : { ...insertData, id })
 
       return client
         .select()
@@ -252,21 +311,77 @@ export function MySqlDrizzleAdapter(
           )
         )
     },
+    async getAccount(providerAccountId: string, provider: string) {
+      return client
+        .select()
+        .from(accountsTable)
+        .where(
+          and(
+            eq(accountsTable.provider, provider),
+            eq(accountsTable.providerAccountId, providerAccountId)
+          )
+        )
+        .then((res) => res[0] ?? null) as Promise<AdapterAccount | null>
+    },
+    async createAuthenticator(data: AdapterAuthenticator) {
+      await client.insert(authenticatorsTable).values(data)
+
+      return await client
+        .select()
+        .from(authenticatorsTable)
+        .where(eq(authenticatorsTable.credentialID, data.credentialID))
+        .then((res) => res[0] ?? null)
+    },
+    async getAuthenticator(credentialID: string) {
+      return await client
+        .select()
+        .from(authenticatorsTable)
+        .where(eq(authenticatorsTable.credentialID, credentialID))
+        .then((res) => res[0] ?? null)
+    },
+    async listAuthenticatorsByUserId(userId: string) {
+      return await client
+        .select()
+        .from(authenticatorsTable)
+        .where(eq(authenticatorsTable.userId, userId))
+        .then((res) => res)
+    },
+    async updateAuthenticatorCounter(credentialID: string, newCounter: number) {
+      await client
+        .update(authenticatorsTable)
+        .set({ counter: newCounter })
+        .where(eq(authenticatorsTable.credentialID, credentialID))
+
+      const authenticator = await client
+        .select()
+        .from(authenticatorsTable)
+        .where(eq(authenticatorsTable.credentialID, credentialID))
+        .then((res) => res[0])
+
+      if (!authenticator) throw new Error("Authenticator not found.")
+
+      return authenticator
+    },
   }
 }
 
 type DefaultMyqlColumn<
   T extends {
-    data: string | number | Date
-    dataType: "string" | "number" | "date"
+    data: string | number | boolean | Date
+    dataType: "string" | "number" | "boolean" | "date"
     notNull: boolean
-    columnType: "MySqlVarChar" | "MySqlText" | "MySqlTimestamp" | "MySqlInt"
+    columnType:
+      | "MySqlVarChar"
+      | "MySqlText"
+      | "MySqlBoolean"
+      | "MySqlTimestamp"
+      | "MySqlInt"
   },
 > = MySqlColumn<{
   name: string
   columnType: T["columnType"]
   data: T["data"]
-  driverParam: string | number
+  driverParam: string | number | boolean
   notNull: T["notNull"]
   hasDefault: boolean
   enumValues: any
@@ -439,9 +554,66 @@ export type DefaultMySqlVerificationTokenTable = MySqlTableWithColumns<{
   schema: string | undefined
 }>
 
+export type DefaultMySqlAuthenticatorTable = MySqlTableWithColumns<{
+  name: string
+  columns: {
+    credentialID: DefaultMyqlColumn<{
+      columnType: "MySqlVarChar" | "MySqlText"
+      data: string
+      notNull: true
+      dataType: "string"
+    }>
+    userId: DefaultMyqlColumn<{
+      columnType: "MySqlVarChar" | "MySqlText"
+      data: string
+      notNull: true
+      dataType: "string"
+    }>
+    providerAccountId: DefaultMyqlColumn<{
+      columnType: "MySqlVarChar" | "MySqlText"
+      data: string
+      notNull: true
+      dataType: "string"
+    }>
+    credentialPublicKey: DefaultMyqlColumn<{
+      columnType: "MySqlVarChar" | "MySqlText"
+      data: string
+      notNull: true
+      dataType: "string"
+    }>
+    counter: DefaultMyqlColumn<{
+      columnType: "MySqlInt"
+      data: number
+      notNull: true
+      dataType: "number"
+    }>
+    credentialDeviceType: DefaultMyqlColumn<{
+      columnType: "MySqlVarChar" | "MySqlText"
+      data: string
+      notNull: true
+      dataType: "string"
+    }>
+    credentialBackedUp: DefaultMyqlColumn<{
+      columnType: "MySqlBoolean"
+      data: boolean
+      notNull: true
+      dataType: "boolean"
+    }>
+    transports: DefaultMyqlColumn<{
+      columnType: "MySqlVarChar" | "MySqlText"
+      data: string
+      notNull: false
+      dataType: "string"
+    }>
+  }
+  dialect: "mysql"
+  schema: string | undefined
+}>
+
 export type DefaultMySqlSchema = {
   usersTable: DefaultMySqlUsersTable
   accountsTable: DefaultMySqlAccountsTable
-  sessionsTable: DefaultMySqlSessionsTable
-  verificationTokensTable: DefaultMySqlVerificationTokenTable
+  sessionsTable?: DefaultMySqlSessionsTable
+  verificationTokensTable?: DefaultMySqlVerificationTokenTable
+  authenticatorsTable?: DefaultMySqlAuthenticatorTable
 }