@ductape/sdk 0.1.6 → 0.1.8

package/dist/sessions/sessions.service.js

@@ -1,988 +0,0 @@
-"use strict";
-/**
- * SessionsService - Main Sessions Service Class
- *
- * Provides a unified interface for JWT-based session management including
- * creating, refreshing, verifying, and revoking sessions.
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SessionsService = exports.SessionError = void 0;
-const sessions_resolver_1 = require("./sessions.resolver");
-const products_service_1 = __importDefault(require("../products/services/products.service"));
-const processorApi_service_1 = require("../api/services/processorApi.service");
-const inputs_service_1 = __importDefault(require("../inputs/inputs.service"));
-const types_1 = require("../types");
-const uuid_1 = require("uuid");
-const processor_utils_1 = require("../processor/utils/processor.utils");
-const string_utils_1 = require("../products/utils/string.utils");
-const logs_service_1 = __importDefault(require("../logs/logs.service"));
-const logs_types_1 = require("../logs/logs.types");
-const cache_manager_1 = require("../cache/cache.manager");
-/**
- * Load JWT module dynamically (Node.js only)
- */
-async function loadJWT() {
-    if (typeof window === 'undefined') {
-        const JWT = await Promise.resolve().then(() => __importStar(require('jsonwebtoken')));
-        return JWT;
-    }
-    return null;
-}
-/**
- * Error class for session operations
- */
-class SessionError extends Error {
-    constructor(message, code, details) {
-        super(message);
-        this.code = code;
-        this.details = details;
-        this.name = 'SessionError';
-    }
-}
-exports.SessionError = SessionError;
-/**
- * Recording session context for defining sessions
- */
-class RecordingSessionContext {
-    constructor() {
-        this._selector = '';
-        this._expiry = 3600;
-        this._period = 'seconds';
-        this._schema = {};
-    }
-    selector(path) {
-        this._selector = path;
-        return this;
-    }
-    expiry(value, period) {
-        this._expiry = value;
-        this._period = period;
-        return this;
-    }
-    schema(fields) {
-        this._schema = fields;
-        return this;
-    }
-    getResult() {
-        return {
-            selector: this._selector,
-            expiry: this._expiry,
-            period: this._period,
-            schemaData: this._schema,
-        };
-    }
-}
-/**
- * SessionsService
- *
- * Unified API for JWT-based session management.
- *
- * @example
- * ```ts
- * import { SessionsService } from '@ductape/sdk';
- *
- * const sessions = new SessionsService({
- *   workspace_id: 'your-workspace-id',
- *   public_key: 'your-public-key',
- *   user_id: 'your-user-id',
- *   token: 'your-token',
- *   env_type: 'prd',
- * });
- *
- * // Create a session
- * const result = await sessions.create({
- *   product: 'my-product',
- *   env: 'production',
- *   tag: 'user-session',
- *   data: { userId: '123', email: 'user@example.com' },
- * });
- *
- * // Verify a session
- * const verifyResult = await sessions.verify({
- *   product: 'my-product',
- *   env: 'production',
- *   tag: 'user-session',
- *   token: result.token,
- * });
- *
- * // Refresh a session
- * const refreshResult = await sessions.refresh({
- *   product: 'my-product',
- *   env: 'production',
- *   tag: 'user-session',
- *   refreshToken: result.refreshToken,
- * });
- *
- * // Revoke a session
- * await sessions.revoke({
- *   product: 'my-product',
- *   env: 'production',
- *   tag: 'user-session',
- *   sessionId: verifyResult.sessionId,
- * });
- * ```
- */
-class SessionsService {
-    constructor(config) {
-        this.logService = null;
-        this.productId = '';
-        /** Cache manager for 3-tier caching */
-        this.cacheManager = null;
-        /** Private keys per product for cache encryption */
-        this.privateKeys = new Map();
-        /** Local cache for cache configurations to avoid repeated API calls */
-        this.cacheConfigCache = new Map();
-        this.config = config;
-        this.productBuilderService = new products_service_1.default({
-            workspace_id: config.workspace_id,
-            public_key: config.public_key,
-            user_id: config.user_id,
-            token: config.token,
-            env_type: config.env_type,
-            redis_client: config.redis_client,
-            access_key: config.access_key,
-        });
-        this.processorApiService = new processorApi_service_1.ProcessorApiService(config.env_type);
-        this.inputService = new inputs_service_1.default();
-        // Initialize CacheManager and session resolver cache if Redis client is provided
-        if (config.redis_client) {
-            this.cacheManager = new cache_manager_1.CacheManager({
-                workspace_id: config.workspace_id,
-                public_key: config.public_key,
-                user_id: config.user_id,
-                token: config.token,
-                env_type: config.env_type,
-                redis_client: config.redis_client,
-            });
-            // Wire up Redis client for session resolver 2-tier caching
-            (0, sessions_resolver_1.setSessionCacheRedisClient)(config.redis_client);
-        }
-    }
-    /**
-     * Get user access credentials
-     */
-    getUserAccess() {
-        return {
-            user_id: this.config.user_id,
-            token: this.config.token,
-            workspace_id: this.config.workspace_id,
-            public_key: this.config.public_key,
-        };
-    }
-    /**
-     * Initialize logging service
-     */
-    initializeLogService() {
-        if (!this.logService) {
-            this.logService = new logs_service_1.default({
-                product_id: this.productId,
-                workspace_id: this.config.workspace_id,
-                public_key: this.config.public_key,
-                user_id: this.config.user_id,
-                token: this.config.token,
-                env_type: this.config.env_type,
-                workspace_private_key: this.config.workspace_private_key,
-            });
-        }
-    }
-    /**
-     * Validate cache tag exists in product and return cache configuration
-     * Uses local in-memory cache to avoid repeated API calls (5 minute TTL)
-     */
-    async validateCache(cacheTag, productTag) {
-        const cacheKey = `${productTag}:${cacheTag}`;
-        const cached = this.cacheConfigCache.get(cacheKey);
-        const now = Date.now();
-        const CACHE_TTL = 5 * 60 * 1000; // 5 minutes
-        // Return cached config if still valid
-        if (cached && (now - cached.fetchedAt) < CACHE_TTL) {
-            return { expiry: cached.expiry };
-        }
-        // Fetch from API and cache the result
-        const cache = await this.productBuilderService.fetchCache(cacheTag);
-        if (!cache) {
-            throw new SessionError(`Cache configuration '${cacheTag}' does not exist`, 'CACHE_NOT_FOUND');
-        }
-        this.cacheConfigCache.set(cacheKey, { expiry: cache.expiry, fetchedAt: now });
-        return { expiry: cache.expiry };
-    }
-    /**
-     * Create a new session
-     */
-    async create(options) {
-        var _a, _b, _c, _d, _e, _f, _g;
-        const process_id = (0, processor_utils_1.generateObjectId)();
-        const start = Date.now();
-        const { product, env, tag, data, cache } = options;
-        // Initialize logging
-        this.initializeLogService();
-        const baseLogs = {
-            product_tag: product,
-            workspace_id: this.config.workspace_id,
-            env,
-            process_id,
-            type: logs_types_1.LogEventTypes.SESSION,
-            parent_tag: tag,
-            child_tag: 'create',
-            data: { tag, operation: 'create' },
-        };
-        (_a = this.logService) === null || _a === void 0 ? void 0 : _a.add(Object.assign(Object.assign({}, baseLogs), { start, message: 'Session create - initiated', status: logs_types_1.LogEventStatus.PROCESSING }));
-        try {
-            // Parse and validate input
-            const input = (await this.inputService.parseJson({
-                data,
-                expected: types_1.ExpectedValues.PARSEINPUT,
-            }));
-            await this.productBuilderService.initializeProductByTag(product);
-            this.productId = this.productBuilderService.fetchProductId() || '';
-            const privateKey = this.productBuilderService.fetchPrivateKey();
-            // Store private key for cache operations
-            if (privateKey) {
-                this.privateKeys.set(product, privateKey);
-            }
-            // Check cache for idempotency (prevent duplicate creates with same data)
-            if (cache && this.cacheManager && privateKey) {
-                const cacheConfig = await this.validateCache(cache, product);
-                const cacheOptions = {
-                    cache_tag: cache,
-                    product_tag: product,
-                    component_tag: tag,
-                    component_type: 'session',
-                    operation: 'create',
-                    input: { tag, data },
-                    privateKey,
-                    expiry: cacheConfig.expiry,
-                };
-                const cached = await this.cacheManager.fetch(cacheOptions);
-                if (cached.hit && cached.data) {
-                    const end = Date.now();
-                    (_b = this.logService) === null || _b === void 0 ? void 0 : _b.add(Object.assign(Object.assign({}, baseLogs), { start,
-                        end, message: `Session create - cache hit (${cached.source})`, successful_execution: true, status: logs_types_1.LogEventStatus.SUCCESS, data: { tag, operation: 'create', cache_source: cached.source }, cache_tag: cache, cache_key: cached.key, cache_status: true }));
-                    (_c = this.logService) === null || _c === void 0 ? void 0 : _c.publish();
-                    return cached.data;
-                }
-            }
-            const session = await this.productBuilderService.fetchSession(tag);
-            if (!session) {
-                throw new SessionError(`Session with tag ${tag} does not exist`, 'SESSION_NOT_FOUND');
-            }
-            const productEnv = await this.productBuilderService.fetchEnv(env);
-            if (!productEnv) {
-                throw new SessionError(`Environment with slug ${env} does not exist`, 'ENV_NOT_FOUND');
-            }
-            // Validate input against session schema
-            await this.inputService.validateInput(input, session.schema_data);
-            // Extract user identifier from data using selector
-            const stages = (0, string_utils_1.extractStages)(session.selector);
-            const stringStages = stages.map((stage) => String(stage));
-            const identifier = (0, processor_utils_1.extractSelectorValue)(data, stringStages, session.selector);
-            // Calculate expiry
-            const expiry = (0, processor_utils_1.calculateJWTExpiry)(session.expiry, session.period);
-            const endAt = (0, processor_utils_1.calculateExpiry)(session.expiry, session.period);
-            const JWT = await loadJWT();
-            if (!JWT) {
-                throw new SessionError('JWT service not available in browser environment', 'JWT_NOT_AVAILABLE');
-            }
-            const sessionId = (0, uuid_1.v4)();
-            const token = JWT.sign({ session: tag, env, session_id: sessionId, data }, privateKey, { expiresIn: expiry });
-            const refreshToken = (0, processor_utils_1.encrypt)(JSON.stringify(data), privateKey);
-            // Save session info to database
-            const details = {
-                identifier,
-                start_at: Date.now(),
-                end_at: endAt,
-                session_tag: tag,
-                data: (0, processor_utils_1.encrypt)(JSON.stringify(JSON.stringify(data)), privateKey),
-                session_id: sessionId,
-            };
-            await this.processorApiService.createSessionInfo(Object.assign({ product_tag: product, env, refreshToken }, details), this.getUserAccess());
-            const result = {
-                token: `${tag}:${token}`,
-                refreshToken,
-                expiresAt: new Date(endAt),
-                sessionId,
-            };
-            // Store in cache for idempotency (fire-and-forget)
-            if (cache && this.cacheManager && privateKey) {
-                const cacheConfig = await this.validateCache(cache, product);
-                this.cacheManager.store({
-                    cache_tag: cache,
-                    product_tag: product,
-                    component_tag: tag,
-                    component_type: 'session',
-                    operation: 'create',
-                    input: { tag, data },
-                    privateKey,
-                    expiry: cacheConfig.expiry,
-                }, result);
-            }
-            const end = Date.now();
-            (_d = this.logService) === null || _d === void 0 ? void 0 : _d.add(Object.assign(Object.assign({}, baseLogs), { start,
-                end, message: 'Session create - success', successful_execution: true, status: logs_types_1.LogEventStatus.SUCCESS }));
-            (_e = this.logService) === null || _e === void 0 ? void 0 : _e.publish();
-            return result;
-        }
-        catch (error) {
-            const end = Date.now();
-            (_f = this.logService) === null || _f === void 0 ? void 0 : _f.add(Object.assign(Object.assign({}, baseLogs), { start,
-                end, message: 'Session create - failed', failed_execution: true, data: { tag, operation: 'create', error: String(error) }, status: logs_types_1.LogEventStatus.FAIL }));
-            await ((_g = this.logService) === null || _g === void 0 ? void 0 : _g.publish());
-            if (error instanceof SessionError)
-                throw error;
-            throw new SessionError(`Failed to create session: ${error}`, 'CREATE_FAILED', error);
-        }
-    }
-    /**
-     * Refresh an existing session
-     */
-    async refresh(options) {
-        var _a, _b, _c, _d, _e;
-        const process_id = (0, processor_utils_1.generateObjectId)();
-        const start = Date.now();
-        const { product, env, tag, refreshToken, cache } = options;
-        // Initialize logging
-        this.initializeLogService();
-        const baseLogs = {
-            product_tag: product,
-            workspace_id: this.config.workspace_id,
-            env,
-            process_id,
-            type: logs_types_1.LogEventTypes.SESSION,
-            parent_tag: tag,
-            child_tag: 'refresh',
-            data: { tag, operation: 'refresh' },
-        };
-        (_a = this.logService) === null || _a === void 0 ? void 0 : _a.add(Object.assign(Object.assign({}, baseLogs), { start, message: 'Session refresh - initiated', status: logs_types_1.LogEventStatus.PROCESSING }));
-        try {
-            await this.productBuilderService.initializeProductByTag(product);
-            this.productId = this.productBuilderService.fetchProductId() || '';
-            const privateKey = this.productBuilderService.fetchPrivateKey();
-            // Validate refresh token
-            const valid = await this.processorApiService.validateRefreshToken({ refreshToken, product, env }, this.getUserAccess());
-            if (!valid) {
-                throw new SessionError('Invalid refresh token', 'INVALID_REFRESH_TOKEN');
-            }
-            // Decrypt refresh token to get original data
-            const data = JSON.parse((0, processor_utils_1.decrypt)(refreshToken, privateKey));
-            // Create new session with same data (pass cache for the new session)
-            const result = await this.create({ product, env, tag, data, cache });
-            const end = Date.now();
-            (_b = this.logService) === null || _b === void 0 ? void 0 : _b.add(Object.assign(Object.assign({}, baseLogs), { start,
-                end, message: 'Session refresh - success', successful_execution: true, status: logs_types_1.LogEventStatus.SUCCESS }));
-            (_c = this.logService) === null || _c === void 0 ? void 0 : _c.publish();
-            return result;
-        }
-        catch (error) {
-            const end = Date.now();
-            (_d = this.logService) === null || _d === void 0 ? void 0 : _d.add(Object.assign(Object.assign({}, baseLogs), { start,
-                end, message: 'Session refresh - failed', failed_execution: true, data: { tag, operation: 'refresh', error: String(error) }, status: logs_types_1.LogEventStatus.FAIL }));
-            await ((_e = this.logService) === null || _e === void 0 ? void 0 : _e.publish());
-            if (error instanceof SessionError)
-                throw error;
-            throw new SessionError(`Failed to refresh session: ${error}`, 'REFRESH_FAILED', error);
-        }
-    }
-    /**
-     * Verify a session token
-     */
-    async verify(options) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
-        const process_id = (0, processor_utils_1.generateObjectId)();
-        const start = Date.now();
-        const { product, env, tag, token, cache } = options;
-        // Initialize logging
-        this.initializeLogService();
-        const baseLogs = {
-            product_tag: product,
-            workspace_id: this.config.workspace_id,
-            env,
-            process_id,
-            type: logs_types_1.LogEventTypes.SESSION,
-            parent_tag: tag,
-            child_tag: 'verify',
-            data: { tag, operation: 'verify' },
-        };
-        (_a = this.logService) === null || _a === void 0 ? void 0 : _a.add(Object.assign(Object.assign({}, baseLogs), { start, message: 'Session verify - initiated', status: logs_types_1.LogEventStatus.PROCESSING }));
-        try {
-            await this.productBuilderService.initializeProductByTag(product);
-            this.productId = this.productBuilderService.fetchProductId() || '';
-            const privateKey = this.productBuilderService.fetchPrivateKey();
-            // Store private key for cache operations
-            if (privateKey) {
-                this.privateKeys.set(product, privateKey);
-            }
-            // Check cache for verify result
-            if (cache && this.cacheManager && privateKey) {
-                const cacheConfig = await this.validateCache(cache, product);
-                const cacheOptions = {
-                    cache_tag: cache,
-                    product_tag: product,
-                    component_tag: tag,
-                    component_type: 'session',
-                    operation: 'verify',
-                    input: { tag, token },
-                    privateKey,
-                    expiry: cacheConfig.expiry,
-                };
-                const cached = await this.cacheManager.fetch(cacheOptions);
-                if (cached.hit && cached.data) {
-                    const end = Date.now();
-                    (_b = this.logService) === null || _b === void 0 ? void 0 : _b.add(Object.assign(Object.assign({}, baseLogs), { start,
-                        end, message: `Session verify - cache hit (${cached.source})`, successful_execution: true, status: logs_types_1.LogEventStatus.SUCCESS, data: { tag, operation: 'verify', cache_source: cached.source }, cache_tag: cache, cache_key: cached.key, cache_status: true }));
-                    (_c = this.logService) === null || _c === void 0 ? void 0 : _c.publish();
-                    return cached.data;
-                }
-            }
-            const JWT = await loadJWT();
-            if (!JWT) {
-                throw new SessionError('JWT service not available in browser environment', 'JWT_NOT_AVAILABLE');
-            }
-            const decoded = JWT.verify(token, privateKey);
-            if (decoded.session !== tag) {
-                throw new SessionError(`Invalid token for session ${tag}`, 'SESSION_MISMATCH');
-            }
-            if (decoded.env !== env) {
-                throw new SessionError('Invalid session environment', 'ENV_MISMATCH');
-            }
-            // Check if session has been revoked via blacklist
-            const { revoked } = await this.processorApiService.checkSessionRevoked({ product, env, sessionId: decoded.session_id }, this.getUserAccess());
-            if (revoked) {
-                const end = Date.now();
-                (_d = this.logService) === null || _d === void 0 ? void 0 : _d.add(Object.assign(Object.assign({}, baseLogs), { start,
-                    end, message: 'Session verify - session revoked', failed_execution: true, status: logs_types_1.LogEventStatus.FAIL }));
-                (_e = this.logService) === null || _e === void 0 ? void 0 : _e.publish();
-                return { valid: false };
-            }
-            const result = {
-                valid: true,
-                data: decoded.data,
-                sessionId: decoded.session_id,
-                expiresAt: decoded.exp ? new Date(decoded.exp * 1000) : undefined,
-            };
-            // Store in cache (fire-and-forget)
-            if (cache && this.cacheManager && privateKey) {
-                const cacheConfig = await this.validateCache(cache, product);
-                this.cacheManager.store({
-                    cache_tag: cache,
-                    product_tag: product,
-                    component_tag: tag,
-                    component_type: 'session',
-                    operation: 'verify',
-                    input: { tag, token },
-                    privateKey,
-                    expiry: cacheConfig.expiry,
-                }, result);
-            }
-            const end = Date.now();
-            (_f = this.logService) === null || _f === void 0 ? void 0 : _f.add(Object.assign(Object.assign({}, baseLogs), { start,
-                end, message: 'Session verify - success', successful_execution: true, status: logs_types_1.LogEventStatus.SUCCESS }));
-            (_g = this.logService) === null || _g === void 0 ? void 0 : _g.publish();
-            return result;
-        }
-        catch (error) {
-            const end = Date.now();
-            if (error instanceof SessionError) {
-                (_h = this.logService) === null || _h === void 0 ? void 0 : _h.add(Object.assign(Object.assign({}, baseLogs), { start,
-                    end, message: 'Session verify - failed', failed_execution: true, data: { tag, operation: 'verify', error: String(error) }, status: logs_types_1.LogEventStatus.FAIL }));
-                await ((_j = this.logService) === null || _j === void 0 ? void 0 : _j.publish());
-                throw error;
-            }
-            // Check if it's a JWT error
-            if (error instanceof Error && error.name === 'JsonWebTokenError') {
-                (_k = this.logService) === null || _k === void 0 ? void 0 : _k.add(Object.assign(Object.assign({}, baseLogs), { start,
-                    end, message: 'Session verify - invalid token', failed_execution: true, status: logs_types_1.LogEventStatus.FAIL }));
-                (_l = this.logService) === null || _l === void 0 ? void 0 : _l.publish();
-                return { valid: false };
-            }
-            if (error instanceof Error && error.name === 'TokenExpiredError') {
-                (_m = this.logService) === null || _m === void 0 ? void 0 : _m.add(Object.assign(Object.assign({}, baseLogs), { start,
-                    end, message: 'Session verify - token expired', failed_execution: true, status: logs_types_1.LogEventStatus.FAIL }));
-                (_o = this.logService) === null || _o === void 0 ? void 0 : _o.publish();
-                return { valid: false };
-            }
-            (_p = this.logService) === null || _p === void 0 ? void 0 : _p.add(Object.assign(Object.assign({}, baseLogs), { start,
-                end, message: 'Session verify - failed', failed_execution: true, data: { tag, operation: 'verify', error: String(error) }, status: logs_types_1.LogEventStatus.FAIL }));
-            await ((_q = this.logService) === null || _q === void 0 ? void 0 : _q.publish());
-            throw new SessionError(`Failed to verify session: ${error}`, 'VERIFY_FAILED', error);
-        }
-    }
-    /**
-     * Revoke a session
-     */
-    async revoke(options) {
-        var _a, _b, _c, _d, _e;
-        const process_id = (0, processor_utils_1.generateObjectId)();
-        const start = Date.now();
-        const { product, env, tag, sessionId, identifier } = options;
-        // Initialize logging
-        this.initializeLogService();
-        const baseLogs = {
-            product_tag: product,
-            workspace_id: this.config.workspace_id,
-            env,
-            process_id,
-            type: logs_types_1.LogEventTypes.SESSION,
-            parent_tag: tag,
-            child_tag: 'revoke',
-            data: { tag, operation: 'revoke', sessionId, identifier },
-        };
-        (_a = this.logService) === null || _a === void 0 ? void 0 : _a.add(Object.assign(Object.assign({}, baseLogs), { start, message: 'Session revoke - initiated', status: logs_types_1.LogEventStatus.PROCESSING }));
-        try {
-            if (!sessionId && !identifier) {
-                throw new SessionError('Either sessionId or identifier must be provided', 'INVALID_PARAMS');
-            }
-            await this.productBuilderService.initializeProductByTag(product);
-            this.productId = this.productBuilderService.fetchProductId() || '';
-            await this.processorApiService.revokeSession({ product, env, sessionId, identifier }, this.getUserAccess());
-            const end = Date.now();
-            (_b = this.logService) === null || _b === void 0 ? void 0 : _b.add(Object.assign(Object.assign({}, baseLogs), { start,
-                end, message: 'Session revoke - success', successful_execution: true, status: logs_types_1.LogEventStatus.SUCCESS }));
-            (_c = this.logService) === null || _c === void 0 ? void 0 : _c.publish();
-        }
-        catch (error) {
-            const end = Date.now();
-            (_d = this.logService) === null || _d === void 0 ? void 0 : _d.add(Object.assign(Object.assign({}, baseLogs), { start,
-                end, message: 'Session revoke - failed', failed_execution: true, data: { tag, operation: 'revoke', sessionId, identifier, error: String(error) }, status: logs_types_1.LogEventStatus.FAIL }));
-            await ((_e = this.logService) === null || _e === void 0 ? void 0 : _e.publish());
-            if (error instanceof SessionError)
-                throw error;
-            throw new SessionError(`Failed to revoke session: ${error}`, 'REVOKE_FAILED', error);
-        }
-    }
-    /**
-     * List active sessions
-     */
-    async list(options) {
-        var _a, _b, _c, _d, _e, _f, _g;
-        const process_id = (0, processor_utils_1.generateObjectId)();
-        const start = Date.now();
-        const { product, env, tag, identifier, page = 1, limit = 10, cache } = options;
-        // Initialize logging
-        this.initializeLogService();
-        const baseLogs = {
-            product_tag: product,
-            workspace_id: this.config.workspace_id,
-            env,
-            process_id,
-            type: logs_types_1.LogEventTypes.SESSION,
-            parent_tag: tag,
-            child_tag: 'list',
-            data: { tag, operation: 'list', identifier, page, limit },
-        };
-        (_a = this.logService) === null || _a === void 0 ? void 0 : _a.add(Object.assign(Object.assign({}, baseLogs), { start, message: 'Session list - initiated', status: logs_types_1.LogEventStatus.PROCESSING }));
-        try {
-            await this.productBuilderService.initializeProductByTag(product);
-            this.productId = this.productBuilderService.fetchProductId() || '';
-            const privateKey = this.productBuilderService.fetchPrivateKey();
-            // Store private key for cache operations
-            if (privateKey) {
-                this.privateKeys.set(product, privateKey);
-            }
-            // Check cache for list result
-            if (cache && this.cacheManager && privateKey) {
-                const cacheConfig = await this.validateCache(cache, product);
-                const cacheOptions = {
-                    cache_tag: cache,
-                    product_tag: product,
-                    component_tag: tag,
-                    component_type: 'session',
-                    operation: 'list',
-                    input: { tag, identifier, page, limit },
-                    privateKey,
-                    expiry: cacheConfig.expiry,
-                };
-                const cached = await this.cacheManager.fetch(cacheOptions);
-                if (cached.hit && cached.data) {
-                    const end = Date.now();
-                    (_b = this.logService) === null || _b === void 0 ? void 0 : _b.add(Object.assign(Object.assign({}, baseLogs), { start,
-                        end, message: `Session list - cache hit (${cached.source})`, successful_execution: true, status: logs_types_1.LogEventStatus.SUCCESS, data: { tag, operation: 'list', cache_source: cached.source }, cache_tag: cache, cache_key: cached.key, cache_status: true }));
-                    (_c = this.logService) === null || _c === void 0 ? void 0 : _c.publish();
-                    return cached.data;
-                }
-            }
-            const result = await this.processorApiService.listSessions({ product, env, tag, identifier, page, limit }, this.getUserAccess());
-            const mappedResult = {
-                sessions: result.sessions.map((session) => ({
-                    sessionId: session.session_id,
-                    identifier: session.identifier,
-                    startAt: new Date(session.start_at),
-                    endAt: new Date(session.end_at),
-                    sessionTag: session.session_tag,
-                    active: session.end_at > Date.now(),
-                })),
-                total: result.total,
-                page: result.page,
-                limit: result.limit,
-            };
-            // Store in cache (fire-and-forget)
-            if (cache && this.cacheManager && privateKey) {
-                const cacheConfig = await this.validateCache(cache, product);
-                this.cacheManager.store({
-                    cache_tag: cache,
-                    product_tag: product,
-                    component_tag: tag,
-                    component_type: 'session',
-                    operation: 'list',
-                    input: { tag, identifier, page, limit },
-                    privateKey,
-                    expiry: cacheConfig.expiry,
-                }, mappedResult);
-            }
-            const end = Date.now();
-            (_d = this.logService) === null || _d === void 0 ? void 0 : _d.add(Object.assign(Object.assign({}, baseLogs), { start,
-                end, message: 'Session list - success', successful_execution: true, data: { tag, operation: 'list', total: result.total }, status: logs_types_1.LogEventStatus.SUCCESS }));
-            (_e = this.logService) === null || _e === void 0 ? void 0 : _e.publish();
-            return mappedResult;
-        }
-        catch (error) {
-            const end = Date.now();
-            (_f = this.logService) === null || _f === void 0 ? void 0 : _f.add(Object.assign(Object.assign({}, baseLogs), { start,
-                end, message: 'Session list - failed', failed_execution: true, data: { tag, operation: 'list', identifier, error: String(error) }, status: logs_types_1.LogEventStatus.FAIL }));
-            await ((_g = this.logService) === null || _g === void 0 ? void 0 : _g.publish());
-            if (error instanceof SessionError)
-                throw error;
-            throw new SessionError(`Failed to list sessions: ${error}`, 'LIST_FAILED', error);
-        }
-    }
-    /**
-     * Define a new session schema
-     */
-    async define(options) {
-        var _a, _b, _c, _d, _e;
-        const process_id = (0, processor_utils_1.generateObjectId)();
-        const start = Date.now();
-        const { tag, name, description } = options;
-        // Initialize logging
-        this.initializeLogService();
-        const baseLogs = {
-            product_tag: '',
-            workspace_id: this.config.workspace_id,
-            env: '',
-            process_id,
-            type: logs_types_1.LogEventTypes.SESSION,
-            parent_tag: tag,
-            child_tag: 'define',
-            data: { tag, name, operation: 'define' },
-        };
-        (_a = this.logService) === null || _a === void 0 ? void 0 : _a.add(Object.assign(Object.assign({}, baseLogs), { start, message: 'Session define - initiated', status: logs_types_1.LogEventStatus.PROCESSING }));
-        try {
-            const ctx = new RecordingSessionContext();
-            await options.handler(ctx);
-            const result = ctx.getResult();
-            const definedSession = {
-                tag,
-                name,
-                description,
-                selector: result.selector,
-                expiry: result.expiry,
-                period: result.period,
-                schemaData: result.schemaData,
-            };
-            const end = Date.now();
-            (_b = this.logService) === null || _b === void 0 ? void 0 : _b.add(Object.assign(Object.assign({}, baseLogs), { start,
-                end, message: 'Session define - success', successful_execution: true, status: logs_types_1.LogEventStatus.SUCCESS }));
-            (_c = this.logService) === null || _c === void 0 ? void 0 : _c.publish();
-            return definedSession;
-        }
-        catch (error) {
-            const end = Date.now();
-            (_d = this.logService) === null || _d === void 0 ? void 0 : _d.add(Object.assign(Object.assign({}, baseLogs), { start,
-                end, message: 'Session define - failed', failed_execution: true, data: { tag, name, operation: 'define', error: String(error) }, status: logs_types_1.LogEventStatus.FAIL }));
-            await ((_e = this.logService) === null || _e === void 0 ? void 0 : _e.publish());
-            throw new SessionError(`Failed to define session: ${error}`, 'DEFINE_FAILED', error);
-        }
-    }
-    /**
-     * Register a defined session with a product
-     */
-    async register(product, session) {
-        var _a, _b, _c, _d, _e;
-        const process_id = (0, processor_utils_1.generateObjectId)();
-        const start = Date.now();
-        // Initialize logging
-        this.initializeLogService();
-        const baseLogs = {
-            product_tag: product,
-            workspace_id: this.config.workspace_id,
-            env: '',
-            process_id,
-            type: logs_types_1.LogEventTypes.SESSION,
-            parent_tag: session.tag,
-            child_tag: 'register',
-            data: { tag: session.tag, name: session.name, operation: 'register' },
-        };
-        (_a = this.logService) === null || _a === void 0 ? void 0 : _a.add(Object.assign(Object.assign({}, baseLogs), { start, message: 'Session register - initiated', status: logs_types_1.LogEventStatus.PROCESSING }));
-        try {
-            await this.productBuilderService.initializeProductByTag(product);
-            this.productId = this.productBuilderService.fetchProductId() || '';
-            // Map period string to TokenPeriods format
-            const periodMap = {
-                seconds: 'secs',
-                minutes: 'mins',
-                hours: 'hours',
-                days: 'days',
-            };
-            // Convert IDefinedSession to IProductSession format
-            const sessionData = {
-                tag: session.tag,
-                name: session.name || session.tag,
-                description: session.description || '',
-                expiry: session.expiry,
-                period: periodMap[session.period] || session.period,
-                selector: `$Session{${session.selector}}`,
-                schema: session.schemaData,
-            };
-            await this.productBuilderService.createSession(sessionData);
-            const end = Date.now();
-            (_b = this.logService) === null || _b === void 0 ? void 0 : _b.add(Object.assign(Object.assign({}, baseLogs), { start,
-                end, message: 'Session register - success', successful_execution: true, status: logs_types_1.LogEventStatus.SUCCESS }));
-            (_c = this.logService) === null || _c === void 0 ? void 0 : _c.publish();
-        }
-        catch (error) {
-            const end = Date.now();
-            (_d = this.logService) === null || _d === void 0 ? void 0 : _d.add(Object.assign(Object.assign({}, baseLogs), { start,
-                end, message: 'Session register - failed', failed_execution: true, data: { tag: session.tag, name: session.name, operation: 'register', error: String(error) }, status: logs_types_1.LogEventStatus.FAIL }));
-            await ((_e = this.logService) === null || _e === void 0 ? void 0 : _e.publish());
-            if (error instanceof SessionError)
-                throw error;
-            throw new SessionError(`Failed to register session: ${error}`, 'REGISTER_FAILED', error);
-        }
-    }
-    // ==================== SESSION ACTIVITY METHODS ====================
-    /**
-     * Fetch paginated session users
-     *
-     * @example
-     * ```ts
-     * const users = await sessions.fetchUsers({
-     *   product: 'my-product',
-     *   session: 'user-session',
-     *   env: 'production',
-     *   page: 1,
-     *   limit: 20,
-     * });
-     * ```
-     */
-    async fetchUsers(options) {
-        const { product, session: sessionTag, env, page = 1, limit = 20 } = options;
-        try {
-            await this.productBuilderService.initializeProductByTag(product);
-            this.productId = this.productBuilderService.fetchProductId() || '';
-            const result = await this.processorApiService.fetchSessionUsers({
-                product_tag: product,
-                session_tag: sessionTag,
-                env,
-                page,
-                limit,
-            }, this.getUserAccess());
-            return {
-                users: result.users || [],
-                total: result.total || 0,
-                page: result.page || page,
-                limit: result.limit || limit,
-                totalPages: result.totalPages || 0,
-            };
-        }
-        catch (error) {
-            throw new SessionError(`Failed to fetch session users: ${error}`, 'FETCH_USERS_FAILED', error);
-        }
-    }
-    /**
-     * Fetch detailed information about a single session user
-     *
-     * @example
-     * ```ts
-     * const userDetails = await sessions.fetchUserDetails({
-     *   product: 'my-product',
-     *   session: 'user-session',
-     *   identifier: 'user@example.com',
-     *   env: 'production',
-     * });
-     * ```
-     */
-    async fetchUserDetails(options) {
-        var _a;
-        const { product, session: sessionTag, identifier, env } = options;
-        try {
-            await this.productBuilderService.initializeProductByTag(product);
-            this.productId = this.productBuilderService.fetchProductId() || '';
-            const result = await this.processorApiService.fetchSessionUserDetails({
-                product_tag: product,
-                session_tag: sessionTag,
-                identifier,
-                env,
-            }, this.getUserAccess());
-            return result;
-        }
-        catch (error) {
-            if ((_a = error.message) === null || _a === void 0 ? void 0 : _a.includes('not found')) {
-                throw new SessionError('Session user not found', 'USER_NOT_FOUND', error);
-            }
-            throw new SessionError(`Failed to fetch session user details: ${error}`, 'FETCH_USER_DETAILS_FAILED', error);
-        }
-    }
-    /**
-     * Fetch paginated session activity logs
-     *
-     * @example
-     * ```ts
-     * const logs = await sessions.fetchActivityLogs({
-     *   product: 'my-product',
-     *   session: 'user-session',
-     *   env: 'production',
-     *   status: 'success',
-     *   page: 1,
-     *   limit: 20,
-     * });
-     * ```
-     */
-    async fetchActivityLogs(options) {
-        const { product, session: sessionTag, env, status, start: startDate, end: endDate, page = 1, limit = 20 } = options;
-        try {
-            await this.productBuilderService.initializeProductByTag(product);
-            this.productId = this.productBuilderService.fetchProductId() || '';
-            const result = await this.processorApiService.fetchSessionActivityLogs({
-                product_tag: product,
-                session_tag: sessionTag,
-                env,
-                status,
-                start_date: startDate,
-                end_date: endDate,
-                page,
-                limit,
-            }, this.getUserAccess());
-            return {
-                logs: result.logs || [],
-                total: result.total || 0,
-                page: result.page || page,
-                limit: result.limit || limit,
-                totalPages: result.totalPages || 0,
-            };
-        }
-        catch (error) {
-            throw new SessionError(`Failed to fetch session activity logs: ${error}`, 'FETCH_ACTIVITY_LOGS_FAILED', error);
-        }
-    }
-    /**
-     * Fetch session dashboard metrics
-     *
-     * @example
-     * ```ts
-     * const dashboard = await sessions.fetchDashboard({
-     *   product: 'my-product',
-     *   session: 'user-session',
-     *   env: 'production',
-     * });
-     * ```
-     */
-    async fetchDashboard(options) {
-        const { product, session: sessionTag, env } = options;
-        try {
-            await this.productBuilderService.initializeProductByTag(product);
-            this.productId = this.productBuilderService.fetchProductId() || '';
-            // Fetch dashboard metrics from backend
-            const dashboard = await this.processorApiService.fetchSessionUsersDashboard({
-                product_tag: product,
-                session_tag: sessionTag,
-                env,
-            }, this.getUserAccess());
-            return {
-                totalUsers: dashboard.totalUsers || 0,
-                activeUsers: dashboard.activeUsers || 0,
-                inactiveUsers: dashboard.inactiveUsers || 0,
-                expiredUsers: dashboard.expiredUsers || 0,
-                newUsersToday: dashboard.newUsersToday || 0,
-                newUsersThisWeek: dashboard.newUsersThisWeek || 0,
-                totalSessions: dashboard.totalSessions || 0,
-                activeSessions: dashboard.activeSessions || 0,
-                averageSessionsPerUser: dashboard.averageSessionsPerUser || 0,
-                // Extended metrics
-                dau: dashboard.dau || { current: 0, previous: 0, change: 0 },
-                wau: dashboard.wau || { current: 0, previous: 0, change: 0 },
-                mau: dashboard.mau || { current: 0, previous: 0, change: 0 },
-                activityTimeline: dashboard.activityTimeline || [],
-                peakHours: dashboard.peakHours || [],
-                environmentBreakdown: dashboard.environmentBreakdown || [],
-                avgSessionDuration: dashboard.avgSessionDuration || { current: '0s', previous: '0s', change: 0 },
-            };
-        }
-        catch (error) {
-            throw new SessionError(`Failed to fetch session dashboard: ${error}`, 'FETCH_DASHBOARD_FAILED', error);
-        }
-    }
-    /**
-     * Fetch user-specific dashboard metrics
-     *
-     * @example
-     * ```ts
-     * const userDashboard = await sessions.fetchUserDashboard({
-     *   product: 'my-product',
-     *   session: 'user-session',
-     *   identifier: 'user@example.com',
-     *   env: 'production',
-     * });
-     * ```
-     */
-    async fetchUserDashboard(options) {
-        const { product, session: sessionTag, identifier, env } = options;
-        try {
-            await this.productBuilderService.initializeProductByTag(product);
-            this.productId = this.productBuilderService.fetchProductId() || '';
-            // Fetch user dashboard metrics from backend
-            const dashboard = await this.processorApiService.fetchUserDashboard({
-                product_tag: product,
-                session_tag: sessionTag,
-                identifier,
-                env,
-            }, this.getUserAccess());
-            return {
-                totalLogs: dashboard.totalLogs || 0,
-                successRate: dashboard.successRate || 0,
-                activityTimeline: dashboard.activityTimeline || [],
-                peakHours: dashboard.peakHours || [],
-            };
-        }
-        catch (error) {
-            throw new SessionError(`Failed to fetch user dashboard: ${error}`, 'FETCH_USER_DASHBOARD_FAILED', error);
-        }
-    }
-}
-exports.SessionsService = SessionsService;
-exports.default = SessionsService;
-//# sourceMappingURL=sessions.service.js.map