@ductape/sdk 0.1.6 → 0.1.8

package/dist/storage/storage.service.js

@@ -1,905 +0,0 @@
-"use strict";
-/**
- * StorageService - Main Storage Service Class
- *
- * Provides a unified interface for cloud storage operations including
- * upload, download, delete, list, and signed URL generation.
- *
- * Supported providers: AWS S3, Google Cloud Storage, Azure Blob Storage
- * Supports Redis caching for download operations
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StorageService = exports.StorageError = void 0;
-const storage_util_1 = require("./utils/storage.util");
-const products_service_1 = __importDefault(require("../products/services/products.service"));
-const types_1 = require("../types");
-const logs_service_1 = __importDefault(require("../logs/logs.service"));
-const types_2 = require("../types");
-const processor_utils_1 = require("../processor/utils/processor.utils");
-const processor_service_1 = __importDefault(require("../processor/services/processor.service"));
-const crypto_1 = require("crypto");
-const secrets_1 = require("../secrets");
-const cache_manager_1 = require("../cache/cache.manager");
-const sessions_1 = require("../sessions");
-/**
- * Error class for storage operations
- */
-class StorageError extends Error {
-    constructor(message, code, details) {
-        super(message);
-        this.code = code;
-        this.details = details;
-        this.name = 'StorageError';
-    }
-}
-exports.StorageError = StorageError;
-/**
- * StorageService
- *
- * Unified API for all cloud storage operations.
- *
- * @example
- * ```ts
- * import { StorageService } from '@ductape/sdk';
- *
- * const storage = new StorageService({
- *   workspace_id: 'your-workspace-id',
- *   public_key: 'your-public-key',
- *   user_id: 'your-user-id',
- *   token: 'your-token',
- *   env_type: 'prd',
- * });
- *
- * // Upload a file
- * const result = await storage.upload({
- *   product: 'my-product',
- *   env: 'production',
- *   storage: 'main-storage',
- *   fileName: 'documents/report.pdf',
- *   buffer: fileBuffer,
- *   mimeType: 'application/pdf',
- * });
- *
- * // Download a file
- * const downloadResult = await storage.download({
- *   product: 'my-product',
- *   env: 'production',
- *   storage: 'main-storage',
- *   fileName: 'documents/report.pdf',
- * });
- *
- * // Delete a file
- * await storage.delete({
- *   product: 'my-product',
- *   env: 'production',
- *   storage: 'main-storage',
- *   fileName: 'documents/report.pdf',
- * });
- *
- * // List files
- * const files = await storage.list({
- *   product: 'my-product',
- *   env: 'production',
- *   storage: 'main-storage',
- *   prefix: 'documents/',
- * });
- *
- * // Get signed URL
- * const signedUrl = await storage.getSignedUrl({
- *   product: 'my-product',
- *   env: 'production',
- *   storage: 'main-storage',
- *   fileName: 'documents/report.pdf',
- *   expiresIn: 3600, // 1 hour
- * });
- * ```
- */
-class StorageService {
-    constructor(config) {
-        this.logService = null;
-        this.productId = '';
-        this.productTag = '';
-        this.cacheManager = null;
-        this.privateKey = ''; // product private key for caching
-        this.cacheConfigCache = new Map(); // Local cache for cache configurations
-        this.privateKeys = new Map(); // Cache private keys per product for fast cache lookups
-        if (typeof window !== 'undefined') {
-            throw new Error('Ductape SDK can only be initialized in a server environment.');
-        }
-        this.config = config;
-        this._privateKey = config.private_key;
-        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,
-        });
-        // Initialize cache manager (Redis is optional - Tier 1 internal cache and Tier 3 remote cache always work)
-        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, // Optional - Tier 2 cache
-        });
-    }
-    /**
-     * Initialize product and get storage configuration
-     */
-    async initializeStorage(productTag, envSlug, storageTag) {
-        // Use bootstrap API for optimized single call
-        const bootstrapData = await this.productBuilderService.bootstrapStorage({
-            product_tag: productTag,
-            env_slug: envSlug,
-            storage_tag: storageTag,
-        });
-        this.productId = bootstrapData.product_id;
-        this.productTag = productTag;
-        this.privateKey = bootstrapData.private_key || '';
-        const storage = bootstrapData.storage;
-        const storageEnv = bootstrapData.storage_env;
-        if (!storageEnv) {
-            throw new StorageError(`Storage environment for ${envSlug} not found`, 'STORAGE_ENV_NOT_FOUND');
-        }
-        // Build provider config
-        const providerConfig = {
-            provider: storageEnv.type,
-        };
-        // Get the raw config - it may be encrypted and needs decryption
-        let resolvedConfig = storageEnv.config;
-        // If config is a string (encrypted), decrypt it using the product's private key
-        if (typeof resolvedConfig === 'string' && this.privateKey) {
-            try {
-                const decrypted = (0, processor_utils_1.decrypt)(resolvedConfig, this.privateKey);
-                resolvedConfig = JSON.parse(decrypted);
-            }
-            catch (err) {
-                throw new StorageError(`Failed to decrypt storage configuration: ${err.message}`, 'DECRYPT_ERROR', err);
-            }
-        }
-        // Resolve any secret references in the config
-        if (resolvedConfig && (0, secrets_1.mightContainSecrets)(resolvedConfig)) {
-            const secretsService = (0, secrets_1.getSecretsService)();
-            if (secretsService) {
-                const resolved = await secretsService.resolve(resolvedConfig, { env: envSlug });
-                resolvedConfig = resolved.value;
-            }
-            else {
-                throw new StorageError(`Storage configuration contains secret references but secrets service is not initialized. ` +
-                    `Please ensure the Ductape client is properly initialized.`, 'SECRETS_NOT_INITIALIZED');
-            }
-        }
-        if (storageEnv.type === types_1.StorageProviders.AWS) {
-            providerConfig.awsConfig = resolvedConfig;
-        }
-        else if (storageEnv.type === types_1.StorageProviders.GCP) {
-            providerConfig.gcpConfig = resolvedConfig;
-        }
-        else if (storageEnv.type === types_1.StorageProviders.AZURE) {
-            providerConfig.azureConfig = resolvedConfig;
-        }
-        return { storage, storageEnv, config: providerConfig };
-    }
-    /**
-     * Initialize logging service
-     */
-    initializeLogService() {
-        var _a;
-        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: (_a = this._privateKey) !== null && _a !== void 0 ? _a : undefined,
-            });
-        }
-    }
-    /**
-     * 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) {
-        const cacheKey = `${this.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 StorageError(`Cache configuration '${cacheTag}' does not exist`, 'CACHE_NOT_FOUND');
-        }
-        this.cacheConfigCache.set(cacheKey, { expiry: cache.expiry, fetchedAt: now });
-        return { expiry: cache.expiry };
-    }
-    /**
-     * Upload a file to cloud storage
-     */
-    async upload(options) {
-        var _a;
-        const process_id = (0, processor_utils_1.generateObjectId)();
-        const start = Date.now();
-        let sessionLogFields = {};
-        try {
-            const { storage, storageEnv, config } = await this.initializeStorage(options.product, options.env, options.storage);
-            this.initializeLogService();
-            // Process session if provided
-            if (options.session && this.privateKey) {
-                const sessionResult = await (0, sessions_1.processSessionForExecution)(options.session, this.privateKey, { fileName: options.fileName }, options.env, {
-                    fetchSessionSelector: async (sessionTag) => {
-                        const sessionConfig = await this.productBuilderService.fetchSession(sessionTag);
-                        return sessionConfig === null || sessionConfig === void 0 ? void 0 : sessionConfig.selector;
-                    },
-                });
-                if (sessionResult.error) {
-                    throw new StorageError(`Session validation failed: ${sessionResult.error}`, 'SESSION_INVALID');
-                }
-                sessionLogFields = sessionResult.logFields;
-                // Resolve session references in fileName if present
-                if (typeof sessionResult.input.fileName === 'string') {
-                    options.fileName = sessionResult.input.fileName;
-                }
-            }
-            const baseLogs = Object.assign({ product_tag: options.product, workspace_id: this.config.workspace_id, env: options.env, process_id, type: types_2.LogEventTypes.STORAGE, parent_tag: options.storage, child_tag: 'upload' }, sessionLogFields);
-            this.logService.add(Object.assign(Object.assign({}, baseLogs), { message: 'Upload file - initiated', status: types_2.LogEventStatus.PROCESSING, data: { fileName: options.fileName, mimeType: options.mimeType }, start }));
-            // Support both buffer (SDK) and data base64 (client/proxy over JSON)
-            const rawPayload = (_a = options.buffer) !== null && _a !== void 0 ? _a : options.data;
-            if (rawPayload == null) {
-                throw new StorageError('Upload requires buffer or data (base64 string). When calling via proxy, the client sends data.', 'MISSING_PAYLOAD');
-            }
-            const bufferPayload = typeof rawPayload === 'string' ? Buffer.from(rawPayload, 'base64') : rawPayload;
-            const url = await (0, storage_util_1.uploadBlobToCloud)({
-                data: bufferPayload,
-                destinationPath: options.fileName,
-                config,
-                mimeType: options.mimeType,
-            });
-            const end = Date.now();
-            const latency = end - start;
-            const result = {
-                success: true,
-                url,
-                fileName: options.fileName,
-                mimeType: options.mimeType,
-            };
-            this.logService.add(Object.assign(Object.assign({}, baseLogs), { message: 'Upload file - success', storage: bufferPayload === null || bufferPayload === void 0 ? void 0 : bufferPayload.length, successful_execution: true, data: { fileName: options.fileName, url, mimeType: options.mimeType, size: bufferPayload === null || bufferPayload === void 0 ? void 0 : bufferPayload.length }, status: types_2.LogEventStatus.SUCCESS, start,
-                end,
-                latency }));
-            this.logService.publish();
-            return result;
-        }
-        catch (error) {
-            const end = Date.now();
-            const latency = end - start;
-            this.initializeLogService();
-            this.logService.add(Object.assign({ product_tag: options.product, workspace_id: this.config.workspace_id, env: options.env, process_id, type: types_2.LogEventTypes.STORAGE, parent_tag: options.storage, child_tag: 'upload', message: 'Upload file - failed', failed_execution: true, data: { fileName: options.fileName, mimeType: options.mimeType, error: String(error) }, status: types_2.LogEventStatus.FAIL, start,
-                end,
-                latency }, sessionLogFields));
-            this.logService.publish();
-            throw new StorageError(`Failed to upload file: ${error}`, 'UPLOAD_FAILED', error);
-        }
-    }
-    /**
-     * Download a file from cloud storage
-     * Supports caching when cache option is provided
-     */
-    async download(options) {
-        const process_id = (0, processor_utils_1.generateObjectId)();
-        const start = Date.now();
-        let sessionLogFields = {};
-        try {
-            const { storage, storageEnv, config } = await this.initializeStorage(options.product, options.env, options.storage);
-            this.initializeLogService();
-            // Process session if provided
-            if (options.session && this.privateKey) {
-                const sessionResult = await (0, sessions_1.processSessionForExecution)(options.session, this.privateKey, { fileName: options.fileName }, options.env, {
-                    fetchSessionSelector: async (sessionTag) => {
-                        const sessionConfig = await this.productBuilderService.fetchSession(sessionTag);
-                        return sessionConfig === null || sessionConfig === void 0 ? void 0 : sessionConfig.selector;
-                    },
-                });
-                if (sessionResult.error) {
-                    throw new StorageError(`Session validation failed: ${sessionResult.error}`, 'SESSION_INVALID');
-                }
-                sessionLogFields = sessionResult.logFields;
-                // Resolve session references in fileName if present
-                if (typeof sessionResult.input.fileName === 'string') {
-                    options.fileName = sessionResult.input.fileName;
-                }
-            }
-            const baseLogs = Object.assign({ product_tag: options.product, workspace_id: this.config.workspace_id, env: options.env, process_id, type: types_2.LogEventTypes.STORAGE, parent_tag: options.storage, child_tag: 'download' }, sessionLogFields);
-            this.logService.add(Object.assign(Object.assign({}, baseLogs), { message: 'Download file - initiated', status: types_2.LogEventStatus.PROCESSING, data: { fileName: options.fileName }, start }));
-            // Check cache if cache tag is provided and cache manager is available
-            let cacheKey;
-            if (options.cache && this.cacheManager && this.privateKey) {
-                const cacheOptions = {
-                    cache_tag: options.cache,
-                    product_tag: options.product,
-                    component_tag: options.storage,
-                    component_type: 'storage',
-                    input: { fileName: options.fileName, env: options.env },
-                    privateKey: this.privateKey,
-                    expiry: storage === null || storage === void 0 ? void 0 : storage.expiry,
-                };
-                const cached = await this.cacheManager.fetch(cacheOptions);
-                cacheKey = cached.key;
-                if (cached.hit && cached.data) {
-                    const end = Date.now();
-                    const latency = end - start;
-                    this.logService.add(Object.assign(Object.assign({}, baseLogs), { message: 'Download file - cache hit', successful_execution: true, data: { fileName: options.fileName, source: cached.source }, status: types_2.LogEventStatus.SUCCESS, cache_tag: options.cache, cache_key: cached.key, cache_status: true, start,
-                        end,
-                        latency }));
-                    this.logService.publish();
-                    return cached.data;
-                }
-            }
-            const result = await (0, storage_util_1.downloadBlobFromCloud)({
-                filePath: options.fileName,
-                config,
-            });
-            const end = Date.now();
-            const latency = end - start;
-            // Store in cache if cache tag is provided (fire-and-forget)
-            if (options.cache && this.cacheManager && this.privateKey) {
-                this.cacheManager.store({
-                    cache_tag: options.cache,
-                    product_tag: options.product,
-                    component_tag: options.storage,
-                    component_type: 'storage',
-                    input: { fileName: options.fileName, env: options.env },
-                    privateKey: this.privateKey,
-                    expiry: storage === null || storage === void 0 ? void 0 : storage.expiry,
-                }, result);
-            }
-            this.logService.add(Object.assign(Object.assign({}, baseLogs), { message: options.cache ? 'Download file - cache miss' : 'Download file - success', storage: result.size, successful_execution: true, data: { fileName: options.fileName, size: result.size, mimeType: result.mimeType }, status: types_2.LogEventStatus.SUCCESS, cache_tag: options.cache, cache_key: cacheKey, start,
-                end,
-                latency }));
-            this.logService.publish();
-            return result;
-        }
-        catch (error) {
-            const end = Date.now();
-            const latency = end - start;
-            this.initializeLogService();
-            this.logService.add(Object.assign({ product_tag: options.product, workspace_id: this.config.workspace_id, env: options.env, process_id, type: types_2.LogEventTypes.STORAGE, parent_tag: options.storage, child_tag: 'download', message: 'Download file - failed', failed_execution: true, data: { fileName: options.fileName, error: String(error) }, status: types_2.LogEventStatus.FAIL, start,
-                end,
-                latency }, sessionLogFields));
-            this.logService.publish();
-            throw new StorageError(`Failed to download file: ${error}`, 'DOWNLOAD_FAILED', error);
-        }
-    }
-    /**
-     * Delete a file from cloud storage
-     */
-    async delete(options) {
-        const process_id = (0, processor_utils_1.generateObjectId)();
-        const start = Date.now();
-        let sessionLogFields = {};
-        try {
-            const { storage, storageEnv, config } = await this.initializeStorage(options.product, options.env, options.storage);
-            this.initializeLogService();
-            // Process session if provided
-            if (options.session && this.privateKey) {
-                const sessionResult = await (0, sessions_1.processSessionForExecution)(options.session, this.privateKey, { fileName: options.fileName }, options.env, {
-                    fetchSessionSelector: async (sessionTag) => {
-                        const sessionConfig = await this.productBuilderService.fetchSession(sessionTag);
-                        return sessionConfig === null || sessionConfig === void 0 ? void 0 : sessionConfig.selector;
-                    },
-                });
-                if (sessionResult.error) {
-                    throw new StorageError(`Session validation failed: ${sessionResult.error}`, 'SESSION_INVALID');
-                }
-                sessionLogFields = sessionResult.logFields;
-                // Resolve session references in fileName if present
-                if (typeof sessionResult.input.fileName === 'string') {
-                    options.fileName = sessionResult.input.fileName;
-                }
-            }
-            const baseLogs = Object.assign({ product_tag: options.product, workspace_id: this.config.workspace_id, env: options.env, process_id, type: types_2.LogEventTypes.STORAGE, parent_tag: options.storage, child_tag: 'delete' }, sessionLogFields);
-            this.logService.add(Object.assign(Object.assign({}, baseLogs), { message: 'Delete file - initiated', status: types_2.LogEventStatus.PROCESSING, data: { fileName: options.fileName }, start }));
-            const result = await (0, storage_util_1.deleteBlobFromCloud)({
-                filePath: options.fileName,
-                config,
-            });
-            const end = Date.now();
-            const latency = end - start;
-            this.logService.add(Object.assign(Object.assign({}, baseLogs), { message: 'Delete file - success', successful_execution: true, data: { fileName: options.fileName }, status: types_2.LogEventStatus.SUCCESS, start,
-                end,
-                latency }));
-            this.logService.publish();
-            return result;
-        }
-        catch (error) {
-            const end = Date.now();
-            const latency = end - start;
-            this.initializeLogService();
-            this.logService.add(Object.assign({ product_tag: options.product, workspace_id: this.config.workspace_id, env: options.env, process_id, type: types_2.LogEventTypes.STORAGE, parent_tag: options.storage, child_tag: 'delete', message: 'Delete file - failed', failed_execution: true, data: { fileName: options.fileName, error: String(error) }, status: types_2.LogEventStatus.FAIL, start,
-                end,
-                latency }, sessionLogFields));
-            this.logService.publish();
-            throw new StorageError(`Failed to delete file: ${error}`, 'DELETE_FAILED', error);
-        }
-    }
-    /**
-     * List files in cloud storage
-     */
-    async list(options) {
-        var _a, _b;
-        const process_id = (0, processor_utils_1.generateObjectId)();
-        const start = Date.now();
-        const { cache } = options;
-        let sessionLogFields = {};
-        try {
-            // Check cache FIRST before expensive initialization (if we have a cached private key)
-            const cachedPrivateKey = this.privateKeys.get(options.product);
-            if (cache && this.cacheManager && cachedPrivateKey && !options.session) {
-                const cacheConfig = await this.validateCache(cache);
-                const cacheOptions = {
-                    cache_tag: cache,
-                    product_tag: options.product,
-                    component_tag: options.storage,
-                    component_type: 'storage',
-                    operation: 'list',
-                    input: { storage: options.storage, prefix: options.prefix, fileType: options.fileType, limit: options.limit, page: options.page },
-                    privateKey: cachedPrivateKey,
-                    expiry: cacheConfig.expiry,
-                };
-                const cached = await this.cacheManager.fetch(cacheOptions);
-                if (cached.hit && cached.data) {
-                    const end = Date.now();
-                    const latency = end - start;
-                    this.initializeLogService();
-                    this.logService.add({
-                        product_tag: options.product,
-                        workspace_id: this.config.workspace_id,
-                        env: options.env,
-                        process_id,
-                        type: types_2.LogEventTypes.STORAGE,
-                        parent_tag: options.storage,
-                        child_tag: 'list',
-                        message: `List files - cache hit (${cached.source})`,
-                        successful_execution: true,
-                        status: types_2.LogEventStatus.SUCCESS,
-                        data: { prefix: options.prefix, cache_source: cached.source, count: (_a = cached.data.files) === null || _a === void 0 ? void 0 : _a.length },
-                        cache_tag: cache,
-                        cache_status: true,
-                        cache_key: cached.key,
-                        start,
-                        end,
-                        latency,
-                    });
-                    this.logService.publish();
-                    return cached.data;
-                }
-            }
-            // Full initialization only needed for cache miss or no cache
-            const { storage, storageEnv, config } = await this.initializeStorage(options.product, options.env, options.storage);
-            // Store private key for future cache lookups
-            if (this.privateKey) {
-                this.privateKeys.set(options.product, this.privateKey);
-            }
-            this.initializeLogService();
-            // Process session if provided
-            if (options.session && this.privateKey) {
-                const sessionResult = await (0, sessions_1.processSessionForExecution)(options.session, this.privateKey, { prefix: options.prefix }, options.env, {
-                    fetchSessionSelector: async (sessionTag) => {
-                        const sessionConfig = await this.productBuilderService.fetchSession(sessionTag);
-                        return sessionConfig === null || sessionConfig === void 0 ? void 0 : sessionConfig.selector;
-                    },
-                });
-                if (sessionResult.error) {
-                    throw new StorageError(`Session validation failed: ${sessionResult.error}`, 'SESSION_INVALID');
-                }
-                sessionLogFields = sessionResult.logFields;
-                // Resolve session references in prefix if present
-                if (typeof sessionResult.input.prefix === 'string') {
-                    options.prefix = sessionResult.input.prefix;
-                }
-            }
-            const baseLogs = Object.assign({ product_tag: options.product, workspace_id: this.config.workspace_id, env: options.env, process_id, type: types_2.LogEventTypes.STORAGE, parent_tag: options.storage, child_tag: 'list' }, sessionLogFields);
-            this.logService.add(Object.assign(Object.assign({}, baseLogs), { message: 'List files - initiated', status: types_2.LogEventStatus.PROCESSING, data: { prefix: options.prefix, fileType: options.fileType, limit: options.limit }, start }));
-            // Check cache again after initialization (for session-based requests or first-time calls)
-            let listCacheKey;
-            if (cache && this.cacheManager && this.privateKey) {
-                const cacheConfig = await this.validateCache(cache);
-                const cacheOptions = {
-                    cache_tag: cache,
-                    product_tag: options.product,
-                    component_tag: options.storage,
-                    component_type: 'storage',
-                    operation: 'list',
-                    input: { storage: options.storage, prefix: options.prefix, fileType: options.fileType, limit: options.limit, page: options.page },
-                    privateKey: this.privateKey,
-                    expiry: cacheConfig.expiry,
-                };
-                const cached = await this.cacheManager.fetch(cacheOptions);
-                listCacheKey = cached.key;
-                if (cached.hit && cached.data) {
-                    const end = Date.now();
-                    const latency = end - start;
-                    this.logService.add(Object.assign(Object.assign({}, baseLogs), { message: `List files - cache hit (${cached.source})`, successful_execution: true, status: types_2.LogEventStatus.SUCCESS, data: { prefix: options.prefix, cache_source: cached.source, count: (_b = cached.data.files) === null || _b === void 0 ? void 0 : _b.length }, cache_tag: cache, cache_key: cached.key, cache_status: true, start,
-                        end,
-                        latency }));
-                    this.logService.publish();
-                    return cached.data;
-                }
-            }
-            const result = await (0, storage_util_1.listBlobsInCloud)({
-                prefix: options.prefix,
-                fileType: options.fileType,
-                maxResults: options.limit,
-                continuationToken: options.continuationToken,
-                config,
-            });
-            const end = Date.now();
-            const latency = end - start;
-            // Store in cache (fire-and-forget)
-            if (cache && this.cacheManager && this.privateKey) {
-                const cacheConfig = await this.validateCache(cache);
-                this.cacheManager.store({
-                    cache_tag: cache,
-                    product_tag: options.product,
-                    component_tag: options.storage,
-                    component_type: 'storage',
-                    operation: 'list',
-                    input: { storage: options.storage, prefix: options.prefix, fileType: options.fileType, limit: options.limit, page: options.page },
-                    privateKey: this.privateKey,
-                    expiry: cacheConfig.expiry,
-                }, result);
-            }
-            this.logService.add(Object.assign(Object.assign({}, baseLogs), { message: cache ? 'List files - cache miss' : 'List files - success', successful_execution: true, data: { prefix: options.prefix, fileType: options.fileType, count: result.files.length, hasMore: result.hasMore }, status: types_2.LogEventStatus.SUCCESS, cache_tag: cache, cache_key: listCacheKey, start,
-                end,
-                latency }));
-            this.logService.publish();
-            return result;
-        }
-        catch (error) {
-            const end = Date.now();
-            const latency = end - start;
-            this.initializeLogService();
-            this.logService.add(Object.assign({ product_tag: options.product, workspace_id: this.config.workspace_id, env: options.env, process_id, type: types_2.LogEventTypes.STORAGE, parent_tag: options.storage, child_tag: 'list', message: 'List files - failed', failed_execution: true, data: { prefix: options.prefix, error: String(error) }, status: types_2.LogEventStatus.FAIL, start,
-                end,
-                latency }, sessionLogFields));
-            this.logService.publish();
-            throw new StorageError(`Failed to list files: ${error}`, 'LIST_FAILED', error);
-        }
-    }
-    /**
-     * Get a signed URL for temporary file access
-     */
-    async getSignedUrl(options) {
-        const process_id = (0, processor_utils_1.generateObjectId)();
-        const start = Date.now();
-        const { cache } = options;
-        let sessionLogFields = {};
-        try {
-            const { storage, storageEnv, config } = await this.initializeStorage(options.product, options.env, options.storage);
-            this.initializeLogService();
-            // Process session if provided
-            if (options.session && this.privateKey) {
-                const sessionResult = await (0, sessions_1.processSessionForExecution)(options.session, this.privateKey, { fileName: options.fileName }, options.env, {
-                    fetchSessionSelector: async (sessionTag) => {
-                        const sessionConfig = await this.productBuilderService.fetchSession(sessionTag);
-                        return sessionConfig === null || sessionConfig === void 0 ? void 0 : sessionConfig.selector;
-                    },
-                });
-                if (sessionResult.error) {
-                    throw new StorageError(`Session validation failed: ${sessionResult.error}`, 'SESSION_INVALID');
-                }
-                sessionLogFields = sessionResult.logFields;
-                // Resolve session references in fileName if present
-                if (typeof sessionResult.input.fileName === 'string') {
-                    options.fileName = sessionResult.input.fileName;
-                }
-            }
-            const baseLogs = Object.assign({ product_tag: options.product, workspace_id: this.config.workspace_id, env: options.env, process_id, type: types_2.LogEventTypes.STORAGE, parent_tag: options.storage, child_tag: 'getSignedUrl' }, sessionLogFields);
-            this.logService.add(Object.assign(Object.assign({}, baseLogs), { message: 'Generate signed URL - initiated', status: types_2.LogEventStatus.PROCESSING, data: { fileName: options.fileName, action: options.action, expiresIn: options.expiresIn }, start }));
-            // Check cache for signed URL
-            let signedUrlCacheKey;
-            if (cache && this.cacheManager && this.privateKey) {
-                const cacheConfig = await this.validateCache(cache);
-                const cacheOptions = {
-                    cache_tag: cache,
-                    product_tag: options.product,
-                    component_tag: options.storage,
-                    component_type: 'storage',
-                    operation: 'getSignedUrl',
-                    input: { storage: options.storage, fileName: options.fileName, action: options.action },
-                    privateKey: this.privateKey,
-                    expiry: cacheConfig.expiry,
-                };
-                const cached = await this.cacheManager.fetch(cacheOptions);
-                signedUrlCacheKey = cached.key;
-                if (cached.hit && cached.data) {
-                    const end = Date.now();
-                    const latency = end - start;
-                    this.logService.add(Object.assign(Object.assign({}, baseLogs), { message: `Generate signed URL - cache hit (${cached.source})`, successful_execution: true, status: types_2.LogEventStatus.SUCCESS, data: { fileName: options.fileName, cache_source: cached.source }, cache_tag: cache, cache_key: cached.key, cache_status: true, start,
-                        end,
-                        latency }));
-                    this.logService.publish();
-                    return cached.data;
-                }
-            }
-            const result = await (0, storage_util_1.generateSignedUrl)({
-                filePath: options.fileName,
-                config,
-                expiresIn: options.expiresIn,
-                action: options.action,
-            });
-            const end = Date.now();
-            const latency = end - start;
-            // Store in cache (fire-and-forget)
-            if (cache && this.cacheManager && this.privateKey) {
-                const cacheConfig = await this.validateCache(cache);
-                this.cacheManager.store({
-                    cache_tag: cache,
-                    product_tag: options.product,
-                    component_tag: options.storage,
-                    component_type: 'storage',
-                    operation: 'getSignedUrl',
-                    input: { storage: options.storage, fileName: options.fileName, action: options.action },
-                    privateKey: this.privateKey,
-                    expiry: cacheConfig.expiry,
-                }, result);
-            }
-            this.logService.add(Object.assign(Object.assign({}, baseLogs), { message: cache ? 'Generate signed URL - cache miss' : 'Generate signed URL - success', successful_execution: true, data: { fileName: options.fileName, action: options.action, expiresAt: result.expiresAt }, status: types_2.LogEventStatus.SUCCESS, cache_tag: cache, cache_key: signedUrlCacheKey, start,
-                end,
-                latency }));
-            this.logService.publish();
-            return result;
-        }
-        catch (error) {
-            const end = Date.now();
-            const latency = end - start;
-            this.initializeLogService();
-            this.logService.add(Object.assign({ product_tag: options.product, workspace_id: this.config.workspace_id, env: options.env, process_id, type: types_2.LogEventTypes.STORAGE, parent_tag: options.storage, child_tag: 'getSignedUrl', message: 'Generate signed URL - failed', failed_execution: true, data: { fileName: options.fileName, action: options.action, error: String(error) }, status: types_2.LogEventStatus.FAIL, start,
-                end,
-                latency }, sessionLogFields));
-            this.logService.publish();
-            throw new StorageError(`Failed to generate signed URL: ${error}`, 'SIGNED_URL_FAILED', error);
-        }
-    }
-    /**
-     * Dispatch a storage operation as a background job
-     */
-    async dispatch(options) {
-        const processorService = new processor_service_1.default({
-            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,
-            redis_client: this.config.redis_client,
-            private_key: this._privateKey,
-        });
-        const jobId = (0, crypto_1.randomUUID)();
-        // Queue the storage job
-        await processorService.processJob({
-            product: options.product,
-            env: options.env,
-            event: options.storage,
-            input: {
-                buffer: options.buffer,
-                fileName: options.fileName,
-                mimeType: options.mimeType,
-                operation: options.operation,
-            },
-            retries: 0,
-            start_at: options.startAt || 0,
-            session: options.session,
-        });
-        return {
-            jobId,
-            status: 'queued',
-        };
-    }
-    /**
-     * Test connection to a storage provider
-     *
-     * Validates storage configuration and attempts to list objects (with limit 1)
-     * to verify connectivity and credentials.
-     *
-     * @example
-     * ```ts
-     * const result = await storage.testConnection({
-     *   product: 'my-product',
-     *   env: 'prd',
-     *   storage: 'main-bucket',
-     * });
-     * console.log(result.connected); // true or false
-     * ```
-     */
-    async testConnection(options) {
-        const startTime = Date.now();
-        try {
-            const { config } = await this.initializeStorage(options.product, options.env, options.storage);
-            // Use list with maxResults=1 as a lightweight connectivity test
-            await (0, storage_util_1.listBlobsInCloud)({
-                prefix: '',
-                maxResults: 1,
-                config,
-            });
-            return {
-                connected: true,
-                latency: Date.now() - startTime,
-            };
-        }
-        catch (error) {
-            return {
-                connected: false,
-                latency: Date.now() - startTime,
-                error: error.message,
-            };
-        }
-    }
-    /**
-     * Get storage statistics (file counts and sizes by type)
-     *
-     * Efficiently counts all files in the storage without downloading content.
-     * Uses provider-native pagination to iterate through all objects and
-     * categorizes files by type based on file extension.
-     *
-     * @example
-     * ```ts
-     * const stats = await storage.stats({
-     *   product: 'my-product',
-     *   env: 'prd',
-     *   storage: 'main-bucket',
-     * });
-     * console.log(stats.totalFiles); // 1234
-     * console.log(stats.byType.image.count); // 567
-     * ```
-     */
-    async stats(options) {
-        const process_id = (0, processor_utils_1.generateObjectId)();
-        const start = Date.now();
-        const { cache } = options;
-        let sessionLogFields = {};
-        try {
-            // Check cache FIRST before expensive initialization (if we have a cached private key)
-            const cachedPrivateKey = this.privateKeys.get(options.product);
-            if (cache && this.cacheManager && cachedPrivateKey && !options.session) {
-                const cacheConfig = await this.validateCache(cache);
-                const cacheOptions = {
-                    cache_tag: cache,
-                    product_tag: options.product,
-                    component_tag: options.storage,
-                    component_type: 'storage',
-                    operation: 'stats',
-                    input: { storage: options.storage, prefix: options.prefix },
-                    privateKey: cachedPrivateKey,
-                    expiry: cacheConfig.expiry,
-                };
-                const cached = await this.cacheManager.fetch(cacheOptions);
-                if (cached.hit && cached.data) {
-                    const end = Date.now();
-                    const latency = end - start;
-                    this.initializeLogService();
-                    this.logService.add({
-                        product_tag: options.product,
-                        workspace_id: this.config.workspace_id,
-                        env: options.env,
-                        process_id,
-                        type: types_2.LogEventTypes.STORAGE,
-                        parent_tag: options.storage,
-                        child_tag: 'stats',
-                        message: `Get storage stats - cache hit (${cached.source})`,
-                        successful_execution: true,
-                        status: types_2.LogEventStatus.SUCCESS,
-                        data: { prefix: options.prefix, cache_source: cached.source, totalFiles: cached.data.totalFiles },
-                        cache_tag: cache,
-                        cache_key: cached.key,
-                        cache_status: true,
-                        start,
-                        end,
-                        latency,
-                    });
-                    this.logService.publish();
-                    return cached.data;
-                }
-            }
-            // Full initialization only needed for cache miss or no cache
-            const { storage, storageEnv, config } = await this.initializeStorage(options.product, options.env, options.storage);
-            // Store private key for future cache lookups
-            if (this.privateKey) {
-                this.privateKeys.set(options.product, this.privateKey);
-            }
-            this.initializeLogService();
-            // Process session if provided
-            if (options.session && this.privateKey) {
-                const sessionResult = await (0, sessions_1.processSessionForExecution)(options.session, this.privateKey, { prefix: options.prefix }, options.env, {
-                    fetchSessionSelector: async (sessionTag) => {
-                        const sessionConfig = await this.productBuilderService.fetchSession(sessionTag);
-                        return sessionConfig === null || sessionConfig === void 0 ? void 0 : sessionConfig.selector;
-                    },
-                });
-                if (sessionResult.error) {
-                    throw new StorageError(`Session validation failed: ${sessionResult.error}`, 'SESSION_INVALID');
-                }
-                sessionLogFields = sessionResult.logFields;
-                // Resolve session references in prefix if present
-                if (typeof sessionResult.input.prefix === 'string') {
-                    options.prefix = sessionResult.input.prefix;
-                }
-            }
-            const baseLogs = Object.assign({ product_tag: options.product, workspace_id: this.config.workspace_id, env: options.env, process_id, type: types_2.LogEventTypes.STORAGE, parent_tag: options.storage, child_tag: 'stats' }, sessionLogFields);
-            this.logService.add(Object.assign(Object.assign({}, baseLogs), { message: 'Get storage stats - initiated', status: types_2.LogEventStatus.PROCESSING, data: { prefix: options.prefix }, start }));
-            // Check cache again after initialization (for session-based requests or first-time calls)
-            let statsCacheKey;
-            if (cache && this.cacheManager && this.privateKey) {
-                const cacheConfig = await this.validateCache(cache);
-                const cacheOptions = {
-                    cache_tag: cache,
-                    product_tag: options.product,
-                    component_tag: options.storage,
-                    component_type: 'storage',
-                    operation: 'stats',
-                    input: { storage: options.storage, prefix: options.prefix },
-                    privateKey: this.privateKey,
-                    expiry: cacheConfig.expiry,
-                };
-                const cached = await this.cacheManager.fetch(cacheOptions);
-                statsCacheKey = cached.key;
-                if (cached.hit && cached.data) {
-                    const end = Date.now();
-                    const latency = end - start;
-                    this.logService.add(Object.assign(Object.assign({}, baseLogs), { message: `Get storage stats - cache hit (${cached.source})`, successful_execution: true, status: types_2.LogEventStatus.SUCCESS, data: { prefix: options.prefix, cache_source: cached.source, totalFiles: cached.data.totalFiles }, cache_tag: cache, cache_key: cached.key, cache_status: true, start,
-                        end,
-                        latency }));
-                    this.logService.publish();
-                    return cached.data;
-                }
-            }
-            const result = await (0, storage_util_1.getStorageStats)({
-                prefix: options.prefix,
-                config,
-            });
-            const end = Date.now();
-            const latency = end - start;
-            // Store in cache (fire-and-forget)
-            if (cache && this.cacheManager && this.privateKey) {
-                const cacheConfig = await this.validateCache(cache);
-                this.cacheManager.store({
-                    cache_tag: cache,
-                    product_tag: options.product,
-                    component_tag: options.storage,
-                    component_type: 'storage',
-                    operation: 'stats',
-                    input: { storage: options.storage, prefix: options.prefix },
-                    privateKey: this.privateKey,
-                    expiry: cacheConfig.expiry,
-                }, result);
-            }
-            this.logService.add(Object.assign(Object.assign({}, baseLogs), { message: cache ? 'Get storage stats - cache miss' : 'Get storage stats - success', successful_execution: true, data: { prefix: options.prefix, totalFiles: result.totalFiles, totalSize: result.totalSize }, status: types_2.LogEventStatus.SUCCESS, cache_tag: cache, cache_key: statsCacheKey, start,
-                end,
-                latency }));
-            this.logService.publish();
-            return result;
-        }
-        catch (error) {
-            const end = Date.now();
-            const latency = end - start;
-            this.initializeLogService();
-            this.logService.add(Object.assign({ product_tag: options.product, workspace_id: this.config.workspace_id, env: options.env, process_id, type: types_2.LogEventTypes.STORAGE, parent_tag: options.storage, child_tag: 'stats', message: 'Get storage stats - failed', failed_execution: true, data: { prefix: options.prefix, error: String(error) }, status: types_2.LogEventStatus.FAIL, start,
-                end,
-                latency }, sessionLogFields));
-            this.logService.publish();
-            throw new StorageError(`Failed to get storage stats: ${error}`, 'STATS_FAILED', error);
-        }
-    }
-}
-exports.StorageService = StorageService;
-exports.default = StorageService;
-//# sourceMappingURL=storage.service.js.map