@plyaz/auth 1.0.0

package/src/session/memory-store.ts

@@ -0,0 +1,320 @@
+/**
+ * @fileoverview Memory-based session store for @plyaz/auth
+ * @module @plyaz/auth/session/memory-store
+ * 
+ * @description
+ * Implements session storage using in-memory storage. Provides fast session
+ * access but sessions are lost on server restart. Suitable for development,
+ * testing, or single-instance applications where session persistence across
+ * restarts is not required.
+ * 
+ * @example
+ * ```typescript
+ * import { MemoryStore } from '@plyaz/auth';
+ * 
+ * const store = new MemoryStore({
+ *   maxSessionsPerUser: 10,
+ *   cleanupInterval: 300
+ * });
+ * 
+ * await store.set('session_123', sessionData, 3600);
+ * ```
+ */
+
+import { NUMERIX } from "@plyaz/config";
+import type { SessionData, SessionStore, SessionStoreConfig } from "@plyaz/types";
+
+
+/**
+ * Memory store configuration
+ */
+export interface MemoryStoreConfig extends Partial<SessionStoreConfig> {
+  /** Enable automatic cleanup */
+  autoCleanup?: boolean;
+}
+
+/**
+ * Memory-based session store implementation
+ * Stores session data in server memory (Map)
+ */
+export class MemoryStore implements SessionStore {
+  private readonly config: Required<MemoryStoreConfig>;
+  private readonly sessions = new Map<string, SessionData>();
+  private readonly userSessions = new Map<string, Set<string>>();
+  private cleanupTimer?:string;
+
+  constructor(config: MemoryStoreConfig = {}) {
+    this.config = {
+      defaultTTL: 3600,
+      maxSessionsPerUser: 5,
+      cleanupInterval: 300,
+      keyPrefix: 'session:',
+      autoCleanup: true,
+      ...config
+    };
+
+    // Start automatic cleanup if enabled
+    if (this.config.autoCleanup) {
+      this.startCleanupTimer();
+    }
+  }
+
+  /**
+   * Store session data in memory
+   * @param sessionId - Session identifier
+   * @param data - Session data to store
+   * @param ttlSeconds - Time to live in seconds
+   */
+  async set(sessionId: string, data: SessionData, ttlSeconds: number): Promise<void> {
+    const sessionData: SessionData = {
+      ...data,
+      expiresAt: new Date(Date.now() + ttlSeconds * NUMERIX.THOUSAND)
+    };
+
+    // Enforce session limits per user
+    await this.enforceSessionLimits(data.userId);
+
+    // Store session
+    this.sessions.set(sessionId, sessionData);
+
+    // Track user sessions
+    if (!this.userSessions.has(data.userId)) {
+      this.userSessions.set(data.userId, new Set());
+    }
+    this.userSessions.get(data.userId)!.add(sessionId);
+  }
+
+  /**
+   * Retrieve session data from memory
+   * @param sessionId - Session identifier
+   * @returns Session data or null if not found/expired
+   */
+  async get(sessionId: string): Promise<SessionData | null> {
+    const data = this.sessions.get(sessionId);
+    
+    if (!data) {
+      return null;
+    }
+
+    // Check expiration
+    if (data.expiresAt < new Date()) {
+      await this.delete(sessionId);
+      return null;
+    }
+
+    return data;
+  }
+
+  /**
+   * Delete session from memory
+   * @param sessionId - Session identifier
+   */
+  async delete(sessionId: string): Promise<void> {
+    const data = this.sessions.get(sessionId);
+    
+    if (data) {
+      // Remove from sessions
+      this.sessions.delete(sessionId);
+      
+      // Remove from user sessions tracking
+      const userSessionSet = this.userSessions.get(data.userId);
+      if (userSessionSet) {
+        userSessionSet.delete(sessionId);
+        if (userSessionSet.size === 0) {
+          this.userSessions.delete(data.userId);
+        }
+      }
+    }
+  }
+
+  /**
+   * Delete all sessions for a user
+   * @param userId - User identifier
+   * @returns Number of deleted sessions
+   */
+  async deleteByUserId(userId: string): Promise<number> {
+    const userSessionSet = this.userSessions.get(userId);
+    
+    if (!userSessionSet) {
+      return 0;
+    }
+
+    const sessionIds = Array.from(userSessionSet);
+    let deletedCount = 0;
+
+    for (const sessionId of sessionIds) {
+      if (this.sessions.has(sessionId)) {
+        this.sessions.delete(sessionId);
+        deletedCount++;
+      }
+    }
+
+    // Clear user session tracking
+    this.userSessions.delete(userId);
+    
+    return deletedCount;
+  }
+
+  /**
+   * Update session activity timestamp
+   * @param sessionId - Session identifier
+   */
+  async updateActivity(sessionId: string): Promise<void> {
+    const data = this.sessions.get(sessionId);
+    if (data) {
+      data.lastActivityAt = new Date();
+      this.sessions.set(sessionId, data);
+    }
+  }
+
+  /**
+   * Check if session exists and is valid
+   * @param sessionId - Session identifier
+   * @returns True if session exists and is valid
+   */
+  async exists(sessionId: string): Promise<boolean> {
+    const data = await this.get(sessionId);
+    return data !== null;
+  }
+
+  /**
+   * Get all active sessions for a user
+   * @param userId - User identifier
+   * @returns Array of session data
+   */
+  async getByUserId(userId: string): Promise<SessionData[]> {
+    const userSessionSet = this.userSessions.get(userId);
+    
+    if (!userSessionSet) {
+      return [];
+    }
+
+    const userSessions: SessionData[] = [];
+    const now = new Date();
+
+    for (const sessionId of userSessionSet) {
+      const data = this.sessions.get(sessionId);
+      if (data && data.expiresAt > now) {
+        userSessions.push(data);
+      }
+    }
+
+    return userSessions;
+  }
+
+  /**
+   * Clean up expired sessions
+   * @returns Number of cleaned sessions
+   */
+  async cleanup(): Promise<number> {
+    let cleanedCount = 0;
+    const now = new Date();
+    const expiredSessions: string[] = [];
+
+    // Find expired sessions
+    for (const [sessionId, data] of this.sessions.entries()) {
+      if (data.expiresAt < now) {
+        expiredSessions.push(sessionId);
+      }
+    }
+
+    // Delete expired sessions
+    for (const sessionId of expiredSessions) {
+      await this.delete(sessionId);
+      cleanedCount++;
+    }
+
+    return cleanedCount;
+  }
+
+  /**
+   * Get session count for a user
+   * @param userId - User identifier
+   * @returns Session count
+   */
+  async getSessionCount(userId: string): Promise<number> {
+    const sessions = await this.getByUserId(userId);
+    return sessions.length;
+  }
+
+  /**
+   * Get total number of active sessions
+   * @returns Total session count
+   */
+  getTotalSessionCount(): number {
+    return this.sessions.size;
+  }
+
+  /**
+   * Get memory usage statistics
+   * @returns Memory usage information
+   */
+  getStats(): {
+    totalSessions: number;
+    totalUsers: number;
+    memoryUsage: number;
+  } {
+    return {
+      totalSessions: this.sessions.size,
+      totalUsers: this.userSessions.size,
+      memoryUsage: this.estimateMemoryUsage()
+    };
+  }
+
+  /**
+   * Destroy the store and cleanup resources
+   */
+  destroy(): void {
+    if (this.cleanupTimer) {
+
+      this.cleanupTimer = undefined;
+    }
+    
+    this.sessions.clear();
+    this.userSessions.clear();
+  }
+
+  /**
+   * Enforce session limits per user
+   * @param userId - User identifier
+   * @private
+   */
+  private async enforceSessionLimits(userId: string): Promise<void> {
+    const userSessions = await this.getByUserId(userId);
+    
+    if (userSessions.length >= this.config.maxSessionsPerUser) {
+      // Sort by last activity (oldest first)
+      userSessions.sort((a, b) => a.lastActivityAt.getTime() - b.lastActivityAt.getTime());
+      
+      // Remove oldest sessions to make room
+      const sessionsToRemove = userSessions.length - this.config.maxSessionsPerUser + 1;
+      for (let i = 0; i < sessionsToRemove; i++) {
+        await this.delete(userSessions[i].id);
+      }
+    }
+  }
+
+  /**
+   * Start automatic cleanup timer
+   * @private
+   */
+  private startCleanupTimer(): void {
+   
+  }
+
+  /**
+   * Estimate memory usage (rough calculation)
+   * @returns Estimated memory usage in bytes
+   * @private
+   */
+  private estimateMemoryUsage(): number {
+    let totalSize = 0;
+    
+    for (const [sessionId, data] of this.sessions.entries()) {
+      totalSize += sessionId.length * NUMERIX.TWO; // UTF-16 encoding
+      totalSize += JSON.stringify(data).length * NUMERIX.TWO;
+    }
+    
+    return totalSize;
+  }
+}