@joonweb/joonweb-sdk 1.0.0

package/src/Auth/session/storage/PostgreSQLStorage.js

@@ -0,0 +1,372 @@
+// src/Auth/session/storage/PostgreSQLStorage.js
+let pg;
+
+try {
+    pg = require('pg');
+} catch (error) {
+    // pg package not installed
+    pg = null;
+}
+
+class PostgreSQLStorage {
+    constructor(options = {}) {
+        if (!pg) {
+            throw new Error('pg package not installed. Run: npm install pg');
+        }
+        
+        this.config = {
+            host: options.host || 'localhost',
+            port: options.port || 5432,
+            user: options.user || 'postgres',
+            password: options.password || '',
+            database: options.database || 'joonweb_sessions',
+            max: options.max || 20,
+            idleTimeoutMillis: options.idleTimeoutMillis || 30000,
+            connectionTimeoutMillis: options.connectionTimeoutMillis || 2000,
+        };
+        
+        this.tableName = options.tableName || 'sessions';
+        this.schema = options.schema || 'public';
+        this.pool = null;
+        this.initialized = false;
+    }
+
+    async initDatabase() {
+        if (!this.pool) {
+            this.pool = new pg.Pool(this.config);
+            
+            // Test connection
+            const client = await this.pool.connect();
+            try {
+                // Create schema if it doesn't exist
+                await client.query(`CREATE SCHEMA IF NOT EXISTS ${this.schema}`);
+                
+                // Create table if not exists
+                await this.createTable(client);
+                
+                // Create cleanup job for expired sessions
+                await this.createCleanupTrigger(client);
+                
+                this.initialized = true;
+                console.log(`✅ PostgreSQL storage initialized (${this.config.database}.${this.schema}.${this.tableName})`);
+            } finally {
+                client.release();
+            }
+        }
+    }
+
+    async createTable(client) {
+        await client.query(`
+            CREATE TABLE IF NOT EXISTS ${this.schema}.${this.tableName} (
+                id VARCHAR(255) PRIMARY KEY,
+                site_domain VARCHAR(255) NOT NULL,
+                access_token TEXT NOT NULL,
+                scope TEXT,
+                user_data JSONB,
+                expires_at BIGINT,
+                authenticated_at BIGINT NOT NULL,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                is_online BOOLEAN DEFAULT FALSE,
+                online_access_info JSONB,
+                state VARCHAR(255),
+                metadata JSONB,
+                
+                -- Indexes for performance
+                CONSTRAINT unique_site_domain UNIQUE (site_domain)
+            )
+        `);
+
+        // Create indexes
+        await client.query(`
+            CREATE INDEX IF NOT EXISTS idx_sessions_expires_at 
+            ON ${this.schema}.${this.tableName} (expires_at) 
+            WHERE expires_at IS NOT NULL
+        `);
+        
+        await client.query(`
+            CREATE INDEX IF NOT EXISTS idx_sessions_created_at 
+            ON ${this.schema}.${this.tableName} (created_at)
+        `);
+        
+        await client.query(`
+            CREATE INDEX IF NOT EXISTS idx_sessions_is_online 
+            ON ${this.schema}.${this.tableName} (is_online)
+        `);
+    }
+
+    async createCleanupTrigger(client) {
+        // Create function to cleanup expired sessions
+        await client.query(`
+            CREATE OR REPLACE FUNCTION ${this.schema}.cleanup_expired_sessions()
+            RETURNS void AS $$
+            BEGIN
+                DELETE FROM ${this.schema}.${this.tableName}
+                WHERE expires_at IS NOT NULL 
+                AND expires_at < EXTRACT(EPOCH FROM CURRENT_TIMESTAMP) * 1000;
+            END;
+            $$ LANGUAGE plpgsql
+        `);
+    }
+
+    async ensureConnected() {
+        if (!this.initialized) {
+            await this.initDatabase();
+        }
+    }
+
+    async store(siteDomain, session) {
+        await this.ensureConnected();
+        
+        const client = await this.pool.connect();
+        try {
+            // Generate a unique ID for the session
+            const crypto = require('crypto');
+            const sessionId = crypto.randomBytes(16).toString('hex');
+            
+            await client.query(
+                `INSERT INTO ${this.schema}.${this.tableName} 
+                (id, site_domain, access_token, scope, user_data, expires_at, 
+                 authenticated_at, is_online, online_access_info, state, metadata)
+                VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)
+                ON CONFLICT (site_domain) 
+                DO UPDATE SET
+                access_token = EXCLUDED.access_token,
+                scope = EXCLUDED.scope,
+                user_data = EXCLUDED.user_data,
+                expires_at = EXCLUDED.expires_at,
+                is_online = EXCLUDED.is_online,
+                online_access_info = EXCLUDED.online_access_info,
+                state = EXCLUDED.state,
+                metadata = EXCLUDED.metadata,
+                updated_at = CURRENT_TIMESTAMP`,
+                [
+                    sessionId,
+                    siteDomain,
+                    session.access_token,
+                    session.scope,
+                    JSON.stringify(session.user || {}),
+                    session.expires_at,
+                    session.authenticated_at,
+                    session.is_online || false,
+                    JSON.stringify(session.online_access_info || {}),
+                    session.state || '',
+                    JSON.stringify(session.metadata || {})
+                ]
+            );
+            
+            return true;
+        } finally {
+            client.release();
+        }
+    }
+
+    async load(siteDomain) {
+        await this.ensureConnected();
+        
+        const client = await this.pool.connect();
+        try {
+            const result = await client.query(
+                `SELECT * FROM ${this.schema}.${this.tableName} 
+                 WHERE site_domain = $1 
+                 ORDER BY updated_at DESC LIMIT 1`,
+                [siteDomain]
+            );
+            
+            if (result.rows.length === 0) {
+                return null;
+            }
+            
+            const row = result.rows[0];
+            
+            // Parse JSONB fields (PostgreSQL returns them as objects)
+            const session = {
+                id: row.id,
+                site_domain: row.site_domain,
+                access_token: row.access_token,
+                scope: row.scope,
+                user: row.user_data || null,
+                expires_at: row.expires_at,
+                authenticated_at: row.authenticated_at,
+                is_online: Boolean(row.is_online),
+                online_access_info: row.online_access_info || {},
+                state: row.state,
+                metadata: row.metadata || {},
+                created_at: row.created_at,
+                updated_at: row.updated_at
+            };
+            
+            return session;
+        } finally {
+            client.release();
+        }
+    }
+
+    async delete(siteDomain) {
+        await this.ensureConnected();
+        
+        const client = await this.pool.connect();
+        try {
+            const result = await client.query(
+                `DELETE FROM ${this.schema}.${this.tableName} WHERE site_domain = $1`,
+                [siteDomain]
+            );
+            
+            return result.rowCount > 0;
+        } finally {
+            client.release();
+        }
+    }
+
+    async list() {
+        await this.ensureConnected();
+        
+        const client = await this.pool.connect();
+        try {
+            const result = await client.query(
+                `SELECT * FROM ${this.schema}.${this.tableName} 
+                 ORDER BY updated_at DESC`
+            );
+            
+            return result.rows.map(row => ({
+                id: row.id,
+                site_domain: row.site_domain,
+                access_token: row.access_token,
+                scope: row.scope,
+                user: row.user_data || null,
+                expires_at: row.expires_at,
+                authenticated_at: row.authenticated_at,
+                is_online: Boolean(row.is_online),
+                online_access_info: row.online_access_info || {},
+                state: row.state,
+                metadata: row.metadata || {},
+                created_at: row.created_at,
+                updated_at: row.updated_at
+            }));
+        } finally {
+            client.release();
+        }
+    }
+
+    async clear() {
+        await this.ensureConnected();
+        
+        const client = await this.pool.connect();
+        try {
+            await client.query(`TRUNCATE TABLE ${this.schema}.${this.tableName} RESTART IDENTITY`);
+            return true;
+        } finally {
+            client.release();
+        }
+    }
+
+    async close() {
+        if (this.pool) {
+            await this.pool.end();
+        }
+        return true;
+    }
+
+    async cleanupExpiredSessions() {
+        await this.ensureConnected();
+        
+        const client = await this.pool.connect();
+        try {
+            const result = await client.query(
+                `DELETE FROM ${this.schema}.${this.tableName} 
+                 WHERE expires_at IS NOT NULL 
+                 AND expires_at < EXTRACT(EPOCH FROM CURRENT_TIMESTAMP) * 1000`
+            );
+            
+            if (result.rowCount > 0) {
+                console.log(`🧹 Cleaned up ${result.rowCount} expired sessions from PostgreSQL`);
+            }
+            
+            return result.rowCount;
+        } finally {
+            client.release();
+        }
+    }
+
+    async getStats() {
+        await this.ensureConnected();
+        
+        const client = await this.pool.connect();
+        try {
+            const result = await client.query(`
+                SELECT 
+                    COUNT(*) as total_sessions,
+                    COUNT(CASE WHEN expires_at IS NULL OR expires_at > EXTRACT(EPOCH FROM CURRENT_TIMESTAMP) * 1000 THEN 1 END) as active_sessions,
+                    COUNT(CASE WHEN is_online = TRUE THEN 1 END) as online_sessions,
+                    MIN(created_at) as oldest_session,
+                    MAX(updated_at) as latest_activity,
+                    pg_size_pretty(pg_total_relation_size('${this.schema}.${this.tableName}')) as table_size
+                FROM ${this.schema}.${this.tableName}
+            `);
+            
+            return result.rows[0];
+        } finally {
+            client.release();
+        }
+    }
+
+    async healthCheck() {
+        try {
+            await this.ensureConnected();
+            const client = await this.pool.connect();
+            await client.query('SELECT 1');
+            client.release();
+            
+            return { 
+                status: 'healthy', 
+                storage: 'postgresql',
+                database: this.config.database,
+                table: `${this.schema}.${this.tableName}`
+            };
+        } catch (error) {
+            return { 
+                status: 'unhealthy', 
+                storage: 'postgresql', 
+                error: error.message 
+            };
+        }
+    }
+
+    // PostgreSQL-specific: Full-text search
+    async searchSessions(searchTerm) {
+        await this.ensureConnected();
+        
+        const client = await this.pool.connect();
+        try {
+            const result = await client.query(
+                `SELECT * FROM ${this.schema}.${this.tableName} 
+                 WHERE site_domain ILIKE $1 
+                    OR access_token ILIKE $1
+                    OR scope ILIKE $1
+                    OR (metadata::text) ILIKE $1
+                 ORDER BY updated_at DESC`,
+                [`%${searchTerm}%`]
+            );
+            
+            return result.rows.map(row => ({
+                id: row.id,
+                site_domain: row.site_domain,
+                access_token: row.access_token,
+                scope: row.scope,
+                user: row.user_data || null,
+                expires_at: row.expires_at,
+                authenticated_at: row.authenticated_at,
+                is_online: Boolean(row.is_online),
+                online_access_info: row.online_access_info || {},
+                state: row.state,
+                metadata: row.metadata || {},
+                created_at: row.created_at,
+                updated_at: row.updated_at
+            }));
+        } finally {
+            client.release();
+        }
+    }
+}
+
+module.exports = PostgreSQLStorage;

