@riocrypto/common-server 1.0.2480 → 1.0.2481

package/build/clients/secret-manager-client.d.ts

@@ -8,22 +8,34 @@ declare class SecretManagerClient {
     private readonly POLL_INTERVAL_MS;
     constructor(env: RioEnv);
     /**
-     * Get a secret value from cache or fetch it from Secret Manager
-     * Once fetched, the secret will be cached and automatically refreshed every 15 seconds
+     * Get a secret value from cache or fetch the entire secret file
+     * Once fetched, all secrets are cached and automatically refreshed every hour
      */
     getSecretValue(secretId: string): Promise<string | null>;
     /**
-     * Fetch a secret value directly from Secret Manager without using the cache
+     * Refresh the entire secret cache by fetching the complete secret file
      */
-    private fetchSecretValue;
+    private refreshSecretCache;
     /**
-     * Set up cache entry with polling for a secret
+     * Set up cache with polling for the entire secret file
      */
     private setupCacheWithPolling;
     /**
-     * Clear the cache for a specific secret or all secrets
+     * Clear the entire secret cache
      */
-    clearCache(secretId?: string): void;
+    clearCache(): void;
+    /**
+     * Get all cached secrets (useful for debugging)
+     */
+    getAllSecrets(): Record<string, string> | null;
+    /**
+     * Get cache status information
+     */
+    getCacheStatus(): {
+        isLoaded: boolean;
+        secretCount: number;
+        lastFetched: Date | null;
+    };
 }
 export declare const secretManagerClient: SecretManagerClient;
 export {};

package/build/clients/secret-manager-client.js

