inup 1.6.0 → 1.6.3

package/dist/services/cache-manager.js

@@ -1,95 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.packageCache = exports.CacheManager = void 0;
-const config_1 = require("../config");
-const persistent_cache_1 = require("./persistent-cache");
-// Single TTL policy for both memory and disk.
-class CacheManager {
-    memoryCache = new Map();
-    ttl;
-    constructor(ttl = config_1.CACHE_TTL) {
-        this.ttl = ttl;
-    }
-    /**
-     * Get cached data for a key, checking memory first, then disk.
-     * Returns null if not found or expired.
-     */
-    get(key) {
-        // Check in-memory cache first (fastest)
-        const memoryCached = this.memoryCache.get(key);
-        if (memoryCached && Date.now() - memoryCached.timestamp < this.ttl) {
-            return memoryCached.data;
-        }
-        // Check persistent disk cache (survives restarts)
-        const diskCached = persistent_cache_1.persistentCache.get(key);
-        if (diskCached && Date.now() - diskCached.timestamp < this.ttl) {
-            // Populate in-memory cache for subsequent accesses
-            this.memoryCache.set(key, {
-                data: diskCached,
-                timestamp: diskCached.timestamp,
-            });
-            return diskCached;
-        }
-        return null;
-    }
-    /**
-     * Store data in both memory and disk cache.
-     */
-    set(key, data) {
-        // Cache in memory
-        this.memoryCache.set(key, {
-            data,
-            timestamp: Date.now(),
-        });
-        // Cache to disk for persistence
-        persistent_cache_1.persistentCache.set(key, data);
-    }
-    /**
-     * Get data from cache or fetch it using the provided fetcher function.
-     * This is the main entry point for cache-aside pattern.
-     */
-    async getOrFetch(key, fetcher) {
-        // Try cache first
-        const cached = this.get(key);
-        if (cached) {
-            return cached;
-        }
-        // Fetch fresh data
-        const data = await fetcher();
-        if (data) {
-            this.set(key, data);
-        }
-        return data;
-    }
-    /**
-     * Check if a key exists and is not expired in cache.
-     */
-    has(key) {
-        return this.get(key) !== null;
-    }
-    /**
-     * Clear in-memory cache (useful for testing).
-     */
-    clear() {
-        this.memoryCache.clear();
-    }
-    /**
-     * Flush pending disk cache writes.
-     */
-    flush() {
-        persistent_cache_1.persistentCache.flush();
-    }
-    /**
-     * Get cache statistics.
-     */
-    getStats() {
-        return {
-            memoryEntries: this.memoryCache.size,
-            diskStats: persistent_cache_1.persistentCache.getStats(),
-        };
-    }
-}
-exports.CacheManager = CacheManager;
-// Default package version cache instance
-exports.packageCache = new CacheManager();
-//# sourceMappingURL=cache-manager.js.map

package/dist/services/persistent-cache.js

