Required dependencies

Install only what your chosen adapter requires:

# Core (always required)
npm install @auth/core

# Drizzle ORM adapter
npm install drizzle-orm @auth/drizzle-adapter
npm install drizzle-kit --save-dev

# Prisma adapter
npm install @prisma/client @auth/prisma-adapter

# DynamoDB adapter
npm install @aws-sdk/lib-dynamodb @aws-sdk/client-dynamodb @auth/dynamodb-adapter

# Azure Table Storage adapter
npm install @azure/data-tables @auth/azure-tables-adapter

# Cloudflare D1 adapter (Workers runtime — no separate npm install needed)
npm install @auth/d1-adapter

# Dgraph adapter
npm install @auth/dgraph-adapter

# MongoDB adapter
npm install mongodb @auth/mongodb-adapter

# Upstash Redis adapter
npm install @upstash/redis @auth/upstash-redis-adapter

# Next.js
npm install next-auth

No native build steps (pod install / NDK) are required. For Cloudflare D1, the @cloudflare/workers-types and @miniflare/d1 packages are type-only peer dependencies; install them as devDependencies.

Project setup

1. Copy the source/ directory into your project root, e.g. src/auth-source/.

2. In tsconfig.json add path aliases so relative workspace imports resolve:

{
  "compilerOptions": {
    "baseUrl": ".",
    "paths": {
      "@auth/core/*": ["src/auth-source/core/src/*"],
      "@auth/drizzle-adapter": ["src/auth-source/adapter-drizzle/src/index.ts"],
      "@auth/dynamodb-adapter": ["src/auth-source/adapter-dynamodb/src/index.ts"]
    },
    "moduleResolution": "Bundler",
    "target": "ES2022"
  }
}

3. Set required environment variables:

AUTH_SECRET=your_32_byte_random_secret
AUTH_URL=https://yourdomain.com
# Provider-specific keys, e.g.:
AUTH_GITHUB_ID=...
AUTH_GITHUB_SECRET=...

4. For the Drizzle adapter, generate and run migrations with drizzle-kit push against your target DB dialect.

5. For the D1 adapter, call the exported up() migration function once during Worker startup.

Public API

DrizzleAdapter

import { DrizzleAdapter } from "@auth/drizzle-adapter"
import type { Adapter } from "@auth/core/adapters"

function DrizzleAdapter<SqlFlavor extends SqlFlavorOptions>(
  db: SqlFlavor,
  schema?: DefaultSchema<SqlFlavor>
): Adapter

Pass a Drizzle db instance (MySQL, Postgres, or SQLite). Optionally supply a custom schema object mapping the four Auth.js tables. Throws at runtime if an unsupported DB type is passed.

DynamoDBAdapter

import { DynamoDBAdapter } from "@auth/dynamodb-adapter"
import type { DynamoDBAdapterOptions } from "@auth/dynamodb-adapter"

function DynamoDBAdapter(
  client: DynamoDBDocument,
  options?: DynamoDBAdapterOptions
): Adapter

interface DynamoDBAdapterOptions {
  tableName?: string        // default: "next-auth"
  partitionKey?: string     // default: "pk"
  sortKey?: string          // default: "sk"
  indexName?: string        // default: "GSI1"
  indexPartitionKey?: string
  indexSortKey?: string
}

Wraps @aws-sdk/lib-dynamodb's DynamoDBDocument. Override key/index names when your table schema differs from the defaults.

TableStorageAdapter

import { TableStorageAdapter } from "@auth/azure-tables-adapter"
import type { TableClient } from "@azure/data-tables"

function TableStorageAdapter(client: TableClient): Adapter

Takes an @azure/data-tables TableClient and returns a fully compliant Adapter. Use when deploying to Azure with Table Storage as your session/account backend.

DgraphAdapter

import { DgraphAdapter } from "@auth/dgraph-adapter"
import type { DgraphAdapterOptions, DgraphClientParams } from "@auth/dgraph-adapter"

