@alliance-droid/svelte-auth-core 1.0.0

package/src/adapter-context.ts

@@ -0,0 +1,72 @@
+import type { DatabaseAdapter } from './adapters/adapter';
+import { FileSystemAdapter } from './adapters/filesystem-adapter';
+
+/**
+ * Global adapter context
+ * Manages the active database adapter instance
+ */
+class AdapterContext {
+	private adapter: DatabaseAdapter | null = null;
+
+	/**
+	 * Set the database adapter
+	 */
+	setAdapter(adapter: DatabaseAdapter): void {
+		this.adapter = adapter;
+	}
+
+	/**
+	 * Get the current database adapter
+	 * Throws if no adapter is set
+	 */
+	getAdapter(): DatabaseAdapter {
+		if (!this.adapter) {
+			throw new Error(
+				'Database adapter not initialized. Call initializeAdapter() first.'
+			);
+		}
+		return this.adapter;
+	}
+
+	/**
+	 * Check if adapter is initialized
+	 */
+	isInitialized(): boolean {
+		return this.adapter !== null;
+	}
+}
+
+// Global singleton instance
+const context = new AdapterContext();
+
+/**
+ * Initialize the database adapter
+ * Must be called before any auth operations
+ */
+export async function initializeAdapter(adapter: DatabaseAdapter): Promise<void> {
+	context.setAdapter(adapter);
+	await adapter.initialize();
+}
+
+/**
+ * Initialize with the default FileSystem adapter
+ */
+export async function initializeDefaultAdapter(dbPath?: string): Promise<void> {
+	const adapter = new FileSystemAdapter(dbPath);
+	await initializeAdapter(adapter);
+}
+
+/**
+ * Get the current adapter
+ */
+export function getAdapter(): DatabaseAdapter {
+	return context.getAdapter();
+}
+
+/**
+ * Close the current adapter
+ */
+export async function closeAdapter(): Promise<void> {
+	const adapter = context.getAdapter();
+	await adapter.close();
+}

package/src/adapters/__tests__/adapter-tests.ts