@@ -1,237 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.persistentCache = void 0;
-const fs_1 = require("fs");
-const path_1 = require("path");
-const env_paths_1 = __importDefault(require("env-paths"));
-const config_1 = require("../config");
-// Maximum cache size (number of packages)
-const MAX_CACHE_ENTRIES = 5000;
-// Cache file format version (increment when structure changes)
-const CACHE_VERSION = 2;
-/**
- * Persistent cache manager for package registry data.
- * Stores cache on disk for fast repeated runs across CLI invocations.
- */
-class PersistentCacheManager {
-    cacheDir;
-    indexPath;
-    index = null;
-    dirty = false;
-    constructor() {
-        const paths = (0, env_paths_1.default)(config_1.PACKAGE_NAME);
-        this.cacheDir = (0, path_1.join)(paths.cache, 'registry');
-        this.indexPath = (0, path_1.join)(this.cacheDir, 'index.json');
-    }
-    /**
-     * Ensure cache directory exists
-     */
-    ensureCacheDir() {
-        if (!(0, fs_1.existsSync)(this.cacheDir)) {
-            (0, fs_1.mkdirSync)(this.cacheDir, { recursive: true });
-        }
-    }
-    /**
-     * Load cache index from disk
-     */
-    loadIndex() {
-        if (this.index) {
-            return this.index;
-        }
-        try {
-            if ((0, fs_1.existsSync)(this.indexPath)) {
-                const content = (0, fs_1.readFileSync)(this.indexPath, 'utf-8');
-                const parsed = JSON.parse(content);
-                // Check cache version - invalidate if outdated
-                if (parsed.version !== CACHE_VERSION) {
-                    this.clearCache();
-                    this.index = { version: CACHE_VERSION, entries: {} };
-                    return this.index;
-                }
-                this.index = parsed;
-                return this.index;
-            }
-        }
-        catch {
-            // Corrupted index, start fresh
-        }
-        this.index = { version: CACHE_VERSION, entries: {} };
-        return this.index;
-    }
-    /**
-     * Save cache index to disk
-     */
-    saveIndex() {
-        if (!this.dirty || !this.index) {
-            return;
-        }
-        try {
-            this.ensureCacheDir();
-            (0, fs_1.writeFileSync)(this.indexPath, JSON.stringify(this.index), 'utf-8');
-            this.dirty = false;
-        }
-        catch {
-            // Silently fail - cache is not critical
-        }
-    }
-    /**
-     * Generate a safe filename for a package name
-     */
-    getFilename(packageName) {
-        // Handle scoped packages: @scope/name -> scope__name
-        const safeName = packageName.replace(/^@/, '').replace(/\//g, '__');
-        return `${safeName}.json`;
-    }
-    /**
-     * Get cached data for a package
-     */
-    get(packageName) {
-        const index = this.loadIndex();
-        const entry = index.entries[packageName];
-        if (!entry) {
-            return null;
-        }
-        // Read the actual cache file
-        try {
-            const filePath = (0, path_1.join)(this.cacheDir, entry.file);
-            if (!(0, fs_1.existsSync)(filePath)) {
-                delete index.entries[packageName];
-                this.dirty = true;
-                return null;
-            }
-            const content = (0, fs_1.readFileSync)(filePath, 'utf-8');
-            const cached = JSON.parse(content);
-            return {
-                latestVersion: cached.latestVersion,
-                allVersions: cached.allVersions,
-                timestamp: entry.timestamp,
-            };
-        }
-        catch {
-            // Corrupted cache file, remove from index
-            delete index.entries[packageName];
-            this.dirty = true;
-            return null;
-        }
-    }
-    /**
-     * Store data for a package
-     */
-    set(packageName, data) {
-        const index = this.loadIndex();
-        // Evict old entries if cache is too large
-        const entryCount = Object.keys(index.entries).length;
-        if (entryCount >= MAX_CACHE_ENTRIES) {
-            this.evictOldest(Math.floor(MAX_CACHE_ENTRIES * 0.1)); // Evict 10%
-        }
-        const filename = this.getFilename(packageName);
-        const entry = {
-            ...data,
-            timestamp: Date.now(),
-        };
-        try {
-            this.ensureCacheDir();
-            const filePath = (0, path_1.join)(this.cacheDir, filename);
-            (0, fs_1.writeFileSync)(filePath, JSON.stringify(entry), 'utf-8');
-            index.entries[packageName] = {
-                file: filename,
-                timestamp: Date.now(),
-            };
-            this.dirty = true;
-        }
-        catch {
-            // Silently fail - cache is not critical
-        }
-    }
-    /**
-     * Batch get multiple packages (returns map of found entries)
-     */
-    getMany(packageNames) {
-        const results = new Map();
-        for (const name of packageNames) {
-            const cached = this.get(name);
-            if (cached) {
-                results.set(name, cached);
-            }
-        }
-        return results;
-    }
-    /**
-     * Batch set multiple packages
-     */
-    setMany(entries) {
-        for (const [name, data] of entries) {
-            this.set(name, data);
-        }
-        this.flush();
-    }
-    /**
-     * Evict oldest cache entries
-     */
-    evictOldest(count) {
-        const index = this.loadIndex();
-        const entries = Object.entries(index.entries);
-        // Sort by timestamp (oldest first)
-        entries.sort((a, b) => a[1].timestamp - b[1].timestamp);
-        // Remove oldest entries
-        const toRemove = entries.slice(0, count);
-        for (const [packageName, entry] of toRemove) {
-            try {
-                const filePath = (0, path_1.join)(this.cacheDir, entry.file);
-                if ((0, fs_1.existsSync)(filePath)) {
-                    (0, fs_1.unlinkSync)(filePath);
-                }
-            }
-            catch {
-                // Ignore deletion errors
-            }
-            delete index.entries[packageName];
-        }
-        this.dirty = true;
-    }
-    /**
-     * Clear all cache
-     */
-    clearCache() {
-        try {
-            if ((0, fs_1.existsSync)(this.cacheDir)) {
-                const files = (0, fs_1.readdirSync)(this.cacheDir);
-                for (const file of files) {
-                    try {
-                        (0, fs_1.unlinkSync)((0, path_1.join)(this.cacheDir, file));
-                    }
-                    catch {
-                        // Ignore
-                    }
-                }
-            }
-        }
-        catch {
-            // Ignore
-        }
-        this.index = { version: CACHE_VERSION, entries: {} };
-        this.dirty = true;
-    }
-    /**
-     * Flush pending changes to disk
-     */
-    flush() {
-        this.saveIndex();
-    }
-    /**
-     * Get cache statistics
-     */
-    getStats() {
-        const index = this.loadIndex();
-        return {
-            entries: Object.keys(index.entries).length,
-            cacheDir: this.cacheDir,
-        };
-    }
-}
-// Export singleton instance
-exports.persistentCache = new PersistentCacheManager();
-//# sourceMappingURL=persistent-cache.js.map