misc

.gitignore

@@ -63,6 +63,7 @@ packages/adapter-prisma/prisma/dev.db
 packages/adapter-prisma/prisma/migrations
 db.sqlite
 packages/adapter-supabase/supabase/.branches
+packages/adapter-drizzle/drizzle
 
 # Tests
 coverage

docs/docs/reference/adapters/index.md

@@ -9,6 +9,10 @@ Using a Auth.js / NextAuth.js adapter you can connect to any database service or
     <img src="/img/adapters/dgraph.png" width="30" />
     <h4 class="adapter-card__title">Dgraph Adapter</h4>
   </a>
+  <a href="/reference/adapter/drizzle" class="adapter-card">
+    <img src="/img/adapters/drizzle-orm.png" width="30" />
+    <h4 class="adapter-card__title">Drizzle ORM Adapter</h4>
+  </a>
   <a href="/reference/adapter/dynamodb" class="adapter-card">
     <img src="/img/adapters/dynamodb.png" width="30" />
     <h4 class="adapter-card__title">DynamoDB Adapter</h4>

docs/docusaurus.config.js

@@ -262,6 +262,7 @@ const docusaurusConfig = {
       },
     ],
     typedocAdapter("Dgraph"),
+    typedocAdapter("Drizzle ORM"),
     typedocAdapter("DynamoDB"),
     typedocAdapter("Fauna"),
     typedocAdapter("Firebase"),

docs/sidebars.js

@@ -53,6 +53,7 @@ module.exports = {
       items: [
         { type: "doc", id: "reference/adapter/dgraph/index" },
         { type: "doc", id: "reference/adapter/dynamodb/index" },
+        { type: "doc", id: "reference/adapter/drizzle/index" },
         { type: "doc", id: "reference/adapter/fauna/index" },
         { type: "doc", id: "reference/adapter/firebase/index" },
         { type: "doc", id: "reference/adapter/mikro-orm/index" },

packages/adapter-drizzle/README.md

@@ -0,0 +1,28 @@
+<p align="center">
+  <br/>
+  <a href="https://authjs.dev" target="_blank">
+    <img height="64px" src="https://authjs.dev/img/logo/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"/>
+  </a>
+  <h3 align="center"><b>Drizzle ORM Adapter</b> - NextAuth.js / Auth.js</a></h3>
+  <p align="center" style="align: center;">
+    <a href="https://npm.im/@auth/drizzle-adapter">
+      <img src="https://img.shields.io/badge/TypeScript-blue?style=flat-square" alt="TypeScript" />
+    </a>
+    <a href="https://npm.im/@auth/drizzle-adapter">
+      <img alt="npm" src="https://img.shields.io/npm/v/@auth/drizzle-adapter?color=green&label=@auth/drizzle-adapter&style=flat-square">
+    </a>
+    <a href="https://www.npmtrends.com/@auth/drizzle-adapter">
+      <img src="https://img.shields.io/npm/dm/@auth/drizzle-adapter?label=%20downloads&style=flat-square" alt="Downloads" />
+    </a>
+    <a href="https://github.com/nextauthjs/next-auth/stargazers">
+      <img src="https://img.shields.io/github/stars/nextauthjs/next-auth?style=flat-square" alt="Github Stars" />
+    </a>
+  </p>
+</p>
+
+---
+
+Check out the documentation at [authjs.dev](https://authjs.dev/reference/adapter/drizzle).

packages/adapter-drizzle/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@auth/drizzle-adapter",
+  "version": "0.0.1",
+  "description": "Drizzle ORM adapter for Auth.js",
+  "homepage": "https://authjs.dev/reference/adapter/drizzle",
+  "repository": "https://github.com/nextauthjs/next-auth",
+  "bugs": {
+    "url": "https://github.com/nextauthjs/next-auth/issues"
+  },
+  "author": "Anthony Shew",
+  "license": "ISC",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.js"
+    }
+  },
+  "keywords": [
+    "auth.js",
+    "next-auth",
+    "next.js",
+    "oauth",
+    "drizzle"
+  ],
+  "private": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "clean": "rm -rf *.js *.d.ts* ./drizzle db.sqlite",
+    "test:init": "pnpm clean && drizzle-kit generate:sqlite --schema=src/schema.ts --breakpoints",
+    "test": "pnpm test:init && jest",
+    "build": "pnpm clean && drizzle-kit generate:sqlite --schema=src/schema.ts && tsc",
+    "dev": "drizzle-kit generate:sqlite --schema=src/schema.ts && tsc -w"
+  },
+  "files": [
+    "src",
+    "*.js",
+    "*.d.ts*"
+  ],
+  "peerDependencies": {
+    "drizzle-orm": "^0.23.5"
+  },
+  "devDependencies": {
+    "@next-auth/adapter-test": "workspace:*",
+    "@types/better-sqlite3": "^7.6.3",
+    "better-sqlite3": "^8.2.0",
+    "drizzle-kit": "^0.17.3",
+    "drizzle-orm": "^0.23.5",
+    "jest": "^27.4.3",
+    "next-auth": "workspace:*"
+  },
+  "jest": {
+    "preset": "@next-auth/adapter-test/jest"
+  }
+}

