archicore 0.2.0 → 0.2.2

package/dist/server/services/auth-service.js

@@ -1,40 +1,46 @@
 /**
  * Authentication Service for ArchiCore
+ *
+ * Supports PostgreSQL (primary) with JSON file fallback
  */
 import { randomUUID } from 'crypto';
 import { createHash } from 'crypto';
 import { readFile, writeFile, mkdir } from 'fs/promises';
+import bcrypt from 'bcrypt';
 import { join } from 'path';
 import { TIER_LIMITS } from '../../types/user.js';
+import { db } from './database.js';
+import { Logger } from '../../utils/logger.js';
 const DATA_DIR = '.archicore';
 const USERS_FILE = 'users.json';
 const SESSIONS_FILE = 'sessions.json';
 export class AuthService {
     static instance = null;
     dataDir;
+    // JSON fallback storage
     users = [];
     sessions = [];
-    initialized = false;
+    jsonInitialized = false;
     constructor(dataDir = DATA_DIR) {
         this.dataDir = dataDir;
     }
-    /**
-     * Get singleton instance of AuthService
-     */
     static getInstance() {
         if (!AuthService.instance) {
             AuthService.instance = new AuthService();
         }
         return AuthService.instance;
     }
-    async ensureInitialized() {
-        if (this.initialized)
+    useDatabase() {
+        return db.isAvailable();
+    }
+    // ========== JSON FALLBACK METHODS ==========
+    async ensureJsonInitialized() {
+        if (this.jsonInitialized)
             return;
         try {
             await mkdir(this.dataDir, { recursive: true });
         }
         catch { }
-        // Load users
         try {
             const usersPath = join(this.dataDir, USERS_FILE);
             const data = await readFile(usersPath, 'utf-8');
@@ -43,10 +49,8 @@ export class AuthService {
         }
         catch {
             this.users = [];
-            // Create default admin user
             await this.createDefaultAdmin();
         }
-        // Load sessions
         try {
             const sessionsPath = join(this.dataDir, SESSIONS_FILE);
             const data = await readFile(sessionsPath, 'utf-8');
@@ -56,13 +60,13 @@ export class AuthService {
         catch {
             this.sessions = [];
         }
-        this.initialized = true;
+        this.jsonInitialized = true;
     }
     async createDefaultAdmin() {
         const admin = {
             id: 'admin-' + randomUUID(),
             email: 'admin@archicore.io',
-            username: 'Administrator',
+            username: 'ArchiCore Team',
             passwordHash: this.hashPassword('admin123'),
             tier: 'admin',
             provider: 'email',
@@ -81,9 +85,46 @@ export class AuthService {
         const sessionsPath = join(this.dataDir, SESSIONS_FILE);
         await writeFile(sessionsPath, JSON.stringify({ sessions: this.sessions }, null, 2));
     }
-    hashPassword(password) {
+    // ========== HELPER METHODS ==========
+    BCRYPT_ROUNDS = 12;
+    /**
+     * Hash password with bcrypt (async)
+     */
+    async hashPasswordAsync(password) {
+        return bcrypt.hash(password, this.BCRYPT_ROUNDS);
+    }
+    /**
+     * Legacy SHA256 hash for backward compatibility
+     */
+    hashPasswordLegacy(password) {
         return createHash('sha256').update(password + 'archicore-salt-2024').digest('hex');
     }
+    /**
+     * Verify password against hash (supports both bcrypt and legacy SHA256)
+     */
+    async verifyPassword(password, hash) {
+        // Check if it's a bcrypt hash (starts with $2b$ or $2a$)
+        if (hash.startsWith('$2')) {
+            return bcrypt.compare(password, hash);
+        }
+        // Legacy SHA256 hash
+        return this.hashPasswordLegacy(password) === hash;
+    }
+    /**
+     * Check if password needs rehashing (from legacy to bcrypt)
+     */
+    needsRehash(hash) {
+        return !hash.startsWith('$2');
+    }
+    /**
+     * Sync hash for JSON fallback (still uses legacy for simplicity)
+     * @deprecated Use hashPasswordAsync for new passwords
+     */
+    hashPassword(password) {
+        // For new registrations, we should use async version
+        // This is kept for backward compatibility with JSON storage
+        return this.hashPasswordLegacy(password);
+    }
     createEmptyUsage() {
         return {
             requestsToday: 0,
@@ -99,13 +140,73 @@ export class AuthService {
         const { passwordHash, ...sanitized } = user;
         return sanitized;
     }
+    rowToUser(row) {
+        return {
+            id: row.id,
+            email: row.email,
+            username: row.username,
+            passwordHash: row.password_hash || undefined,
+            avatar: row.avatar || undefined,
+            tier: row.tier,
+            provider: row.provider,
+            providerId: row.provider_id || undefined,
+            createdAt: row.created_at,
+            lastLoginAt: row.last_login_at,
+            usage: {
+                requestsToday: row.requests_today,
+                fullAnalysisToday: row.full_analysis_today,
+                projectsToday: row.projects_today,
+                lastResetDate: row.usage_reset_date
+            }
+        };
+    }
+    // ========== DATABASE METHODS ==========
+    async dbCreateDefaultAdmin() {
+        const result = await db.query('SELECT id FROM users WHERE tier = $1 LIMIT 1', ['admin']);
+        if (result.rows.length > 0)
+            return;
+        const adminId = 'admin-' + randomUUID();
+        await db.query(`INSERT INTO users (id, email, username, password_hash, tier, provider)
+       VALUES ($1, $2, $3, $4, $5, $6)`, [adminId, 'admin@archicore.io', 'ArchiCore Team', this.hashPassword('admin123'), 'admin', 'email']);
+        Logger.info('Default admin user created');
+    }
+    // ========== PUBLIC API ==========
     async register(email, username, password) {
-        await this.ensureInitialized();
-        // Check if email already exists
+        if (this.useDatabase()) {
+            try {
+                // Check email exists
+                const emailCheck = await db.query('SELECT id FROM users WHERE LOWER(email) = LOWER($1)', [email]);
+                if (emailCheck.rows.length > 0) {
+                    return { success: false, error: 'Email already registered' };
+                }
+                // Check username exists
+                const usernameCheck = await db.query('SELECT id FROM users WHERE LOWER(username) = LOWER($1)', [username]);
+                if (usernameCheck.rows.length > 0) {
+                    return { success: false, error: 'Username already taken' };
+                }
+                const userId = 'user-' + randomUUID();
+                const token = this.generateToken();
+                const passwordHash = await this.hashPasswordAsync(password);
+                await db.transaction(async (client) => {
+                    await client.query(`INSERT INTO users (id, email, username, password_hash, tier, provider)
+             VALUES ($1, $2, $3, $4, $5, $6)`, [userId, email.toLowerCase(), username, passwordHash, 'free', 'email']);
+                    await client.query(`INSERT INTO sessions (token, user_id, expires_at)
+             VALUES ($1, $2, $3)`, [token, userId, new Date(Date.now() + 7 * 24 * 60 * 60 * 1000)]);
+                });
+                const userResult = await db.query('SELECT * FROM users WHERE id = $1', [userId]);
+                const user = this.rowToUser(userResult.rows[0]);
+                return { success: true, token, user: this.sanitizeUser(user) };
+            }
+            catch (error) {
+                Logger.error('Register error:', error);
+                return { success: false, error: 'Registration failed' };
+            }
+        }
+        // JSON fallback
+        await this.ensureJsonInitialized();
         if (this.users.find(u => u.email.toLowerCase() === email.toLowerCase())) {
             return { success: false, error: 'Email already registered' };
         }
-        // Check if username already exists
         if (this.users.find(u => u.username.toLowerCase() === username.toLowerCase())) {
             return { success: false, error: 'Username already taken' };
         }
@@ -122,23 +223,48 @@ export class AuthService {
         };
         this.users.push(user);
         await this.saveUsers();
-        // Create session
         const token = this.generateToken();
         const session = {
             token,
             userId: user.id,
-            expiresAt: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000) // 7 days
+            expiresAt: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000)
         };
         this.sessions.push(session);
         await this.saveSessions();
-        return {
-            success: true,
-            token,
-            user: this.sanitizeUser(user)
-        };
+        return { success: true, token, user: this.sanitizeUser(user) };
     }
     async login(email, password) {
-        await this.ensureInitialized();
+        if (this.useDatabase()) {
+            try {
+                const result = await db.query('SELECT * FROM users WHERE LOWER(email) = LOWER($1)', [email]);
+                if (result.rows.length === 0) {
+                    return { success: false, error: 'Invalid email or password' };
+                }
+                const row = result.rows[0];
+                // Verify password (supports both bcrypt and legacy SHA256)
+                const isValid = await this.verifyPassword(password, row.password_hash || '');
+                if (!isValid) {
+                    return { success: false, error: 'Invalid email or password' };
+                }
+                const token = this.generateToken();
+                // Rehash legacy passwords to bcrypt
+                if (row.password_hash && this.needsRehash(row.password_hash)) {
+                    const newHash = await this.hashPasswordAsync(password);
+                    await db.query('UPDATE users SET password_hash = $1 WHERE id = $2', [newHash, row.id]);
+                    Logger.info(`Upgraded password hash for user ${row.id}`);
+                }
+                await db.query('UPDATE users SET last_login_at = NOW() WHERE id = $1', [row.id]);
+                await db.query('INSERT INTO sessions (token, user_id, expires_at) VALUES ($1, $2, $3)', [token, row.id, new Date(Date.now() + 7 * 24 * 60 * 60 * 1000)]);
+                const user = this.rowToUser(row);
+                return { success: true, token, user: this.sanitizeUser(user) };
+            }
+            catch (error) {
+                Logger.error('Login error:', error);
+                return { success: false, error: 'Login failed' };
+            }
+        }
+        // JSON fallback
+        await this.ensureJsonInitialized();
         const user = this.users.find(u => u.email.toLowerCase() === email.toLowerCase());
         if (!user) {
             return { success: false, error: 'Invalid email or password' };
@@ -146,10 +272,8 @@ export class AuthService {
         if (user.passwordHash !== this.hashPassword(password)) {
             return { success: false, error: 'Invalid email or password' };
         }
-        // Update last login
         user.lastLoginAt = new Date();
         await this.saveUsers();
-        // Create session
         const token = this.generateToken();
         const session = {
             token,
@@ -158,19 +282,44 @@ export class AuthService {
         };
         this.sessions.push(session);
         await this.saveSessions();
-        return {
-            success: true,
-            token,
-            user: this.sanitizeUser(user)
-        };
+        return { success: true, token, user: this.sanitizeUser(user) };
     }
     async oauthLogin(provider, profile) {
-        await this.ensureInitialized();
-        // Find existing user by provider ID or email
+        if (this.useDatabase()) {
+            try {
+                // Find by provider ID or email
+                let result = await db.query(`SELECT * FROM users WHERE (provider = $1 AND provider_id = $2) OR LOWER(email) = LOWER($3) LIMIT 1`, [provider, profile.id, profile.email]);
+                let userId;
+                if (result.rows.length === 0) {
+                    // Create new user
+                    userId = 'user-' + randomUUID();
+                    await db.query(`INSERT INTO users (id, email, username, avatar, tier, provider, provider_id)
+             VALUES ($1, $2, $3, $4, $5, $6, $7)`, [userId, profile.email.toLowerCase(), profile.name || profile.email.split('@')[0], profile.avatar, 'free', provider, profile.id]);
+                }
+                else {
+                    // Update existing
+                    userId = result.rows[0].id;
+                    await db.query(`UPDATE users SET last_login_at = NOW(), avatar = COALESCE($2, avatar),
+             provider = CASE WHEN provider_id IS NULL THEN $3 ELSE provider END,
+             provider_id = CASE WHEN provider_id IS NULL THEN $4 ELSE provider_id END
+             WHERE id = $1`, [userId, profile.avatar, provider, profile.id]);
+                }
+                const token = this.generateToken();
+                await db.query('INSERT INTO sessions (token, user_id, expires_at) VALUES ($1, $2, $3)', [token, userId, new Date(Date.now() + 7 * 24 * 60 * 60 * 1000)]);
+                result = await db.query('SELECT * FROM users WHERE id = $1', [userId]);
+                const user = this.rowToUser(result.rows[0]);
+                return { success: true, token, user: this.sanitizeUser(user) };
+            }
+            catch (error) {
+                Logger.error('OAuth login error:', error);
+                return { success: false, error: 'OAuth login failed' };
+            }
+        }
+        // JSON fallback
+        await this.ensureJsonInitialized();
         let user = this.users.find(u => (u.provider === provider && u.providerId === profile.id) ||
             u.email.toLowerCase() === profile.email.toLowerCase());
         if (!user) {
-            // Create new user
             user = {
                 id: 'user-' + randomUUID(),
                 email: profile.email.toLowerCase(),
@@ -186,7 +335,6 @@ export class AuthService {
             this.users.push(user);
         }
         else {
-            // Update existing user
             user.lastLoginAt = new Date();
             if (profile.avatar)
                 user.avatar = profile.avatar;
@@ -196,7 +344,6 @@ export class AuthService {
             }
         }
         await this.saveUsers();
-        // Create session
         const token = this.generateToken();
         const session = {
             token,
@@ -205,37 +352,78 @@ export class AuthService {
         };
         this.sessions.push(session);
         await this.saveSessions();
-        return {
-            success: true,
-            token,
-            user: this.sanitizeUser(user)
-        };
+        return { success: true, token, user: this.sanitizeUser(user) };
     }
     async validateToken(token) {
-        await this.ensureInitialized();
+        if (this.useDatabase()) {
+            try {
+                const result = await db.query('SELECT * FROM sessions WHERE token = $1', [token]);
+                if (result.rows.length === 0)
+                    return null;
+                const session = result.rows[0];
+                if (new Date(session.expires_at) < new Date()) {
+                    await db.query('DELETE FROM sessions WHERE token = $1', [token]);
+                    return null;
+                }
+                const userResult = await db.query('SELECT * FROM users WHERE id = $1', [session.user_id]);
+                if (userResult.rows.length === 0)
+                    return null;
+                return this.rowToUser(userResult.rows[0]);
+            }
+            catch (error) {
+                Logger.error('Token validation error:', error);
+                return null;
+            }
+        }
+        // JSON fallback
+        await this.ensureJsonInitialized();
         const session = this.sessions.find(s => s.token === token);
         if (!session)
             return null;
         if (new Date(session.expiresAt) < new Date()) {
-            // Session expired, remove it
             this.sessions = this.sessions.filter(s => s.token !== token);
             await this.saveSessions();
             return null;
         }
-        const user = this.users.find(u => u.id === session.userId);
-        return user || null;
+        return this.users.find(u => u.id === session.userId) || null;
     }
     async logout(token) {
-        await this.ensureInitialized();
+        if (this.useDatabase()) {
+            await db.query('DELETE FROM sessions WHERE token = $1', [token]);
+            return;
+        }
+        await this.ensureJsonInitialized();
         this.sessions = this.sessions.filter(s => s.token !== token);
         await this.saveSessions();
     }
     async getUser(userId) {
-        await this.ensureInitialized();
+        if (this.useDatabase()) {
+            try {
+                const result = await db.query('SELECT * FROM users WHERE id = $1', [userId]);
+                if (result.rows.length === 0)
+                    return null;
+                return this.rowToUser(result.rows[0]);
+            }
+            catch (error) {
+                Logger.error('Get user error:', error);
+                return null;
+            }
+        }
+        await this.ensureJsonInitialized();
         return this.users.find(u => u.id === userId) || null;
     }
     async updateUserTier(userId, tier) {
-        await this.ensureInitialized();
+        if (this.useDatabase()) {
+            try {
+                const result = await db.query('UPDATE users SET tier = $1 WHERE id = $2', [tier, userId]);
+                return (result.rowCount ?? 0) > 0;
+            }
+            catch (error) {
+                Logger.error('Update tier error:', error);
+                return false;
+            }
+        }
+        await this.ensureJsonInitialized();
         const user = this.users.find(u => u.id === userId);
         if (!user)
             return false;
@@ -244,12 +432,59 @@ export class AuthService {
         return true;
     }
     async checkAndUpdateUsage(userId, type) {
-        await this.ensureInitialized();
+        if (this.useDatabase()) {
+            try {
+                const result = await db.query('SELECT * FROM users WHERE id = $1', [userId]);
+                if (result.rows.length === 0)
+                    return { allowed: false, remaining: 0, limit: 0 };
+                const row = result.rows[0];
+                const today = new Date().toISOString().split('T')[0];
+                // Reset usage if new day
+                if (row.usage_reset_date !== today) {
+                    await db.query(`UPDATE users SET requests_today = 0, full_analysis_today = 0, projects_today = 0, usage_reset_date = $1 WHERE id = $2`, [today, userId]);
+                    row.requests_today = 0;
+                    row.full_analysis_today = 0;
+                    row.projects_today = 0;
+                }
+                const limits = TIER_LIMITS[row.tier];
+                let current;
+                let limit;
+                let column;
+                switch (type) {
+                    case 'request':
+                        current = row.requests_today;
+                        limit = limits.requestsPerDay;
+                        column = 'requests_today';
+                        break;
+                    case 'analysis':
+                        current = row.full_analysis_today;
+                        limit = limits.fullAnalysisPerDay;
+                        column = 'full_analysis_today';
+                        break;
+                    case 'project':
+                        current = row.projects_today;
+                        limit = limits.projectsPerDay;
+                        column = 'projects_today';
+                        break;
+                }
+                if (current >= limit && limit !== Infinity) {
+                    return { allowed: false, remaining: 0, limit };
+                }
+                await db.query(`UPDATE users SET ${column} = ${column} + 1 WHERE id = $1`, [userId]);
+                const remaining = limit === Infinity ? Infinity : limit - current - 1;
+                return { allowed: true, remaining, limit };
+            }
+            catch (error) {
+                Logger.error('Usage check error:', error);
+                return { allowed: false, remaining: 0, limit: 0 };
+            }
+        }
+        // JSON fallback
+        await this.ensureJsonInitialized();
         const user = this.users.find(u => u.id === userId);
         if (!user)
             return { allowed: false, remaining: 0, limit: 0 };
         const today = new Date().toISOString().split('T')[0];
-        // Reset usage if new day
         if (user.usage.lastResetDate !== today) {
             user.usage = this.createEmptyUsage();
         }
@@ -273,7 +508,6 @@ export class AuthService {
         if (current >= limit && limit !== Infinity) {
             return { allowed: false, remaining: 0, limit };
         }
-        // Increment usage
         switch (type) {
             case 'request':
                 user.usage.requestsToday++;
@@ -290,15 +524,38 @@ export class AuthService {
         return { allowed: true, remaining, limit };
     }
     async getAllUsers() {
-        await this.ensureInitialized();
+        if (this.useDatabase()) {
+            try {
+                const result = await db.query('SELECT * FROM users ORDER BY created_at DESC');
+                return result.rows.map(row => this.sanitizeUser(this.rowToUser(row)));
+            }
+            catch (error) {
+                Logger.error('Get all users error:', error);
+                return [];
+            }
+        }
+        await this.ensureJsonInitialized();
         return this.users.map(u => this.sanitizeUser(u));
     }
     async deleteUser(userId) {
-        await this.ensureInitialized();
+        if (this.useDatabase()) {
+            try {
+                // Don't delete admin
+                const check = await db.query('SELECT tier FROM users WHERE id = $1', [userId]);
+                if (check.rows.length === 0 || check.rows[0].tier === 'admin')
+                    return false;
+                await db.query('DELETE FROM users WHERE id = $1', [userId]);
+                return true;
+            }
+            catch (error) {
+                Logger.error('Delete user error:', error);
+                return false;
+            }
+        }
+        await this.ensureJsonInitialized();
         const index = this.users.findIndex(u => u.id === userId);
         if (index === -1)
             return false;
-        // Don't delete admin
         if (this.users[index].tier === 'admin')
             return false;
         this.users.splice(index, 1);
@@ -308,7 +565,35 @@ export class AuthService {
         return true;
     }
     async updateUser(userId, updates) {
-        await this.ensureInitialized();
+        if (this.useDatabase()) {
+            try {
+                const sets = [];
+                const values = [];
+                let paramIndex = 1;
+                if (updates.username) {
+                    sets.push(`username = $${paramIndex++}`);
+                    values.push(updates.username);
+                }
+                if (updates.email) {
+                    sets.push(`email = $${paramIndex++}`);
+                    values.push(updates.email);
+                }
+                if (updates.avatar) {
+                    sets.push(`avatar = $${paramIndex++}`);
+                    values.push(updates.avatar);
+                }
+                if (sets.length === 0)
+                    return true;
+                values.push(userId);
+                const result = await db.query(`UPDATE users SET ${sets.join(', ')} WHERE id = $${paramIndex}`, values);
+                return (result.rowCount ?? 0) > 0;
+            }
+            catch (error) {
+                Logger.error('Update user error:', error);
+                return false;
+            }
+        }
+        await this.ensureJsonInitialized();
         const user = this.users.find(u => u.id === userId);
         if (!user)
             return false;
@@ -321,5 +606,13 @@ export class AuthService {
         await this.saveUsers();
         return true;
     }
+    /**
+     * Initialize database and create default admin if needed
+     */
+    async initDatabase() {
+        if (this.useDatabase()) {
+            await this.dbCreateDefaultAdmin();
+        }
+    }
 }
 //# sourceMappingURL=auth-service.js.map

package/dist/server/services/cache.d.ts

@@ -0,0 +1,77 @@
+/**
+ * ArchiCore Redis Cache Service
+ *
+ * Provides caching for API responses to improve performance
+ */
+export interface CacheOptions {
+    ttl?: number;
+    prefix?: string;
+}
+declare class CacheService {
+    private client;
+    private enabled;
+    private memoryCache;
+    connect(): Promise<void>;
+    private getKey;
+    /**
+     * Get value from cache
+     */
+    get<T>(key: string, prefix?: string): Promise<T | null>;
+    /**
+     * Set value in cache
+     */
+    set(key: string, value: any, options?: CacheOptions): Promise<void>;
+    /**
+     * Delete value from cache
+     */
+    del(key: string, prefix?: string): Promise<void>;
+    /**
+     * Delete all keys matching pattern
+     */
+    delPattern(pattern: string): Promise<void>;
+    /**
+     * Clear all cache
+     */
+    flush(): Promise<void>;
+    /**
+     * Get or set cache with callback
+     */
+    getOrSet<T>(key: string, callback: () => Promise<T>, options?: CacheOptions): Promise<T>;
+    /**
+     * Check if cache is available
+     */
+    isEnabled(): boolean;
+    /**
+     * Get cache stats
+     */
+    getStats(): Promise<{
+        enabled: boolean;
+        type: string;
+        keys: number;
+    }>;
+    /**
+     * Cleanup expired memory cache entries
+     */
+    private cleanupMemoryCache;
+    /**
+     * Disconnect from Redis
+     */
+    disconnect(): Promise<void>;
+}
+export declare const cache: CacheService;
+export declare const cacheKeys: {
+    project: (projectId: string) => string;
+    projectAnalysis: (projectId: string) => string;
+    projectMetrics: (projectId: string) => string;
+    projectSearch: (projectId: string, query: string) => string;
+    user: (userId: string) => string;
+    userProjects: (userId: string) => string;
+};
+export declare const cacheTTL: {
+    short: number;
+    medium: number;
+    long: number;
+    day: number;
+};
+export {};
+//# sourceMappingURL=cache.d.ts.map