function DgraphAdapter(
  client: DgraphClientParams,
  options?: DgraphAdapterOptions
): Adapter

Connects to a Dgraph GraphQL endpoint. The optional fragments field in DgraphAdapterOptions lets you extend the default entity shapes.

Working examples

Scenario - Drizzle ORM with Postgres and NextAuth.js

Configure NextAuth.js to persist sessions and accounts in a Postgres database via Drizzle.

// src/auth.ts
import NextAuth from "next-auth"
import GitHub from "next-auth/providers/github"
import { drizzle } from "drizzle-orm/node-postgres"
import { Pool } from "pg"
import { DrizzleAdapter } from "@auth/drizzle-adapter"

const pool = new Pool({ connectionString: process.env.DATABASE_URL })
const db = drizzle(pool)

export const { handlers, auth, signIn, signOut } = NextAuth({
  adapter: DrizzleAdapter(db),
  providers: [
    GitHub({
      clientId: process.env.AUTH_GITHUB_ID!,
      clientSecret: process.env.AUTH_GITHUB_SECRET!,
    }),
  ],
})

Scenario - DynamoDB adapter in a serverless API

Use the DynamoDB adapter with a single-table design on AWS Lambda.

// src/auth.config.ts
import { DynamoDBAdapter } from "@auth/dynamodb-adapter"
import { DynamoDBClient } from "@aws-sdk/client-dynamodb"
import { DynamoDBDocument } from "@aws-sdk/lib-dynamodb"
import NextAuth from "next-auth"
import Google from "next-auth/providers/google"

const client = DynamoDBDocument.from(
  new DynamoDBClient({ region: process.env.AWS_REGION }),
  { marshallOptions: { convertEmptyValues: true, removeUndefinedValues: true } }
)

export const { handlers, auth } = NextAuth({
  adapter: DynamoDBAdapter(client, {
    tableName: "my-auth-table",
    partitionKey: "PK",
    sortKey: "SK",
    indexName: "GSI1",
    indexPartitionKey: "GSI1PK",
    indexSortKey: "GSI1SK",
  }),
  providers: [Google],
})

Scenario - Azure Table Storage adapter with Express

Integrate Auth.js into an Express server backed by Azure Table Storage.

// src/server.ts
import express from "express"
import { ExpressAuth } from "@auth/express"
import { TableClient } from "@azure/data-tables"
import { TableStorageAdapter } from "@auth/azure-tables-adapter"
import GitHub from "next-auth/providers/github"

const tableClient = TableClient.fromConnectionString(
  process.env.AZURE_STORAGE_CONNECTION_STRING!,
  "nextauth"
)

const app = express()
app.set("trust proxy", true)

app.use(
  "/auth/*",
  ExpressAuth({
    providers: [GitHub],
    adapter: TableStorageAdapter(tableClient),
    secret: process.env.AUTH_SECRET,
  })
)

app.listen(3000)

Scenario - Cloudflare D1 adapter with Workers

Apply the D1 schema migration and configure the adapter inside a Cloudflare Worker.

// src/worker.ts
import { D1Adapter, up } from "@auth/d1-adapter"

export default {
  async fetch(request: Request, env: { DB: D1Database; AUTH_SECRET: string }) {
    // Run once to create tables (idempotent)
    await up(env.DB)

    // Adapter is ready for use with your Auth.js handler
    const adapter = D1Adapter(env.DB)
    // ... pass adapter to your Auth.js configuration
  },
}

File walkthrough

