@juspay/neurolink 9.31.2 → 9.32.1

package/dist/auth/sessionManager.js

@@ -0,0 +1,437 @@
+// src/lib/auth/sessionManager.ts
+import { logger } from "../utils/logger.js";
+/** Mask an identifier for safe logging: show first 4 chars + "***" */
+function maskId(id) {
+    if (id.length <= 4) {
+        return "***";
+    }
+    return `${id.slice(0, 4)}***`;
+}
+/**
+ * In-memory session storage
+ *
+ * Simple session storage using Map. Suitable for single-instance deployments
+ * or development. Sessions are lost on restart.
+ */
+export class MemorySessionStorage {
+    sessions = new Map();
+    userSessions = new Map();
+    async get(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            return null;
+        }
+        // Check expiration
+        if (session.expiresAt && new Date() > session.expiresAt) {
+            await this.delete(sessionId);
+            return null;
+        }
+        return session;
+    }
+    async set(session) {
+        this.sessions.set(session.id, session);
+        // Track user's sessions
+        if (!this.userSessions.has(session.user.id)) {
+            this.userSessions.set(session.user.id, new Set());
+        }
+        this.userSessions.get(session.user.id).add(session.id);
+    }
+    async delete(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (session) {
+            const userSessionSet = this.userSessions.get(session.user.id);
+            if (userSessionSet) {
+                userSessionSet.delete(sessionId);
+                if (userSessionSet.size === 0) {
+                    this.userSessions.delete(session.user.id);
+                }
+            }
+            this.sessions.delete(sessionId);
+        }
+    }
+    async getUserSessions(userId) {
+        const sessionIds = this.userSessions.get(userId);
+        if (!sessionIds) {
+            return [];
+        }
+        const sessions = [];
+        for (const sessionId of sessionIds) {
+            const session = await this.get(sessionId);
+            if (session) {
+                sessions.push(session);
+            }
+        }
+        return sessions;
+    }
+    async deleteUserSessions(userId) {
+        const sessionIds = this.userSessions.get(userId);
+        if (sessionIds) {
+            for (const sessionId of sessionIds) {
+                this.sessions.delete(sessionId);
+            }
+            this.userSessions.delete(userId);
+        }
+    }
+    async clear() {
+        this.sessions.clear();
+        this.userSessions.clear();
+    }
+    async isHealthy() {
+        return true;
+    }
+}
+/**
+ * Redis session storage
+ *
+ * Distributed session storage using Redis. Suitable for multi-instance
+ * deployments. Requires ioredis or similar Redis client.
+ *
+ * Note: Redis client must be provided or configured via environment.
+ */
+export class RedisSessionStorage {
+    prefix;
+    ttl;
+    redisUrl;
+    client = null;
+    initPromise = null;
+    constructor(config) {
+        this.redisUrl = config.url;
+        this.prefix = config.prefix || "neurolink:sessions:";
+        this.ttl = config.ttl || 3600;
+    }
+    async getClient() {
+        if (this.client) {
+            return this.client;
+        }
+        if (!this.initPromise) {
+            this.initPromise = this.createClient();
+        }
+        return this.initPromise;
+    }
+    async createClient() {
+        try {
+            // Use variable indirection to prevent TypeScript from resolving the module at compile time
+            const moduleName = "ioredis";
+            const ioredis = await import(/* @vite-ignore */ moduleName);
+            const Redis = ioredis.default || ioredis.Redis;
+            this.client = new Redis(this.redisUrl);
+            return this.client;
+        }
+        catch {
+            this.initPromise = null;
+            logger.error('Redis client (ioredis) not available. Install ioredis package and ensure Redis is reachable when using storage: "redis".');
+            throw new Error("Redis client not available");
+        }
+    }
+    sessionKey(sessionId) {
+        return `${this.prefix}${sessionId}`;
+    }
+    userSessionsKey(userId) {
+        return `${this.prefix}user:${userId}`;
+    }
+    async get(sessionId) {
+        try {
+            const client = await this.getClient();
+            const data = await client.get(this.sessionKey(sessionId));
+            if (!data) {
+                return null;
+            }
+            const session = JSON.parse(data);
+            // Parse dates
+            session.createdAt = new Date(session.createdAt);
+            if (session.expiresAt !== null && session.expiresAt !== undefined) {
+                session.expiresAt = new Date(session.expiresAt);
+            }
+            // Check expiration
+            if (new Date() > session.expiresAt) {
+                await this.delete(sessionId);
+                return null;
+            }
+            return session;
+        }
+        catch (error) {
+            logger.error("Redis session get error:", error);
+            return null;
+        }
+    }
+    async set(session) {
+        try {
+            const client = await this.getClient();
+            // Calculate TTL from session expiration
+            const ttlSeconds = session.expiresAt
+                ? Math.max(1, Math.floor((session.expiresAt.getTime() - Date.now()) / 1000))
+                : this.ttl;
+            // Store session
+            await client.setex(this.sessionKey(session.id), ttlSeconds, JSON.stringify(session));
+            // Track user's sessions
+            await client.sadd(this.userSessionsKey(session.user.id), session.id);
+            await client.expire(this.userSessionsKey(session.user.id), this.ttl);
+        }
+        catch (error) {
+            logger.error("Redis session set error:", error);
+            throw error;
+        }
+    }
+    async delete(sessionId) {
+        try {
+            const client = await this.getClient();
+            // Read the raw session data directly instead of calling this.get(),
+            // which checks expiration and calls this.delete() — causing infinite
+            // recursion for expired sessions.
+            const data = await client.get(this.sessionKey(sessionId));
+            if (data) {
+                try {
+                    const session = JSON.parse(data);
+                    await client.srem(this.userSessionsKey(session.user.id), sessionId);
+                }
+                catch {
+                    // If parsing fails, we still delete the key below
+                    logger.warn(`Failed to parse session data for cleanup: ${maskId(sessionId)}`);
+                }
+            }
+            await client.del(this.sessionKey(sessionId));
+        }
+        catch (error) {
+            logger.error("Redis session delete error:", error);
+        }
+    }
+    async getUserSessions(userId) {
+        try {
+            const client = await this.getClient();
+            const sessionIds = await client.smembers(this.userSessionsKey(userId));
+            const sessions = [];
+            for (const sessionId of sessionIds) {
+                const session = await this.get(sessionId);
+                if (session) {
+                    sessions.push(session);
+                }
+            }
+            return sessions;
+        }
+        catch (error) {
+            logger.error("Redis getUserSessions error:", error);
+            return [];
+        }
+    }
+    async deleteUserSessions(userId) {
+        try {
+            const client = await this.getClient();
+            const sessionIds = await client.smembers(this.userSessionsKey(userId));
+            for (const sessionId of sessionIds) {
+                await client.del(this.sessionKey(sessionId));
+            }
+            await client.del(this.userSessionsKey(userId));
+        }
+        catch (error) {
+            logger.error("Redis deleteUserSessions error:", error);
+        }
+    }
+    async clear() {
+        try {
+            const client = await this.getClient();
+            // Use SCAN instead of KEYS to avoid blocking Redis in production
+            let cursor = "0";
+            do {
+                const [nextCursor, keys] = await client.scan(cursor, "MATCH", `${this.prefix}*`, "COUNT", "100");
+                cursor = nextCursor;
+                if (keys.length > 0) {
+                    await client.del(...keys);
+                }
+            } while (cursor !== "0");
+        }
+        catch (error) {
+            logger.error("Redis clear error:", error);
+        }
+    }
+    async isHealthy() {
+        try {
+            const client = await this.getClient();
+            const pong = await client.ping();
+            return pong === "PONG";
+        }
+        catch {
+            return false;
+        }
+    }
+    async disconnect() {
+        if (this.client) {
+            await this.client.quit();
+            this.client = null;
+            this.initPromise = null;
+        }
+    }
+}
+/**
+ * Session Manager
+ *
+ * High-level session management that handles session lifecycle,
+ * automatic refresh, and storage abstraction.
+ */
+export class SessionManager {
+    storage;
+    config;
+    constructor(config = {}) {
+        this.config = {
+            ...config,
+            duration: config.duration || 3600,
+            autoRefresh: config.autoRefresh ?? true,
+            refreshThreshold: config.refreshThreshold || 300,
+            storage: config.storage || "memory",
+        };
+        // Initialize storage based on config
+        this.storage = this.createStorage();
+    }
+    createStorage() {
+        switch (this.config.storage) {
+            case "redis":
+                if (!this.config.redis?.url) {
+                    logger.warn("Redis URL not provided, falling back to memory storage");
+                    return new MemorySessionStorage();
+                }
+                return new RedisSessionStorage({
+                    url: this.config.redis.url,
+                    prefix: this.config.redis.prefix,
+                    ttl: this.config.redis.ttl || this.config.duration,
+                });
+            case "memory":
+            default:
+                return new MemorySessionStorage();
+        }
+    }
+    /**
+     * Create a new session
+     */
+    async createSession(user, metadata) {
+        const sessionId = crypto.randomUUID();
+        const now = new Date();
+        const duration = this.config.duration || 3600;
+        const session = {
+            id: sessionId,
+            user,
+            createdAt: now,
+            expiresAt: new Date(now.getTime() + duration * 1000),
+            isValid: true,
+            ipAddress: metadata?.ipAddress,
+            userAgent: metadata?.userAgent,
+            deviceId: metadata?.deviceId,
+        };
+        await this.storage.set(session);
+        logger.debug(`Session created: ${maskId(sessionId)} for user: ${maskId(user.id)}`);
+        return session;
+    }
+    /**
+     * Get a session by ID
+     *
+     * Optionally auto-refreshes if close to expiration.
+     */
+    async getSession(sessionId, autoRefresh = this.config.autoRefresh) {
+        const session = await this.storage.get(sessionId);
+        if (!session) {
+            return null;
+        }
+        // Auto-refresh if close to expiration
+        if (autoRefresh && this.shouldRefresh(session)) {
+            return this.refreshSession(sessionId);
+        }
+        return session;
+    }
+    /**
+     * Check if session should be refreshed
+     */
+    shouldRefresh(session) {
+        if (!session.expiresAt) {
+            return false;
+        }
+        const threshold = this.config.refreshThreshold || 300;
+        const timeUntilExpiry = (session.expiresAt.getTime() - Date.now()) / 1000;
+        return timeUntilExpiry < threshold;
+    }
+    /**
+     * Refresh a session
+     */
+    async refreshSession(sessionId) {
+        const session = await this.storage.get(sessionId);
+        if (!session) {
+            return null;
+        }
+        const duration = this.config.duration || 3600;
+        session.expiresAt = new Date(Date.now() + duration * 1000);
+        await this.storage.set(session);
+        logger.debug(`Session refreshed: ${maskId(sessionId)}`);
+        return session;
+    }
+    /**
+     * Destroy a session
+     */
+    async destroySession(sessionId) {
+        await this.storage.delete(sessionId);
+        logger.debug(`Session destroyed: ${maskId(sessionId)}`);
+    }
+    /**
+     * Get all sessions for a user
+     */
+    async getUserSessions(userId) {
+        return this.storage.getUserSessions(userId);
+    }
+    /**
+     * Destroy all sessions for a user (global logout)
+     */
+    async destroyAllUserSessions(userId) {
+        await this.storage.deleteUserSessions(userId);
+        logger.debug(`All sessions destroyed for user: ${maskId(userId)}`);
+    }
+    /**
+     * Validate a session is still active
+     */
+    async validateSession(sessionId) {
+        const session = await this.storage.get(sessionId);
+        return session !== null && session.isValid;
+    }
+    /**
+     * Update session metadata
+     */
+    async updateSessionMetadata(sessionId, metadata) {
+        const session = await this.storage.get(sessionId);
+        if (!session) {
+            return null;
+        }
+        session.metadata = {
+            ...session.metadata,
+            ...metadata,
+        };
+        await this.storage.set(session);
+        return session;
+    }
+    /**
+     * Health check
+     */
+    async isHealthy() {
+        return this.storage.isHealthy();
+    }
+    /**
+     * Clear all sessions (for testing/cleanup)
+     */
+    async clear() {
+        await this.storage.clear();
+    }
+}
+/**
+ * Create session storage based on configuration
+ */
+export function createSessionStorage(config) {
+    switch (config.storage) {
+        case "redis":
+            if (!config.redis?.url) {
+                logger.warn("Redis URL not provided, falling back to memory storage");
+                return new MemorySessionStorage();
+            }
+            return new RedisSessionStorage({
+                url: config.redis.url,
+                prefix: config.redis.prefix,
+                ttl: config.redis.ttl || config.duration,
+            });
+        case "memory":
+        default:
+            return new MemorySessionStorage();
+    }
+}