packages/adapter-drizzle/src/index.ts

@@ -0,0 +1,248 @@
+/**
+ * <div style={{display: "flex", justifyContent: "space-between", alignItems: "center", padding: 16}}>
+ *  <p style={{fontWeight: "normal"}}>Official <a href="https://github.com/drizzle-team/drizzle-orm">Drizzle ORM</a> adapter for Auth.js / NextAuth.js.</p>
+ *  <a href="https://github.com/drizzle-team/drizzle-orm">
+ *   <img style={{display: "block"}} src="https://authjs.dev/img/adapters/drizzle-orm.png" width="38" />
+ *  </a>
+ * </div>
+ *
+ * ## Installation
+ *
+ * ```bash npm2yarn2pnpm
+ * npm install next-auth drizzle-orm @auth/drizzle-adapter
+ * npm install drizzle-kit --save-dev
+ * ```
+ *
+ * @module @auth/drizzle-adapter
+ */
+import {
+  accounts,
+  users,
+  sessions,
+  verificationTokens,
+  type DrizzleClient,
+} from "./schema"
+import { and, eq } from "drizzle-orm/expressions"
+import type { Adapter } from "next-auth/adapters"
+
+/**
+ * ## Setup
+ *
+ * Add this adapter to your `pages/api/[...nextauth].js` next-auth configuration object:
+ *
+ * ```js title="pages/api/auth/[...nextauth].js"
+ * import NextAuth from "next-auth"
+ * import GoogleProvider from "next-auth/providers/google"
+ * import { DrizzleAdapter } from "@auth/drizzle-adapter"
+ * import { db } from "./db-schema"
+ *
+ * export default NextAuth({
+ *   adapter: DrizzleAdapter(db),
+ *   providers: [
+ *     GoogleProvider({
+ *       clientId: process.env.GOOGLE_CLIENT_ID,
+ *       clientSecret: process.env.GOOGLE_CLIENT_SECRET,
+ *     }),
+ *   ],
+ * })
+ * ```
+ *
+ * ## Advanced usage
+ *
+ * ### Create the Drizzle schema from scratch
+ *
+ * You'll need to create a database schema that includes the minimal schema for a `next-auth` adapter.
+ * Be sure to use the Drizzle driver version that you're using for your project.
+ *
+ * > This schema is adapted for use in Drizzle and based upon our main [schema](https://authjs.dev/reference/adapters#models)
+ *
+ *
+ * ```json title="db-schema.ts"
+ *
+ * import { integer, pgTable, text, primaryKey } from 'drizzle-orm/pg-core';
+ * import { drizzle } from 'drizzle-orm/node-postgres';
+ * import { migrate } from 'drizzle-orm/node-postgres/migrator';
+ * import { Pool } from 'pg'
+ * import { ProviderType } from 'next-auth/providers';
+ *
+ * export const users = pgTable('users', {
+ * id: text('id').notNull().primaryKey(),
+ * name: text('name'),
+ * email: text("email").notNull(),
+ * emailVerified: integer("emailVerified"),
+ * image: text("image"),
+ * });
+ *
+ * export const accounts = pgTable("accounts", {
+ *  userId: text("userId").notNull().references(() => users.id, { onDelete: "cascade" }),
+ *  type: text("type").$type<ProviderType>().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) => ({
+ *   _: primaryKey(account.provider, account.providerAccountId)
+ * }))
+ *
+ * export const sessions = pgTable("sessions", {
+ *  userId: text("userId").notNull().references(() => users.id, { onDelete: "cascade" }),
+ *  sessionToken: text("sessionToken").notNull().primaryKey(),
+ *  expires: integer("expires").notNull(),
+ * })
+ *
+ * export const verificationTokens = pgTable("verificationToken", {
+ *  identifier: text("identifier").notNull(),
+ *  token: text("token").notNull(),
+ *  expires: integer("expires").notNull()
+ * }, (vt) => ({
+ *   _: primaryKey(vt.identifier, vt.token)
+ * }))
+ *
+ * const pool = new Pool({
+ *   connectionString: "YOUR_CONNECTION_STRING"
+ * });
+ *
+ * export const db = drizzle(pool);
+ *
+ * migrate(db, { migrationsFolder: "./drizzle" })
+ *
+ * ```
+ *
+ **/
+export function DrizzleAdapter(client: DrizzleClient): Adapter {
+  return {
+    createUser(data) {
+      return client
+        .insert(users)
+        .values({ ...data, id: "123" })
+        .returning()
+        .get()
+    },
+    getUser(data) {
+      return client.select().from(users).where(eq(users.id, data)).get() ?? null
+    },
+    getUserByEmail(data) {
+      return (
+        client.select().from(users).where(eq(users.email, data)).get() ?? null
+      )
+    },
+    createSession(data) {
+      return client.insert(sessions).values(data).returning().get()
+    },
+    getSessionAndUser(data) {
+      return (
+        client
+          .select({
+            session: sessions,
+            user: users,
+          })
+          .from(sessions)
+          .where(eq(sessions.sessionToken, data))
+          .innerJoin(users, eq(users.id, sessions.userId))
+          .get() ?? null
+      )
+    },
+    updateUser(data) {
+      if (!data.id) throw new Error("No user id.")
+
+      return client
+        .update(users)
+        .set(data)
+        .where(eq(users.id, data.id))
+        .returning()
+        .get()
+    },
+    updateSession(data) {
+      return client
+        .update(sessions)
+        .set(data)
+        .where(eq(sessions.sessionToken, data.sessionToken))
+        .returning()
+        .get()
+    },
+    linkAccount(rawAccount) {
+      const updatedAccount = client
+        .insert(accounts)
+        .values(rawAccount)
+        .returning()
+        .get()
+
+      // HACK: Should not need to set `undefined` values here
+      return {
+        ...updatedAccount,
+        access_token: updatedAccount.access_token ?? undefined,
+        token_type: updatedAccount.token_type ?? undefined,
+        id_token: updatedAccount.id_token ?? undefined,
+        refresh_token: updatedAccount.refresh_token ?? undefined,
+        scope: updatedAccount.scope ?? undefined,
+        expires_at: updatedAccount.expires_at ?? undefined,
+        session_state: updatedAccount.session_state ?? undefined,
+      }
+    },
+    getUserByAccount(account) {
+      return (
+        client
+          .select()
+          .from(users)
+          .innerJoin(
+            accounts,
+            and(
+              eq(accounts.providerAccountId, account.providerAccountId),
+              eq(accounts.provider, account.provider)
+            )
+          )
+          .get()?.users ?? null
+      )
+    },
+    deleteSession(sessionToken) {
+      return client
+        .delete(sessions)
+        .where(eq(sessions.sessionToken, sessionToken))
+        .returning()
+        .get()
+    },
+    createVerificationToken(token) {
+      return client.insert(verificationTokens).values(token).returning().get()
+    },
+    useVerificationToken(token) {
+      try {
+        return (
+          client
+            .delete(verificationTokens)
+            .where(
+              and(
+                eq(verificationTokens.identifier, token.identifier),
+                eq(verificationTokens.token, token.token)
+              )
+            )
+            .returning()
+            .get() ?? null
+        )
+      } catch (err) {
+        throw new Error("No verification token found.")
+      }
+    },
+    deleteUser(id) {
+      return client.delete(users).where(eq(users.id, id)).returning().get()
+    },
+    unlinkAccount(account) {
+      client
+        .delete(accounts)
+        .where(
+          and(
+            eq(accounts.providerAccountId, account.providerAccountId),
+            eq(accounts.provider, account.provider)
+          )
+        )
+        .run()
+
+      // HACK: void should be fine
+      return undefined
+    },
+  }
+}

