@alliance-droid/svelte-auth-core 1.0.0

package/src/adapters/filesystem-adapter.ts

@@ -0,0 +1,153 @@
+import fs from 'fs';
+import path from 'path';
+import type { User, Session } from '../types';
+import type { DatabaseAdapter } from './adapter';
+
+interface DatabaseStore {
+	users: Record<string, User>;
+	sessions: Record<string, Session>;
+}
+
+/**
+ * File system adapter - JSON file-based storage
+ * Useful for development and testing
+ */
+export class FileSystemAdapter implements DatabaseAdapter {
+	private dbPath: string;
+	private store: DatabaseStore | null = null;
+
+	constructor(dbPath?: string) {
+		this.dbPath = dbPath || path.join(process.cwd(), 'auth.json');
+	}
+
+	async initialize(): Promise<void> {
+		try {
+			if (fs.existsSync(this.dbPath)) {
+				const data = fs.readFileSync(this.dbPath, 'utf-8');
+				this.store = JSON.parse(data) as DatabaseStore;
+			} else {
+				this.store = {
+					users: {},
+					sessions: {}
+				};
+				this.save();
+			}
+		} catch (error) {
+			console.error('Failed to initialize filesystem adapter:', error);
+			this.store = {
+				users: {},
+				sessions: {}
+			};
+		}
+	}
+
+	async close(): Promise<void> {
+		if (this.store) {
+			this.save();
+			this.store = null;
+		}
+	}
+
+	async createUser(user: User): Promise<void> {
+		if (!this.store) throw new Error('Database not initialized');
+		this.store.users[user.id] = user;
+		this.save();
+	}
+
+	async getUserById(id: string): Promise<User | null> {
+		if (!this.store) throw new Error('Database not initialized');
+		return this.store.users[id] || null;
+	}
+
+	async getUserByEmail(email: string): Promise<User | null> {
+		if (!this.store) throw new Error('Database not initialized');
+		return (
+			Object.values(this.store.users).find((u) => u.email === email) || null
+		);
+	}
+
+	async updateUser(id: string, updates: Partial<User>): Promise<void> {
+		if (!this.store) throw new Error('Database not initialized');
+		const user = this.store.users[id];
+		if (!user) throw new Error('User not found');
+
+		this.store.users[id] = { ...user, ...updates };
+		this.save();
+	}
+
+	async createSession(sessionId: string, session: Session): Promise<void> {
+		if (!this.store) throw new Error('Database not initialized');
+		this.store.sessions[sessionId] = session;
+		this.save();
+	}
+
+	async getSession(sessionId: string): Promise<Session | null> {
+		if (!this.store) throw new Error('Database not initialized');
+		const session = this.store.sessions[sessionId];
+
+		if (!session || session.expiresAt < Date.now()) {
+			return null;
+		}
+
+		return session;
+	}
+
+	async deleteSession(sessionId: string): Promise<void> {
+		if (!this.store) throw new Error('Database not initialized');
+		delete this.store.sessions[sessionId];
+		this.save();
+	}
+
+	async deleteExpiredSessions(): Promise<number> {
+		if (!this.store) throw new Error('Database not initialized');
+		const now = Date.now();
+		let count = 0;
+
+		for (const [sessionId, session] of Object.entries(this.store.sessions)) {
+			if (session.expiresAt < now) {
+				delete this.store.sessions[sessionId];
+				count++;
+			}
+		}
+
+		if (count > 0) {
+			this.save();
+		}
+
+		return count;
+	}
+
+	async getAllUsers(): Promise<User[]> {
+		if (!this.store) throw new Error('Database not initialized');
+		return Object.values(this.store.users);
+	}
+
+	async getAllSessions(): Promise<Session[]> {
+		if (!this.store) throw new Error('Database not initialized');
+		return Object.values(this.store.sessions);
+	}
+
+	async clear(): Promise<void> {
+		if (!this.store) throw new Error('Database not initialized');
+		this.store = {
+			users: {},
+			sessions: {}
+		};
+		this.save();
+	}
+
+	private save(): void {
+		if (this.store && this.dbPath) {
+			try {
+				const dir = path.dirname(this.dbPath);
+				if (!fs.existsSync(dir)) {
+					fs.mkdirSync(dir, { recursive: true });
+				}
+				fs.writeFileSync(this.dbPath, JSON.stringify(this.store, null, 2), 'utf-8');
+			} catch (error) {
+				console.error('Failed to save database:', error);
+				throw error;
+			}
+		}
+	}
+}

package/src/adapters/index.ts

@@ -0,0 +1,5 @@
+export type { DatabaseAdapter } from './adapter';
+export { FileSystemAdapter } from './filesystem-adapter';
+export { PostgresAdapter } from './postgres-adapter';
+export { MongoDBAdapter } from './mongodb-adapter';
+export { SqliteAdapter } from './sqlite-adapter';

