@push.rocks/smartregistry 2.2.3 → 2.3.0

package/dist_ts/rubygems/index.js

@@ -4,5 +4,6 @@
  */
 export * from './interfaces.rubygems.js';
 export * from './classes.rubygemsregistry.js';
+export { RubygemsUpstream } from './classes.rubygemsupstream.js';
 export * as rubygemsHelpers from './helpers.rubygems.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9ydWJ5Z2Vtcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7O0dBR0c7QUFFSCxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsK0JBQStCLENBQUM7QUFDOUMsT0FBTyxLQUFLLGVBQWUsTUFBTSx1QkFBdUIsQ0FBQyJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9ydWJ5Z2Vtcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7O0dBR0c7QUFFSCxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsK0JBQStCLENBQUM7QUFDOUMsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sK0JBQStCLENBQUM7QUFDakUsT0FBTyxLQUFLLGVBQWUsTUFBTSx1QkFBdUIsQ0FBQyJ9

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

@@ -0,0 +1,112 @@
+import * as plugins from '../plugins.js';
+import type { IUpstreamRegistryConfig, IUpstreamAuthConfig, IUpstreamCacheConfig, IUpstreamResilienceConfig, IUpstreamResult, IUpstreamFetchContext, IProtocolUpstreamConfig, IUpstreamScopeRule, TCircuitState } from './interfaces.upstream.js';
+import { CircuitBreaker } from './classes.circuitbreaker.js';
+import { UpstreamCache } from './classes.upstreamcache.js';
+/**
+ * Base class for protocol-specific upstream implementations.
+ *
+ * Provides:
+ * - Multi-upstream routing with priority
+ * - Scope-based filtering (glob patterns)
+ * - Authentication handling
+ * - Circuit breaker per upstream
+ * - Caching with TTL
+ * - Retry with exponential backoff
+ * - 429 rate limit handling
+ */
+export declare abstract class BaseUpstream {
+    /** Protocol name for logging */
+    protected abstract readonly protocolName: string;
+    /** Upstream configuration */
+    protected readonly config: IProtocolUpstreamConfig;
+    /** Resolved cache configuration */
+    protected readonly cacheConfig: IUpstreamCacheConfig;
+    /** Resolved resilience configuration */
+    protected readonly resilienceConfig: IUpstreamResilienceConfig;
+    /** Circuit breakers per upstream */
+    protected readonly circuitBreakers: Map<string, CircuitBreaker>;
+    /** Upstream cache */
+    protected readonly cache: UpstreamCache;
+    /** Logger instance */
+    protected readonly logger: plugins.smartlog.Smartlog;
+    constructor(config: IProtocolUpstreamConfig, logger?: plugins.smartlog.Smartlog);
+    /**
+     * Check if upstream is enabled.
+     */
+    isEnabled(): boolean;
+    /**
+     * Get all configured upstreams.
+     */
+    getUpstreams(): IUpstreamRegistryConfig[];
+    /**
+     * Get circuit breaker state for an upstream.
+     */
+    getCircuitState(upstreamId: string): TCircuitState | null;
+    /**
+     * Get cache statistics.
+     */
+    getCacheStats(): import("./classes.upstreamcache.js").ICacheStats;
+    /**
+     * Fetch a resource from upstreams.
+     * Tries upstreams in priority order, respecting circuit breakers and scope rules.
+     */
+    fetch(context: IUpstreamFetchContext): Promise<IUpstreamResult | null>;
+    /**
+     * Invalidate cache for a resource pattern.
+     */
+    invalidateCache(pattern: RegExp): number;
+    /**
+     * Clear all cache entries.
+     */
+    clearCache(): void;
+    /**
+     * Stop the upstream (cleanup resources).
+     */
+    stop(): void;
+    /**
+     * Get upstreams that apply to a resource, sorted by priority.
+     */
+    protected getApplicableUpstreams(resource: string): IUpstreamRegistryConfig[];
+    /**
+     * Check if a resource matches scope rules.
+     * Empty rules = match all.
+     */
+    protected matchesScopeRules(resource: string, rules?: IUpstreamScopeRule[]): boolean;
+    /**
+     * Fetch from a specific upstream with retry logic.
+     */
+    protected fetchFromUpstream(upstream: IUpstreamRegistryConfig, context: IUpstreamFetchContext): Promise<IUpstreamResult>;
+    /**
+     * Execute a single HTTP request to an upstream.
+     */
+    protected executeRequest(upstream: IUpstreamRegistryConfig, context: IUpstreamFetchContext, timeoutMs: number): Promise<Omit<IUpstreamResult, 'upstreamId' | 'fromCache' | 'latencyMs'>>;
+    /**
+     * Build the full URL for an upstream request.
+     * Subclasses can override for protocol-specific URL building.
+     */
+    protected buildUpstreamUrl(upstream: IUpstreamRegistryConfig, context: IUpstreamFetchContext): string;
+    /**
+     * Build headers including authentication.
+     */
+    protected buildHeaders(upstream: IUpstreamRegistryConfig, context: IUpstreamFetchContext): Record<string, string>;
+    /**
+     * Add authentication headers based on auth config.
+     */
+    protected addAuthHeaders(headers: Record<string, string>, auth: IUpstreamAuthConfig): void;
+    /**
+     * Check if an error should not be retried.
+     */
+    protected isNonRetryableError(error: unknown): boolean;
+    /**
+     * Calculate backoff delay with exponential backoff and jitter.
+     */
+    protected calculateBackoffDelay(attempt: number, baseDelayMs: number, maxDelayMs: number): number;
+    /**
+     * Sleep for a specified duration.
+     */
+    protected sleep(ms: number): Promise<void>;
+    /**
+     * Revalidate cache in background.
+     */
+    protected revalidateInBackground(context: IUpstreamFetchContext, upstreams: IUpstreamRegistryConfig[]): Promise<void>;
+}