package/src/Auth/session/storage/RedisStorage.js

@@ -0,0 +1,133 @@
+// src/Auth/session/storage/RedisStorage.js
+let redis;
+
+try {
+    redis = require('redis');
+} catch (error) {
+    // redis not installed
+    redis = null;
+}
+
+class RedisStorage {
+    constructor(options = {}) {
+        if (!redis) {
+            throw new Error('redis package not installed. Run: npm install redis');
+        }
+        
+        this.url = options.url || 'redis://localhost:6379';
+        this.prefix = options.prefix || 'joonweb:session:';
+        this.client = null;
+    }
+
+    async connect() {
+        if (!this.client) {
+            this.client = redis.createClient({ url: this.url });
+            await this.client.connect();
+            
+            // Handle connection errors
+            this.client.on('error', (err) => {
+                console.error('Redis connection error:', err);
+            });
+        }
+        return this.client;
+    }
+
+    async ensureConnected() {
+        if (!this.client) {
+            await this.connect();
+        }
+    }
+
+    async store(siteDomain, session) {
+        await this.ensureConnected();
+        
+        const key = `${this.prefix}${siteDomain}`;
+        const sessionData = JSON.stringify(session);
+        
+        if (session.expires_at) {
+            const ttl = Math.floor((session.expires_at - Date.now()) / 1000);
+            if (ttl > 0) {
+                await this.client.setEx(key, ttl, sessionData);
+            } else {
+                await this.client.set(key, sessionData);
+            }
+        } else {
+            await this.client.set(key, sessionData);
+        }
+        
+        return true;
+    }
+
+    async load(siteDomain) {
+        await this.ensureConnected();
+        
+        const key = `${this.prefix}${siteDomain}`;
+        const data = await this.client.get(key);
+        
+        if (!data) return null;
+        
+        try {
+            return JSON.parse(data);
+        } catch (error) {
+            console.error('Failed to parse Redis session data:', error);
+            return null;
+        }
+    }
+
+    async delete(siteDomain) {
+        await this.ensureConnected();
+        
+        const key = `${this.prefix}${siteDomain}`;
+        const result = await this.client.del(key);
+        return result > 0;
+    }
+
+    async list() {
+        await this.ensureConnected();
+        
+        const keys = await this.client.keys(`${this.prefix}*`);
+        const sessions = [];
+        
+        for (const key of keys) {
+            const data = await this.client.get(key);
+            if (data) {
+                try {
+                    sessions.push(JSON.parse(data));
+                } catch (error) {
+                    console.error(`Failed to parse session from key ${key}:`, error);
+                }
+            }
+        }
+        
+        return sessions;
+    }
+
+    async clear() {
+        await this.ensureConnected();
+        
+        const keys = await this.client.keys(`${this.prefix}*`);
+        if (keys.length > 0) {
+            await this.client.del(keys);
+        }
+        return true;
+    }
+
+    async close() {
+        if (this.client) {
+            await this.client.quit();
+        }
+        return true;
+    }
+
+    async ping() {
+        await this.ensureConnected();
+        return await this.client.ping();
+    }
+
+    async info() {
+        await this.ensureConnected();
+        return await this.client.info();
+    }
+}
+
+module.exports = RedisStorage;

