@ductape/sdk 0.1.8 → 0.1.10

package/dist/sessions/sessions.service.js

@@ -0,0 +1,993 @@
+"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 runtime_defaults_1 = require("../runtime/runtime-defaults");
+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.productEnv = new runtime_defaults_1.ProductEnvResolver((0, runtime_defaults_1.runtimeDefaultsFromConfig)(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);
+        }
+    }
+    resolvePE(options) {
+        return this.productEnv.resolve(options);
+    }
+    /**
+     * 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 } = this.resolvePE(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 } = this.resolvePE(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 } = this.resolvePE(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 } = this.resolvePE(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 } = this.resolvePE(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 } = this.resolvePE(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 } = this.resolvePE(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 } = this.resolvePE(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 } = this.resolvePE(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 } = this.resolvePE(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