@@ -39,7 +39,7 @@ const fs = __importStar(require("fs"));
 class SecretManagerClient {
     constructor(env) {
         this.env = env;
-        this.secretCache = new Map();
+        this.secretCache = null;
         this.POLL_INTERVAL_MS = 60 * 60 * 1000; // 1 hour
         const secretFilePath = "/etc/secrets/secret-manager/secret-manager-service-account-key.json";
         const secretFileContents = fs.readFileSync(secretFilePath, "utf8");
@@ -56,29 +56,34 @@ class SecretManagerClient {
         });
     }
     /**
-     * Get a secret value from cache or fetch it from Secret Manager
-     * Once fetched, the secret will be cached and automatically refreshed every 15 seconds
+     * Get a secret value from cache or fetch the entire secret file
+     * Once fetched, all secrets are cached and automatically refreshed every hour
      */
     getSecretValue(secretId) {
         return __awaiter(this, void 0, void 0, function* () {
-            // Check if the secret is already in the cache
-            const cachedSecret = this.secretCache.get(secretId);
-            if (cachedSecret) {
-                return cachedSecret.value;
+            // Check if we have a cache and the secret exists
+            if (this.secretCache && this.secretCache.secrets[secretId]) {
+                return this.secretCache.secrets[secretId];
             }
-            // If not in cache, fetch it and set up polling
-            const value = yield this.fetchSecretValue(secretId);
-            if (value) {
-                this.setupCacheWithPolling(secretId, value);
+            // If not in cache or cache doesn't exist, fetch entire secret file
+            const success = yield this.refreshSecretCache();
+            if (!success) {
+                return null;
             }
-            return value;
+            // Check again after refresh
+            if (this.secretCache && this.secretCache.secrets[secretId]) {
+                return this.secretCache.secrets[secretId];
+            }
+            // Secret not found even after refresh
+            console.error(`Secret ${secretId} not found in secret file`);
+            return null;
         });
     }
     /**
-     * Fetch a secret value directly from Secret Manager without using the cache
+     * Refresh the entire secret cache by fetching the complete secret file
      */
-    fetchSecretValue(secretId) {
-        var _a, _b;
+    refreshSecretCache() {
+        var _a, _b, _c;
         return __awaiter(this, void 0, void 0, function* () {
             let file;
             if (this.env === common_1.RioEnv.Development) {
@@ -105,7 +110,14 @@ class SecretManagerClient {
                         throw new Error("No payload data");
                     }
                     const secrets = JSON.parse(version.payload.data.toString());
-                    return secrets[secretId];
+                    // Clear existing polling if it exists
+                    if ((_c = this.secretCache) === null || _c === void 0 ? void 0 : _c.pollingInterval) {
+                        clearInterval(this.secretCache.pollingInterval);
+                    }
+                    // Set up new cache with polling
+                    this.setupCacheWithPolling(secrets);
+                    console.info(`Refreshed ${Object.keys(secrets).length} secrets from ${file}`);
+                    return true;
                 }
                 catch (err) {
                     attempt++;
@@ -117,74 +129,77 @@ class SecretManagerClient {
                         continue;
                     }
                     else {
-                        console.error(`Failed to access secret ${secretId}:`, err);
-                        return null;
+                        console.error(`Failed to access secret file ${file}:`, err);
+                        return false;
                     }
                 }
             }
-            console.error(`Failed to access secret ${secretId} after ${maxRetries} attempts.`);
-            return null;
+            console.error(`Failed to access secret file ${file} after ${maxRetries} attempts.`);
+            return false;
         });
     }
     /**
-     * Set up cache entry with polling for a secret
+     * Set up cache with polling for the entire secret file
      */
-    setupCacheWithPolling(secretId, initialValue) {
+    setupCacheWithPolling(secrets) {
         // Only set up polling in non-test environments
         if (process.env.NODE_ENV === "test") {
-            // For test environments, just cache the value without polling
-            this.secretCache.set(secretId, {
-                value: initialValue,
+            // For test environments, just cache the secrets without polling
+            this.secretCache = {
+                secrets,
                 pollingInterval: null,
-            });
+                lastFetched: new Date(),
+            };
             return;
         }
-        // Set up polling interval to refresh the secret
+        // Set up polling interval to refresh all secrets
         const pollingInterval = setInterval(() => __awaiter(this, void 0, void 0, function* () {
             try {
-                const newValue = yield this.fetchSecretValue(secretId);
-                if (newValue) {
-                    const currentCached = this.secretCache.get(secretId);
-                    // Only update and log if the value has changed
-                    if (currentCached && currentCached.value !== newValue) {
-                        console.info(`Secret ${secretId} has been updated`);
-                        this.secretCache.set(secretId, {
-                            value: newValue,
-                            pollingInterval: currentCached.pollingInterval,
-                        });
-                    }
+                const success = yield this.refreshSecretCache();
+                if (!success) {
+                    console.error("Failed to refresh secret cache during polling");
                 }
             }
             catch (error) {
-                console.error(`Error polling secret ${secretId}:`, error);
+                console.error("Error polling secrets:", error);
             }
         }), this.POLL_INTERVAL_MS);
-        // Store the initial value and polling interval
-        this.secretCache.set(secretId, {
-            value: initialValue,
+        // Store the cache with polling interval
+        this.secretCache = {
+            secrets,
             pollingInterval,
-        });
+            lastFetched: new Date(),
+        };
     }
     /**
-     * Clear the cache for a specific secret or all secrets
+     * Clear the entire secret cache
      */
-    clearCache(secretId) {
-        if (secretId) {
-            const cached = this.secretCache.get(secretId);
-            if (cached && cached.pollingInterval) {
-                clearInterval(cached.pollingInterval);
-            }
-            this.secretCache.delete(secretId);
-        }
-        else {
-            // Clear all cached secrets
-            this.secretCache.forEach((cached) => {
-                if (cached.pollingInterval) {
-                    clearInterval(cached.pollingInterval);
-                }
-            });
-            this.secretCache.clear();
+    clearCache() {
+        var _a;
+        if ((_a = this.secretCache) === null || _a === void 0 ? void 0 : _a.pollingInterval) {
+            clearInterval(this.secretCache.pollingInterval);
         }
+        this.secretCache = null;
+    }
+    /**
+     * Get all cached secrets (useful for debugging)
+     */
+    getAllSecrets() {
+        var _a;
+        return ((_a = this.secretCache) === null || _a === void 0 ? void 0 : _a.secrets) || null;
+    }
+    /**
+     * Get cache status information
+     */
+    getCacheStatus() {
+        var _a;
+        return {
+            isLoaded: !!this.secretCache,
+            secretCount: this.secretCache
+                ? Object.keys(this.secretCache.secrets).length
+                : 0,
+            lastFetched: ((_a = this.secretCache) === null || _a === void 0 ? void 0 : _a.lastFetched) || null,
+        };
     }
 }
 exports.secretManagerClient = new SecretManagerClient(process.env.RIO_ENV || process.env.NEXT_PUBLIC_RIO_ENV);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@riocrypto/common-server",
-  "version": "1.0.2480",
+  "version": "1.0.2481",
   "description": "",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",