@@ -0,0 +1,254 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import type { DatabaseAdapter } from '../adapter';
+import type { User, Session } from '../../types';
+
+/**
+ * Shared test suite for database adapters
+ * Can be used to test any implementation of DatabaseAdapter
+ */
+export function createAdapterTestSuite(
+	name: string,
+	createAdapter: () => DatabaseAdapter
+) {
+	describe(`${name} Adapter Tests`, () => {
+		let adapter: DatabaseAdapter;
+
+		beforeEach(async () => {
+			adapter = createAdapter();
+			await adapter.initialize();
+		});
+
+		afterEach(async () => {
+			await adapter.close();
+		});
+
+		describe('User Operations', () => {
+			it('should create a user', async () => {
+				const user: User = {
+					id: 'user-1',
+					email: 'test@example.com',
+					passwordHash: 'hashed-password',
+					emailVerified: false,
+					createdAt: Date.now(),
+					updatedAt: Date.now()
+				};
+
+				await adapter.createUser(user);
+				const retrieved = await adapter.getUserById('user-1');
+
+				expect(retrieved).toBeDefined();
+				expect(retrieved?.email).toBe('test@example.com');
+			});
+
+			it('should get user by email', async () => {
+				const user: User = {
+					id: 'user-2',
+					email: 'test2@example.com',
+					passwordHash: 'hashed-password',
+					emailVerified: false,
+					createdAt: Date.now(),
+					updatedAt: Date.now()
+				};
+
+				await adapter.createUser(user);
+				const retrieved = await adapter.getUserByEmail('test2@example.com');
+
+				expect(retrieved).toBeDefined();
+				expect(retrieved?.id).toBe('user-2');
+			});
+
+			it('should return null for non-existent user', async () => {
+				const user = await adapter.getUserById('non-existent');
+				expect(user).toBeNull();
+			});
+
+			it('should update user', async () => {
+				const user: User = {
+					id: 'user-3',
+					email: 'test3@example.com',
+					passwordHash: 'hashed-password',
+					emailVerified: false,
+					createdAt: Date.now(),
+					updatedAt: Date.now()
+				};
+
+				await adapter.createUser(user);
+				await adapter.updateUser('user-3', {
+					emailVerified: true,
+					passwordHash: 'new-hashed-password'
+				});
+
+				const updated = await adapter.getUserById('user-3');
+				expect(updated?.emailVerified).toBe(true);
+				expect(updated?.passwordHash).toBe('new-hashed-password');
+			});
+
+			it('should get all users', async () => {
+				const user1: User = {
+					id: 'user-4',
+					email: 'test4@example.com',
+					passwordHash: 'hashed-password',
+					emailVerified: false,
+					createdAt: Date.now(),
+					updatedAt: Date.now()
+				};
+
+				const user2: User = {
+					id: 'user-5',
+					email: 'test5@example.com',
+					passwordHash: 'hashed-password',
+					emailVerified: false,
+					createdAt: Date.now(),
+					updatedAt: Date.now()
+				};
+
+				await adapter.createUser(user1);
+				await adapter.createUser(user2);
+
+				const users = await adapter.getAllUsers();
+				expect(users.length).toBeGreaterThanOrEqual(2);
+			});
+		});
+
+		describe('Session Operations', () => {
+			it('should create a session', async () => {
+				const session: Session = {
+					userId: 'user-1',
+					email: 'test@example.com',
+					createdAt: Date.now(),
+					expiresAt: Date.now() + 7 * 24 * 60 * 60 * 1000
+				};
+
+				await adapter.createSession('session-1', session);
+				const retrieved = await adapter.getSession('session-1');
+
+				expect(retrieved).toBeDefined();
+				expect(retrieved?.userId).toBe('user-1');
+				expect(retrieved?.email).toBe('test@example.com');
+			});
+
+			it('should return null for non-existent session', async () => {
+				const session = await adapter.getSession('non-existent');
+				expect(session).toBeNull();
+			});
+
+			it('should return null for expired session', async () => {
+				const now = Date.now();
+				const expiredSession: Session = {
+					userId: 'user-1',
+					email: 'test@example.com',
+					createdAt: now - 1000,
+					expiresAt: now - 100 // Expired 100ms ago
+				};
+
+				await adapter.createSession('expired-session', expiredSession);
+				const retrieved = await adapter.getSession('expired-session');
+
+				expect(retrieved).toBeNull();
+			});
+
+			it('should delete session', async () => {
+				const session: Session = {
+					userId: 'user-1',
+					email: 'test@example.com',
+					createdAt: Date.now(),
+					expiresAt: Date.now() + 7 * 24 * 60 * 60 * 1000
+				};
+
+				await adapter.createSession('session-to-delete', session);
+				await adapter.deleteSession('session-to-delete');
+
+				const retrieved = await adapter.getSession('session-to-delete');
+				expect(retrieved).toBeNull();
+			});
+
+			it('should delete expired sessions', async () => {
+				const now = Date.now();
+
+				const expiredSession1: Session = {
+					userId: 'user-1',
+					email: 'test@example.com',
+					createdAt: now - 2000,
+					expiresAt: now - 1000
+				};
+
+				const expiredSession2: Session = {
+					userId: 'user-2',
+					email: 'test2@example.com',
+					createdAt: now - 2000,
+					expiresAt: now - 500
+				};
+
+				const validSession: Session = {
+					userId: 'user-3',
+					email: 'test3@example.com',
+					createdAt: now,
+					expiresAt: now + 7 * 24 * 60 * 60 * 1000
+				};
+
+				await adapter.createSession('expired-1', expiredSession1);
+				await adapter.createSession('expired-2', expiredSession2);
+				await adapter.createSession('valid', validSession);
+
+				const deletedCount = await adapter.deleteExpiredSessions();
+
+				expect(deletedCount).toBeGreaterThanOrEqual(2);
+				const valid = await adapter.getSession('valid');
+				expect(valid).toBeDefined();
+			});
+
+			it('should get all sessions', async () => {
+				const session1: Session = {
+					userId: 'user-1',
+					email: 'test@example.com',
+					createdAt: Date.now(),
+					expiresAt: Date.now() + 7 * 24 * 60 * 60 * 1000
+				};
+
+				const session2: Session = {
+					userId: 'user-2',
+					email: 'test2@example.com',
+					createdAt: Date.now(),
+					expiresAt: Date.now() + 7 * 24 * 60 * 60 * 1000
+				};
+
+				await adapter.createSession('session-all-1', session1);
+				await adapter.createSession('session-all-2', session2);
+
+				const sessions = await adapter.getAllSessions();
+				expect(sessions.length).toBeGreaterThanOrEqual(2);
+			});
+		});
+
+		describe('Data Clearing', () => {
+			it('should clear all data', async () => {
+				const user: User = {
+					id: 'user-clear',
+					email: 'clear@example.com',
+					passwordHash: 'hashed-password',
+					emailVerified: false,
+					createdAt: Date.now(),
+					updatedAt: Date.now()
+				};
+
+				const session: Session = {
+					userId: 'user-clear',
+					email: 'clear@example.com',
+					createdAt: Date.now(),
+					expiresAt: Date.now() + 7 * 24 * 60 * 60 * 1000
+				};
+
+				await adapter.createUser(user);
+				await adapter.createSession('session-clear', session);
+
+				await adapter.clear();
+
+				const users = await adapter.getAllUsers();
+				const sessions = await adapter.getAllSessions();
+
+				expect(users.length).toBe(0);
+				expect(sessions.length).toBe(0);
+			});
+		});
+	});
+}

