@auth/drizzle-adapter 1.1.0 → 1.2.0

package/lib/sqlite.js

@@ -44,18 +44,40 @@ export function defineTables(schema = {}) {
             identifier: text("identifier").notNull(),
             token: text("token").notNull(),
             expires: integer("expires", { mode: "timestamp_ms" }).notNull(),
-        }, (vt) => ({
-            compositePk: primaryKey({ columns: [vt.identifier, vt.token] }),
+        }, (verficationToken) => ({
+            compositePk: primaryKey({
+                columns: [verficationToken.identifier, verficationToken.token],
+            }),
+        })));
+    const authenticatorsTable = schema.authenticatorsTable ??
+        (sqliteTable("authenticator", {
+            credentialID: text("credentialID").notNull().unique(),
+            userId: text("userId")
+                .notNull()
+                .references(() => usersTable.id, { onDelete: "cascade" }),
+            providerAccountId: text("providerAccountId").notNull(),
+            credentialPublicKey: text("credentialPublicKey").notNull(),
+            counter: integer("counter").notNull(),
+            credentialDeviceType: text("credentialDeviceType").notNull(),
+            credentialBackedUp: integer("credentialBackedUp", {
+                mode: "boolean",
+            }).notNull(),
+            transports: text("transports"),
+        }, (authenticator) => ({
+            compositePK: primaryKey({
+                columns: [authenticator.userId, authenticator.credentialID],
+            }),
         })));
     return {
         usersTable,
         accountsTable,
         sessionsTable,
         verificationTokensTable,
+        authenticatorsTable,
     };
 }
 export function SQLiteDrizzleAdapter(client, schema) {
-    const { usersTable, accountsTable, sessionsTable, verificationTokensTable } = defineTables(schema);
+    const { usersTable, accountsTable, sessionsTable, verificationTokensTable, authenticatorsTable, } = defineTables(schema);
     return {
         async createUser(data) {
             const { id, ...insertData } = data;
@@ -83,7 +105,7 @@ export function SQLiteDrizzleAdapter(client, schema) {
             return result ?? null;
         },
         async createSession(data) {
-            return await client.insert(sessionsTable).values(data).returning().get();
+            return client.insert(sessionsTable).values(data).returning().get();
         },
         async getSessionAndUser(sessionToken) {
             const result = await client
@@ -143,7 +165,7 @@ export function SQLiteDrizzleAdapter(client, schema) {
                 .run();
         },
         async createVerificationToken(data) {
-            return await client
+            return client
                 .insert(verificationTokensTable)
                 .values(data)
                 .returning()
@@ -166,5 +188,44 @@ export function SQLiteDrizzleAdapter(client, schema) {
                 .where(and(eq(accountsTable.provider, params.provider), eq(accountsTable.providerAccountId, params.providerAccountId)))
                 .run();
         },
+        async getAccount(providerAccountId, provider) {
+            return client
+                .select()
+                .from(accountsTable)
+                .where(and(eq(accountsTable.provider, provider), eq(accountsTable.providerAccountId, providerAccountId)))
+                .then((res) => res[0] ?? null);
+        },
+        async createAuthenticator(data) {
+            return client
+                .insert(authenticatorsTable)
+                .values(data)
+                .returning()
+                .then((res) => res[0] ?? null);
+        },
+        async getAuthenticator(credentialID) {
+            return client
+                .select()
+                .from(authenticatorsTable)
+                .where(eq(authenticatorsTable.credentialID, credentialID))
+                .then((res) => res[0] ?? null);
+        },
+        async listAuthenticatorsByUserId(userId) {
+            return client
+                .select()
+                .from(authenticatorsTable)
+                .where(eq(authenticatorsTable.userId, userId))
+                .then((res) => res);
+        },
+        async updateAuthenticatorCounter(credentialID, newCounter) {
+            const authenticator = await client
+                .update(authenticatorsTable)
+                .set({ counter: newCounter })
+                .where(eq(authenticatorsTable.credentialID, credentialID))
+                .returning()
+                .then((res) => res[0]);
+            if (!authenticator)
+                throw new Error("Authenticator not found.");
+            return authenticator;
+        },
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@auth/drizzle-adapter",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Drizzle adapter for Auth.js.",
   "homepage": "https://authjs.dev",
   "repository": "https://github.com/nextauthjs/next-auth",
@@ -37,7 +37,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@auth/core": "0.31.0"
+    "@auth/core": "0.32.0"
   },
   "devDependencies": {
     "@types/uuid": "^8.3.3",

package/src/lib/mysql.ts

@@ -2,14 +2,15 @@ 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 {
@@ -19,6 +20,7 @@ import type {
   AdapterSession,
   AdapterUser,
   VerificationToken,
+  AdapterAuthenticator,
 } from "@auth/core/adapters"
 
 export function defineTables(
@@ -85,16 +87,50 @@ export function defineTables(
         token: varchar("token", { length: 255 }).notNull(),
         expires: timestamp("expires", { mode: "date" }).notNull(),
       },
-      (vt) => ({
-        compositePk: primaryKey({ columns: [vt.identifier, vt.token] }),
+      (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,
   }
 }
 
@@ -102,8 +138,13 @@ export function MySqlDrizzleAdapter(
   client: MySqlDatabase<QueryResultHKT, PreparedQueryHKTBase, any>,
   schema?: DefaultMySqlSchema
 ): Adapter {
-  const { usersTable, accountsTable, sessionsTable, verificationTokensTable } =
-    defineTables(schema)
+  const {
+    usersTable,
+    accountsTable,
+    sessionsTable,
+    verificationTokensTable,
+    authenticatorsTable,
+  } = defineTables(schema)
 
   return {
     async createUser(data: AdapterUser) {
@@ -270,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
@@ -457,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
+  authenticatorsTable?: DefaultMySqlAuthenticatorTable
 }

package/src/lib/pg.ts

@@ -1,9 +1,10 @@
-import { and, eq, getTableColumns } from "drizzle-orm"
+import { InferInsertModel, and, eq, getTableColumns } from "drizzle-orm"
 import {
   PgColumn,
   PgDatabase,
   PgTableWithColumns,
   QueryResultHKT,
+  boolean,
   integer,
   pgTable,
   primaryKey,
@@ -15,6 +16,7 @@ import type {
   Adapter,
   AdapterAccount,
   AdapterAccountType,
+  AdapterAuthenticator,
   AdapterSession,
   AdapterUser,
   VerificationToken,
@@ -54,13 +56,11 @@ export function defineTables(
         id_token: text("id_token"),
         session_state: text("session_state"),
       },
-      (table) => {
-        return {
-          compositePk: primaryKey({
-            columns: [table.provider, table.providerAccountId],
-          }),
-        }
-      }
+      (account) => ({
+        compositePk: primaryKey({
+          columns: [account.provider, account.providerAccountId],
+        }),
+      })
     ) satisfies DefaultPostgresAccountsTable)
 
   const sessionsTable =
@@ -82,18 +82,42 @@ export function defineTables(
         token: text("token").notNull(),
         expires: timestamp("expires", { mode: "date" }).notNull(),
       },
-      (table) => {
-        return {
-          compositePk: primaryKey({ columns: [table.identifier, table.token] }),
-        }
-      }
+      (verficationToken) => ({
+        compositePk: primaryKey({
+          columns: [verficationToken.identifier, verficationToken.token],
+        }),
+      })
     ) satisfies DefaultPostgresVerificationTokenTable)
 
+  const authenticatorsTable =
+    schema.authenticatorsTable ??
+    (pgTable(
+      "authenticator",
+      {
+        credentialID: text("credentialID").notNull().unique(),
+        userId: text("userId")
+          .notNull()
+          .references(() => usersTable.id, { onDelete: "cascade" }),
+        providerAccountId: text("providerAccountId").notNull(),
+        credentialPublicKey: text("credentialPublicKey").notNull(),
+        counter: integer("counter").notNull(),
+        credentialDeviceType: text("credentialDeviceType").notNull(),
+        credentialBackedUp: boolean("credentialBackedUp").notNull(),
+        transports: text("transports"),
+      },
+      (authenticator) => ({
+        compositePK: primaryKey({
+          columns: [authenticator.userId, authenticator.credentialID],
+        }),
+      })
+    ) satisfies DefaultPostgresAuthenticatorTable)
+
   return {
     usersTable,
     accountsTable,
     sessionsTable,
     verificationTokensTable,
+    authenticatorsTable,
   }
 }
 
@@ -101,8 +125,13 @@ export function PostgresDrizzleAdapter(
   client: PgDatabase<QueryResultHKT, any>,
   schema?: DefaultPostgresSchema
 ): Adapter {
-  const { usersTable, accountsTable, sessionsTable, verificationTokensTable } =
-    defineTables(schema)
+  const {
+    usersTable,
+    accountsTable,
+    sessionsTable,
+    verificationTokensTable,
+    authenticatorsTable,
+  } = defineTables(schema)
 
   return {
     async createUser(data: AdapterUser) {
@@ -240,21 +269,72 @@ export function PostgresDrizzleAdapter(
           )
         )
     },
+    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) {
+      return client
+        .insert(authenticatorsTable)
+        .values(data)
+        .returning()
+        .then((res) => res[0] ?? null)
+    },
+    async getAuthenticator(credentialID: string) {
+      return client
+        .select()
+        .from(authenticatorsTable)
+        .where(eq(authenticatorsTable.credentialID, credentialID))
+        .then((res) => res[0] ?? null)
+    },
+    async listAuthenticatorsByUserId(userId: string) {
+      return client
+        .select()
+        .from(authenticatorsTable)
+        .where(eq(authenticatorsTable.userId, userId))
+        .then((res) => res)
+    },
+    async updateAuthenticatorCounter(credentialID: string, newCounter: number) {
+      const authenticator = await client
+        .update(authenticatorsTable)
+        .set({ counter: newCounter })
+        .where(eq(authenticatorsTable.credentialID, credentialID))
+        .returning()
+        .then((res) => res[0])
+
+      if (!authenticator) throw new Error("Authenticator not found.")
+
+      return authenticator
+    },
   }
 }
 
 type DefaultPostgresColumn<
   T extends {
-    data: string | number | Date
-    dataType: "string" | "number" | "date"
+    data: string | number | boolean | Date
+    dataType: "string" | "number" | "boolean" | "date"
     notNull: boolean
-    columnType: "PgVarchar" | "PgText" | "PgTimestamp" | "PgInteger" | "PgUUID"
+    columnType:
+      | "PgVarchar"
+      | "PgText"
+      | "PgBoolean"
+      | "PgTimestamp"
+      | "PgInteger"
+      | "PgUUID"
   },
 > = PgColumn<{
   name: string
   columnType: T["columnType"]
   data: T["data"]
-  driverParam: string | number
+  driverParam: string | number | boolean
   notNull: T["notNull"]
   hasDefault: boolean
   enumValues: any
@@ -426,9 +506,66 @@ export type DefaultPostgresVerificationTokenTable = PgTableWithColumns<{
   schema: string | undefined
 }>
 
+export type DefaultPostgresAuthenticatorTable = PgTableWithColumns<{
+  name: string
+  columns: {
+    credentialID: DefaultPostgresColumn<{
+      columnType: "PgVarchar" | "PgText"
+      data: string
+      notNull: true
+      dataType: "string"
+    }>
+    userId: DefaultPostgresColumn<{
+      columnType: "PgVarchar" | "PgText"
+      data: string
+      notNull: true
+      dataType: "string"
+    }>
+    providerAccountId: DefaultPostgresColumn<{
+      columnType: "PgVarchar" | "PgText"
+      data: string
+      notNull: true
+      dataType: "string"
+    }>
+    credentialPublicKey: DefaultPostgresColumn<{
+      columnType: "PgVarchar" | "PgText"
+      data: string
+      notNull: true
+      dataType: "string"
+    }>
+    counter: DefaultPostgresColumn<{
+      columnType: "PgInteger"
+      data: number
+      notNull: true
+      dataType: "number"
+    }>
+    credentialDeviceType: DefaultPostgresColumn<{
+      columnType: "PgVarchar" | "PgText"
+      data: string
+      notNull: true
+      dataType: "string"
+    }>
+    credentialBackedUp: DefaultPostgresColumn<{
+      columnType: "PgBoolean"
+      data: boolean
+      notNull: true
+      dataType: "boolean"
+    }>
+    transports: DefaultPostgresColumn<{
+      columnType: "PgVarchar" | "PgText"
+      data: string
+      notNull: false
+      dataType: "string"
+    }>
+  }
+  dialect: "pg"
+  schema: string | undefined
+}>
+
 export type DefaultPostgresSchema = {
   usersTable: DefaultPostgresUsersTable
   accountsTable: DefaultPostgresAccountsTable
   sessionsTable?: DefaultPostgresSessionsTable
   verificationTokensTable?: DefaultPostgresVerificationTokenTable
+  authenticatorsTable?: DefaultPostgresAuthenticatorTable
 }