package/src/adapters/mongodb-adapter.ts

@@ -0,0 +1,208 @@
+import { MongoClient, type Db, type Collection } from 'mongodb';
+import type { User, Session } from '../types';
+import type { DatabaseAdapter } from './adapter';
+
+/**
+ * MongoDB adapter
+ * Requires a MongoDB instance (local or MongoDB Atlas)
+ */
+export class MongoDBAdapter implements DatabaseAdapter {
+	private client: MongoClient;
+	private db: Db | null = null;
+	private usersCollection: Collection<User> | null = null;
+	private sessionsCollection: Collection<Session> | null = null;
+
+	constructor(connectionUri?: string) {
+		const uri = connectionUri || process.env.MONGODB_URI || 'mongodb://localhost:27017/auth_db';
+		this.client = new MongoClient(uri);
+	}
+
+	async initialize(): Promise<void> {
+		try {
+			await this.client.connect();
+			this.db = this.client.db('auth_db');
+
+			// Create collections if they don't exist
+			const collections = await this.db.listCollections().toArray();
+			const collectionNames = collections.map((c: any) => c.name);
+
+			if (!collectionNames.includes('users')) {
+				await this.db.createCollection('users');
+			}
+
+			if (!collectionNames.includes('sessions')) {
+				await this.db.createCollection('sessions');
+			}
+
+			this.usersCollection = this.db.collection('users');
+			this.sessionsCollection = this.db.collection('sessions');
+
+			// Create indexes
+			await this.usersCollection.createIndex({ email: 1 }, { unique: true });
+			await this.usersCollection.createIndex({ verificationToken: 1 });
+			await this.usersCollection.createIndex({ resetToken: 1 });
+
+			await this.sessionsCollection.createIndex({ userId: 1 });
+			await this.sessionsCollection.createIndex({ expiresAt: 1 });
+		} catch (error) {
+			console.error('Failed to initialize MongoDB adapter:', error);
+			throw error;
+		}
+	}
+
+	async close(): Promise<void> {
+		try {
+			await this.client.close();
+			this.db = null;
+			this.usersCollection = null;
+			this.sessionsCollection = null;
+		} catch (error) {
+			console.error('Failed to close MongoDB adapter:', error);
+			throw error;
+		}
+	}
+
+	async createUser(user: User): Promise<void> {
+		if (!this.usersCollection) throw new Error('Database not initialized');
+
+		try {
+			await this.usersCollection.insertOne(user as any);
+		} catch (error) {
+			console.error('Failed to create user:', error);
+			throw error;
+		}
+	}
+
+	async getUserById(id: string): Promise<User | null> {
+		if (!this.usersCollection) throw new Error('Database not initialized');
+
+		try {
+			const user = await this.usersCollection.findOne({ _id: id } as any);
+			return user as unknown as User | null;
+		} catch (error) {
+			console.error('Failed to get user by ID:', error);
+			throw error;
+		}
+	}
+
+	async getUserByEmail(email: string): Promise<User | null> {
+		if (!this.usersCollection) throw new Error('Database not initialized');
+
+		try {
+			const user = await this.usersCollection.findOne({ email } as any);
+			return user as unknown as User | null;
+		} catch (error) {
+			console.error('Failed to get user by email:', error);
+			throw error;
+		}
+	}
+
+	async updateUser(id: string, updates: Partial<User>): Promise<void> {
+		if (!this.usersCollection) throw new Error('Database not initialized');
+
+		try {
+			const result = await this.usersCollection.updateOne(
+				{ _id: id } as any,
+				{ $set: updates as any }
+			);
+
+			if (result.matchedCount === 0) {
+				throw new Error('User not found');
+			}
+		} catch (error) {
+			console.error('Failed to update user:', error);
+			throw error;
+		}
+	}
+
+	async createSession(sessionId: string, session: Session): Promise<void> {
+		if (!this.sessionsCollection) throw new Error('Database not initialized');
+
+		try {
+			await this.sessionsCollection.insertOne({ _id: sessionId, ...session } as any);
+		} catch (error) {
+			console.error('Failed to create session:', error);
+			throw error;
+		}
+	}
+
+	async getSession(sessionId: string): Promise<Session | null> {
+		if (!this.sessionsCollection) throw new Error('Database not initialized');
+
+		try {
+			const session = await this.sessionsCollection.findOne({ _id: sessionId } as any);
+
+			if (!session || session.expiresAt < Date.now()) {
+				return null;
+			}
+
+			return session as unknown as Session;
+		} catch (error) {
+			console.error('Failed to get session:', error);
+			throw error;
+		}
+	}
+
+	async deleteSession(sessionId: string): Promise<void> {
+		if (!this.sessionsCollection) throw new Error('Database not initialized');
+
+		try {
+			await this.sessionsCollection.deleteOne({ _id: sessionId } as any);
+		} catch (error) {
+			console.error('Failed to delete session:', error);
+			throw error;
+		}
+	}
+
+	async deleteExpiredSessions(): Promise<number> {
+		if (!this.sessionsCollection) throw new Error('Database not initialized');
+
+		try {
+			const result = await this.sessionsCollection.deleteMany({
+				expiresAt: { $lt: Date.now() }
+			} as any);
+			return result.deletedCount || 0;
+		} catch (error) {
+			console.error('Failed to delete expired sessions:', error);
+			throw error;
+		}
+	}
+
+	async getAllUsers(): Promise<User[]> {
+		if (!this.usersCollection) throw new Error('Database not initialized');
+
+		try {
+			const users = await this.usersCollection.find({} as any).toArray();
+			return users as unknown as User[];
+		} catch (error) {
+			console.error('Failed to get all users:', error);
+			throw error;
+		}
+	}
+
+	async getAllSessions(): Promise<Session[]> {
+		if (!this.sessionsCollection) throw new Error('Database not initialized');
+
+		try {
+			const sessions = await this.sessionsCollection.find({} as any).toArray();
+			return sessions as unknown as Session[];
+		} catch (error) {
+			console.error('Failed to get all sessions:', error);
+			throw error;
+		}
+	}
+
+	async clear(): Promise<void> {
+		try {
+			if (this.usersCollection) {
+				await this.usersCollection.deleteMany({} as any);
+			}
+			if (this.sessionsCollection) {
+				await this.sessionsCollection.deleteMany({} as any);
+			}
+		} catch (error) {
+			console.error('Failed to clear database:', error);
+			throw error;
+		}
+	}
+}

