@joonweb/joonweb-sdk 1.0.0

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

@@ -0,0 +1,107 @@
+// src/Auth/session/storage/MongoDBStorage.js
+let MongoClient;
+
+try {
+    MongoClient = require('mongodb').MongoClient;
+} catch (error) {
+    // mongodb not installed
+    MongoClient = null;
+}
+
+class MongoDBStorage {
+    constructor(options = {}) {
+        if (!MongoClient) {
+            throw new Error('mongodb package not installed. Run: npm install mongodb');
+        }
+        
+        this.url = options.url || 'mongodb://localhost:27017';
+        this.dbName = options.dbName || 'joonweb';
+        this.collectionName = options.collectionName || 'sessions';
+        this.client = null;
+        this.collection = null;
+    }
+
+    async initDatabase() {
+        this.client = new MongoClient(this.url);
+        await this.client.connect();
+        const db = this.client.db(this.dbName);
+        this.collection = db.collection(this.collectionName);
+        
+        // Create TTL index for automatic expiry
+        await this.collection.createIndex(
+            { expires_at: 1 },
+            { expireAfterSeconds: 0 }
+        );
+        
+        // Create index on site_domain
+        await this.collection.createIndex({ site_domain: 1 }, { unique: true });
+    }
+
+    async ensureConnected() {
+        if (!this.collection) {
+            await this.initDatabase();
+        }
+    }
+
+    async store(siteDomain, session) {
+        await this.ensureConnected();
+        
+        await this.collection.updateOne(
+            { site_domain: siteDomain },
+            { 
+                $set: { 
+                    ...session, 
+                    updated_at: Date.now(),
+                    _id: siteDomain // Use siteDomain as _id for uniqueness
+                } 
+            },
+            { upsert: true }
+        );
+        return true;
+    }
+
+    async load(siteDomain) {
+        await this.ensureConnected();
+        const session = await this.collection.findOne({ site_domain: siteDomain });
+        
+        if (session) {
+            // Remove MongoDB _id field
+            delete session._id;
+            return session;
+        }
+        
+        return null;
+    }
+
+    async delete(siteDomain) {
+        await this.ensureConnected();
+        const result = await this.collection.deleteOne({ site_domain: siteDomain });
+        return result.deletedCount > 0;
+    }
+
+    async list() {
+        await this.ensureConnected();
+        const sessions = await this.collection.find({}).toArray();
+        
+        // Remove MongoDB _id field from all sessions
+        return sessions.map(session => {
+            const { _id, ...rest } = session;
+            return rest;
+        });
+    }
+
+    async clear() {
+        await this.ensureConnected();
+        await this.collection.deleteMany({});
+        return true;
+    }
+
+    async close() {
+        if (this.client) {
+            await this.client.close();
+        }
+        return true;
+    }
+}
+
+module.exports = MongoDBStorage;

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

