@push.rocks/smartregistry 2.3.0 → 2.5.0

package/dist_ts/core/interfaces.storage.d.ts

@@ -0,0 +1,120 @@
+import type { TRegistryProtocol } from './interfaces.core.js';
+/**
+ * Actor information from request context
+ */
+export interface IStorageActor {
+    userId?: string;
+    tokenId?: string;
+    ip?: string;
+    userAgent?: string;
+    orgId?: string;
+    sessionId?: string;
+}
+/**
+ * Metadata about the storage operation
+ */
+export interface IStorageMetadata {
+    /** Content type of the object */
+    contentType?: string;
+    /** Size in bytes */
+    size?: number;
+    /** Content digest (e.g., sha256:abc123) */
+    digest?: string;
+    /** Package/artifact name */
+    packageName?: string;
+    /** Version */
+    version?: string;
+}
+/**
+ * Context passed to storage hooks
+ */
+export interface IStorageHookContext {
+    /** Type of operation */
+    operation: 'put' | 'delete' | 'get';
+    /** Storage key/path */
+    key: string;
+    /** Protocol that triggered this operation */
+    protocol: TRegistryProtocol;
+    /** Actor who performed the operation (if known) */
+    actor?: IStorageActor;
+    /** Metadata about the object */
+    metadata?: IStorageMetadata;
+    /** Timestamp of the operation */
+    timestamp: Date;
+}
+/**
+ * Result from a beforePut hook that can modify the operation
+ */
+export interface IBeforePutResult {
+    /** Whether to allow the operation */
+    allowed: boolean;
+    /** Optional reason for rejection */
+    reason?: string;
+    /** Optional modified metadata */
+    metadata?: IStorageMetadata;
+}
+/**
+ * Result from a beforeDelete hook
+ */
+export interface IBeforeDeleteResult {
+    /** Whether to allow the operation */
+    allowed: boolean;
+    /** Optional reason for rejection */
+    reason?: string;
+}
+/**
+ * Storage event hooks for quota tracking, audit logging, cache invalidation, etc.
+ *
+ * @example
+ * ```typescript
+ * const quotaHooks: IStorageHooks = {
+ *   async beforePut(context) {
+ *     const quota = await getQuota(context.actor?.orgId);
+ *     const currentUsage = await getUsage(context.actor?.orgId);
+ *     if (currentUsage + (context.metadata?.size || 0) > quota) {
+ *       return { allowed: false, reason: 'Quota exceeded' };
+ *     }
+ *     return { allowed: true };
+ *   },
+ *
+ *   async afterPut(context) {
+ *     await updateUsage(context.actor?.orgId, context.metadata?.size || 0);
+ *     await auditLog('storage.put', context);
+ *   },
+ *
+ *   async afterDelete(context) {
+ *     await invalidateCache(context.key);
+ *   }
+ * };
+ * ```
+ */
+export interface IStorageHooks {
+    /**
+     * Called before storing an object.
+     * Return { allowed: false } to reject the operation.
+     * Use for quota checks, virus scanning, validation, etc.
+     */
+    beforePut?(context: IStorageHookContext): Promise<IBeforePutResult>;
+    /**
+     * Called after successfully storing an object.
+     * Use for quota tracking, audit logging, notifications, etc.
+     */
+    afterPut?(context: IStorageHookContext): Promise<void>;
+    /**
+     * Called before deleting an object.
+     * Return { allowed: false } to reject the operation.
+     * Use for preventing deletion of protected resources.
+     */
+    beforeDelete?(context: IStorageHookContext): Promise<IBeforeDeleteResult>;
+    /**
+     * Called after successfully deleting an object.
+     * Use for quota updates, audit logging, cache invalidation, etc.
+     */
+    afterDelete?(context: IStorageHookContext): Promise<void>;
+    /**
+     * Called after reading an object.
+     * Use for access logging, analytics, etc.
+     * Note: This is called even for cache hits.
+     */
+    afterGet?(context: IStorageHookContext): Promise<void>;
+}

package/dist_ts/core/interfaces.storage.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJmYWNlcy5zdG9yYWdlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vdHMvY29yZS9pbnRlcmZhY2VzLnN0b3JhZ2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

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

