@ductape/sdk 0.1.8 → 0.1.9

package/dist/storage/storage.service.js

@@ -0,0 +1,938 @@
+"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 runtime_defaults_1 = require("../runtime/runtime-defaults");
+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 cloud_runtime_util_1 = require("../cloud/cloud-runtime.util");
+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.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,
+        });
+        // 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
+        });
+    }
+    resolvePE(options) {
+        return this.productEnv.resolve(options);
+    }
+    /**
+     * 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 $Secret{} and refresh cloud_connection credentials when linked
+        if (resolvedConfig && typeof resolvedConfig === 'object') {
+            try {
+                resolvedConfig = await (0, cloud_runtime_util_1.resolveCloudLinkedConfig)(resolvedConfig, {
+                    environment: this.config.env_type,
+                    auth: {
+                        token: this.config.token,
+                        public_key: this.config.public_key,
+                        user_id: this.config.user_id,
+                        workspace_id: this.config.workspace_id,
+                        access_key: this.config.access_key,
+                    },
+                    productTag,
+                    componentTag: storageTag,
+                    envSlug,
+                });
+            }
+            catch (err) {
+                if ((0, secrets_1.mightContainSecrets)(resolvedConfig)) {
+                    const secretsService = (0, secrets_1.getSecretsService)();
+                    if (!secretsService) {
+                        throw new StorageError(`Storage configuration contains secret references but secrets service is not initialized.`, 'SECRETS_NOT_INITIALIZED');
+                    }
+                    const resolved = await secretsService.resolve(resolvedConfig, { env: envSlug });
+                    resolvedConfig = resolved.value;
+                }
+                else {
+                    throw new StorageError(`Failed to resolve cloud-linked storage config: ${err.message}`, 'CLOUD_CONFIG_RESOLVE_ERROR', err);
+                }
+            }
+        }
+        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;
+        options = this.resolvePE(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: '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) {
+        options = this.resolvePE(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) {
+        options = this.resolvePE(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;
+        options = this.resolvePE(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: '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) {
+        options = this.resolvePE(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) {
+        options = this.resolvePE(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 resolved = this.resolvePE(options);
+        const startTime = Date.now();
+        try {
+            const { config } = await this.initializeStorage(resolved.product, resolved.env, resolved.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) {
+        options = this.resolvePE(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