package/src/adapters/__tests__/filesystem-adapter.test.ts

@@ -0,0 +1,48 @@
+import { describe, it } from 'vitest';
+import { FileSystemAdapter } from '../filesystem-adapter';
+import { createAdapterTestSuite } from './adapter-tests';
+import fs from 'fs';
+import path from 'path';
+
+// Create a temporary directory for tests
+const testDbPath = path.join(__dirname, 'test-fs-adapter.json');
+
+// Clean up after tests
+if (fs.existsSync(testDbPath)) {
+	fs.unlinkSync(testDbPath);
+}
+
+createAdapterTestSuite('FileSystem', () => new FileSystemAdapter(testDbPath));
+
+// Additional FileSystem-specific tests
+describe('FileSystem Adapter - Specific', () => {
+	it('should persist data to file', async () => {
+		const testPath = path.join(__dirname, 'test-fs-persist.json');
+
+		// Create and populate adapter
+		const adapter = new FileSystemAdapter(testPath);
+		await adapter.initialize();
+
+		const user = {
+			id: 'persist-test',
+			email: 'persist@example.com',
+			passwordHash: 'test-hash',
+			emailVerified: false,
+			createdAt: Date.now(),
+			updatedAt: Date.now()
+		};
+
+		await adapter.createUser(user);
+		await adapter.close();
+
+		// Verify file was created and contains data
+		if (fs.existsSync(testPath)) {
+			const fileContent = fs.readFileSync(testPath, 'utf-8');
+			const data = JSON.parse(fileContent);
+			if ('users' in data && data.users) {
+				console.log('File persistence verified');
+			}
+			fs.unlinkSync(testPath);
+		}
+	});
+});

package/src/adapters/__tests__/mongodb-adapter.test.ts

@@ -0,0 +1,64 @@
+import { describe, it } from 'vitest';
+import { MongoDBAdapter } from '../mongodb-adapter';
+import { createAdapterTestSuite } from './adapter-tests';
+
+/**
+ * MongoDB Adapter Tests
+ * 
+ * These tests will only run if a MongoDB database is available
+ * To run these tests:
+ * 1. Start a MongoDB instance (local or MongoDB Atlas)
+ * 2. Set environment variable:
+ *    - MONGODB_URI (default: mongodb://localhost:27017/auth_db)
+ * 3. Run: npm test -- --reporter=verbose
+ */
+
+const isMongoDBAvailable = process.env.TEST_MONGODB === 'true' || 
+	process.env.MONGODB_URI !== undefined;
+
+if (isMongoDBAvailable) {
+	createAdapterTestSuite('MongoDB', () => new MongoDBAdapter());
+} else {
+	describe('MongoDB Adapter', () => {
+		it('should skip tests if database is not configured', () => {
+			console.log('MongoDB tests skipped - set TEST_MONGODB=true or MONGODB_URI to run');
+		});
+	});
+}
+
+// Test connection configuration
+describe('MongoDB Adapter - Configuration', () => {
+	it('should accept custom connection URI', () => {
+		const adapter = new MongoDBAdapter('mongodb+srv://user:pass@cluster.mongodb.net/auth_db');
+		expect(adapter).toBeDefined();
+	});
+
+	it('should read from MONGODB_URI environment variable', () => {
+		const originalUri = process.env.MONGODB_URI;
+
+		process.env.MONGODB_URI = 'mongodb://custom-host:27017/custom_db';
+
+		const adapter = new MongoDBAdapter();
+		expect(adapter).toBeDefined();
+
+		// Restore original env
+		if (originalUri) {
+			process.env.MONGODB_URI = originalUri;
+		} else {
+			delete process.env.MONGODB_URI;
+		}
+	});
+
+	it('should default to localhost', () => {
+		const originalUri = process.env.MONGODB_URI;
+		delete process.env.MONGODB_URI;
+
+		const adapter = new MongoDBAdapter();
+		expect(adapter).toBeDefined();
+
+		// Restore original env
+		if (originalUri) {
+			process.env.MONGODB_URI = originalUri;
+		}
+	});
+});

