@mrgnw/anahtar 0.0.6

package/dist/components/PasskeyPrompt.svelte

@@ -0,0 +1,168 @@
+<script lang="ts">
+import { onDestroy } from 'svelte';
+
+interface Props {
+	countdownSeconds?: number;
+	onRegister: () => Promise<void>;
+	onSkip: () => void;
+}
+
+let { countdownSeconds = 3, onRegister, onSkip }: Props = $props();
+
+let countdown = $state(countdownSeconds);
+let failed = $state(false);
+let registering = $state(false);
+
+let interval = setInterval(() => {
+	countdown -= 1;
+	if (countdown <= 0) {
+		clearInterval(interval);
+		triggerRegistration();
+	}
+}, 1000);
+
+onDestroy(() => {
+	if (interval) clearInterval(interval);
+});
+
+async function triggerRegistration() {
+	if (registering) return;
+	registering = true;
+	try {
+		await onRegister();
+	} catch {
+		failed = true;
+	} finally {
+		registering = false;
+	}
+}
+
+let circumference = 2 * Math.PI * 40;
+let dashOffset = $derived(circumference * (1 - countdown / countdownSeconds));
+</script>
+
+<div class="anahtar-passkey-prompt">
+	<div class="anahtar-passkey-ring">
+		<svg viewBox="0 0 100 100" class="anahtar-passkey-ring-svg">
+			<circle cx="50" cy="50" r="40" fill="none" stroke="var(--anahtar-border, #d1d5db)" stroke-width="4" />
+			<circle
+				cx="50" cy="50" r="40"
+				fill="none"
+				stroke="var(--anahtar-primary, #3b82f6)"
+				stroke-width="4"
+				stroke-linecap="round"
+				stroke-dasharray={circumference}
+				stroke-dashoffset={dashOffset}
+				class="anahtar-passkey-progress"
+			/>
+		</svg>
+		<div class="anahtar-passkey-icon">
+			<svg xmlns="http://www.w3.org/2000/svg" width="28" height="28" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round" class="anahtar-key-pulse">
+				<circle cx="7.5" cy="15.5" r="5.5"/>
+				<path d="m11.5 12 4-4"/>
+				<path d="m15 7 2 2"/>
+				<path d="m17.5 4.5 2 2"/>
+			</svg>
+		</div>
+	</div>
+
+	{#if !failed}
+		<p class="anahtar-passkey-title">Making you a passkey</p>
+		<p class="anahtar-passkey-subtitle">for easier login</p>
+		<button onclick={onSkip} class="anahtar-passkey-skip">Skip</button>
+	{:else}
+		<p class="anahtar-passkey-title">Set up a passkey?</p>
+		<button onclick={triggerRegistration} class="anahtar-passkey-add" disabled={registering}>
+			Add passkey
+		</button>
+		<button onclick={onSkip} class="anahtar-passkey-skip">Maybe later</button>
+	{/if}
+</div>
+
+<style>
+	.anahtar-passkey-prompt {
+		display: flex;
+		flex-direction: column;
+		align-items: center;
+	}
+
+	.anahtar-passkey-ring {
+		position: relative;
+		width: 7rem;
+		height: 7rem;
+		margin-bottom: 1.5rem;
+	}
+
+	.anahtar-passkey-ring-svg {
+		width: 100%;
+		height: 100%;
+		transform: rotate(-90deg);
+	}
+
+	.anahtar-passkey-progress {
+		transition: stroke-dashoffset 1s linear;
+	}
+
+	.anahtar-passkey-icon {
+		position: absolute;
+		inset: 0;
+		display: flex;
+		align-items: center;
+		justify-content: center;
+	}
+
+	@keyframes key-pulse {
+		0%, 100% { filter: drop-shadow(0 0 0 transparent); opacity: 0.8; }
+		50% { filter: drop-shadow(0 0 8px var(--anahtar-primary, #3b82f6)); opacity: 1; }
+	}
+
+	.anahtar-key-pulse {
+		animation: key-pulse 2s ease-in-out infinite;
+	}
+
+	.anahtar-passkey-title {
+		font-size: 0.875rem;
+		font-weight: 500;
+		margin-bottom: 0.25rem;
+	}
+
+	.anahtar-passkey-subtitle {
+		font-size: 0.875rem;
+		opacity: 0.6;
+		margin-bottom: 1.5rem;
+	}
+
+	.anahtar-passkey-add {
+		width: 100%;
+		padding: 0.5rem;
+		font-size: 0.875rem;
+		font-weight: 500;
+		border-radius: 0.375rem;
+		background: var(--anahtar-primary, #3b82f6);
+		color: var(--anahtar-primary-fg, #fff);
+		border: none;
+		cursor: pointer;
+		margin-bottom: 0.75rem;
+	}
+
+	.anahtar-passkey-add:hover {
+		opacity: 0.9;
+	}
+
+	.anahtar-passkey-add:disabled {
+		opacity: 0.5;
+	}
+
+	.anahtar-passkey-skip {
+		font-size: 0.75rem;
+		opacity: 0.6;
+		background: none;
+		border: none;
+		cursor: pointer;
+		color: inherit;
+	}
+
+	.anahtar-passkey-skip:hover {
+		opacity: 1;
+	}
+</style>

package/dist/components/PasskeyPrompt.svelte.d.ts

@@ -0,0 +1,8 @@
+interface Props {
+    countdownSeconds?: number;
+    onRegister: () => Promise<void>;
+    onSkip: () => void;
+}
+declare const PasskeyPrompt: import("svelte").Component<Props, {}, "">;
+type PasskeyPrompt = ReturnType<typeof PasskeyPrompt>;
+export default PasskeyPrompt;

package/dist/components/index.d.ts

@@ -0,0 +1,4 @@
+export { guessDeviceName } from '../device.js';
+export { default as AuthFlow } from './AuthFlow.svelte';
+export { default as OtpInput } from './OtpInput.svelte';
+export { default as PasskeyPrompt } from './PasskeyPrompt.svelte';

package/dist/components/index.js

@@ -0,0 +1,4 @@
+export { guessDeviceName } from '../device.js';
+export { default as AuthFlow } from './AuthFlow.svelte';
+export { default as OtpInput } from './OtpInput.svelte';
+export { default as PasskeyPrompt } from './PasskeyPrompt.svelte';

package/dist/config.d.ts

@@ -0,0 +1,2 @@
+import type { AuthConfig, ResolvedConfig } from './types.js';
+export declare function resolveConfig(config: AuthConfig): ResolvedConfig;

package/dist/config.js

@@ -0,0 +1,15 @@
+const DEFAULTS = {
+    tablePrefix: 'auth_',
+    cookie: 'session',
+    sessionDuration: 30 * 24 * 60 * 60 * 1000,
+    otpExpiry: 30 * 60 * 1000,
+    otpLength: 5,
+    otpMaxAttempts: 5,
+    rpName: 'anahtar',
+};
+export function resolveConfig(config) {
+    return {
+        ...DEFAULTS,
+        ...config,
+    };
+}

package/dist/db/d1.d.ts

@@ -0,0 +1,22 @@
+import type { AuthDB } from '../types.js';
+interface D1Database {
+    prepare(sql: string): D1PreparedStatement;
+    exec(sql: string): Promise<unknown>;
+}
+interface D1PreparedStatement {
+    bind(...values: unknown[]): D1PreparedStatement;
+    first<T = Record<string, unknown>>(): Promise<T | null>;
+    all<T = Record<string, unknown>>(): Promise<{
+        results: T[];
+    }>;
+    run(): Promise<{
+        meta: {
+            changes: number;
+        };
+    }>;
+}
+interface D1AdapterOptions {
+    tablePrefix?: string;
+}
+export declare function d1Adapter(db: D1Database, options?: D1AdapterOptions): AuthDB;
+export {};

package/dist/db/d1.js

@@ -0,0 +1,202 @@
+export function d1Adapter(db, options = {}) {
+    const p = options.tablePrefix ?? 'auth_';
+    const t = {
+        users: `${p}users`,
+        sessions: `${p}sessions`,
+        otpCodes: `${p}otp_codes`,
+        passkeys: `${p}passkeys`,
+        challenges: `${p}challenges`
+    };
+    return {
+        async init() {
+            await db
+                .prepare(`CREATE TABLE IF NOT EXISTS ${t.users} (
+				id TEXT PRIMARY KEY, email TEXT UNIQUE NOT NULL,
+				skip_passkey_prompt INTEGER DEFAULT 0, created_at INTEGER DEFAULT (unixepoch())
+			)`)
+                .run();
+            await db
+                .prepare(`CREATE TABLE IF NOT EXISTS ${t.sessions} (
+				id TEXT PRIMARY KEY, user_id TEXT NOT NULL REFERENCES ${t.users}(id),
+				expires_at INTEGER NOT NULL, created_at INTEGER DEFAULT (unixepoch())
+			)`)
+                .run();
+            await db
+                .prepare(`CREATE TABLE IF NOT EXISTS ${t.otpCodes} (
+				id TEXT PRIMARY KEY, email TEXT NOT NULL, code TEXT NOT NULL,
+				attempts INTEGER NOT NULL DEFAULT 0, expires_at INTEGER NOT NULL,
+				created_at INTEGER DEFAULT (unixepoch())
+			)`)
+                .run();
+            await db
+                .prepare(`CREATE TABLE IF NOT EXISTS ${t.passkeys} (
+				id TEXT PRIMARY KEY, user_id TEXT NOT NULL REFERENCES ${t.users}(id),
+				credential_id TEXT UNIQUE NOT NULL, public_key BLOB NOT NULL,
+				counter INTEGER NOT NULL DEFAULT 0, transports TEXT, name TEXT,
+				created_at INTEGER DEFAULT (unixepoch())
+			)`)
+                .run();
+            await db
+                .prepare(`CREATE TABLE IF NOT EXISTS ${t.challenges} (
+				challenge TEXT PRIMARY KEY, user_id TEXT NOT NULL,
+				expires_at INTEGER NOT NULL, created_at INTEGER DEFAULT (unixepoch())
+			)`)
+                .run();
+        },
+        async getUserByEmail(email) {
+            const row = await db
+                .prepare(`SELECT id, email, skip_passkey_prompt, created_at FROM ${t.users} WHERE email = ?`)
+                .bind(email)
+                .first();
+            if (!row)
+                return null;
+            return {
+                id: row.id,
+                email: row.email,
+                skipPasskeyPrompt: row.skip_passkey_prompt === 1,
+                createdAt: row.created_at
+            };
+        },
+        async createUser(email) {
+            const id = crypto.randomUUID();
+            await db.prepare(`INSERT INTO ${t.users} (id, email) VALUES (?, ?)`).bind(id, email).run();
+            return {
+                id,
+                email,
+                skipPasskeyPrompt: false,
+                createdAt: Math.floor(Date.now() / 1000)
+            };
+        },
+        async setSkipPasskeyPrompt(userId, skip) {
+            await db
+                .prepare(`UPDATE ${t.users} SET skip_passkey_prompt = ? WHERE id = ?`)
+                .bind(skip ? 1 : 0, userId)
+                .run();
+        },
+        async createSession(tokenHash, userId, expiresAt) {
+            await db
+                .prepare(`INSERT INTO ${t.sessions} (id, user_id, expires_at) VALUES (?, ?, ?)`)
+                .bind(tokenHash, userId, expiresAt)
+                .run();
+        },
+        async getSession(tokenHash) {
+            const row = await db
+                .prepare(`SELECT s.id, s.user_id, s.expires_at, u.email
+					FROM ${t.sessions} s
+					JOIN ${t.users} u ON u.id = s.user_id
+					WHERE s.id = ?`)
+                .bind(tokenHash)
+                .first();
+            if (!row)
+                return null;
+            return {
+                id: row.id,
+                userId: row.user_id,
+                expiresAt: row.expires_at,
+                email: row.email
+            };
+        },
+        async deleteSession(tokenHash) {
+            await db.prepare(`DELETE FROM ${t.sessions} WHERE id = ?`).bind(tokenHash).run();
+        },
+        async storeOTP(email, id, code, expiresAt) {
+            await db
+                .prepare(`INSERT INTO ${t.otpCodes} (id, email, code, expires_at) VALUES (?, ?, ?, ?)`)
+                .bind(id, email, code, expiresAt)
+                .run();
+        },
+        async getLatestOTP(email) {
+            const row = await db
+                .prepare(`SELECT id, email, code, attempts, expires_at FROM ${t.otpCodes} WHERE email = ? ORDER BY created_at DESC LIMIT 1`)
+                .bind(email)
+                .first();
+            if (!row)
+                return null;
+            return {
+                id: row.id,
+                email: row.email,
+                code: row.code,
+                attempts: row.attempts,
+                expiresAt: row.expires_at
+            };
+        },
+        async updateOTPAttempts(id, attempts) {
+            await db.prepare(`UPDATE ${t.otpCodes} SET attempts = ? WHERE id = ?`).bind(attempts, id).run();
+        },
+        async deleteOTP(id) {
+            await db.prepare(`DELETE FROM ${t.otpCodes} WHERE id = ?`).bind(id).run();
+        },
+        async deleteOTPsForEmail(email) {
+            await db.prepare(`DELETE FROM ${t.otpCodes} WHERE email = ?`).bind(email).run();
+        },
+        async storeChallenge(challenge, userId, expiresAt) {
+            await db.prepare(`DELETE FROM ${t.challenges} WHERE expires_at < ?`).bind(Date.now()).run();
+            await db
+                .prepare(`INSERT INTO ${t.challenges} (challenge, user_id, expires_at) VALUES (?, ?, ?)`)
+                .bind(challenge, userId, expiresAt)
+                .run();
+        },
+        async consumeChallenge(challenge) {
+            const row = await db
+                .prepare(`SELECT user_id, expires_at FROM ${t.challenges} WHERE challenge = ?`)
+                .bind(challenge)
+                .first();
+            if (!row)
+                return null;
+            await db.prepare(`DELETE FROM ${t.challenges} WHERE challenge = ?`).bind(challenge).run();
+            if (row.expires_at < Date.now())
+                return null;
+            return { userId: row.user_id };
+        },
+        async getPasskeyByCredentialId(credentialId) {
+            const row = await db
+                .prepare(`SELECT p.id, p.user_id, p.credential_id, p.public_key, p.counter, p.transports, p.name, p.created_at, u.email
+					FROM ${t.passkeys} p
+					JOIN ${t.users} u ON u.id = p.user_id
+					WHERE p.credential_id = ?`)
+                .bind(credentialId)
+                .first();
+            if (!row)
+                return null;
+            return {
+                id: row.id,
+                userId: row.user_id,
+                credentialId: row.credential_id,
+                publicKey: new Uint8Array(row.public_key),
+                counter: row.counter,
+                transports: row.transports,
+                name: row.name,
+                createdAt: row.created_at,
+                email: row.email
+            };
+        },
+        async getUserPasskeys(userId) {
+            const { results } = await db
+                .prepare(`SELECT id, credential_id, public_key, counter, transports, name, created_at FROM ${t.passkeys} WHERE user_id = ?`)
+                .bind(userId)
+                .all();
+            return results.map((row) => ({
+                id: row.id,
+                credentialId: row.credential_id,
+                publicKey: new Uint8Array(row.public_key),
+                counter: row.counter,
+                transports: row.transports,
+                name: row.name,
+                createdAt: row.created_at
+            }));
+        },
+        async storePasskey(passkey) {
+            await db
+                .prepare(`INSERT INTO ${t.passkeys} (id, user_id, credential_id, public_key, counter, transports, name) VALUES (?, ?, ?, ?, ?, ?, ?)`)
+                .bind(passkey.id, passkey.userId, passkey.credentialId, passkey.publicKey, passkey.counter, passkey.transports, passkey.name)
+                .run();
+        },
+        async updatePasskeyCounter(id, counter) {
+            await db.prepare(`UPDATE ${t.passkeys} SET counter = ? WHERE id = ?`).bind(counter, id).run();
+        },
+        async deletePasskey(id, userId) {
+            const result = await db.prepare(`DELETE FROM ${t.passkeys} WHERE id = ? AND user_id = ?`).bind(id, userId).run();
+            return result.meta.changes > 0;
+        }
+    };
+}

package/dist/db/postgres.d.ts

@@ -0,0 +1,12 @@
+import type { AuthDB } from '../types.js';
+interface PgPool {
+    query(text: string, values?: unknown[]): Promise<{
+        rows: Record<string, unknown>[];
+        rowCount: number | null;
+    }>;
+}
+interface PostgresAdapterOptions {
+    tablePrefix?: string;
+}
+export declare function postgresAdapter(pool: PgPool, options?: PostgresAdapterOptions): AuthDB;
+export {};

package/dist/db/postgres.js

@@ -0,0 +1,204 @@
+import { randomUUID } from 'node:crypto';
+export function postgresAdapter(pool, options = {}) {
+    const p = options.tablePrefix ?? 'auth_';
+    const t = {
+        users: `${p}users`,
+        sessions: `${p}sessions`,
+        otpCodes: `${p}otp_codes`,
+        passkeys: `${p}passkeys`,
+        challenges: `${p}challenges`
+    };
+    async function queryOne(text, values) {
+        const { rows } = await pool.query(text, values);
+        return rows[0];
+    }
+    async function queryAll(text, values) {
+        const { rows } = await pool.query(text, values);
+        return rows;
+    }
+    return {
+        async init() {
+            await pool.query(`
+				CREATE TABLE IF NOT EXISTS ${t.users} (
+					id TEXT PRIMARY KEY,
+					email TEXT UNIQUE NOT NULL,
+					skip_passkey_prompt BOOLEAN DEFAULT FALSE,
+					created_at TIMESTAMPTZ DEFAULT NOW()
+				);
+				CREATE TABLE IF NOT EXISTS ${t.sessions} (
+					id TEXT PRIMARY KEY,
+					user_id TEXT NOT NULL REFERENCES ${t.users}(id),
+					expires_at BIGINT NOT NULL,
+					created_at TIMESTAMPTZ DEFAULT NOW()
+				);
+				CREATE TABLE IF NOT EXISTS ${t.otpCodes} (
+					id TEXT PRIMARY KEY,
+					email TEXT NOT NULL,
+					code TEXT NOT NULL,
+					attempts INTEGER NOT NULL DEFAULT 0,
+					expires_at BIGINT NOT NULL,
+					created_at TIMESTAMPTZ DEFAULT NOW()
+				);
+				CREATE TABLE IF NOT EXISTS ${t.passkeys} (
+					id TEXT PRIMARY KEY,
+					user_id TEXT NOT NULL REFERENCES ${t.users}(id),
+					credential_id TEXT UNIQUE NOT NULL,
+					public_key BYTEA NOT NULL,
+					counter INTEGER NOT NULL DEFAULT 0,
+					transports TEXT,
+					name TEXT,
+					created_at TIMESTAMPTZ DEFAULT NOW()
+				);
+				CREATE TABLE IF NOT EXISTS ${t.challenges} (
+					challenge TEXT PRIMARY KEY,
+					user_id TEXT NOT NULL,
+					expires_at BIGINT NOT NULL,
+					created_at TIMESTAMPTZ DEFAULT NOW()
+				);
+			`);
+        },
+        async getUserByEmail(email) {
+            const row = await queryOne(`SELECT id, email, skip_passkey_prompt, created_at FROM ${t.users} WHERE email = $1`, [email]);
+            if (!row)
+                return null;
+            return {
+                id: row.id,
+                email: row.email,
+                skipPasskeyPrompt: row.skip_passkey_prompt,
+                createdAt: new Date(row.created_at).getTime()
+            };
+        },
+        async createUser(email) {
+            const id = randomUUID();
+            await pool.query(`INSERT INTO ${t.users} (id, email) VALUES ($1, $2)`, [id, email]);
+            return {
+                id,
+                email,
+                skipPasskeyPrompt: false,
+                createdAt: Date.now()
+            };
+        },
+        async setSkipPasskeyPrompt(userId, skip) {
+            await pool.query(`UPDATE ${t.users} SET skip_passkey_prompt = $1 WHERE id = $2`, [skip, userId]);
+        },
+        async createSession(tokenHash, userId, expiresAt) {
+            await pool.query(`INSERT INTO ${t.sessions} (id, user_id, expires_at) VALUES ($1, $2, $3)`, [
+                tokenHash,
+                userId,
+                expiresAt
+            ]);
+        },
+        async getSession(tokenHash) {
+            const row = await queryOne(`SELECT s.id, s.user_id, s.expires_at, u.email
+				FROM ${t.sessions} s
+				JOIN ${t.users} u ON u.id = s.user_id
+				WHERE s.id = $1`, [tokenHash]);
+            if (!row)
+                return null;
+            return {
+                id: row.id,
+                userId: row.user_id,
+                expiresAt: Number(row.expires_at),
+                email: row.email
+            };
+        },
+        async deleteSession(tokenHash) {
+            await pool.query(`DELETE FROM ${t.sessions} WHERE id = $1`, [tokenHash]);
+        },
+        async storeOTP(email, id, code, expiresAt) {
+            await pool.query(`INSERT INTO ${t.otpCodes} (id, email, code, expires_at) VALUES ($1, $2, $3, $4)`, [
+                id,
+                email,
+                code,
+                expiresAt
+            ]);
+        },
+        async getLatestOTP(email) {
+            const row = await queryOne(`SELECT id, email, code, attempts, expires_at FROM ${t.otpCodes} WHERE email = $1 ORDER BY created_at DESC LIMIT 1`, [email]);
+            if (!row)
+                return null;
+            return {
+                id: row.id,
+                email: row.email,
+                code: row.code,
+                attempts: row.attempts,
+                expiresAt: Number(row.expires_at)
+            };
+        },
+        async updateOTPAttempts(id, attempts) {
+            await pool.query(`UPDATE ${t.otpCodes} SET attempts = $1 WHERE id = $2`, [attempts, id]);
+        },
+        async deleteOTP(id) {
+            await pool.query(`DELETE FROM ${t.otpCodes} WHERE id = $1`, [id]);
+        },
+        async deleteOTPsForEmail(email) {
+            await pool.query(`DELETE FROM ${t.otpCodes} WHERE email = $1`, [email]);
+        },
+        async storeChallenge(challenge, userId, expiresAt) {
+            await pool.query(`DELETE FROM ${t.challenges} WHERE expires_at < $1`, [Date.now()]);
+            await pool.query(`INSERT INTO ${t.challenges} (challenge, user_id, expires_at) VALUES ($1, $2, $3)`, [
+                challenge,
+                userId,
+                expiresAt
+            ]);
+        },
+        async consumeChallenge(challenge) {
+            const row = await queryOne(`SELECT user_id, expires_at FROM ${t.challenges} WHERE challenge = $1`, [challenge]);
+            if (!row)
+                return null;
+            await pool.query(`DELETE FROM ${t.challenges} WHERE challenge = $1`, [challenge]);
+            if (Number(row.expires_at) < Date.now())
+                return null;
+            return { userId: row.user_id };
+        },
+        async getPasskeyByCredentialId(credentialId) {
+            const row = await queryOne(`SELECT p.id, p.user_id, p.credential_id, p.public_key, p.counter, p.transports, p.name, p.created_at, u.email
+				FROM ${t.passkeys} p
+				JOIN ${t.users} u ON u.id = p.user_id
+				WHERE p.credential_id = $1`, [credentialId]);
+            if (!row)
+                return null;
+            return {
+                id: row.id,
+                userId: row.user_id,
+                credentialId: row.credential_id,
+                publicKey: new Uint8Array(row.public_key),
+                counter: row.counter,
+                transports: row.transports,
+                name: row.name,
+                createdAt: new Date(row.created_at).getTime(),
+                email: row.email
+            };
+        },
+        async getUserPasskeys(userId) {
+            const rows = await queryAll(`SELECT id, credential_id, public_key, counter, transports, name, created_at FROM ${t.passkeys} WHERE user_id = $1`, [userId]);
+            return rows.map((row) => ({
+                id: row.id,
+                credentialId: row.credential_id,
+                publicKey: new Uint8Array(row.public_key),
+                counter: row.counter,
+                transports: row.transports,
+                name: row.name,
+                createdAt: new Date(row.created_at).getTime()
+            }));
+        },
+        async storePasskey(passkey) {
+            await pool.query(`INSERT INTO ${t.passkeys} (id, user_id, credential_id, public_key, counter, transports, name) VALUES ($1, $2, $3, $4, $5, $6, $7)`, [
+                passkey.id,
+                passkey.userId,
+                passkey.credentialId,
+                Buffer.from(passkey.publicKey),
+                passkey.counter,
+                passkey.transports,
+                passkey.name
+            ]);
+        },
+        async updatePasskeyCounter(id, counter) {
+            await pool.query(`UPDATE ${t.passkeys} SET counter = $1 WHERE id = $2`, [counter, id]);
+        },
+        async deletePasskey(id, userId) {
+            const result = await pool.query(`DELETE FROM ${t.passkeys} WHERE id = $1 AND user_id = $2`, [id, userId]);
+            return (result.rowCount ?? 0) > 0;
+        }
+    };
+}

package/dist/db/sqlite.d.ts

@@ -0,0 +1,7 @@
+import type Database from 'better-sqlite3';
+import type { AuthDB } from '../types.js';
+interface SqliteAdapterOptions {
+    tablePrefix?: string;
+}
+export declare function sqliteAdapter(db: Database.Database, options?: SqliteAdapterOptions): AuthDB;
+export {};