Lucia

https://v2.lucia-auth.com
Admin
Lucia is a TypeScript authentication library that provides a simple, extensible API for managing...
Tokens:185,748
Snippets:1,339
Trust Score:8.2
Update:11 months ago
Show doc for...
Tokens:
Raw
### Setup Lucia with Prisma adapter

Source: https://v2.lucia-auth.com/getting-started/hono

This example shows how to initialize Lucia with the Prisma adapter. It requires 'lucia', '@lucia-auth/adapter-prisma', and '@prisma/client'. The PrismaClient instance is passed to the adapter.

```typescript
import { lucia } from "lucia";
import { hono } from "lucia/middleware";
import { prisma } from "@lucia-auth/adapter-prisma";
import { PrismaClient } from "@prisma/client";

const client = new PrismaClient();

const auth = lucia({
	env: "DEV", // "PROD" if deployed to HTTPS
	middleware: hono(),
	adapter: prisma(client)
});
```

--------------------------------

### Install Lucia

Source: https://v2.lucia-auth.com/getting-started/elysia

Install Lucia using your preferred package manager. This step is crucial for adding Lucia's authentication capabilities to your project.

```bash
npm i lucia
pnpm add lucia
yarn add lucia
```

--------------------------------

### Setup Lucia with Prisma Adapter

Source: https://v2.lucia-auth.com/getting-started/nuxt

Configure Lucia to use the Prisma ORM for database interactions. This involves importing the Prisma adapter and initializing it with a PrismaClient instance.

```typescript
// server/utils/lucia.ts
import { lucia } from "lucia";
import { h3 } from "lucia/middleware";
import { prisma } from "@lucia-auth/adapter-prisma";
import { PrismaClient } from "@prisma/client";

const client = new PrismaClient();

const auth = lucia({
	env: "DEV", // "PROD" if deployed to HTTPS
	middleware: h3(),
	adapter: prisma(client)
});
```

--------------------------------

### Setup Prisma Database Adapter

Source: https://v2.lucia-auth.com/getting-started/fastify

Configures Lucia with Prisma database adapter for connecting to various databases. Requires Prisma Client instance and Fastify middleware.

```typescript
import { lucia } from "lucia";
import { fastify } from "lucia/middleware";
import { prisma } from "@lucia-auth/adapter-prisma";
import { PrismaClient } from "@prisma/client";

const client = new PrismaClient();

const auth = lucia({
	env: "DEV", // "PROD" if deployed to HTTPS
	middleware: fastify(),
	adapter: prisma(client)
});
```

--------------------------------

### Setup Lucia with Prisma Adapter in Elysia

Source: https://v2.lucia-auth.com/getting-started/elysia

Configure Lucia with the Prisma adapter for database integration. This involves importing necessary modules from Lucia and Prisma, instantiating the Prisma client, and passing it to the Lucia adapter configuration.

```typescript
import { lucia } from "lucia";
import { elysia } from "lucia/middleware";
import { prisma } from "@lucia-auth/adapter-prisma";
import { PrismaClient } from "@prisma/client";

const client = new PrismaClient();

const auth = lucia({
	env: "DEV", // "PROD" if deployed to HTTPS
	middleware: elysia(),
	adapter: prisma(client)
});
```

--------------------------------

### Initialize Lucia in Elysia

Source: https://v2.lucia-auth.com/getting-started/elysia

Initialize the Lucia instance, passing the Elysia middleware. Ensure to set the environment to 'DEV' or 'PROD' and export the 'auth' instance and its type for use throughout your application. Database adapter setup is covered in a subsequent step.

```typescript
// lucia.ts
import { lucia } from "lucia";
import { elysia } from "lucia/middleware";

// expect error (see next section)
export const auth = lucia({
	env: "DEV", // "PROD" if deployed to HTTPS
	middleware: elysia()
});

export type Auth = typeof auth;
```

--------------------------------

### Clone SolidStart GitHub OAuth Example

Source: https://v2.lucia-auth.com/guidebook/github-oauth/solidstart

Use this command to quickly set up a SolidStart project pre-configured with GitHub OAuth, allowing you to start development immediately. Ensure you have npx installed.

```bash
npx degit lucia-auth/examples/solidstart/github-oauth <directory_name>
```

--------------------------------

### Setup Prisma Adapter for Lucia

Source: https://v2.lucia-auth.com/getting-started/astro

Configure Lucia with a Prisma adapter to connect to your database. This example uses PrismaClient for database operations.

```typescript
import { lucia } from "lucia";
import { astro } from "lucia/middleware";
import { prisma } from "@lucia-auth/adapter-prisma";
import { PrismaClient } from "@prisma/client";

const client = new PrismaClient();

const auth = lucia({
	env: import.meta.env.DEV ? "DEV" : "PROD",
	middleware: astro(),
	adapter: prisma(client)
});
```

--------------------------------

### Setup Lucia TypeScript Declarations

Source: https://v2.lucia-auth.com/getting-started/elysia

Declare a global `Lucia` namespace in a `.d.ts` file to enable TypeScript support. This includes referencing the `Auth` type from your Lucia initialization file and defining attributes for database users and sessions.