packages/adapter-drizzle/src/schema.ts

@@ -0,0 +1,63 @@
+import { integer, sqliteTable, text, primaryKey } from "drizzle-orm/sqlite-core"
+import { drizzle } from "drizzle-orm/better-sqlite3"
+import { migrate } from "drizzle-orm/better-sqlite3/migrator"
+import Database from "better-sqlite3"
+import { ProviderType } from "next-auth/providers"
+
+const sqlite = new Database("db.sqlite")
+
+export const users = sqliteTable("users", {
+  id: text("id").notNull().primaryKey(),
+  name: text("name"),
+  email: text("email").notNull(),
+  emailVerified: integer("emailVerified", { mode: "timestamp_ms" }),
+  image: text("image"),
+})
+
+export const accounts = sqliteTable(
+  "accounts",
+  {
+    userId: text("userId")
+      .notNull()
+      .references(() => users.id, { onDelete: "cascade" }),
+    type: text("type").$type<ProviderType>().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) => ({
+    nameDoesntMatter: primaryKey(account.provider, account.providerAccountId),
+  })
+)
+
+export const sessions = sqliteTable("sessions", {
+  sessionToken: text("sessionToken").notNull().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) => ({
+    nameDoesntMatter: primaryKey(vt.identifier, vt.token),
+  })
+)
+
+export const db = drizzle(sqlite)
+
+export type DrizzleClient = typeof db
+
+migrate(db, { migrationsFolder: "./drizzle" })