package/dist/cli/commands/authProviders.d.ts

@@ -0,0 +1,43 @@
+import type { ArgumentsCamelCase } from "yargs";
+import type { AuthProviderType } from "../../lib/types/authTypes.js";
+/**
+ * Auth command argument types
+ */
+export type AuthProvidersArgs = {
+    format?: "text" | "json" | "table";
+};
+export type AuthValidateArgs = {
+    token: string;
+    provider: AuthProviderType;
+    domain?: string;
+    clientId?: string;
+    secretKey?: string;
+    secret?: string;
+    url?: string;
+    anonKey?: string;
+    apiKey?: string;
+    format?: "text" | "json";
+};
+export type AuthHealthArgs = {
+    provider: AuthProviderType;
+    domain?: string;
+    clientId?: string;
+    secretKey?: string;
+    secret?: string;
+    url?: string;
+    anonKey?: string;
+    apiKey?: string;
+    format?: "text" | "json";
+};
+/**
+ * Handle 'auth providers' command
+ */
+export declare function handleProvidersCommand(argv: ArgumentsCamelCase<AuthProvidersArgs>): Promise<void>;
+/**
+ * Handle 'auth validate' command
+ */
+export declare function handleValidateCommand(argv: ArgumentsCamelCase<AuthValidateArgs>): Promise<void>;
+/**
+ * Handle 'auth health' command
+ */
+export declare function handleHealthCommand(argv: ArgumentsCamelCase<AuthHealthArgs>): Promise<void>;