@@ -0,0 +1,281 @@
+// src/Auth/session/storage/MySQLStorage.js
+let mysql;
+
+try {
+    mysql = require('mysql2/promise');
+} catch (error) {
+    // mysql2 not installed
+    mysql = null;
+}
+
+class MySQLStorage {
+    constructor(options = {}) {
+        if (!mysql) {
+            throw new Error('mysql2 package not installed. Run: npm install mysql2');
+        }
+        
+        this.config = {
+            host: options.host || 'localhost',
+            port: options.port || 3306,
+            user: options.user || 'root',
+            password: options.password || '',
+            database: options.database || 'joonweb_sessions',
+            connectionLimit: options.connectionLimit || 10,
+            waitForConnections: true,
+            queueLimit: 0,
+            enableKeepAlive: true,
+            keepAliveInitialDelay: 0
+        };
+        
+        this.tableName = options.tableName || 'sessions';
+        this.pool = null;
+    }
+
+    async initDatabase() {
+        if (!this.pool) {
+            this.pool = mysql.createPool(this.config);
+            
+            // Create table if not exists
+            await this.createTable();
+        }
+    }
+
+    async createTable() {
+        const connection = await this.pool.getConnection();
+        try {
+            await connection.query(`
+                CREATE TABLE IF NOT EXISTS \`${this.tableName}\` (
+                    \`id\` VARCHAR(255) NOT NULL,
+                    \`site_domain\` VARCHAR(255) NOT NULL,
+                    \`access_token\` TEXT NOT NULL,
+                    \`scope\` TEXT,
+                    \`user_data\` JSON,
+                    \`expires_at\` BIGINT,
+                    \`authenticated_at\` BIGINT,
+                    \`created_at\` TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    \`updated_at\` TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+                    \`is_online\` BOOLEAN DEFAULT FALSE,
+                    \`online_access_info\` JSON,
+                    \`state\` VARCHAR(255),
+                    \`metadata\` JSON,
+                    PRIMARY KEY (\`id\`),
+                    UNIQUE KEY \`idx_site_domain\` (\`site_domain\`),
+                    KEY \`idx_expires_at\` (\`expires_at\`),
+                    KEY \`idx_created_at\` (\`created_at\`)
+                ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
+            `);
+            
+            // Add cleanup event for expired sessions
+            await this.cleanupExpiredSessions();
+        } finally {
+            connection.release();
+        }
+    }
+
+    async ensureConnected() {
+        if (!this.pool) {
+            await this.initDatabase();
+        }
+    }
+
+    async store(siteDomain, session) {
+        await this.ensureConnected();
+        
+        const connection = await this.pool.getConnection();
+        try {
+            // Generate a unique ID for the session
+            const sessionId = require('crypto').randomBytes(16).toString('hex');
+            
+            await connection.query(
+                `INSERT INTO \`${this.tableName}\` 
+                (id, site_domain, access_token, scope, user_data, expires_at, authenticated_at, is_online, online_access_info, state, metadata)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                ON DUPLICATE KEY UPDATE
+                access_token = VALUES(access_token),
+                scope = VALUES(scope),
+                user_data = VALUES(user_data),
+                expires_at = VALUES(expires_at),
+                is_online = VALUES(is_online),
+                online_access_info = VALUES(online_access_info),
+                state = VALUES(state),
+                metadata = VALUES(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 {
+            connection.release();
+        }
+    }
+
+    async load(siteDomain) {
+        await this.ensureConnected();
+        
+        const connection = await this.pool.getConnection();
+        try {
+            const [rows] = await connection.query(
+                `SELECT * FROM \`${this.tableName}\` WHERE site_domain = ? ORDER BY updated_at DESC LIMIT 1`,
+                [siteDomain]
+            );
+            
+            if (rows.length === 0) {
+                return null;
+            }
+            
+            const row = rows[0];
+            
+            // Parse JSON fields
+            const session = {
+                id: row.id,
+                site_domain: row.site_domain,
+                access_token: row.access_token,
+                scope: row.scope,
+                user: row.user_data ? JSON.parse(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 ? JSON.parse(row.online_access_info) : {},
+                state: row.state,
+                metadata: row.metadata ? JSON.parse(row.metadata) : {},
+                created_at: row.created_at,
+                updated_at: row.updated_at
+            };
+            
+            return session;
+        } finally {
+            connection.release();
+        }
+    }
+
+    async delete(siteDomain) {
+        await this.ensureConnected();
+        
+        const connection = await this.pool.getConnection();
+        try {
+            const [result] = await connection.query(
+                `DELETE FROM \`${this.tableName}\` WHERE site_domain = ?`,
+                [siteDomain]
+            );
+            
+            return result.affectedRows > 0;
+        } finally {
+            connection.release();
+        }
+    }
+
+    async list() {
+        await this.ensureConnected();
+        
+        const connection = await this.pool.getConnection();
+        try {
+            const [rows] = await connection.query(
+                `SELECT * FROM \`${this.tableName}\` ORDER BY updated_at DESC`
+            );
+            
+            return rows.map(row => ({
+                id: row.id,
+                site_domain: row.site_domain,
+                access_token: row.access_token,
+                scope: row.scope,
+                user: row.user_data ? JSON.parse(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 ? JSON.parse(row.online_access_info) : {},
+                state: row.state,
+                metadata: row.metadata ? JSON.parse(row.metadata) : {},
+                created_at: row.created_at,
+                updated_at: row.updated_at
+            }));
+        } finally {
+            connection.release();
+        }
+    }
+
+    async clear() {
+        await this.ensureConnected();
+        
+        const connection = await this.pool.getConnection();
+        try {
+            await connection.query(`TRUNCATE TABLE \`${this.tableName}\``);
+            return true;
+        } finally {
+            connection.release();
+        }
+    }
+
+    async close() {
+        if (this.pool) {
+            await this.pool.end();
+        }
+        return true;
+    }
+
+    async cleanupExpiredSessions() {
+        await this.ensureConnected();
+        
+        const connection = await this.pool.getConnection();
+        try {
+            const [result] = await connection.query(
+                `DELETE FROM \`${this.tableName}\` WHERE expires_at IS NOT NULL AND expires_at < ?`,
+                [Date.now()]
+            );
+            
+            if (result.affectedRows > 0) {
+                console.log(`🧹 Cleaned up ${result.affectedRows} expired sessions from MySQL`);
+            }
+            
+            return result.affectedRows;
+        } finally {
+            connection.release();
+        }
+    }
+
+    async getStats() {
+        await this.ensureConnected();
+        
+        const connection = await this.pool.getConnection();
+        try {
+            const [rows] = await connection.query(`
+                SELECT 
+                    COUNT(*) as total_sessions,
+                    COUNT(CASE WHEN expires_at IS NULL OR expires_at > ? 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
+                FROM \`${this.tableName}\`
+            `, [Date.now()]);
+            
+            return rows[0];
+        } finally {
+            connection.release();
+        }
+    }
+
+    async healthCheck() {
+        try {
+            await this.ensureConnected();
+            const connection = await this.pool.getConnection();
+            await connection.ping();
+            connection.release();
+            return { status: 'healthy', storage: 'mysql' };
+        } catch (error) {
+            return { status: 'unhealthy', storage: 'mysql', error: error.message };
+        }
+    }
+}
+
+module.exports = MySQLStorage;