• core/ - Auth.js core: provider definitions, JWT helpers, session logic, and all shared TypeScript types (Adapter, AdapterUser, AdapterSession, etc.). Every adapter imports from here.
• adapter-drizzle/ - Drizzle ORM adapter; sub-files lib/pg.ts, lib/mysql.ts, lib/sqlite.ts handle dialect-specific SQL.
• adapter-dynamodb/ - DynamoDB adapter using the @aws-sdk/lib-dynamodb document client; includes Jest config for local DynamoDB testing.
• adapter-azure-tables/ - Azure Table Storage adapter; exports TableStorageAdapter, keys, and withoutKeys helper.
• adapter-d1/ - Cloudflare D1 adapter; exports D1Adapter, up migration runner, and raw SQL query constants.
• adapter-dgraph/ - Dgraph GraphQL adapter; uses internal client.ts and fragments.ts for query composition.
• adapter-prisma/ - Thin Prisma ORM wrapper; delegates all DB calls to the generated Prisma Client.
• adapter-mongodb/ - MongoDB adapter using the native mongodb driver.
• adapter-upstash-redis/ - Upstash Redis adapter for fully serverless, edge-compatible session storage.
• frameworks-express/ - ExpressAuth middleware for wiring Auth.js into Express apps.
• frameworks-sveltekit/ - SvelteKit handle hook and server helpers.
• frameworks-solid-start/ - SolidStart server handler integration.
• frameworks-qwik/ - Qwik City server loader integration.
• next-auth/ - The next-auth npm package; re-exports core with Next.js Route Handler wiring.
• utils/ - Internal shared utilities (not intended for direct import by consumers).

Common pitfalls and fixes

• AUTH_SECRET missing at runtime - Auth.js throws a generic error without it; set a 32-byte random string in every environment including CI and edge deployments.
• ESM/CJS interop with drizzle-orm - Drizzle ships ESM-only in recent versions; set "moduleResolution": "Bundler" or "Node16" in tsconfig.json and ensure your bundler handles .js extension imports.
• D1 adapter up() called on every request - The migration is idempotent but still incurs a DB round-trip; call it once during Worker initialization or a dedicated deploy step, not in the hot path.
• DynamoDB GSI not created - The adapter requires a GSI named GSI1 (or your override) with GSI1PK / GSI1SK attributes; missing this causes getSessionAndUser and getUserByAccount to fail silently with empty results.
• Azure Table Storage withoutKeys mutates the response object - The helper deletes partitionKey, rowKey, etag, timestamp, and odata.metadata in-place; do not cache the raw entity before calling it.
• Dgraph schema not deployed - The DgraphAdapter requires the schema from adapter-dgraph/src/lib/graphql/schema.gql to be applied to your Dgraph Cloud or self-hosted instance before any auth operations succeed.

Vibe-coding prompt template

I have dropped the Auth.js adapters source into `src/auth-source/` in my project.
The USAGE.md is at `src/auth-source/USAGE.md`.
The upstream package name is `user@example.com` (next-auth monorepo, packages/ root).

Please integrate Auth.js into my existing Node.js / TypeScript project step by step:

1. Read USAGE.md and the relevant adapter source under `src/auth-source/` for the
   database I am using: [REPLACE WITH: drizzle-postgres | dynamodb | d1 | prisma | etc.].
2. Install only the npm dependencies listed in USAGE.md for that adapter.
3. Create `src/auth.ts` that initialises Auth.js with my chosen adapter and at least
   one OAuth provider. Use environment variables for all secrets.
4. Wire the Auth.js request handler into my existing [Express / Next.js App Router /
   SvelteKit / other] server.
5. Add the required environment variables to `.env.example`.
6. If a migration step is needed (Drizzle, D1, Prisma), add a `scripts/migrate.ts`
   that runs it.
7. Do not invent any API that is not present in `src/auth-source/` or USAGE.md.

License and credit

Auth.js is released under the ISC License (see source/LICENSE if present, or check the GitHub repository). The upstream package is next-auth maintained by the Auth.js contributors. Per the README, Auth.js is now part of Better Auth; new projects should evaluate Better Auth for future development.

This product’s unique contribution is clean room implementation of valuable code block into AVCP compatible standard.

The full install guide and integration prompts unlock after purchase.