@push.rocks/smartregistry 2.3.0 → 2.5.0

package/dist_ts/upstream/classes.upstreamcache.js

@@ -1,6 +1,6 @@
 import { DEFAULT_CACHE_CONFIG } from './interfaces.upstream.js';
 /**
- * In-memory cache for upstream responses.
+ * S3-backed upstream cache with in-memory hot layer.
  *
  * Features:
  * - TTL-based expiration
@@ -8,22 +8,36 @@ import { DEFAULT_CACHE_CONFIG } from './interfaces.upstream.js';
  * - Negative caching (404s)
  * - Content-type aware caching
  * - ETag support for conditional requests
+ * - Multi-upstream support via URL-based cache paths
+ * - Persistent S3 storage with in-memory hot layer
  *
- * Note: This is an in-memory implementation. For production with persistence,
- * extend this class to use RegistryStorage for S3-backed caching.
+ * Cache paths are structured as:
+ *   cache/{escaped-upstream-url}/{protocol}:{method}:{path}
+ *
+ * @example
+ * ```typescript
+ * // In-memory only (default)
+ * const cache = new UpstreamCache(config);
+ *
+ * // With S3 persistence
+ * const cache = new UpstreamCache(config, 10000, storage);
+ * ```
  */
 export class UpstreamCache {
-    /** Cache storage */
-    cache = new Map();
+    /** In-memory hot cache */
+    memoryCache = new Map();
     /** Configuration */
     config;
-    /** Maximum cache entries (prevents memory bloat) */
-    maxEntries;
+    /** Maximum in-memory cache entries */
+    maxMemoryEntries;
+    /** S3 storage backend (optional) */
+    storage;
     /** Cleanup interval handle */
     cleanupInterval = null;
-    constructor(config, maxEntries = 10000) {
+    constructor(config, maxMemoryEntries = 10000, storage) {
         this.config = { ...DEFAULT_CACHE_CONFIG, ...config };
-        this.maxEntries = maxEntries;
+        this.maxMemoryEntries = maxMemoryEntries;
+        this.storage = storage;
         // Start periodic cleanup if caching is enabled
         if (this.config.enabled) {
             this.startCleanup();
@@ -35,16 +49,32 @@ export class UpstreamCache {
     isEnabled() {
         return this.config.enabled;
     }
+    /**
+     * Check if S3 storage is configured.
+     */
+    hasStorage() {
+        return !!this.storage;
+    }
     /**
      * Get cached entry for a request context.
+     * Checks memory first, then falls back to S3.
      * Returns null if not found or expired (unless stale-while-revalidate).
      */
-    get(context) {
+    async get(context, upstreamUrl) {
         if (!this.config.enabled) {
             return null;
         }
-        const key = this.buildCacheKey(context);
-        const entry = this.cache.get(key);
+        const key = this.buildCacheKey(context, upstreamUrl);
+        // Check memory cache first
+        let entry = this.memoryCache.get(key);
+        // If not in memory and we have storage, check S3
+        if (!entry && this.storage) {
+            entry = await this.loadFromStorage(key);
+            if (entry) {
+                // Promote to memory cache
+                this.memoryCache.set(key, entry);
+            }
+        }
         if (!entry) {
             return null;
         }
@@ -61,23 +91,26 @@ export class UpstreamCache {
                 }
             }
             // Entry is too old, remove it
-            this.cache.delete(key);
+            this.memoryCache.delete(key);
+            if (this.storage) {
+                await this.deleteFromStorage(key).catch(() => { });
+            }
             return null;
         }
         return entry;
     }
     /**
-     * Store a response in the cache.
+     * Store a response in the cache (memory and optionally S3).
      */
-    set(context, data, contentType, headers, upstreamId, options) {
+    async set(context, data, contentType, headers, upstreamId, upstreamUrl, options) {
         if (!this.config.enabled) {
             return;
         }
-        // Enforce max entries limit
-        if (this.cache.size >= this.maxEntries) {
+        // Enforce max memory entries limit
+        if (this.memoryCache.size >= this.maxMemoryEntries) {
             this.evictOldest();
         }
-        const key = this.buildCacheKey(context);
+        const key = this.buildCacheKey(context, upstreamUrl);
         const now = new Date();
         // Determine TTL based on content type
         const ttlSeconds = options?.ttlSeconds ?? this.determineTtl(context, contentType, headers);
@@ -91,16 +124,21 @@ export class UpstreamCache {
             upstreamId,
             stale: false,
         };
-        this.cache.set(key, entry);
+        // Store in memory
+        this.memoryCache.set(key, entry);
+        // Store in S3 if available
+        if (this.storage) {
+            await this.saveToStorage(key, entry, upstreamUrl).catch(() => { });
+        }
     }
     /**
      * Store a negative cache entry (404 response).
      */
-    setNegative(context, upstreamId) {
+    async setNegative(context, upstreamId, upstreamUrl) {
         if (!this.config.enabled || this.config.negativeCacheTtlSeconds <= 0) {
             return;
         }
-        const key = this.buildCacheKey(context);
+        const key = this.buildCacheKey(context, upstreamUrl);
         const now = new Date();
         const entry = {
             data: Buffer.from(''),
@@ -111,31 +149,41 @@ export class UpstreamCache {
             upstreamId,
             stale: false,
         };
-        this.cache.set(key, entry);
+        this.memoryCache.set(key, entry);
+        if (this.storage) {
+            await this.saveToStorage(key, entry, upstreamUrl).catch(() => { });
+        }
     }
     /**
      * Check if there's a negative cache entry for this context.
      */
-    hasNegative(context) {
-        const entry = this.get(context);
+    async hasNegative(context, upstreamUrl) {
+        const entry = await this.get(context, upstreamUrl);
         return entry !== null && entry.data.length === 0;
     }
     /**
      * Invalidate a specific cache entry.
      */
-    invalidate(context) {
-        const key = this.buildCacheKey(context);
-        return this.cache.delete(key);
+    async invalidate(context, upstreamUrl) {
+        const key = this.buildCacheKey(context, upstreamUrl);
+        const deleted = this.memoryCache.delete(key);
+        if (this.storage) {
+            await this.deleteFromStorage(key).catch(() => { });
+        }
+        return deleted;
     }
     /**
      * Invalidate all entries matching a pattern.
      * Useful for invalidating all versions of a package.
      */
-    invalidatePattern(pattern) {
+    async invalidatePattern(pattern) {
         let count = 0;
-        for (const key of this.cache.keys()) {
+        for (const key of this.memoryCache.keys()) {
             if (pattern.test(key)) {
-                this.cache.delete(key);
+                this.memoryCache.delete(key);
+                if (this.storage) {
+                    await this.deleteFromStorage(key).catch(() => { });
+                }
                 count++;
             }
         }
@@ -144,21 +192,26 @@ export class UpstreamCache {
     /**
      * Invalidate all entries from a specific upstream.
      */
-    invalidateUpstream(upstreamId) {
+    async invalidateUpstream(upstreamId) {
         let count = 0;
-        for (const [key, entry] of this.cache.entries()) {
+        for (const [key, entry] of this.memoryCache.entries()) {
             if (entry.upstreamId === upstreamId) {
-                this.cache.delete(key);
+                this.memoryCache.delete(key);
+                if (this.storage) {
+                    await this.deleteFromStorage(key).catch(() => { });
+                }
                 count++;
             }
         }
         return count;
     }
     /**
-     * Clear all cache entries.
+     * Clear all cache entries (memory and S3).
      */
-    clear() {
-        this.cache.clear();
+    async clear() {
+        this.memoryCache.clear();
+        // Note: S3 cleanup would require listing and deleting all cache/* objects
+        // This is left as a future enhancement for bulk cleanup
     }
     /**
      * Get cache statistics.
@@ -169,7 +222,7 @@ export class UpstreamCache {
         let negativeCount = 0;
         let totalSize = 0;
         const now = new Date();
-        for (const entry of this.cache.values()) {
+        for (const entry of this.memoryCache.values()) {
             totalSize += entry.data.length;
             if (entry.data.length === 0) {
                 negativeCount++;
@@ -182,13 +235,14 @@ export class UpstreamCache {
             }
         }
         return {
-            totalEntries: this.cache.size,
+            totalEntries: this.memoryCache.size,
             freshEntries: freshCount,
             staleEntries: staleCount,
             negativeEntries: negativeCount,
             totalSizeBytes: totalSize,
-            maxEntries: this.maxEntries,
+            maxEntries: this.maxMemoryEntries,
             enabled: this.config.enabled,
+            hasStorage: !!this.storage,
         };
     }
     /**
@@ -200,16 +254,119 @@ export class UpstreamCache {
             this.cleanupInterval = null;
         }
     }
+    // ========================================================================
+    // Storage Methods
+    // ========================================================================
+    /**
+     * Build storage path for a cache key.
+     * Escapes upstream URL for safe use in S3 paths.
+     */
+    buildStoragePath(key) {
+        return `cache/${key}`;
+    }
+    /**
+     * Build storage path for cache metadata.
+     */
+    buildMetadataPath(key) {
+        return `cache/${key}.meta`;
+    }
+    /**
+     * Load a cache entry from S3 storage.
+     */
+    async loadFromStorage(key) {
+        if (!this.storage)
+            return null;
+        try {
+            const dataPath = this.buildStoragePath(key);
+            const metaPath = this.buildMetadataPath(key);
+            // Load data and metadata in parallel
+            const [data, metaBuffer] = await Promise.all([
+                this.storage.getObject(dataPath),
+                this.storage.getObject(metaPath),
+            ]);
+            if (!data || !metaBuffer) {
+                return null;
+            }
+            const meta = JSON.parse(metaBuffer.toString('utf-8'));
+            return {
+                data,
+                contentType: meta.contentType,
+                headers: meta.headers,
+                cachedAt: new Date(meta.cachedAt),
+                expiresAt: meta.expiresAt ? new Date(meta.expiresAt) : undefined,
+                etag: meta.etag,
+                upstreamId: meta.upstreamId,
+                stale: false,
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Save a cache entry to S3 storage.
+     */
+    async saveToStorage(key, entry, upstreamUrl) {
+        if (!this.storage)
+            return;
+        const dataPath = this.buildStoragePath(key);
+        const metaPath = this.buildMetadataPath(key);
+        const meta = {
+            contentType: entry.contentType,
+            headers: entry.headers,
+            cachedAt: entry.cachedAt.toISOString(),
+            expiresAt: entry.expiresAt?.toISOString(),
+            etag: entry.etag,
+            upstreamId: entry.upstreamId,
+            upstreamUrl,
+        };
+        // Save data and metadata in parallel
+        await Promise.all([
+            this.storage.putObject(dataPath, entry.data),
+            this.storage.putObject(metaPath, Buffer.from(JSON.stringify(meta), 'utf-8')),
+        ]);
+    }
+    /**
+     * Delete a cache entry from S3 storage.
+     */
+    async deleteFromStorage(key) {
+        if (!this.storage)
+            return;
+        const dataPath = this.buildStoragePath(key);
+        const metaPath = this.buildMetadataPath(key);
+        await Promise.all([
+            this.storage.deleteObject(dataPath).catch(() => { }),
+            this.storage.deleteObject(metaPath).catch(() => { }),
+        ]);
+    }
+    // ========================================================================
+    // Helper Methods
+    // ========================================================================
+    /**
+     * Escape a URL for safe use in storage paths.
+     */
+    escapeUrl(url) {
+        // Remove protocol prefix and escape special characters
+        return url
+            .replace(/^https?:\/\//, '')
+            .replace(/[\/\\:*?"<>|]/g, '_')
+            .replace(/__+/g, '_');
+    }
     /**
      * Build a unique cache key for a request context.
+     * Includes escaped upstream URL for multi-upstream support.
      */
-    buildCacheKey(context) {
+    buildCacheKey(context, upstreamUrl) {
         // Include method, protocol, path, and sorted query params
         const queryString = Object.keys(context.query)
             .sort()
             .map(k => `${k}=${context.query[k]}`)
             .join('&');
-        return `${context.protocol}:${context.method}:${context.path}${queryString ? '?' + queryString : ''}`;
+        const baseKey = `${context.protocol}:${context.method}:${context.path}${queryString ? '?' + queryString : ''}`;
+        if (upstreamUrl) {
+            return `${this.escapeUrl(upstreamUrl)}/${baseKey}`;
+        }
+        return baseKey;
     }
     /**
      * Determine TTL based on content characteristics.
@@ -272,26 +429,26 @@ export class UpstreamCache {
      */
     evictOldest() {
         // Evict 10% of max entries
-        const evictCount = Math.ceil(this.maxEntries * 0.1);
+        const evictCount = Math.ceil(this.maxMemoryEntries * 0.1);
         let evicted = 0;
         // First, try to evict stale entries
         const now = new Date();
-        for (const [key, entry] of this.cache.entries()) {
+        for (const [key, entry] of this.memoryCache.entries()) {
             if (evicted >= evictCount)
                 break;
             if (entry.stale || (entry.expiresAt && entry.expiresAt < now)) {
-                this.cache.delete(key);
+                this.memoryCache.delete(key);
                 evicted++;
             }
         }
         // If not enough evicted, evict oldest by cachedAt
         if (evicted < evictCount) {
-            const entries = Array.from(this.cache.entries())
+            const entries = Array.from(this.memoryCache.entries())
                 .sort((a, b) => a[1].cachedAt.getTime() - b[1].cachedAt.getTime());
             for (const [key] of entries) {
                 if (evicted >= evictCount)
                     break;
-                this.cache.delete(key);
+                this.memoryCache.delete(key);
                 evicted++;
             }
         }
@@ -310,19 +467,19 @@ export class UpstreamCache {
         }
     }
     /**
-     * Remove all expired entries.
+     * Remove all expired entries from memory cache.
      */
     cleanup() {
         const now = new Date();
         const staleDeadline = new Date(now.getTime() - this.config.staleMaxAgeSeconds * 1000);
-        for (const [key, entry] of this.cache.entries()) {
+        for (const [key, entry] of this.memoryCache.entries()) {
             if (entry.expiresAt) {
                 // Remove if past stale deadline
                 if (entry.expiresAt < staleDeadline) {
-                    this.cache.delete(key);
+                    this.memoryCache.delete(key);
                 }
             }
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.upstreamcache.js","sourceRoot":"","sources":["../../ts/upstream/classes.upstreamcache.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.upstreamcache.js","sourceRoot":"","sources":["../../ts/upstream/classes.upstreamcache.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/smartregistry",
-  "version": "2.3.0",
+  "version": "2.5.0",
   "private": false,
   "description": "A composable TypeScript library implementing OCI, NPM, Maven, Cargo, Composer, PyPI, and RubyGems registries for building unified container and package registries",
   "main": "dist_ts/index.js",