```typescript
// app.d.ts
/// <reference types="lucia" />
declare namespace Lucia {
	type Auth = import("./lucia.js").Auth;
	type DatabaseUserAttributes = {};
	type DatabaseSessionAttributes = {};
}
```

--------------------------------

### Initialize Lucia with Prisma Database Adapter

Source: https://v2.lucia-auth.com/getting-started

Sets up Lucia authentication with the Prisma ORM adapter. Requires initializing PrismaClient and passing it to the prisma() function.

```typescript
import { lucia } from "lucia";
import { prisma } from "@lucia-auth/adapter-prisma";
import { PrismaClient } from "@prisma/client";

const client = new PrismaClient();

const auth = lucia({
	env: "DEV", // "PROD" if deployed to HTTPS
	adapter: prisma(client)
});
```

--------------------------------

### Initialize Lucia Authentication Instance

Source: https://v2.lucia-auth.com/getting-started

Initializes the Lucia authentication instance, exporting it as 'auth'. Requires specifying the environment ('DEV' or 'PROD') and an adapter (covered separately).

```typescript
// lucia.ts
import { lucia } from "lucia";

// expect error (see next section)
export const auth = lucia({
	env: "DEV" // "PROD" if deployed to HTTPS
});

export type Auth = typeof auth;
```

--------------------------------

### Clone SvelteKit Email and Password Example Project

Source: https://v2.lucia-auth.com/guidebook/password-reset-link/sveltekit

Provides a command to quickly set up a SvelteKit project that includes email and password authentication with password reset functionality. This is useful for getting started or for reference.

```bash
npx degit lucia-auth/examples/sveltekit/email-and-password <directory_name>

```

--------------------------------

### Run Nuxt with Node Flags for Web Crypto

Source: https://v2.lucia-auth.com/getting-started/nuxt

Alternatively, run Nuxt commands with the `--experimental-global-webcrypto` flag to enable the Web Crypto API without a side-effect import. This is useful for build and development scripts.

```json
// package.json
{
	// ...
	"scripts": {
		"build": "NODE_OPTIONS=--experimental-global-webcrypto nuxt build",
		"dev": "NODE_OPTIONS=--experimental-global-webcrypto nuxt dev",
		"generate": "NODE_OPTIONS=--experimental-global-webcrypto nuxt generate",
		"preview": "NODE_OPTIONS=--experimental-global-webcrypto nuxt preview",
		"postinstall": "NODE_OPTIONS=--experimental-global-webcrypto nuxt prepare"
	}
	// ...
}
```

--------------------------------

### Setup Lucia with Prisma Adapter

Source: https://v2.lucia-auth.com/getting-started/express

Initialize Lucia with a Prisma adapter. This example shows how to connect Lucia to a Prisma client for database operations.

```typescript
import { lucia } from "lucia";
import { express } from "lucia/middleware";
import { prisma } from "@lucia-auth/adapter-prisma";
import { PrismaClient } from "@prisma/client";

const client = new PrismaClient();

const auth = lucia({
	env: "DEV",
	middleware: express(),
	adapter: prisma(client)
});
```

--------------------------------

### npm package installation (@lucia-auth/oauth)

Source: https://v2.lucia-auth.com/migrate/v2

Shows the correct npm command to install the OAuth integration v2.

```bash
npm i @lucia-auth/oauth@latest
```

--------------------------------

### npm package installation (Lucia)

Source: https://v2.lucia-auth.com/migrate/v2

Shows the correct npm command to install Lucia v2.

```bash
npm i lucia@latest
```

--------------------------------

### pnpm package installation (@lucia-auth/oauth)

Source: https://v2.lucia-auth.com/migrate/v2

Shows the correct pnpm command to install the OAuth integration v2.

```bash
pnpm add @lucia-auth/oauth@latest
```

--------------------------------

### Setup database adapter for Lucia

Source: https://v2.lucia-auth.com/getting-started/nextjs-app

Integrate a database adapter with Lucia authentication. This example uses the Prisma adapter with a Prisma Client instance. The adapter connects Lucia to your database for user and session storage.

```typescript
// auth/lucia.ts
import { lucia } from "lucia";
import { nextjs_future } from "lucia/middleware";
import { prisma } from "@lucia-auth/adapter-prisma";
import { PrismaClient } from "@prisma/client";

const client = new PrismaClient();

const auth = lucia({
	env: "DEV", // "PROD" if deployed to HTTPS
	middleware: nextjs_future(),
	sessionCookie: {
		expires: false
	},

	adapter: prisma(client)
});
```

--------------------------------

### Setup Lucia with Prisma Adapter

Source: https://v2.lucia-auth.com/getting-started/solidstart

Integrate Lucia with your database using an adapter. This example demonstrates the Prisma adapter, requiring a Prisma client instance and the `@lucia-auth/adapter-prisma` package. Ensure your database client is initialized.

```typescript
import { lucia } from "lucia";
import { web } from "lucia/middleware";
import { prisma } from "@lucia-auth/adapter-prisma";
import { PrismaClient } from "@prisma/client";

const client = new PrismaClient();

const auth = lucia({
	env: process.env.NODE_ENV === "production" ? "PROD" : "DEV",
	middleware: web(),
	sessionCookie: {
		expires: false
	},

	adapter: prisma(client)
});

```

--------------------------------