@@ -54,11 +54,11 @@ export declare abstract class BaseUpstream {
     /**
      * Invalidate cache for a resource pattern.
      */
-    invalidateCache(pattern: RegExp): number;
+    invalidateCache(pattern: RegExp): Promise<number>;
     /**
      * Clear all cache entries.
      */
-    clearCache(): void;
+    clearCache(): Promise<void>;
     /**
      * Stop the upstream (cleanup resources).
      */

package/dist_ts/upstream/classes.baseupstream.js

@@ -79,8 +79,15 @@ export class BaseUpstream {
         if (!this.config.enabled) {
             return null;
         }
+        // Get applicable upstreams sorted by priority
+        const applicableUpstreams = this.getApplicableUpstreams(context.resource);
+        if (applicableUpstreams.length === 0) {
+            return null;
+        }
+        // Use the first applicable upstream's URL for cache key
+        const primaryUpstreamUrl = applicableUpstreams[0]?.url;
         // Check cache first
-        const cached = this.cache.get(context);
+        const cached = await this.cache.get(context, primaryUpstreamUrl);
         if (cached && !cached.stale) {
             return {
                 success: true,
@@ -93,7 +100,7 @@ export class BaseUpstream {
             };
         }
         // Check for negative cache (recent 404)
-        if (this.cache.hasNegative(context)) {
+        if (await this.cache.hasNegative(context, primaryUpstreamUrl)) {
             return {
                 success: false,
                 status: 404,
@@ -103,11 +110,6 @@ export class BaseUpstream {
                 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
@@ -132,11 +134,11 @@ export class BaseUpstream {
                 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);
+                    await 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, upstream.url);
                 }
                 // Cache 404 responses
                 if (result.status === 404) {
-                    this.cache.setNegative(context, upstream.id);
+                    await this.cache.setNegative(context, upstream.id, upstream.url);
                 }
                 return result;
             }
@@ -160,14 +162,14 @@ export class BaseUpstream {
     /**
      * Invalidate cache for a resource pattern.
      */
-    invalidateCache(pattern) {
+    async invalidateCache(pattern) {
         return this.cache.invalidatePattern(pattern);
     }
     /**
      * Clear all cache entries.
      */
-    clearCache() {
-        this.cache.clear();
+    async clearCache() {
+        await this.cache.clear();
     }
     /**
      * Stop the upstream (cleanup resources).
@@ -392,7 +394,7 @@ export class BaseUpstream {
                 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);
+                        await 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, upstream.url);
                         return; // Successfully revalidated
                     }
                 }
@@ -406,4 +408,4 @@ export class BaseUpstream {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.baseupstream.js","sourceRoot":"","sources":["../../ts/upstream/classes.baseupstream.ts"],"names":[],"mappings":"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"}
+//# 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.upstreamcache.d.ts

@@ -1,6 +1,7 @@
 import type { ICacheEntry, IUpstreamCacheConfig, IUpstreamFetchContext } from './interfaces.upstream.js';
+import type { IStorageBackend } from '../core/interfaces.core.js';
 /**
- * In-memory cache for upstream responses.
+ * S3-backed upstream cache with in-memory hot layer.
  *
  * Features:
  * - TTL-based expiration
@@ -8,58 +9,76 @@ import type { ICacheEntry, IUpstreamCacheConfig, IUpstreamFetchContext } from '.
  * - 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 declare class UpstreamCache {
-    /** Cache storage */
-    private readonly cache;
+    /** In-memory hot cache */
+    private readonly memoryCache;
     /** Configuration */
     private readonly config;
-    /** Maximum cache entries (prevents memory bloat) */
-    private readonly maxEntries;
+    /** Maximum in-memory cache entries */
+    private readonly maxMemoryEntries;
+    /** S3 storage backend (optional) */
+    private readonly storage?;
     /** Cleanup interval handle */
     private cleanupInterval;
-    constructor(config?: Partial<IUpstreamCacheConfig>, maxEntries?: number);
+    constructor(config?: Partial<IUpstreamCacheConfig>, maxMemoryEntries?: number, storage?: IStorageBackend);
     /**
      * Check if caching is enabled.
      */
     isEnabled(): boolean;
+    /**
+     * Check if S3 storage is configured.
+     */
+    hasStorage(): boolean;
     /**
      * 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: IUpstreamFetchContext): ICacheEntry | null;
+    get(context: IUpstreamFetchContext, upstreamUrl?: string): Promise<ICacheEntry | null>;
     /**
-     * Store a response in the cache.
+     * Store a response in the cache (memory and optionally S3).
      */
-    set(context: IUpstreamFetchContext, data: Buffer, contentType: string, headers: Record<string, string>, upstreamId: string, options?: ICacheSetOptions): void;
+    set(context: IUpstreamFetchContext, data: Buffer, contentType: string, headers: Record<string, string>, upstreamId: string, upstreamUrl: string, options?: ICacheSetOptions): Promise<void>;
     /**
      * Store a negative cache entry (404 response).
      */
-    setNegative(context: IUpstreamFetchContext, upstreamId: string): void;
+    setNegative(context: IUpstreamFetchContext, upstreamId: string, upstreamUrl: string): Promise<void>;
     /**
      * Check if there's a negative cache entry for this context.
      */
-    hasNegative(context: IUpstreamFetchContext): boolean;
+    hasNegative(context: IUpstreamFetchContext, upstreamUrl?: string): Promise<boolean>;
     /**
      * Invalidate a specific cache entry.
      */
-    invalidate(context: IUpstreamFetchContext): boolean;
+    invalidate(context: IUpstreamFetchContext, upstreamUrl?: string): Promise<boolean>;
     /**
      * Invalidate all entries matching a pattern.
      * Useful for invalidating all versions of a package.
      */
-    invalidatePattern(pattern: RegExp): number;
+    invalidatePattern(pattern: RegExp): Promise<number>;
     /**
      * Invalidate all entries from a specific upstream.
      */
-    invalidateUpstream(upstreamId: string): number;
+    invalidateUpstream(upstreamId: string): Promise<number>;
     /**
-     * Clear all cache entries.
+     * Clear all cache entries (memory and S3).
      */
-    clear(): void;
+    clear(): Promise<void>;
     /**
      * Get cache statistics.
      */
@@ -68,8 +87,34 @@ export declare class UpstreamCache {
      * Stop the cache and cleanup.
      */
     stop(): void;
+    /**
+     * Build storage path for a cache key.
+     * Escapes upstream URL for safe use in S3 paths.
+     */
+    private buildStoragePath;
+    /**
+     * Build storage path for cache metadata.
+     */
+    private buildMetadataPath;
+    /**
+     * Load a cache entry from S3 storage.
+     */
+    private loadFromStorage;
+    /**
+     * Save a cache entry to S3 storage.
+     */
+    private saveToStorage;
+    /**
+     * Delete a cache entry from S3 storage.
+     */
+    private deleteFromStorage;
+    /**
+     * Escape a URL for safe use in storage paths.
+     */
+    private escapeUrl;
     /**
      * Build a unique cache key for a request context.
+     * Includes escaped upstream URL for multi-upstream support.
      */
     private buildCacheKey;
     /**
@@ -89,7 +134,7 @@ export declare class UpstreamCache {
      */
     private startCleanup;
     /**
-     * Remove all expired entries.
+     * Remove all expired entries from memory cache.
      */
     private cleanup;
 }
@@ -106,7 +151,7 @@ export interface ICacheSetOptions {
  * Cache statistics.
  */
 export interface ICacheStats {
-    /** Total number of cached entries */
+    /** Total number of cached entries in memory */
     totalEntries: number;
     /** Number of fresh (non-expired) entries */
     freshEntries: number;
@@ -114,10 +159,12 @@ export interface ICacheStats {
     staleEntries: number;
     /** Number of negative cache entries */
     negativeEntries: number;
-    /** Total size of cached data in bytes */
+    /** Total size of cached data in bytes (memory only) */
     totalSizeBytes: number;
-    /** Maximum allowed entries */
+    /** Maximum allowed memory entries */
     maxEntries: number;
     /** Whether caching is enabled */
     enabled: boolean;
+    /** Whether S3 storage is configured */
+    hasStorage: boolean;
 }