package/src/adapters/__tests__/postgres-adapter.test.ts

@@ -0,0 +1,62 @@
+import { describe, it, expect } from 'vitest';
+import { PostgresAdapter } from '../postgres-adapter';
+import { createAdapterTestSuite } from './adapter-tests';
+
+/**
+ * PostgreSQL Adapter Tests
+ * 
+ * These tests will only run if a PostgreSQL database is available
+ * To run these tests:
+ * 1. Start a PostgreSQL database (local or docker)
+ * 2. Set environment variables:
+ *    - DB_HOST (default: localhost)
+ *    - DB_PORT (default: 5432)
+ *    - DB_NAME (default: auth_db)
+ *    - DB_USER (default: postgres)
+ *    - DB_PASSWORD (default: postgres)
+ * 3. Run: npm test
+ */
+
+const isPostgresAvailable = process.env.TEST_POSTGRES === 'true' || 
+	process.env.DB_HOST !== undefined;
+
+if (isPostgresAvailable) {
+	createAdapterTestSuite('PostgreSQL', () => new PostgresAdapter());
+} else {
+	describe('PostgreSQL Adapter', () => {
+		it('should skip tests if database is not configured', () => {
+			console.log('PostgreSQL tests skipped - set TEST_POSTGRES=true or DB_HOST to run');
+		});
+	});
+}
+
+// Test connection configuration
+describe('PostgreSQL Adapter - Configuration', () => {
+	it('should accept custom connection config', () => {
+		const adapter = new PostgresAdapter({
+			host: 'custom-host',
+			port: 5433,
+			database: 'custom_db',
+			user: 'custom_user',
+			password: 'custom_pass'
+		});
+
+		expect(adapter).toBeDefined();
+	});
+
+	it('should read from environment variables', () => {
+		const originalEnv = { ...process.env };
+
+		process.env.DB_HOST = 'env-host';
+		process.env.DB_PORT = '5434';
+		process.env.DB_NAME = 'env_db';
+		process.env.DB_USER = 'env_user';
+		process.env.DB_PASSWORD = 'env_pass';
+
+		const adapter = new PostgresAdapter();
+		expect(adapter).toBeDefined();
+
+		// Restore original env
+		process.env = originalEnv;
+	});
+});

package/src/adapters/__tests__/sqlite-adapter.test.ts