package/src/adapters/postgres-adapter.ts

@@ -0,0 +1,261 @@
+import { Pool } from 'pg';
+import type { User, Session } from '../types';
+import type { DatabaseAdapter } from './adapter';
+
+/**
+ * PostgreSQL adapter using pg library
+ * Requires a PostgreSQL database to be set up
+ */
+export class PostgresAdapter implements DatabaseAdapter {
+	private pool: Pool;
+
+	constructor(connectionConfig?: {
+		host?: string;
+		port?: number;
+		database?: string;
+		user?: string;
+		password?: string;
+	}) {
+		const config = {
+			host: connectionConfig?.host || process.env.DB_HOST || 'localhost',
+			port: connectionConfig?.port || parseInt(process.env.DB_PORT || '5432'),
+			database: connectionConfig?.database || process.env.DB_NAME || 'auth_db',
+			user: connectionConfig?.user || process.env.DB_USER || 'postgres',
+			password: connectionConfig?.password || process.env.DB_PASSWORD || 'postgres'
+		};
+
+		this.pool = new Pool(config);
+	}
+
+	async initialize(): Promise<void> {
+		try {
+			const client = await this.pool.connect();
+			try {
+				// Create users table
+				await client.query(`
+					CREATE TABLE IF NOT EXISTS users (
+						id VARCHAR(255) PRIMARY KEY,
+						email VARCHAR(255) UNIQUE NOT NULL,
+						"passwordHash" VARCHAR(255) NOT NULL,
+						"emailVerified" BOOLEAN DEFAULT FALSE,
+						"verificationToken" VARCHAR(255),
+						"verificationTokenExpires" BIGINT,
+						"resetToken" VARCHAR(255),
+						"resetTokenExpires" BIGINT,
+						"createdAt" BIGINT NOT NULL,
+						"updatedAt" BIGINT NOT NULL,
+						CONSTRAINT unique_email UNIQUE (email)
+					)
+				`);
+
+				// Create sessions table
+				await client.query(`
+					CREATE TABLE IF NOT EXISTS sessions (
+						id VARCHAR(255) PRIMARY KEY,
+						"userId" VARCHAR(255) NOT NULL,
+						email VARCHAR(255) NOT NULL,
+						"createdAt" BIGINT NOT NULL,
+						"expiresAt" BIGINT NOT NULL,
+						FOREIGN KEY ("userId") REFERENCES users(id) ON DELETE CASCADE
+					)
+				`);
+
+				// Create indexes for performance
+				await client.query(`
+					CREATE INDEX IF NOT EXISTS idx_users_email ON users(email)
+				`);
+
+				await client.query(`
+					CREATE INDEX IF NOT EXISTS idx_sessions_expires ON sessions("expiresAt")
+				`);
+
+			} finally {
+				client.release();
+			}
+		} catch (error) {
+			console.error('Failed to initialize PostgreSQL adapter:', error);
+			throw error;
+		}
+	}
+
+	async close(): Promise<void> {
+		try {
+			await this.pool.end();
+		} catch (error) {
+			console.error('Failed to close PostgreSQL adapter:', error);
+			throw error;
+		}
+	}
+
+	async createUser(user: User): Promise<void> {
+		const query = `
+			INSERT INTO users (
+				id, email, "passwordHash", "emailVerified", 
+				"verificationToken", "verificationTokenExpires",
+				"createdAt", "updatedAt"
+			) VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
+		`;
+
+		try {
+			await this.pool.query(query, [
+				user.id,
+				user.email,
+				user.passwordHash,
+				user.emailVerified,
+				user.verificationToken,
+				user.verificationTokenExpires,
+				user.createdAt,
+				user.updatedAt
+			]);
+		} catch (error) {
+			console.error('Failed to create user:', error);
+			throw error;
+		}
+	}
+
+	async getUserById(id: string): Promise<User | null> {
+		const query = 'SELECT * FROM users WHERE id = $1';
+
+		try {
+			const result = await this.pool.query(query, [id]);
+			return result.rows[0] || null;
+		} catch (error) {
+			console.error('Failed to get user by ID:', error);
+			throw error;
+		}
+	}
+
+	async getUserByEmail(email: string): Promise<User | null> {
+		const query = 'SELECT * FROM users WHERE email = $1';
+
+		try {
+			const result = await this.pool.query(query, [email]);
+			return result.rows[0] || null;
+		} catch (error) {
+			console.error('Failed to get user by email:', error);
+			throw error;
+		}
+	}
+
+	async updateUser(id: string, updates: Partial<User>): Promise<void> {
+		const updateEntries = Object.entries(updates).filter(
+			([_, value]) => value !== undefined
+		);
+
+		if (updateEntries.length === 0) {
+			return;
+		}
+
+		const setClause = updateEntries
+			.map(([key], index) => `"${key}" = $${index + 1}`)
+			.join(', ');
+
+		const values = [...updateEntries.map(([_, value]) => value), id];
+		const query = `UPDATE users SET ${setClause} WHERE id = $${values.length}`;
+
+		try {
+			await this.pool.query(query, values);
+		} catch (error) {
+			console.error('Failed to update user:', error);
+			throw error;
+		}
+	}
+
+	async createSession(sessionId: string, session: Session): Promise<void> {
+		const query = `
+			INSERT INTO sessions (id, "userId", email, "createdAt", "expiresAt")
+			VALUES ($1, $2, $3, $4, $5)
+		`;
+
+		try {
+			await this.pool.query(query, [
+				sessionId,
+				session.userId,
+				session.email,
+				session.createdAt,
+				session.expiresAt
+			]);
+		} catch (error) {
+			console.error('Failed to create session:', error);
+			throw error;
+		}
+	}
+
+	async getSession(sessionId: string): Promise<Session | null> {
+		const query = 'SELECT * FROM sessions WHERE id = $1';
+
+		try {
+			const result = await this.pool.query(query, [sessionId]);
+			const session = result.rows[0];
+
+			if (!session || session.expiresAt < Date.now()) {
+				return null;
+			}
+
+			return session;
+		} catch (error) {
+			console.error('Failed to get session:', error);
+			throw error;
+		}
+	}
+
+	async deleteSession(sessionId: string): Promise<void> {
+		const query = 'DELETE FROM sessions WHERE id = $1';
+
+		try {
+			await this.pool.query(query, [sessionId]);
+		} catch (error) {
+			console.error('Failed to delete session:', error);
+			throw error;
+		}
+	}
+
+	async deleteExpiredSessions(): Promise<number> {
+		const query = 'DELETE FROM sessions WHERE "expiresAt" < $1';
+
+		try {
+			const result = await this.pool.query(query, [Date.now()]);
+			return result.rowCount || 0;
+		} catch (error) {
+			console.error('Failed to delete expired sessions:', error);
+			throw error;
+		}
+	}
+
+	async getAllUsers(): Promise<User[]> {
+		const query = 'SELECT * FROM users';
+
+		try {
+			const result = await this.pool.query(query);
+			return result.rows;
+		} catch (error) {
+			console.error('Failed to get all users:', error);
+			throw error;
+		}
+	}
+
+	async getAllSessions(): Promise<Session[]> {
+		const query = 'SELECT * FROM sessions';
+
+		try {
+			const result = await this.pool.query(query);
+			return result.rows;
+		} catch (error) {
+			console.error('Failed to get all sessions:', error);
+			throw error;
+		}
+	}
+
+	async clear(): Promise<void> {
+		const client = await this.pool.connect();
+		try {
+			await client.query('TRUNCATE sessions CASCADE');
+			await client.query('TRUNCATE users CASCADE');
+		} catch (error) {
+			console.error('Failed to clear database:', error);
+			throw error;
+		} finally {
+			client.release();
+		}
+	}
+}