package/src/Auth/session/storage/SQLiteStorage.js

@@ -0,0 +1,133 @@
+// src/Auth/session/storage/SQLiteStorage.js
+const sqlite3 = require('sqlite3').verbose();
+
+class SQLiteStorage {
+    constructor(options = {}) {
+        this.dbPath = options.path || './joonweb-sessions.db';
+        this.db = new sqlite3.Database(this.dbPath);
+        this.initDatabase();
+    }
+
+    async initDatabase() {
+        return new Promise((resolve, reject) => {
+            this.db.run(`
+                CREATE TABLE IF NOT EXISTS sessions (
+                    site_domain TEXT PRIMARY KEY,
+                    access_token TEXT NOT NULL,
+                    scope TEXT,
+                    user_data TEXT,
+                    expires_at INTEGER,
+                    authenticated_at INTEGER,
+                    created_at INTEGER DEFAULT (strftime('%s', 'now')),
+                    updated_at INTEGER DEFAULT (strftime('%s', 'now')),
+                    metadata TEXT
+                )
+            `, (err) => {
+                if (err) reject(err);
+                else resolve();
+            });
+        });
+    }
+
+    async store(siteDomain, session) {
+        return new Promise((resolve, reject) => {
+            this.db.run(
+                `INSERT OR REPLACE INTO sessions 
+                 (site_domain, access_token, scope, user_data, expires_at, 
+                  authenticated_at, updated_at, metadata)
+                 VALUES (?, ?, ?, ?, ?, ?, strftime('%s', 'now'), ?)`,
+                [
+                    siteDomain,
+                    session.access_token,
+                    session.scope,
+                    JSON.stringify(session.user || {}),
+                    session.expires_at,
+                    session.authenticated_at,
+                    JSON.stringify(session.metadata || {})
+                ],
+                (err) => {
+                    if (err) reject(err);
+                    else resolve(true);
+                }
+            );
+        });
+    }
+
+    async load(siteDomain) {
+        return new Promise((resolve, reject) => {
+            this.db.get(
+                'SELECT * FROM sessions WHERE site_domain = ?',
+                [siteDomain],
+                (err, row) => {
+                    if (err) {
+                        reject(err);
+                    } else if (row) {
+                        // Parse JSON fields
+                        const session = {
+                            site_domain: row.site_domain,
+                            access_token: row.access_token,
+                            scope: row.scope,
+                            user: JSON.parse(row.user_data || '{}'),
+                            expires_at: row.expires_at,
+                            authenticated_at: row.authenticated_at,
+                            metadata: JSON.parse(row.metadata || {})
+                        };
+                        resolve(session);
+                    } else {
+                        resolve(null);
+                    }
+                }
+            );
+        });
+    }
+
+    async delete(siteDomain) {
+        return new Promise((resolve, reject) => {
+            this.db.run('DELETE FROM sessions WHERE site_domain = ?', [siteDomain], (err) => {
+                if (err) reject(err);
+                else resolve(true);
+            });
+        });
+    }
+
+    async list() {
+        return new Promise((resolve, reject) => {
+            this.db.all('SELECT * FROM sessions', (err, rows) => {
+                if (err) {
+                    reject(err);
+                } else {
+                    const sessions = rows.map(row => ({
+                        site_domain: row.site_domain,
+                        access_token: row.access_token,
+                        scope: row.scope,
+                        user: JSON.parse(row.user_data || '{}'),
+                        expires_at: row.expires_at,
+                        authenticated_at: row.authenticated_at,
+                        metadata: JSON.parse(row.metadata || {})
+                    }));
+                    resolve(sessions);
+                }
+            });
+        });
+    }
+
+    async clear() {
+        return new Promise((resolve, reject) => {
+            this.db.run('DELETE FROM sessions', (err) => {
+                if (err) reject(err);
+                else resolve(true);
+            });
+        });
+    }
+
+    async close() {
+        return new Promise((resolve, reject) => {
+            this.db.close((err) => {
+                if (err) reject(err);
+                else resolve(true);
+            });
+        });
+    }
+}
+
+module.exports = SQLiteStorage;