### Clone Express Example Project with npx

Source: https://v2.lucia-auth.com/guidebook/sign-in-with-username-and-password/express

Use npx and degit to clone the Express example project for username and password authentication. This is a quick way to start with a pre-configured setup.

```bash
npx degit lucia-auth/examples/express/username-and-password <directory_name>
```

--------------------------------

### Setup Middleware for Lucia in Astro

Source: https://v2.lucia-auth.com/getting-started/astro

Create middleware to handle Lucia authentication requests and store Auth in locals for efficient request validation.

```typescript
// src/middleware.ts
import { auth } from "$lib/server/lucia";

import type { MiddlewareResponseHandler } from "astro";

export const onRequest: MiddlewareResponseHandler = async (context, next) => {
	context.locals.auth = auth.handleRequest(context);
	return await next();
};
```

--------------------------------

### Run Node.js with experimental Web Crypto flag

Source: https://v2.lucia-auth.com/getting-started/hono

Alternatively to polyfilling, this command shows how to run Node.js applications with the '--experimental-global-webcrypto' flag to enable the Web Crypto API. This is an alternative for older Node.js versions.

```bash
node --experimental-global-webcrypto index.js
```

--------------------------------

### yarn package installation (@lucia-auth/oauth)

Source: https://v2.lucia-auth.com/migrate/v2

Shows the correct yarn command to install the OAuth integration v2.

```bash
yarn add @lucia-auth/oauth@latest
```

--------------------------------

### Configure Web Standard Middleware for Lucia

Source: https://v2.lucia-auth.com/getting-started

Initializes Lucia with Web Standard middleware, suitable for environments using standard 'Request' and 'Response' objects. Configures session cookies to not expire.

```typescript
import { lucia } from "lucia";
import { web } from "lucia/middleware";

export const auth = lucia({
	env: "DEV", // "PROD" if deployed to HTTPS
	middleware: web(),
	sessionCookie: {
		expires: false
	}
});
```

--------------------------------

### yarn package installation (Lucia)

Source: https://v2.lucia-auth.com/migrate/v2

Shows the correct yarn command to install Lucia v2.

```bash
yarn add lucia@latest
```

--------------------------------

### pnpm package installation (Lucia)

Source: https://v2.lucia-auth.com/migrate/v2

Shows the correct pnpm command to install Lucia v2.

```bash
pnpm add lucia@latest
```

--------------------------------

### Initialize Lucia with Hono middleware

Source: https://v2.lucia-auth.com/getting-started/hono

This code snippet demonstrates the basic initialization of Lucia with the Hono framework middleware. It requires the 'lucia' and 'lucia/middleware' packages. The 'env' parameter should be set to 'DEV' or 'PROD'.

```typescript
// lucia.ts
import { lucia } from "lucia";
import { hono } from "lucia/middleware";

// expect error (see next section)
export const auth = lucia({
	env: "DEV", // "PROD" if deployed to HTTPS
	middleware: hono()
});

export type Auth = typeof auth;
```

--------------------------------

### Clone SvelteKit GitHub OAuth Example Project

Source: https://v2.lucia-auth.com/guidebook/github-oauth/sveltekit

Quickly start with a pre-configured SvelteKit example for GitHub OAuth authentication. This command clones the official Lucia example repository into your specified directory.

```bash
npx degit lucia-auth/examples/sveltekit/github-oauth <directory_name>
```

--------------------------------

### Clone Express Email and Password Example

Source: https://v2.lucia-auth.com/guidebook/email-verification-links/express

Clones the Express.js example project from the Lucia Auth repository for getting started with email and password authentication.

```bash
npx degit lucia-auth/examples/express/email-and-password <directory_name>
```

--------------------------------

### Install @lucia-auth/adapter-postgresql package

Source: https://v2.lucia-auth.com/migrate/v2/postgresql

Install the latest version of the PostgreSQL adapter package using npm, pnpm, or yarn. Requires Node.js and a compatible package manager. The process installs the package and its dependencies.

```sh
npm i @lucia-auth/adapter-postgresql@latest
```

```sh
pnpm add @lucia-auth/adapter-postgresql@latest
```

```sh
yarn add @lucia-auth/adapter-postgresql@latest
```

--------------------------------

### Configure Node.js Middleware for Lucia

Source: https://v2.lucia-auth.com/getting-started

Initializes Lucia with Node.js specific middleware, allowing it to correctly handle Node.js 'IncomingMessage' and 'OutgoingMessage' objects.

```typescript
import { lucia } from "lucia";
import { node } from "lucia/middleware";

export const auth = lucia({
	env: "DEV", // "PROD" if deployed to HTTPS
	middleware: node()
});
```

--------------------------------

### Clone Astro Lucia example project using shell command

Source: https://v2.lucia-auth.com/guidebook/sign-in-with-username-and-password/astro

Clones the Astro example repository to start with a template for username and password authentication. Requires npx and degit. Takes a directory name as input. No limitations.

```shell
npx degit lucia-auth/examples/astro/username-and-password <directory_name>
```

--------------------------------

### Initialize Lucia in Astro

Source: https://v2.lucia-auth.com/getting-started/astro

Initialize Lucia in a separate module with Astro middleware. This sets up the basic configuration for Lucia, including environment settings.