packages/adapter-drizzle/tests/index.test.ts

@@ -0,0 +1,68 @@
+import { randomUUID, runBasicTests } from "@next-auth/adapter-test"
+import { DrizzleAdapter } from "../src"
+import { db, users, accounts, sessions, verificationTokens } from '../src/schema'
+import { eq, and } from 'drizzle-orm/expressions';
+
+
+runBasicTests({
+  adapter: DrizzleAdapter(db),
+  db: {
+    id() {
+      return randomUUID()
+    },
+    connect: async () => {
+      await Promise.all([
+        db.delete(sessions).run(),
+        db.delete(accounts).run(),
+        db.delete(verificationTokens).run(),
+        db.delete(users).run(),
+      ])
+    },
+    disconnect: async () => {
+      await Promise.all([
+        db.delete(sessions).run(),
+        db.delete(accounts).run(),
+        db.delete(verificationTokens).run(),
+        db.delete(users).run(),
+      ])
+    },
+    user: (id) => db
+      .select()
+      .from(users)
+      .where(eq(users.id, id))
+      .get() ?? null,
+    session: (sessionToken) => db
+      .select()
+      .from(sessions)
+      .where(eq(sessions.sessionToken, sessionToken))
+      .get() ?? null,
+    account: (provider_providerAccountId) => {
+      return db
+        .select()
+        .from(accounts)
+        .where(
+          eq(
+            accounts.providerAccountId,
+            provider_providerAccountId.providerAccountId
+          )
+        )
+        .get()
+        ?? null
+    },
+    verificationToken: (identifier_token) => db
+      .select()
+      .from(verificationTokens)
+      .where(
+        and(
+          eq(
+            verificationTokens.token,
+            identifier_token.token
+          ),
+          eq(
+            verificationTokens.identifier,
+            identifier_token.identifier
+          )
+        )
+      ).get() ?? null,
+  },
+})

packages/adapter-drizzle/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "allowSyntheticDefaultImports": true,
+    "declaration": true,
+    "declarationMap": true,
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "outDir": ".",
+    "rootDir": "src",
+    "skipDefaultLibCheck": true,
+    "skipLibCheck": true,
+    "strictNullChecks": true,
+    "stripInternal": true,
+    "target": "ES2020",
+  },
+  "exclude": [
+    "tests",
+    "*.js",
+    "*.d.ts*",
+  ]
+}