@push.rocks/smartregistry 2.2.3 → 2.4.0

package/dist_ts/upstream/classes.upstreamcache.js

@@ -0,0 +1,485 @@
+import { DEFAULT_CACHE_CONFIG } from './interfaces.upstream.js';
+/**
+ * S3-backed upstream cache with in-memory hot layer.
+ *
+ * Features:
+ * - TTL-based expiration
+ * - Stale-while-revalidate support
+ * - 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
+ *
+ * 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 {
+    /** In-memory hot cache */
+    memoryCache = new Map();
+    /** Configuration */
+    config;
+    /** Maximum in-memory cache entries */
+    maxMemoryEntries;
+    /** S3 storage backend (optional) */
+    storage;
+    /** Cleanup interval handle */
+    cleanupInterval = null;
+    constructor(config, maxMemoryEntries = 10000, storage) {
+        this.config = { ...DEFAULT_CACHE_CONFIG, ...config };
+        this.maxMemoryEntries = maxMemoryEntries;
+        this.storage = storage;
+        // Start periodic cleanup if caching is enabled
+        if (this.config.enabled) {
+            this.startCleanup();
+        }
+    }
+    /**
+     * Check if caching is enabled.
+     */
+    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).
+     */
+    async get(context, upstreamUrl) {
+        if (!this.config.enabled) {
+            return null;
+        }
+        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;
+        }
+        const now = new Date();
+        // Check if entry is expired
+        if (entry.expiresAt && entry.expiresAt < now) {
+            // Check if we can serve stale content
+            if (this.config.staleWhileRevalidate && !entry.stale) {
+                const staleAge = (now.getTime() - entry.expiresAt.getTime()) / 1000;
+                if (staleAge <= this.config.staleMaxAgeSeconds) {
+                    // Mark as stale and return
+                    entry.stale = true;
+                    return entry;
+                }
+            }
+            // Entry is too old, remove it
+            this.memoryCache.delete(key);
+            if (this.storage) {
+                await this.deleteFromStorage(key).catch(() => { });
+            }
+            return null;
+        }
+        return entry;
+    }
+    /**
+     * Store a response in the cache (memory and optionally S3).
+     */
+    async set(context, data, contentType, headers, upstreamId, upstreamUrl, options) {
+        if (!this.config.enabled) {
+            return;
+        }
+        // Enforce max memory entries limit
+        if (this.memoryCache.size >= this.maxMemoryEntries) {
+            this.evictOldest();
+        }
+        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);
+        const entry = {
+            data,
+            contentType,
+            headers,
+            cachedAt: now,
+            expiresAt: ttlSeconds > 0 ? new Date(now.getTime() + ttlSeconds * 1000) : undefined,
+            etag: headers['etag'] || options?.etag,
+            upstreamId,
+            stale: false,
+        };
+        // 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).
+     */
+    async setNegative(context, upstreamId, upstreamUrl) {
+        if (!this.config.enabled || this.config.negativeCacheTtlSeconds <= 0) {
+            return;
+        }
+        const key = this.buildCacheKey(context, upstreamUrl);
+        const now = new Date();
+        const entry = {
+            data: Buffer.from(''),
+            contentType: 'application/octet-stream',
+            headers: {},
+            cachedAt: now,
+            expiresAt: new Date(now.getTime() + this.config.negativeCacheTtlSeconds * 1000),
+            upstreamId,
+            stale: false,
+        };
+        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.
+     */
+    async hasNegative(context, upstreamUrl) {
+        const entry = await this.get(context, upstreamUrl);
+        return entry !== null && entry.data.length === 0;
+    }
+    /**
+     * Invalidate a specific cache entry.
+     */
+    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.
+     */
+    async invalidatePattern(pattern) {
+        let count = 0;
+        for (const key of this.memoryCache.keys()) {
+            if (pattern.test(key)) {
+                this.memoryCache.delete(key);
+                if (this.storage) {
+                    await this.deleteFromStorage(key).catch(() => { });
+                }
+                count++;
+            }
+        }
+        return count;
+    }
+    /**
+     * Invalidate all entries from a specific upstream.
+     */
+    async invalidateUpstream(upstreamId) {
+        let count = 0;
+        for (const [key, entry] of this.memoryCache.entries()) {
+            if (entry.upstreamId === upstreamId) {
+                this.memoryCache.delete(key);
+                if (this.storage) {
+                    await this.deleteFromStorage(key).catch(() => { });
+                }
+                count++;
+            }
+        }
+        return count;
+    }
+    /**
+     * Clear all cache entries (memory and S3).
+     */
+    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.
+     */
+    getStats() {
+        let freshCount = 0;
+        let staleCount = 0;
+        let negativeCount = 0;
+        let totalSize = 0;
+        const now = new Date();
+        for (const entry of this.memoryCache.values()) {
+            totalSize += entry.data.length;
+            if (entry.data.length === 0) {
+                negativeCount++;
+            }
+            else if (entry.stale || (entry.expiresAt && entry.expiresAt < now)) {
+                staleCount++;
+            }
+            else {
+                freshCount++;
+            }
+        }
+        return {
+            totalEntries: this.memoryCache.size,
+            freshEntries: freshCount,
+            staleEntries: staleCount,
+            negativeEntries: negativeCount,
+            totalSizeBytes: totalSize,
+            maxEntries: this.maxMemoryEntries,
+            enabled: this.config.enabled,
+            hasStorage: !!this.storage,
+        };
+    }
+    /**
+     * Stop the cache and cleanup.
+     */
+    stop() {
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+            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, upstreamUrl) {
+        // Include method, protocol, path, and sorted query params
+        const queryString = Object.keys(context.query)
+            .sort()
+            .map(k => `${k}=${context.query[k]}`)
+            .join('&');
+        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.
+     */
+    determineTtl(context, contentType, headers) {
+        // Check for Cache-Control header
+        const cacheControl = headers['cache-control'];
+        if (cacheControl) {
+            const maxAgeMatch = cacheControl.match(/max-age=(\d+)/);
+            if (maxAgeMatch) {
+                return parseInt(maxAgeMatch[1], 10);
+            }
+            if (cacheControl.includes('no-store') || cacheControl.includes('no-cache')) {
+                return 0;
+            }
+        }
+        // Check if content is immutable (content-addressable)
+        if (this.isImmutableContent(context, contentType)) {
+            return this.config.immutableTtlSeconds;
+        }
+        // Default TTL for mutable content
+        return this.config.defaultTtlSeconds;
+    }
+    /**
+     * Check if content is immutable (content-addressable).
+     */
+    isImmutableContent(context, contentType) {
+        // OCI blobs with digest are immutable
+        if (context.protocol === 'oci' && context.resourceType === 'blob') {
+            return true;
+        }
+        // NPM tarballs are immutable (versioned)
+        if (context.protocol === 'npm' && context.resourceType === 'tarball') {
+            return true;
+        }
+        // Maven artifacts with version are immutable
+        if (context.protocol === 'maven' && context.resourceType === 'artifact') {
+            return true;
+        }
+        // Cargo crate files are immutable
+        if (context.protocol === 'cargo' && context.resourceType === 'crate') {
+            return true;
+        }
+        // Composer dist files are immutable
+        if (context.protocol === 'composer' && context.resourceType === 'dist') {
+            return true;
+        }
+        // PyPI package files are immutable
+        if (context.protocol === 'pypi' && context.resourceType === 'package') {
+            return true;
+        }
+        // RubyGems .gem files are immutable
+        if (context.protocol === 'rubygems' && context.resourceType === 'gem') {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Evict oldest entries to make room for new ones.
+     */
+    evictOldest() {
+        // Evict 10% of max entries
+        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.memoryCache.entries()) {
+            if (evicted >= evictCount)
+                break;
+            if (entry.stale || (entry.expiresAt && entry.expiresAt < now)) {
+                this.memoryCache.delete(key);
+                evicted++;
+            }
+        }
+        // If not enough evicted, evict oldest by cachedAt
+        if (evicted < evictCount) {
+            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.memoryCache.delete(key);
+                evicted++;
+            }
+        }
+    }
+    /**
+     * Start periodic cleanup of expired entries.
+     */
+    startCleanup() {
+        // Run cleanup every minute
+        this.cleanupInterval = setInterval(() => {
+            this.cleanup();
+        }, 60000);
+        // Don't keep the process alive just for cleanup
+        if (this.cleanupInterval.unref) {
+            this.cleanupInterval.unref();
+        }
+    }
+    /**
+     * 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.memoryCache.entries()) {
+            if (entry.expiresAt) {
+                // Remove if past stale deadline
+                if (entry.expiresAt < staleDeadline) {
+                    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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"}

package/dist_ts/upstream/index.d.ts

@@ -0,0 +1,6 @@
+export * from './interfaces.upstream.js';
+export { CircuitBreaker, CircuitOpenError, withCircuitBreaker } from './classes.circuitbreaker.js';
+export type { ICircuitBreakerMetrics } from './classes.circuitbreaker.js';
+export { UpstreamCache } from './classes.upstreamcache.js';
+export type { ICacheSetOptions, ICacheStats } from './classes.upstreamcache.js';
+export { BaseUpstream } from './classes.baseupstream.js';

package/dist_ts/upstream/index.js

@@ -0,0 +1,7 @@
+// Interfaces and types
+export * from './interfaces.upstream.js';
+// Classes
+export { CircuitBreaker, CircuitOpenError, withCircuitBreaker } from './classes.circuitbreaker.js';
+export { UpstreamCache } from './classes.upstreamcache.js';
+export { BaseUpstream } from './classes.baseupstream.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy91cHN0cmVhbS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSx1QkFBdUI7QUFDdkIsY0FBYywwQkFBMEIsQ0FBQztBQUV6QyxVQUFVO0FBQ1YsT0FBTyxFQUFFLGNBQWMsRUFBRSxnQkFBZ0IsRUFBRSxrQkFBa0IsRUFBRSxNQUFNLDZCQUE2QixDQUFDO0FBR25HLE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSw0QkFBNEIsQ0FBQztBQUczRCxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sMkJBQTJCLENBQUMifQ==