```typescript
// src/lib/lucia.ts
import { lucia } from "lucia";
import { astro } from "lucia/middleware";

// expect error (see next section)
export const auth = lucia({
	env: import.meta.env.DEV ? "DEV" : "PROD",
	middleware: astro()
});

export type Auth = typeof auth;
```

--------------------------------

### Polyfill Web Crypto API for Node.js < 18

Source: https://v2.lucia-auth.com/getting-started/hono

This code snippet polyfills the Web Crypto API for Node.js versions 18 and below. It requires importing 'lucia/polyfill/node'. This is not needed for Node.js v20+ or other runtimes like Deno or Bun.

```typescript
import { lucia } from "lucia";
import "lucia/polyfill/node";

export const auth = lucia({
	// ...
});
```

--------------------------------

### Install Lucia SQLite Adapter Package

Source: https://v2.lucia-auth.com/migrate/v2/sqlite

Installs the latest version of the Lucia SQLite adapter using npm, pnpm, or yarn. Requires Node.js and a package manager. Outputs updated package.json with the new dependency.

```shell
npm i @lucia-auth/adapter-sqlite@latest
```

```shell
pnpm add @lucia-auth/adapter-sqlite@latest
```

```shell
yarn add @lucia-auth/adapter-sqlite@latest
```

--------------------------------

### Install Mongoose Adapter for Lucia v2

Source: https://v2.lucia-auth.com/migrate/v2/mongoose

Commands to install the latest version of the Mongoose adapter for Lucia v2 using npm, pnpm, or yarn.

```bash
npm i @lucia-auth/adapter-mongoose@latest
```

```bash
pnpm add @lucia-auth/adapter-mongoose@latest
```

```bash
yarn add @lucia-auth/adapter-mongoose@latest
```

--------------------------------

### Install Lucia Prisma Adapter v2

Source: https://v2.lucia-auth.com/migrate/v2/prisma

Installs the latest version of the Prisma adapter for Lucia v2. Supports npm, pnpm, and yarn package managers.

```bash
npm i @lucia-auth/adapter-prisma@latest
pnpm add @lucia-auth/adapter-prisma@latest
yarn add @lucia-auth/adapter-prisma@latest
```

--------------------------------

### Configure Database Adapter for Prisma

Source: https://v2.lucia-auth.com/getting-started/sveltekit

Configures Lucia to use Prisma as the database adapter. Initializes a Prisma client and passes it to the Prisma adapter. This pattern varies based on the chosen database technology.

```typescript
// src/lib/server/lucia.ts
import { lucia } from "lucia";
import { sveltekit } from "lucia/middleware";
import { dev } from "$app/environment";
import { prisma } from "@lucia-auth/adapter-prisma";
import { PrismaClient } from "@prisma/client";

const client = new PrismaClient();

export const auth = lucia({
	env: dev ? "DEV" : "PROD",
	middleware: sveltekit(),
	adapter: prisma(client)
});
```

--------------------------------

### Add Web Crypto Polyfill to npm Scripts

Source: https://v2.lucia-auth.com/getting-started/fastify

Alternative approach to polyfilling Web Crypto API by adding experimental flag to npm scripts. Works with Fastify CLI commands.

```json
{
	"scripts": {
		"start": "NODE_OPTIONS=--experimental-global-webcrypto fastify start -l info app.js",
		"dev": "NODE_OPTIONS=--experimental-global-webcrypto npm run build && fastify start -w -l info -P app.js"
		// ...
	}
	// ...
}
```

--------------------------------

### Configure Remix for Lucia Dependencies (JavaScript)

Source: https://v2.lucia-auth.com/getting-started/remix

Configures the Remix project to bundle Lucia and its dependencies on the server side. This is required because Lucia is an ESM package. Add the adapter package being used. No inputs or outputs beyond configuration. Essential for Remix projects using Lucia.

```javascript
// remix.config.js

/** @type {import('@remix-run/dev').AppConfig} */
module.exports = {
	// ...
	serverDependenciesToBundle: [
		"lucia",
		"lucia/middleware",
		"lucia/polyfill/node",
		"@lucia-auth/adapter-prisma" // adapter you're using
	]
};
```

--------------------------------

### Initialize Lucia with SQLite Adapters

Source: https://v2.lucia-auth.com/migrate/v2/sqlite

Sets up Lucia v2 authentication with either better-sqlite3 or Cloudflare D1 adapter, defining custom table names. Requires 'lucia' and adapter packages installed. Returns a configured lucia instance for handling auth.

```javascript
import { lucia } from "lucia";
import { betterSqlite3 } from "@lucia-auth/adapter-sqlite";
import sqlite from "better-sqlite3";

const db = sqlite("main.db");

lucia({
	adapter: betterSqlite3(db, {
		user: "auth_user",
		key: "auth_key",
		session: "auth_session"
	})
	// ...
});
```

```javascript
import { lucia } from "lucia";
import { d1 } from "@lucia-auth/adapter-sqlite";

lucia({
	adapter: d1(db, {
		user: "auth_user",
		key: "auth_key",
		session: "auth_session"
	})
	// ...
});
//
```

--------------------------------

### Initialize Lucia with Fastify Middleware

