@push.rocks/smartregistry 2.2.3 → 2.3.0

package/dist_ts/upstream/classes.circuitbreaker.js

@@ -0,0 +1,192 @@
+import { DEFAULT_RESILIENCE_CONFIG } from './interfaces.upstream.js';
+/**
+ * Circuit breaker implementation for upstream resilience.
+ *
+ * States:
+ * - CLOSED: Normal operation, requests pass through
+ * - OPEN: Circuit is tripped, requests fail fast
+ * - HALF_OPEN: Testing if upstream has recovered
+ *
+ * Transitions:
+ * - CLOSED → OPEN: When failure count exceeds threshold
+ * - OPEN → HALF_OPEN: After reset timeout expires
+ * - HALF_OPEN → CLOSED: On successful request
+ * - HALF_OPEN → OPEN: On failed request
+ */
+export class CircuitBreaker {
+    /** Unique identifier for logging and metrics */
+    id;
+    /** Current circuit state */
+    state = 'CLOSED';
+    /** Count of consecutive failures */
+    failureCount = 0;
+    /** Timestamp when circuit was opened */
+    openedAt = 0;
+    /** Number of successful requests in half-open state */
+    halfOpenSuccesses = 0;
+    /** Configuration */
+    config;
+    /** Number of successes required to close circuit from half-open */
+    halfOpenThreshold = 2;
+    constructor(id, config) {
+        this.id = id;
+        this.config = { ...DEFAULT_RESILIENCE_CONFIG, ...config };
+    }
+    /**
+     * Get current circuit state.
+     */
+    getState() {
+        // Check if we should transition from OPEN to HALF_OPEN
+        if (this.state === 'OPEN') {
+            const elapsed = Date.now() - this.openedAt;
+            if (elapsed >= this.config.circuitBreakerResetMs) {
+                this.transitionTo('HALF_OPEN');
+            }
+        }
+        return this.state;
+    }
+    /**
+     * Check if circuit allows requests.
+     * Returns true if requests should be allowed.
+     */
+    canRequest() {
+        const currentState = this.getState();
+        return currentState !== 'OPEN';
+    }
+    /**
+     * Record a successful request.
+     * May transition circuit from HALF_OPEN to CLOSED.
+     */
+    recordSuccess() {
+        if (this.state === 'HALF_OPEN') {
+            this.halfOpenSuccesses++;
+            if (this.halfOpenSuccesses >= this.halfOpenThreshold) {
+                this.transitionTo('CLOSED');
+            }
+        }
+        else if (this.state === 'CLOSED') {
+            // Reset failure count on success
+            this.failureCount = 0;
+        }
+    }
+    /**
+     * Record a failed request.
+     * May transition circuit from CLOSED/HALF_OPEN to OPEN.
+     */
+    recordFailure() {
+        if (this.state === 'HALF_OPEN') {
+            // Any failure in half-open immediately opens circuit
+            this.transitionTo('OPEN');
+        }
+        else if (this.state === 'CLOSED') {
+            this.failureCount++;
+            if (this.failureCount >= this.config.circuitBreakerThreshold) {
+                this.transitionTo('OPEN');
+            }
+        }
+    }
+    /**
+     * Force circuit to open state.
+     * Useful for manual intervention or external health checks.
+     */
+    forceOpen() {
+        this.transitionTo('OPEN');
+    }
+    /**
+     * Force circuit to closed state.
+     * Useful for manual intervention after fixing upstream issues.
+     */
+    forceClose() {
+        this.transitionTo('CLOSED');
+    }
+    /**
+     * Reset circuit to initial state.
+     */
+    reset() {
+        this.state = 'CLOSED';
+        this.failureCount = 0;
+        this.openedAt = 0;
+        this.halfOpenSuccesses = 0;
+    }
+    /**
+     * Get circuit metrics for monitoring.
+     */
+    getMetrics() {
+        return {
+            id: this.id,
+            state: this.getState(),
+            failureCount: this.failureCount,
+            openedAt: this.openedAt > 0 ? new Date(this.openedAt) : null,
+            timeUntilHalfOpen: this.state === 'OPEN'
+                ? Math.max(0, this.config.circuitBreakerResetMs - (Date.now() - this.openedAt))
+                : 0,
+            halfOpenSuccesses: this.halfOpenSuccesses,
+            threshold: this.config.circuitBreakerThreshold,
+            resetMs: this.config.circuitBreakerResetMs,
+        };
+    }
+    /**
+     * Transition to a new state with proper cleanup.
+     */
+    transitionTo(newState) {
+        const previousState = this.state;
+        this.state = newState;
+        switch (newState) {
+            case 'OPEN':
+                this.openedAt = Date.now();
+                this.halfOpenSuccesses = 0;
+                break;
+            case 'HALF_OPEN':
+                this.halfOpenSuccesses = 0;
+                break;
+            case 'CLOSED':
+                this.failureCount = 0;
+                this.openedAt = 0;
+                this.halfOpenSuccesses = 0;
+                break;
+        }
+        // Log state transition (useful for debugging and monitoring)
+        // In production, this would emit events or metrics
+        if (previousState !== newState) {
+            // State changed - could emit event here
+        }
+    }
+}
+/**
+ * Execute a function with circuit breaker protection.
+ *
+ * @param breaker The circuit breaker to use
+ * @param fn The async function to execute
+ * @param fallback Optional fallback function when circuit is open
+ * @returns The result of fn or fallback
+ * @throws CircuitOpenError if circuit is open and no fallback provided
+ */
+export async function withCircuitBreaker(breaker, fn, fallback) {
+    if (!breaker.canRequest()) {
+        if (fallback) {
+            return fallback();
+        }
+        throw new CircuitOpenError(breaker.id);
+    }
+    try {
+        const result = await fn();
+        breaker.recordSuccess();
+        return result;
+    }
+    catch (error) {
+        breaker.recordFailure();
+        throw error;
+    }
+}
+/**
+ * Error thrown when circuit is open and no fallback is provided.
+ */
+export class CircuitOpenError extends Error {
+    circuitId;
+    constructor(circuitId) {
+        super(`Circuit breaker '${circuitId}' is open`);
+        this.name = 'CircuitOpenError';
+        this.circuitId = circuitId;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/upstream/classes.upstreamcache.d.ts

@@ -0,0 +1,123 @@
+import type { ICacheEntry, IUpstreamCacheConfig, IUpstreamFetchContext } from './interfaces.upstream.js';
+/**
+ * In-memory cache for upstream responses.
+ *
+ * Features:
+ * - TTL-based expiration
+ * - Stale-while-revalidate support
+ * - Negative caching (404s)
+ * - Content-type aware caching
+ * - ETag support for conditional requests
+ *
+ * Note: This is an in-memory implementation. For production with persistence,
+ * extend this class to use RegistryStorage for S3-backed caching.
+ */
+export declare class UpstreamCache {
+    /** Cache storage */
+    private readonly cache;
+    /** Configuration */
+    private readonly config;
+    /** Maximum cache entries (prevents memory bloat) */
+    private readonly maxEntries;
+    /** Cleanup interval handle */
+    private cleanupInterval;
+    constructor(config?: Partial<IUpstreamCacheConfig>, maxEntries?: number);
+    /**
+     * Check if caching is enabled.
+     */
+    isEnabled(): boolean;
+    /**
+     * Get cached entry for a request context.
+     * Returns null if not found or expired (unless stale-while-revalidate).
+     */
+    get(context: IUpstreamFetchContext): ICacheEntry | null;
+    /**
+     * Store a response in the cache.
+     */
+    set(context: IUpstreamFetchContext, data: Buffer, contentType: string, headers: Record<string, string>, upstreamId: string, options?: ICacheSetOptions): void;
+    /**
+     * Store a negative cache entry (404 response).
+     */
+    setNegative(context: IUpstreamFetchContext, upstreamId: string): void;
+    /**
+     * Check if there's a negative cache entry for this context.
+     */
+    hasNegative(context: IUpstreamFetchContext): boolean;
+    /**
+     * Invalidate a specific cache entry.
+     */
+    invalidate(context: IUpstreamFetchContext): boolean;
+    /**
+     * Invalidate all entries matching a pattern.
+     * Useful for invalidating all versions of a package.
+     */
+    invalidatePattern(pattern: RegExp): number;
+    /**
+     * Invalidate all entries from a specific upstream.
+     */
+    invalidateUpstream(upstreamId: string): number;
+    /**
+     * Clear all cache entries.
+     */
+    clear(): void;
+    /**
+     * Get cache statistics.
+     */
+    getStats(): ICacheStats;
+    /**
+     * Stop the cache and cleanup.
+     */
+    stop(): void;
+    /**
+     * Build a unique cache key for a request context.
+     */
+    private buildCacheKey;
+    /**
+     * Determine TTL based on content characteristics.
+     */
+    private determineTtl;
+    /**
+     * Check if content is immutable (content-addressable).
+     */
+    private isImmutableContent;
+    /**
+     * Evict oldest entries to make room for new ones.
+     */
+    private evictOldest;
+    /**
+     * Start periodic cleanup of expired entries.
+     */
+    private startCleanup;
+    /**
+     * Remove all expired entries.
+     */
+    private cleanup;
+}
+/**
+ * Options for cache set operation.
+ */
+export interface ICacheSetOptions {
+    /** Override TTL in seconds */
+    ttlSeconds?: number;
+    /** ETag for conditional requests */
+    etag?: string;
+}
+/**
+ * Cache statistics.
+ */
+export interface ICacheStats {
+    /** Total number of cached entries */
+    totalEntries: number;
+    /** Number of fresh (non-expired) entries */
+    freshEntries: number;
+    /** Number of stale entries (expired but still usable) */
+    staleEntries: number;
+    /** Number of negative cache entries */
+    negativeEntries: number;
+    /** Total size of cached data in bytes */
+    totalSizeBytes: number;
+    /** Maximum allowed entries */
+    maxEntries: number;
+    /** Whether caching is enabled */
+    enabled: boolean;
+}

package/dist_ts/upstream/classes.upstreamcache.js

@@ -0,0 +1,328 @@
+import { DEFAULT_CACHE_CONFIG } from './interfaces.upstream.js';
+/**
+ * In-memory cache for upstream responses.
+ *
+ * Features:
+ * - TTL-based expiration
+ * - Stale-while-revalidate support
+ * - Negative caching (404s)
+ * - Content-type aware caching
+ * - ETag support for conditional requests
+ *
+ * Note: This is an in-memory implementation. For production with persistence,
+ * extend this class to use RegistryStorage for S3-backed caching.
+ */
+export class UpstreamCache {
+    /** Cache storage */
+    cache = new Map();
+    /** Configuration */
+    config;
+    /** Maximum cache entries (prevents memory bloat) */
+    maxEntries;
+    /** Cleanup interval handle */
+    cleanupInterval = null;
+    constructor(config, maxEntries = 10000) {
+        this.config = { ...DEFAULT_CACHE_CONFIG, ...config };
+        this.maxEntries = maxEntries;
+        // Start periodic cleanup if caching is enabled
+        if (this.config.enabled) {
+            this.startCleanup();
+        }
+    }
+    /**
+     * Check if caching is enabled.
+     */
+    isEnabled() {
+        return this.config.enabled;
+    }
+    /**
+     * Get cached entry for a request context.
+     * Returns null if not found or expired (unless stale-while-revalidate).
+     */
+    get(context) {
+        if (!this.config.enabled) {
+            return null;
+        }
+        const key = this.buildCacheKey(context);
+        const entry = this.cache.get(key);
+        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.cache.delete(key);
+            return null;
+        }
+        return entry;
+    }
+    /**
+     * Store a response in the cache.
+     */
+    set(context, data, contentType, headers, upstreamId, options) {
+        if (!this.config.enabled) {
+            return;
+        }
+        // Enforce max entries limit
+        if (this.cache.size >= this.maxEntries) {
+            this.evictOldest();
+        }
+        const key = this.buildCacheKey(context);
+        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,
+        };
+        this.cache.set(key, entry);
+    }
+    /**
+     * Store a negative cache entry (404 response).
+     */
+    setNegative(context, upstreamId) {
+        if (!this.config.enabled || this.config.negativeCacheTtlSeconds <= 0) {
+            return;
+        }
+        const key = this.buildCacheKey(context);
+        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.cache.set(key, entry);
+    }
+    /**
+     * Check if there's a negative cache entry for this context.
+     */
+    hasNegative(context) {
+        const entry = this.get(context);
+        return entry !== null && entry.data.length === 0;
+    }
+    /**
+     * Invalidate a specific cache entry.
+     */
+    invalidate(context) {
+        const key = this.buildCacheKey(context);
+        return this.cache.delete(key);
+    }
+    /**
+     * Invalidate all entries matching a pattern.
+     * Useful for invalidating all versions of a package.
+     */
+    invalidatePattern(pattern) {
+        let count = 0;
+        for (const key of this.cache.keys()) {
+            if (pattern.test(key)) {
+                this.cache.delete(key);
+                count++;
+            }
+        }
+        return count;
+    }
+    /**
+     * Invalidate all entries from a specific upstream.
+     */
+    invalidateUpstream(upstreamId) {
+        let count = 0;
+        for (const [key, entry] of this.cache.entries()) {
+            if (entry.upstreamId === upstreamId) {
+                this.cache.delete(key);
+                count++;
+            }
+        }
+        return count;
+    }
+    /**
+     * Clear all cache entries.
+     */
+    clear() {
+        this.cache.clear();
+    }
+    /**
+     * 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.cache.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.cache.size,
+            freshEntries: freshCount,
+            staleEntries: staleCount,
+            negativeEntries: negativeCount,
+            totalSizeBytes: totalSize,
+            maxEntries: this.maxEntries,
+            enabled: this.config.enabled,
+        };
+    }
+    /**
+     * Stop the cache and cleanup.
+     */
+    stop() {
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+            this.cleanupInterval = null;
+        }
+    }
+    /**
+     * Build a unique cache key for a request context.
+     */
+    buildCacheKey(context) {
+        // 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 : ''}`;
+    }
+    /**
+     * 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.maxEntries * 0.1);
+        let evicted = 0;
+        // First, try to evict stale entries
+        const now = new Date();
+        for (const [key, entry] of this.cache.entries()) {
+            if (evicted >= evictCount)
+                break;
+            if (entry.stale || (entry.expiresAt && entry.expiresAt < now)) {
+                this.cache.delete(key);
+                evicted++;
+            }
+        }
+        // If not enough evicted, evict oldest by cachedAt
+        if (evicted < evictCount) {
+            const entries = Array.from(this.cache.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);
+                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.
+     */
+    cleanup() {
+        const now = new Date();
+        const staleDeadline = new Date(now.getTime() - this.config.staleMaxAgeSeconds * 1000);
+        for (const [key, entry] of this.cache.entries()) {
+            if (entry.expiresAt) {
+                // Remove if past stale deadline
+                if (entry.expiresAt < staleDeadline) {
+                    this.cache.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==