package/dist_ts/upstream/classes.baseupstream.js

@@ -0,0 +1,409 @@
+import * as plugins from '../plugins.js';
+import { DEFAULT_CACHE_CONFIG, DEFAULT_RESILIENCE_CONFIG, } from './interfaces.upstream.js';
+import { CircuitBreaker, CircuitOpenError, withCircuitBreaker } from './classes.circuitbreaker.js';
+import { UpstreamCache } from './classes.upstreamcache.js';
+/**
+ * Base class for protocol-specific upstream implementations.
+ *
+ * Provides:
+ * - Multi-upstream routing with priority
+ * - Scope-based filtering (glob patterns)
+ * - Authentication handling
+ * - Circuit breaker per upstream
+ * - Caching with TTL
+ * - Retry with exponential backoff
+ * - 429 rate limit handling
+ */
+export class BaseUpstream {
+    /** Upstream configuration */
+    config;
+    /** Resolved cache configuration */
+    cacheConfig;
+    /** Resolved resilience configuration */
+    resilienceConfig;
+    /** Circuit breakers per upstream */
+    circuitBreakers = new Map();
+    /** Upstream cache */
+    cache;
+    /** Logger instance */
+    logger;
+    constructor(config, logger) {
+        this.config = config;
+        this.cacheConfig = { ...DEFAULT_CACHE_CONFIG, ...config.cache };
+        this.resilienceConfig = { ...DEFAULT_RESILIENCE_CONFIG, ...config.resilience };
+        this.cache = new UpstreamCache(this.cacheConfig);
+        this.logger = logger || new plugins.smartlog.Smartlog({
+            logContext: {
+                company: 'smartregistry',
+                companyunit: 'upstream',
+                environment: 'production',
+                runtime: 'node',
+            }
+        });
+        // Initialize circuit breakers for each upstream
+        for (const upstream of config.upstreams) {
+            const upstreamResilience = { ...this.resilienceConfig, ...upstream.resilience };
+            this.circuitBreakers.set(upstream.id, new CircuitBreaker(upstream.id, upstreamResilience));
+        }
+    }
+    /**
+     * Check if upstream is enabled.
+     */
+    isEnabled() {
+        return this.config.enabled;
+    }
+    /**
+     * Get all configured upstreams.
+     */
+    getUpstreams() {
+        return this.config.upstreams;
+    }
+    /**
+     * Get circuit breaker state for an upstream.
+     */
+    getCircuitState(upstreamId) {
+        const breaker = this.circuitBreakers.get(upstreamId);
+        return breaker ? breaker.getState() : null;
+    }
+    /**
+     * Get cache statistics.
+     */
+    getCacheStats() {
+        return this.cache.getStats();
+    }
+    /**
+     * Fetch a resource from upstreams.
+     * Tries upstreams in priority order, respecting circuit breakers and scope rules.
+     */
+    async fetch(context) {
+        if (!this.config.enabled) {
+            return null;
+        }
+        // Check cache first
+        const cached = this.cache.get(context);
+        if (cached && !cached.stale) {
+            return {
+                success: true,
+                status: 200,
+                headers: cached.headers,
+                body: cached.data,
+                upstreamId: cached.upstreamId,
+                fromCache: true,
+                latencyMs: 0,
+            };
+        }
+        // Check for negative cache (recent 404)
+        if (this.cache.hasNegative(context)) {
+            return {
+                success: false,
+                status: 404,
+                headers: {},
+                upstreamId: 'cache',
+                fromCache: true,
+                latencyMs: 0,
+            };
+        }
+        // Get applicable upstreams sorted by priority
+        const applicableUpstreams = this.getApplicableUpstreams(context.resource);
+        if (applicableUpstreams.length === 0) {
+            return null;
+        }
+        // If we have stale cache, return it immediately and revalidate in background
+        if (cached?.stale && this.cacheConfig.staleWhileRevalidate) {
+            // Fire and forget revalidation
+            this.revalidateInBackground(context, applicableUpstreams);
+            return {
+                success: true,
+                status: 200,
+                headers: cached.headers,
+                body: cached.data,
+                upstreamId: cached.upstreamId,
+                fromCache: true,
+                latencyMs: 0,
+            };
+        }
+        // Try each upstream in order
+        let lastError = null;
+        for (const upstream of applicableUpstreams) {
+            const breaker = this.circuitBreakers.get(upstream.id);
+            if (!breaker)
+                continue;
+            try {
+                const result = await withCircuitBreaker(breaker, () => this.fetchFromUpstream(upstream, context));
+                // Cache successful responses
+                if (result.success && result.body) {
+                    this.cache.set(context, Buffer.isBuffer(result.body) ? result.body : Buffer.from(JSON.stringify(result.body)), result.headers['content-type'] || 'application/octet-stream', result.headers, upstream.id);
+                }
+                // Cache 404 responses
+                if (result.status === 404) {
+                    this.cache.setNegative(context, upstream.id);
+                }
+                return result;
+            }
+            catch (error) {
+                if (error instanceof CircuitOpenError) {
+                    this.logger.log('debug', `Circuit open for upstream ${upstream.id}, trying next`);
+                }
+                else {
+                    this.logger.log('warn', `Upstream ${upstream.id} failed: ${error.message}`);
+                }
+                lastError = error;
+                // Continue to next upstream
+            }
+        }
+        // All upstreams failed
+        if (lastError) {
+            this.logger.log('error', `All upstreams failed for ${context.resource}: ${lastError.message}`);
+        }
+        return null;
+    }
+    /**
+     * Invalidate cache for a resource pattern.
+     */
+    invalidateCache(pattern) {
+        return this.cache.invalidatePattern(pattern);
+    }
+    /**
+     * Clear all cache entries.
+     */
+    clearCache() {
+        this.cache.clear();
+    }
+    /**
+     * Stop the upstream (cleanup resources).
+     */
+    stop() {
+        this.cache.stop();
+    }
+    /**
+     * Get upstreams that apply to a resource, sorted by priority.
+     */
+    getApplicableUpstreams(resource) {
+        return this.config.upstreams
+            .filter(upstream => {
+            if (!upstream.enabled)
+                return false;
+            // Check circuit breaker
+            const breaker = this.circuitBreakers.get(upstream.id);
+            if (breaker && !breaker.canRequest())
+                return false;
+            // Check scope rules
+            return this.matchesScopeRules(resource, upstream.scopeRules);
+        })
+            .sort((a, b) => a.priority - b.priority);
+    }
+    /**
+     * Check if a resource matches scope rules.
+     * Empty rules = match all.
+     */
+    matchesScopeRules(resource, rules) {
+        if (!rules || rules.length === 0) {
+            return true;
+        }
+        // Process rules in order
+        // Start with default exclude (nothing matches)
+        let matched = false;
+        for (const rule of rules) {
+            const isMatch = plugins.minimatch(resource, rule.pattern);
+            if (isMatch) {
+                matched = rule.action === 'include';
+            }
+        }
+        return matched;
+    }
+    /**
+     * Fetch from a specific upstream with retry logic.
+     */
+    async fetchFromUpstream(upstream, context) {
+        const upstreamResilience = { ...this.resilienceConfig, ...upstream.resilience };
+        const startTime = Date.now();
+        let lastError = null;
+        for (let attempt = 0; attempt <= upstreamResilience.maxRetries; attempt++) {
+            try {
+                const result = await this.executeRequest(upstream, context, upstreamResilience.timeoutMs);
+                return {
+                    ...result,
+                    upstreamId: upstream.id,
+                    fromCache: false,
+                    latencyMs: Date.now() - startTime,
+                };
+            }
+            catch (error) {
+                lastError = error;
+                // Don't retry on 4xx errors (except 429)
+                if (this.isNonRetryableError(error)) {
+                    break;
+                }
+                // Calculate delay with exponential backoff and jitter
+                if (attempt < upstreamResilience.maxRetries) {
+                    const delay = this.calculateBackoffDelay(attempt, upstreamResilience.retryDelayMs, upstreamResilience.retryMaxDelayMs);
+                    await this.sleep(delay);
+                }
+            }
+        }
+        throw lastError || new Error('Request failed');
+    }
+    /**
+     * Execute a single HTTP request to an upstream.
+     */
+    async executeRequest(upstream, context, timeoutMs) {
+        // Build the full URL
+        const url = this.buildUpstreamUrl(upstream, context);
+        // Build headers with auth
+        const headers = this.buildHeaders(upstream, context);
+        // Make the request using SmartRequest
+        const request = plugins.smartrequest.SmartRequest.create()
+            .url(url)
+            .method(context.method)
+            .headers(headers)
+            .timeout(timeoutMs)
+            .handle429Backoff({ maxRetries: 3, fallbackDelay: 1000, maxWaitTime: 30000 });
+        // Add query params if present
+        if (Object.keys(context.query).length > 0) {
+            request.query(context.query);
+        }
+        let response;
+        switch (context.method.toUpperCase()) {
+            case 'GET':
+                response = await request.get();
+                break;
+            case 'HEAD':
+                // SmartRequest doesn't have head(), use options
+                response = await request.method('HEAD').get();
+                break;
+            default:
+                response = await request.get();
+        }
+        // Parse response
+        const responseHeaders = {};
+        for (const [key, value] of Object.entries(response.headers)) {
+            responseHeaders[key.toLowerCase()] = Array.isArray(value) ? value[0] : value;
+        }
+        let body;
+        const contentType = responseHeaders['content-type'] || '';
+        if (response.ok) {
+            if (contentType.includes('application/json')) {
+                body = await response.json();
+            }
+            else {
+                const arrayBuffer = await response.arrayBuffer();
+                body = Buffer.from(arrayBuffer);
+            }
+        }
+        return {
+            success: response.ok,
+            status: response.status,
+            headers: responseHeaders,
+            body,
+        };
+    }
+    /**
+     * Build the full URL for an upstream request.
+     * Subclasses can override for protocol-specific URL building.
+     */
+    buildUpstreamUrl(upstream, context) {
+        // Remove leading slash if URL already has trailing slash
+        let path = context.path;
+        if (upstream.url.endsWith('/') && path.startsWith('/')) {
+            path = path.slice(1);
+        }
+        return `${upstream.url}${path}`;
+    }
+    /**
+     * Build headers including authentication.
+     */
+    buildHeaders(upstream, context) {
+        const headers = { ...context.headers };
+        // Remove host header (will be set by HTTP client)
+        delete headers['host'];
+        // Add authentication
+        this.addAuthHeaders(headers, upstream.auth);
+        return headers;
+    }
+    /**
+     * Add authentication headers based on auth config.
+     */
+    addAuthHeaders(headers, auth) {
+        switch (auth.type) {
+            case 'basic':
+                if (auth.username && auth.password) {
+                    const credentials = Buffer.from(`${auth.username}:${auth.password}`).toString('base64');
+                    headers['authorization'] = `Basic ${credentials}`;
+                }
+                break;
+            case 'bearer':
+                if (auth.token) {
+                    headers['authorization'] = `Bearer ${auth.token}`;
+                }
+                break;
+            case 'api-key':
+                if (auth.token) {
+                    const headerName = auth.headerName || 'authorization';
+                    headers[headerName.toLowerCase()] = auth.token;
+                }
+                break;
+            case 'none':
+            default:
+                // No authentication
+                break;
+        }
+    }
+    /**
+     * Check if an error should not be retried.
+     */
+    isNonRetryableError(error) {
+        // Check for HTTP status errors
+        if (error && typeof error === 'object' && 'status' in error) {
+            const status = error.status;
+            // Don't retry 4xx errors except 429 (rate limited)
+            if (status >= 400 && status < 500 && status !== 429) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Calculate backoff delay with exponential backoff and jitter.
+     */
+    calculateBackoffDelay(attempt, baseDelayMs, maxDelayMs) {
+        // Exponential backoff: delay = base * 2^attempt
+        const exponentialDelay = baseDelayMs * Math.pow(2, attempt);
+        // Cap at max delay
+        const cappedDelay = Math.min(exponentialDelay, maxDelayMs);
+        // Add jitter (±25%)
+        const jitter = cappedDelay * 0.25 * (Math.random() * 2 - 1);
+        return Math.floor(cappedDelay + jitter);
+    }
+    /**
+     * Sleep for a specified duration.
+     */
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    /**
+     * Revalidate cache in background.
+     */
+    async revalidateInBackground(context, upstreams) {
+        try {
+            for (const upstream of upstreams) {
+                const breaker = this.circuitBreakers.get(upstream.id);
+                if (!breaker || !breaker.canRequest())
+                    continue;
+                try {
+                    const result = await withCircuitBreaker(breaker, () => this.fetchFromUpstream(upstream, context));
+                    if (result.success && result.body) {
+                        this.cache.set(context, Buffer.isBuffer(result.body) ? result.body : Buffer.from(JSON.stringify(result.body)), result.headers['content-type'] || 'application/octet-stream', result.headers, upstream.id);
+                        return; // Successfully revalidated
+                    }
+                }
+                catch {
+                    // Continue to next upstream
+                }
+            }
+        }
+        catch (error) {
+            this.logger.log('debug', `Background revalidation failed: ${error.message}`);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.baseupstream.js","sourceRoot":"","sources":["../../ts/upstream/classes.baseupstream.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,111 @@
+import type { TCircuitState, IUpstreamResilienceConfig } 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 declare class CircuitBreaker {
+    /** Unique identifier for logging and metrics */
+    readonly id: string;
+    /** Current circuit state */
+    private state;
+    /** Count of consecutive failures */
+    private failureCount;
+    /** Timestamp when circuit was opened */
+    private openedAt;
+    /** Number of successful requests in half-open state */
+    private halfOpenSuccesses;
+    /** Configuration */
+    private readonly config;
+    /** Number of successes required to close circuit from half-open */
+    private readonly halfOpenThreshold;
+    constructor(id: string, config?: Partial<IUpstreamResilienceConfig>);
+    /**
+     * Get current circuit state.
+     */
+    getState(): TCircuitState;
+    /**
+     * Check if circuit allows requests.
+     * Returns true if requests should be allowed.
+     */
+    canRequest(): boolean;
+    /**
+     * Record a successful request.
+     * May transition circuit from HALF_OPEN to CLOSED.
+     */
+    recordSuccess(): void;
+    /**
+     * Record a failed request.
+     * May transition circuit from CLOSED/HALF_OPEN to OPEN.
+     */
+    recordFailure(): void;
+    /**
+     * Force circuit to open state.
+     * Useful for manual intervention or external health checks.
+     */
+    forceOpen(): void;
+    /**
+     * Force circuit to closed state.
+     * Useful for manual intervention after fixing upstream issues.
+     */
+    forceClose(): void;
+    /**
+     * Reset circuit to initial state.
+     */
+    reset(): void;
+    /**
+     * Get circuit metrics for monitoring.
+     */
+    getMetrics(): ICircuitBreakerMetrics;
+    /**
+     * Transition to a new state with proper cleanup.
+     */
+    private transitionTo;
+}
+/**
+ * Metrics for circuit breaker monitoring.
+ */
+export interface ICircuitBreakerMetrics {
+    /** Circuit breaker identifier */
+    id: string;
+    /** Current state */
+    state: TCircuitState;
+    /** Number of consecutive failures */
+    failureCount: number;
+    /** When circuit was opened (null if never opened) */
+    openedAt: Date | null;
+    /** Milliseconds until circuit transitions to half-open (0 if not open) */
+    timeUntilHalfOpen: number;
+    /** Number of successes in half-open state */
+    halfOpenSuccesses: number;
+    /** Failure threshold for opening circuit */
+    threshold: number;
+    /** Reset timeout in milliseconds */
+    resetMs: number;
+}
+/**
+ * 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 declare function withCircuitBreaker<T>(breaker: CircuitBreaker, fn: () => Promise<T>, fallback?: () => Promise<T>): Promise<T>;
+/**
+ * Error thrown when circuit is open and no fallback is provided.
+ */
+export declare class CircuitOpenError extends Error {
+    readonly circuitId: string;
+    constructor(circuitId: string);
+}