Source: https://v2.lucia-auth.com/getting-started/fastify

Initializes Lucia authentication instance with Fastify middleware. Exports auth instance and its type for use in the application. Database adapter configuration is deferred to later steps.

```typescript
import { lucia } from "lucia";
import { fastify } from "lucia/middleware";

// expect error (see next section)
export const auth = lucia({
	env: "DEV", // "PROD" if deployed to HTTPS
	middleware: fastify()
});

export type Auth = typeof auth;
```

--------------------------------

### Initialize Lucia with SvelteKit Middleware

Source: https://v2.lucia-auth.com/getting-started/sveltekit

Sets up Lucia authentication instance with SvelteKit-specific middleware. Exports the configured auth instance and its TypeScript type for type safety. Note that a database adapter must be added in the next step.

```typescript
// src/lib/server/lucia.ts
import { lucia } from "lucia";
import { sveltekit } from "lucia/middleware";
import { dev } from "$app/environment";

// expect error (see next section)
export const auth = lucia({
	env: dev ? "DEV" : "PROD",
	middleware: sveltekit()
});

export type Auth = typeof auth;
```

--------------------------------

### PostgreSQL Setup with Kysely and Lucia (TypeScript)

Source: https://v2.lucia-auth.com/guidebook/kysely

Configures Kysely and Lucia for PostgreSQL using the `pg` package. Includes installing the package, creating a connection pool, and initializing both Kysely with `PostgresDialect` and Lucia with the `pg` adapter.

```typescript
npm install pg

```

```typescript
// db.ts
import { Pool } from "pg";
import { Kysely, PostgresDialect } from "kysely";

export const pool = new Pool({
	// ...
});

const dialect = new PostgresDialect({
	pool
});

export const db = new Kysely<Database>({
	dialect
});

```

```typescript
// lucia.ts
import { lucia } from "lucia";
import { pg } from "@lucia-auth/adapter-postgresql";

import { pool } from "./db.js";

export const auth = lucia({
	adapter: pg(pool, tableNames)
});

```

--------------------------------

### MySQL Setup with Kysely and Lucia (TypeScript)

Source: https://v2.lucia-auth.com/guidebook/kysely

Configures Kysely and Lucia for MySQL using the `mysql2` driver. Includes installing the package, creating a connection pool, and initializing both Kysely with `MysqlDialect` and Lucia with the `mysql2` adapter.

```typescript
npm install mysql2

```

```typescript
// db.ts
import { createPool } from "mysql2/promise";
import { Kysely, MysqlDialect } from "kysely";

export const pool = createPool({
	// ...
});

const dialect = new MysqlDialect({
	pool: pool.pool // IMPORTANT NOT TO JUST PASS `pool`
});

export const db = new Kysely<Database>({
	dialect
});

```

```typescript
// lucia.ts
import { lucia } from "lucia";
import { mysql2 } from "@lucia-auth/adapter-mysql";

import { pool } from "./db.js";

export const auth = lucia({
	adapter: mysql2(pool, tableNames)
});

```

--------------------------------

### Configure Lucia with PostgreSQL - JavaScript

Source: https://v2.lucia-auth.com/database-adapters/pg

Complete setup example for configuring Lucia with PostgreSQL adapter. Creates a connection pool, initializes the adapter with table names, and integrates with Lucia authentication system. Supports @vercel/postgres and @neondatabase/serverless.

```javascript
import { lucia } from "lucia";
import { pg } from "@lucia-auth/adapter-postgresql";
import postgres from "pg";

const pool = new postgres.Pool({
	connectionString: CONNECTION_URL
});

const auth = lucia({
	adapter: pg(pool, {
		user: "auth_user",
		key: "user_key",
		session: "user_session"
	})
	// ...
});
```

--------------------------------

### Polyfill with Node.js experimental flag

Source: https://v2.lucia-auth.com/getting-started/nextjs-app

Alternative polyfill method using Node.js experimental flags. Configure package.json scripts to include --experimental-global-webcrypto flag when running Next.js commands for Node.js 18 and below.

```json
// package.json
{
	// ...	"scripts": {
		"dev": "NODE_OPTIONS=--experimental-global-webcrypto next dev",
		"start": "NODE_OPTIONS=--experimental-global-webcrypto next start"
		// ...
	}
	// ...
}
```

--------------------------------

### Initialize Lucia with PostgreSQL adapter in JavaScript

Source: https://v2.lucia-auth.com/migrate/v2/postgresql

Import and configure Lucia authentication library with the PostgreSQL adapter using a connection pool. Requires installation of lucia, @lucia-auth/adapter-postgresql, and pg packages. Initializes the auth system with specified table names or defaults.

```javascript
import { lucia } from "lucia";
import { pg } from "@lucia-auth/adapter-postgresql";
import postgres from "pg";

const pool = new postgres.Pool({
  connectionString: CONNECTION_URL
});

lucia({
  adapter: pg(pool, {
    user: "auth_user",
    key: "auth_key",
    session: "auth_session"
  })
  // ...
});
```

--------------------------------

### SQLite Setup with Kysely and Lucia (TypeScript)

Source: https://v2.lucia-auth.com/guidebook/kysely