@@ -0,0 +1,103 @@
+import { describe, it, expect } from 'vitest';
+import { SqliteAdapter } from '../sqlite-adapter';
+import { createAdapterTestSuite } from './adapter-tests';
+import fs from 'fs';
+import path from 'path';
+
+// Create a temporary directory for tests
+const testDbPath = path.join(__dirname, 'test-sqlite-adapter.db');
+
+// Clean up before tests
+if (fs.existsSync(testDbPath)) {
+	fs.unlinkSync(testDbPath);
+}
+
+createAdapterTestSuite('SQLite', () => new SqliteAdapter(testDbPath));
+
+// Additional SQLite-specific tests
+describe('SQLite Adapter - Specific', () => {
+	it('should create database file', async () => {
+		const testPath = path.join(__dirname, 'test-sqlite-create.db');
+
+		const adapter = new SqliteAdapter(testPath);
+		await adapter.initialize();
+		await adapter.close();
+
+		expect(fs.existsSync(testPath)).toBe(true);
+
+		// Clean up
+		if (fs.existsSync(testPath)) {
+			fs.unlinkSync(testPath);
+		}
+	});
+
+	it('should persist data to database file', async () => {
+		const testPath = path.join(__dirname, 'test-sqlite-persist.db');
+
+		// Create and populate adapter
+		const adapter = new SqliteAdapter(testPath);
+		await adapter.initialize();
+
+		const user = {
+			id: 'persist-test',
+			email: 'persist@example.com',
+			passwordHash: 'test-hash',
+			emailVerified: true,
+			createdAt: Date.now(),
+			updatedAt: Date.now()
+		};
+
+		await adapter.createUser(user);
+		await adapter.close();
+
+		// Verify data persists by opening new adapter instance
+		const adapter2 = new SqliteAdapter(testPath);
+		await adapter2.initialize();
+
+		const retrievedUser = await adapter2.getUserById('persist-test');
+		expect(retrievedUser).toBeDefined();
+		expect(retrievedUser?.email).toBe('persist@example.com');
+
+		await adapter2.close();
+
+		// Clean up
+		if (fs.existsSync(testPath)) {
+			fs.unlinkSync(testPath);
+		}
+	});
+
+	it('should support database reuse', async () => {
+		const testPath = path.join(__dirname, 'test-sqlite-reuse.db');
+
+		// First adapter session
+		const adapter1 = new SqliteAdapter(testPath);
+		await adapter1.initialize();
+
+		const user1 = {
+			id: 'user-1',
+			email: 'user1@example.com',
+			passwordHash: 'hash1',
+			emailVerified: false,
+			createdAt: Date.now(),
+			updatedAt: Date.now()
+		};
+
+		await adapter1.createUser(user1);
+		await adapter1.close();
+
+		// Second adapter session - should see data from first
+		const adapter2 = new SqliteAdapter(testPath);
+		await adapter2.initialize();
+
+		const users = await adapter2.getAllUsers();
+		expect(users.length).toBeGreaterThan(0);
+		expect(users.some((u) => u.id === 'user-1')).toBe(true);
+
+		await adapter2.close();
+
+		// Clean up
+		if (fs.existsSync(testPath)) {
+			fs.unlinkSync(testPath);
+		}
+	});
+});

package/src/adapters/__tests__/test-fs-adapter.json

@@ -0,0 +1,4 @@
+{
+  "users": {},
+  "sessions": {}
+}

package/src/adapters/adapter.ts

@@ -0,0 +1,72 @@
+import type { User, Session } from '../types';
+
+/**
+ * Database adapter interface
+ * Defines the contract that all database adapters must implement
+ */
+export interface DatabaseAdapter {
+	/**
+	 * Initialize the database connection and schema
+	 */
+	initialize(): Promise<void>;
+
+	/**
+	 * Close the database connection
+	 */
+	close(): Promise<void>;
+
+	/**
+	 * Create a new user
+	 */
+	createUser(user: User): Promise<void>;
+
+	/**
+	 * Get user by ID
+	 */
+	getUserById(id: string): Promise<User | null>;
+
+	/**
+	 * Get user by email
+	 */
+	getUserByEmail(email: string): Promise<User | null>;
+
+	/**
+	 * Update user
+	 */
+	updateUser(id: string, updates: Partial<User>): Promise<void>;
+
+	/**
+	 * Create a new session
+	 */
+	createSession(sessionId: string, session: Session): Promise<void>;
+
+	/**
+	 * Get session by ID
+	 */
+	getSession(sessionId: string): Promise<Session | null>;
+
+	/**
+	 * Delete session
+	 */
+	deleteSession(sessionId: string): Promise<void>;
+
+	/**
+	 * Delete all expired sessions
+	 */
+	deleteExpiredSessions(): Promise<number>;
+
+	/**
+	 * Get all users (for testing/admin purposes)
+	 */
+	getAllUsers(): Promise<User[]>;
+
+	/**
+	 * Get all sessions (for testing/admin purposes)
+	 */
+	getAllSessions(): Promise<Session[]>;
+
+	/**
+	 * Clear all data (for testing)
+	 */
+	clear(): Promise<void>;
+}