package/src/Auth/session/storage/index.js

@@ -0,0 +1,46 @@
+// src/Auth/session/storage/index.js
+const MemoryStorage = require('./MemoryStorage');
+const SQLiteStorage = require('./SQLiteStorage');
+const MongoDBStorage = require('./MongoDBStorage');
+const RedisStorage = require('./RedisStorage');
+const MySQLStorage = require('./MySQLStorage');
+const PostgreSQLStorage = require('./PostgreSQLStorage');
+
+function createStorageAdapter(type = 'memory', options = {}) {
+    const normalizedType = type.toLowerCase();
+    
+    switch (normalizedType) {
+        case 'sqlite':
+            return new SQLiteStorage(options);
+        
+        case 'mongodb':
+            return new MongoDBStorage(options);
+        
+        case 'redis':
+            return new RedisStorage(options);
+        
+        case 'mysql':
+        case 'mariadb':
+            return new MySQLStorage(options);
+        
+        case 'postgres':
+        case 'postgresql':
+        case 'pgsql':
+            return new PostgreSQLStorage(options);
+        
+        case 'memory':
+        default:
+            return new MemoryStorage();
+    }
+}
+
+// Export everything
+module.exports = {
+    MemoryStorage,
+    SQLiteStorage,
+    MongoDBStorage,
+    RedisStorage,
+    MySQLStorage,
+    PostgreSQLStorage,
+    createStorageAdapter
+};