Configures Kysely and Lucia for SQLite using the `better-sqlite3` driver. Includes installing the package, creating a SQLite database instance, and initializing both Kysely with `SqliteDialect` and Lucia with the `betterSqlite3` adapter.

```typescript
npm install better-sqlite3

```

```typescript
// db.ts
import sqlite from "better-sqlite3";
import { Kysely, SqliteDialect } from "kysely";

export const sqliteDatabase = sqlite(/* ... */);

const dialect = new SqliteDialect({
	database: sqliteDatabase
});

export const db = new Kysely<Database>({
	dialect
});

```

```typescript
// lucia.ts
import { lucia } from "lucia";
import { betterSqlite3 } from "@lucia-auth/adapter-sqlite";

import { sqliteDatabase } from "./db.js";

const auth = lucia({
	adapter: betterSqlite3(sqliteDatabase, tableNames)
	// ...
});

```

--------------------------------

### Install Lucia Cloudflare D1 Adapter

Source: https://v2.lucia-auth.com/database-adapters/cloudflare-d1

Installs the necessary Lucia Auth adapter package for Cloudflare D1 using npm, pnpm, or yarn. Ensure you have Node.js and a package manager installed.

```bash
npm i @lucia-auth/adapter-sqlite

```

```bash
pnpm add @lucia-auth/adapter-sqlite

```

```bash
yarn add @lucia-auth/adapter-sqlite

```

--------------------------------

### Initialize Lucia in Nuxt API Module

Source: https://v2.lucia-auth.com/getting-started/nuxt

Initialize Lucia with the h3 middleware in a Nuxt API module. This sets up the core authentication instance. The adapter is configured in a subsequent step.

```typescript
// server/utils/lucia.ts
import { lucia } from "lucia";
import { h3 } from "lucia/middleware";

// expect error (see next section)
export const auth = lucia({
	env: process.dev ? "DEV" : "PROD",
	middleware: h3()
});

export type Auth = typeof auth;
```

--------------------------------

### Initialize Lucia in SolidStart

Source: https://v2.lucia-auth.com/getting-started/solidstart

Initialize Lucia by importing `lucia` and `web` middleware. Configure environment, middleware, and session cookie settings. This sets up the core authentication instance.

```typescript
// src/auth/lucia.ts
import { lucia } from "lucia";
import { web } from "lucia/middleware";

// expect error (see next section)
export const auth = lucia({
	env: process.env.NODE_ENV === "production" ? "PROD" : "DEV",
	middleware: web(),
	sessionCookie: {
		expires: false
	}
});

export type Auth = typeof auth;

```

--------------------------------

### Configure Nuxt Nitro for Side-Effect Imports

Source: https://v2.lucia-auth.com/getting-started/nuxt

Configure Nuxt's nitro build process to include side-effect imports like the Lucia Node.js polyfill. This prevents the import from being unexpectedly excluded during the build.

```typescript
// nuxt.config.ts
export default defineNuxtConfig({
	// ...
	nitro: {
		moduleSideEffects: ["lucia/polyfill/node"]
	}
});
```

--------------------------------

### Install Lucia

Source: https://v2.lucia-auth.com/getting-started/nextjs-pages

Installs the Lucia authentication library using npm, pnpm, or yarn.

```bash
npm i lucia

```

```bash
pnpm add lucia

```

```bash
yarn add lucia

```

--------------------------------

### Declare Lucia Types in Nuxt App

Source: https://v2.lucia-auth.com/getting-started/nuxt

Define Lucia's type extensions in a TypeScript declaration file. This allows for type safety when interacting with Lucia's `Auth` object and database user/session attributes.

```typescript
// server/app.d.ts
/// <reference types="lucia" />
declare namespace Lucia {
	type Auth = import("./utils/auth.js").Auth;
	type DatabaseUserAttributes = {};
	ttype DatabaseSessionAttributes = {};
}
```

--------------------------------

### Lucia Initialization (v2)

Source: https://v2.lucia-auth.com/migrate/v2

Shows how to initialize Lucia in version 2.

```javascript
const auth = lucia({
  adapter: adapter(), // no change
  env, // no change
  middleware: framework(), // no change

  // previously `transformDatabaseUser`
  getUserAttributes: (data) => {
    return {
      // IMPORTANT!!!!
      // `userId` included by default!!
      username: data.username
    };
  },

  // autoDatabaseCleanup: false, <= removed for now
  csrfProtection: {  // can be boolean
    allowedSubdomains: ["foo"]
  } // can be boolean
  // generateCustomUserId, <= removed, see `csrfProtection`
  passwordHash, // previously `hash`
  // origin, <= removed
  sessionCookie: {
    name: "user_session", // session cookie name
    attributes: {
      // moved previous `sessionCookie` value here
      sameSite: "strict"
    }
  },
  sessionExpiresIn // no change
});
```

--------------------------------

### Lucia Initialization (v1)

Source: https://v2.lucia-auth.com/migrate/v2

Shows how to initialize Lucia in version 1.

```javascript
const auth = lucia({
  adapter: adapter(),
  env,
  middleware: framework(),

  transformDatabaseUser = (data) => {
    return {
      userId: data.id,
      username: data.username
    };
  },

  autoDatabaseCleanup: false,
  csrfProtection: true,
  generateCustomUserId: () => generateRandomString(16),
  hash,
  origin: ["https://foo.example.com"],
  sessionCookie: {
    sameSite: "strict"
  },
  sessionExpiresIn
});
```

--------------------------------

### Initialize Lucia with better-sqlite3 Adapter (JavaScript)

Source: https://v2.lucia-auth.com/database-adapters/better-sqlite3

Example of initializing Lucia authentication with the better-sqlite3 adapter. It shows how to import necessary modules, create a database instance, and configure the adapter with table names.

```javascript
import { lucia } from "lucia";
import { betterSqlite3 } from "@lucia-auth/adapter-sqlite";
import sqlite from "better-sqlite3";

const db = sqlite("main.db");

const auth = lucia({
	adapter: betterSqlite3(db, {
		user: "user",
		key: "user_key",
		session: "user_session"
	})
	// ...
});
```

--------------------------------

### Initialize Lucia Authentication (TypeScript)

Source: https://v2.lucia-auth.com/getting-started/remix

Initializes the Lucia authentication instance using the web middleware for Remix. Pass the environment and set session cookie expiration to false. For database, add an adapter (example shows Prisma). Provides auth instance and type for use in the application. Limitations: Specific to Remix's web environment.

```typescript
// auth/lucia.server.ts
import { lucia } from "lucia";
import { web } from "lucia/middleware";

// expect error (see next section)
export const auth = lucia({
	env: process.dev ? "DEV" : "PROD",
	middleware: web(),
	sessionCookie: {
		expires: false
	}
});

export type Auth = typeof auth;
```

```typescript
// auth/lucia.server.ts
import { lucia } from "lucia";
import { web } from "lucia/middleware";
import { prisma } from "@lucia-auth/adapter-prisma";
import { PrismaClient } from "@prisma/client";

const client = new PrismaClient();

const auth = lucia({
	env: "DEV", // "PROD" if deployed to HTTPS
	middleware: web(),
	sessionCookie: {
		expires: false
	},

	adapter: prisma(client)
});
```

--------------------------------

### Clone Nuxt GitHub OAuth Example

Source: https://v2.lucia-auth.com/guidebook/github-oauth/nuxt

Clones the Nuxt example project with GitHub OAuth pre-configured. This provides a quick start for implementing the authentication flow.

```bash
npx degit lucia-auth/examples/nuxt/github-oauth <directory_name>
```

--------------------------------

### Clone Next.js GitHub OAuth Example

Source: https://v2.lucia-auth.com/guidebook/github-oauth/nextjs-pages

Clones the Next.js example project for GitHub OAuth integration with Lucia. This provides a pre-configured starting point for the implementation.

```bash
npx degit lucia-auth/examples/nextjs-pages/github-oauth <directory_name>
```

--------------------------------

### Clone Astro GitHub OAuth Example

Source: https://v2.lucia-auth.com/guidebook/github-oauth/astro

Clones the Astro example project for GitHub OAuth integration using the degit tool. This provides a starting point for implementing the authentication flow.

```bash
npx degit lucia-auth/examples/astro/github-oauth <directory_name>
```

--------------------------------

### Create Key (v1)

Source: https://v2.lucia-auth.com/migrate/v2

Shows how to create a key in Lucia v1.

```javascript
await auth.createKey(userId, {
  // ...
});
```

--------------------------------

### Clone Next.js Example Project

Source: https://v2.lucia-auth.com/guidebook/sign-in-with-username-and-password/nextjs-app

Clones a Next.js example project with username and password authentication using the degit tool. This is a quick way to start an implementation.

```shell
npx degit lucia-auth/examples/nextjs-app/username-and-password <directory_name>
```

--------------------------------

### Install ioredis Session Adapter for Lucia Auth

Source: https://v2.lucia-auth.com/database-adapters/ioredis

These commands show how to install the `@lucia-auth/adapter-session-redis` package using npm, pnpm, and yarn. This package provides the ioredis session adapter for Lucia Auth.

```bash
npm i @lucia-auth/adapter-session-redis
pnpm add @lucia-auth/adapter-session-redis
yarn add @lucia-auth/adapter-session-redis
```

--------------------------------

### Install MySQL adapter for Lucia v2

Source: https://v2.lucia-auth.com/migrate/v2/mysql

Install the latest version of the MySQL adapter package for Lucia v2 using npm, pnpm, or yarn. This is required to use Lucia with MySQL databases.

```shell
npm i @lucia-auth/adapter-mysql@latest
```

```shell
pnpm add @lucia-auth/adapter-mysql@latest
```

```shell
yarn add @lucia-auth/adapter-mysql@latest
```

--------------------------------

### Create Key (v2)

Source: https://v2.lucia-auth.com/migrate/v2

Shows how to create a key in Lucia v2.

```javascript
await auth.createKey({
  userId
  // ...
});
```

--------------------------------

### Configure ESM in tsconfig.json

Source: https://v2.lucia-auth.com/getting-started/fastify

Configures TypeScript compiler options for ESM module resolution. Required for proper Lucia integration in TypeScript projects.

```json
{
	"compilerOptions": {
		"module": "ESNext", // "ES2022" etc
		"moduleResolution": "NodeNext" // "Node", "Node16"
		// ...
	}
	// ...
}
```

--------------------------------

### Install mysql2 Lucia Adapter

Source: https://v2.lucia-auth.com/database-adapters/mysql2

Provides commands to install the mysql2 adapter for Lucia Auth using npm, pnpm, and yarn package managers.

```bash
npm i @lucia-auth/adapter-mysql

```

```bash
pnpm add @lucia-auth/adapter-mysql

```

```bash
yarn add @lucia-auth/adapter-mysql

```

--------------------------------

### Type Locals for Lucia in Astro

Source: https://v2.lucia-auth.com/getting-started/astro

Extend the App.Locals interface to include the AuthRequest type for Lucia, ensuring type safety in your middleware and routes.

```typescript
// src/env.d.ts
/// <reference types="lucia" />
declare namespace Lucia {
	// ...
}

/// <reference types="astro/client" />
declare namespace App {
	interface Locals {
		auth: import("lucia").AuthRequest;
	}
}
```

--------------------------------

### Declare Lucia Types in Astro

Source: https://v2.lucia-auth.com/getting-started/astro

Declare Lucia namespace and types in your env.d.ts file to ensure type safety across your Astro project.

```typescript
// src/env.d.ts
/// <reference types="lucia" />
declare namespace Lucia {
	type Auth = import("./lib/lucia").Auth;
	type DatabaseUserAttributes = {};
	type DatabaseSessionAttributes = {};
}
```

--------------------------------

### Enable Web Crypto via CLI Flag

Source: https://v2.lucia-auth.com/getting-started/solidstart

Alternatively, enable the Web Crypto API by using the `--experimental-global-webcrypto` flag in your `package.json` scripts for development, build, and start commands.

```json
{
	// ...
	"scripts": {
		"dev": "NODE_OPTIONS=--experimental-global-webcrypto solid-start dev",
		"build": "NODE_OPTIONS=--experimental-global-webcrypto solid-start build",
		"start": "NODE_OPTIONS=--experimental-global-webcrypto solid-start start"
		// ...
	}
	// ...
}

```

--------------------------------

### Type SvelteKit Locals for Lucia

Source: https://v2.lucia-auth.com/getting-started/sveltekit

Extends SvelteKit's App.Locals interface to include the Lucia AuthRequest type. This provides TypeScript support for accessing auth from event.locals in server-side code.

```typescript
// src/app.d.ts
declare global {
	namespace App {
		interface Locals {
			auth: import("lucia").AuthRequest;
		}
	}
}
```

--------------------------------

### Install PlanetScale Adapter (npm/pnpm/yarn)

Source: https://v2.lucia-auth.com/database-adapters/planetscale-serverless

Provides the necessary commands to install the `@lucia-auth/adapter-mysql` package using different package managers (npm, pnpm, yarn). This dependency is required for using the PlanetScale adapter.

```bash
npm i @lucia-auth/adapter-mysql
pnpm add @lucia-auth/adapter-mysql
yarn add @lucia-auth/adapter-mysql
```

--------------------------------

### Configure Lucia Auth with libSQL Adapter

Source: https://v2.lucia-auth.com/database-adapters/libsql

Demonstrates how to initialize Lucia Auth with the libSQL adapter. It shows creating a libSQL client and passing it along with table names to the adapter configuration.

```typescript
import { lucia } from "lucia";
import { libsql } from "@lucia-auth/adapter-sqlite";
import { createClient } from "@libsql/client";

const db = createClient({
	url: "file:test/main.db"
});

const auth = lucia({
	adapter: libsql(db, {
		user: "user",
		key: "user_key",
		session: "user_session"
	})
	// ...
});
```

--------------------------------

### Clone SvelteKit example project

Source: https://v2.lucia-auth.com/guidebook/sign-in-with-username-and-password/sveltekit

This shell command clones a pre-built SvelteKit example project from Lucia's repository using degit. Replace <directory_name> with your desired folder name. No dependencies are required as degit is a Node.js tool.

```shell
npx degit lucia-auth/examples/sveltekit/username-and-password <directory_name>
```

--------------------------------

### Install libSQL Adapter for Lucia Auth

Source: https://v2.lucia-auth.com/database-adapters/libsql

Installs the libSQL adapter for Lucia Auth using npm, pnpm, or yarn. This package is necessary for connecting Lucia Auth to libSQL databases.

```bash
npm i @lucia-auth/adapter-sqlite
pnpm add @lucia-auth/adapter-sqlite
yarn add @lucia-auth/adapter-sqlite
```

--------------------------------

### Create Session (v1)

Source: https://v2.lucia-auth.com/migrate/v2

Shows how to create a session in Lucia v1.

```javascript
await auth.createSession(userId);
```

--------------------------------

### Declare Lucia TypeScript Types (TypeScript)

Source: https://v2.lucia-auth.com/getting-started/remix

Creates a declaration file to define Lucia types, including Auth, DatabaseUserAttributes, and DatabaseSessionAttributes. This enables type safety in the Remix project. No dependencies or limitations mentioned.

```typescript
// app.d.ts
/// <reference types="lucia" />
declare namespace Lucia {
	type Auth = import("./auth/lucia.server.js").Auth;
	type DatabaseUserAttributes = {};
	type DatabaseSessionAttributes = {};
}
```
Tokens:
Raw