inup 1.5.5 → 1.5.6

package/dist/services/cache-manager.js

@@ -3,13 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.packageCache = exports.CacheManager = void 0;
 const config_1 = require("../config");
 const persistent_cache_1 = require("./persistent-cache");
-/**
- * Unified cache manager that handles both in-memory and persistent disk caching.
- * Consolidates caching logic used across registry services.
- */
+// Single TTL policy for both memory and disk.
 class CacheManager {
+    memoryCache = new Map();
+    ttl;
     constructor(ttl = config_1.CACHE_TTL) {
-        this.memoryCache = new Map();
         this.ttl = ttl;
     }
     /**
@@ -24,11 +22,11 @@ class CacheManager {
         }
         // Check persistent disk cache (survives restarts)
         const diskCached = persistent_cache_1.persistentCache.get(key);
-        if (diskCached) {
+        if (diskCached && Date.now() - diskCached.timestamp < this.ttl) {
             // Populate in-memory cache for subsequent accesses
             this.memoryCache.set(key, {
                 data: diskCached,
-                timestamp: Date.now(),
+                timestamp: diskCached.timestamp,
             });
             return diskCached;
         }

package/dist/services/http/inflight.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InflightMap = void 0;
+class InflightMap {
+    map = new Map();
+    async dedupe(key, fn) {
+        const existing = this.map.get(key);
+        if (existing) {
+            return await existing;
+        }
+        const promise = fn().finally(() => {
+            this.map.delete(key);
+        });
+        this.map.set(key, promise);
+        return await promise;
+    }
+    clear() {
+        this.map.clear();
+    }
+}
+exports.InflightMap = InflightMap;
+//# sourceMappingURL=inflight.js.map

package/dist/services/http/retry.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTransientNetworkError = exports.isRetryableStatus = exports.sleep = void 0;
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+exports.sleep = sleep;
+const isRetryableStatus = (statusCode) => statusCode === 408 || statusCode === 429 || statusCode >= 500;
+exports.isRetryableStatus = isRetryableStatus;
+const isTransientNetworkError = (error) => {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    const maybeCode = error.code;
+    return (error.name === 'AbortError' ||
+        error.name === 'HeadersTimeoutError' ||
+        error.name === 'BodyTimeoutError' ||
+        error.name === 'ConnectTimeoutError' ||
+        error.name === 'SocketError' ||
+        maybeCode === 'UND_ERR_HEADERS_TIMEOUT' ||
+        maybeCode === 'UND_ERR_BODY_TIMEOUT' ||
+        maybeCode === 'UND_ERR_CONNECT_TIMEOUT' ||
+        maybeCode === 'UND_ERR_SOCKET' ||
+        maybeCode === 'ENOTFOUND' ||
+        maybeCode === 'EAI_AGAIN' ||
+        maybeCode === 'ECONNRESET' ||
+        maybeCode === 'ECONNREFUSED' ||
+        maybeCode === 'ETIMEDOUT' ||
+        maybeCode === 'EPIPE');
+};
+exports.isTransientNetworkError = isTransientNetworkError;
+//# sourceMappingURL=retry.js.map

package/dist/services/jsdelivr/client.js

@@ -0,0 +1,191 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jsdelivrPool = exports.RETRY_TIMEOUTS = void 0;
+exports.fetchPackageManifestFromJsdelivr = fetchPackageManifestFromJsdelivr;
+exports.fetchPackageManifestFromNpmRegistry = fetchPackageManifestFromNpmRegistry;
+const undici_1 = require("undici");
+const config_1 = require("../../config");
+const utils_1 = require("../../utils");
+const retry_1 = require("../http/retry");
+const DEFAULT_JSDELIVR_RETRY_TIMEOUT_MS = 2000;
+const DEFAULT_JSDELIVR_POOL_TIMEOUT_MS = 60000;
+const MIN_JSDELIVR_CONNECT_TIMEOUT_MS = 500;
+const toPositiveInteger = (value) => {
+    if (!Number.isFinite(value) || value <= 0) {
+        return null;
+    }
+    const normalized = Math.floor(value);
+    return normalized > 0 ? normalized : null;
+};
+exports.RETRY_TIMEOUTS = (() => {
+    const configured = Array.from(new Set(config_1.JSDELIVR_RETRY_TIMEOUTS.map(toPositiveInteger).filter((value) => value !== null))).sort((a, b) => a - b);
+    return configured.length > 0 ? configured : [DEFAULT_JSDELIVR_RETRY_TIMEOUT_MS];
+})();
+const RETRY_DELAYS = config_1.JSDELIVR_RETRY_DELAYS.map(toPositiveInteger).filter((value) => value !== null);
+const MAX_RETRY_AFTER_DELAY_MS = exports.RETRY_TIMEOUTS[exports.RETRY_TIMEOUTS.length - 1];
+const RETRY_AFTER_HEADER = 'retry-after';
+const parseRetryAfterMs = (value) => {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return null;
+    }
+    const seconds = Number(trimmed);
+    if (Number.isFinite(seconds)) {
+        if (seconds <= 0) {
+            return null;
+        }
+        const delayMs = Math.floor(seconds * 1000);
+        return delayMs > 0 ? delayMs : null;
+    }
+    const dateMs = Date.parse(trimmed);
+    if (Number.isNaN(dateMs)) {
+        return null;
+    }
+    const delayMs = dateMs - Date.now();
+    return delayMs > 0 ? delayMs : null;
+};
+const getHeaderValue = (headers, name) => {
+    if (!headers) {
+        return null;
+    }
+    const direct = headers[name];
+    if (typeof direct === 'string') {
+        return direct;
+    }
+    if (Array.isArray(direct)) {
+        return direct.find((value) => typeof value === 'string') ?? null;
+    }
+    const headerEntry = Object.entries(headers).find(([headerName]) => headerName.toLowerCase() === name);
+    if (!headerEntry) {
+        return null;
+    }
+    const [, rawValue] = headerEntry;
+    if (typeof rawValue === 'string') {
+        return rawValue;
+    }
+    if (Array.isArray(rawValue)) {
+        return rawValue.find((value) => typeof value === 'string') ?? null;
+    }
+    return null;
+};
+const getRetryAfterDelay = (headers) => {
+    const retryAfterValue = getHeaderValue(headers, RETRY_AFTER_HEADER);
+    if (!retryAfterValue) {
+        return null;
+    }
+    const parsedDelay = parseRetryAfterMs(retryAfterValue);
+    if (parsedDelay === null) {
+        return null;
+    }
+    return Math.min(parsedDelay, MAX_RETRY_AFTER_DELAY_MS);
+};
+const getRetryDelay = (attempt, headers) => {
+    const configuredDelay = RETRY_DELAYS.length === 0 ? 0 : RETRY_DELAYS[Math.min(attempt, RETRY_DELAYS.length - 1)];
+    const retryAfterDelay = getRetryAfterDelay(headers);
+    return retryAfterDelay === null ? configuredDelay : Math.max(configuredDelay, retryAfterDelay);
+};
+// Keep connection setup bounded by retry budget so fallback stays responsive.
+const JSDELIVR_CONNECT_TIMEOUT_MS = Math.max(exports.RETRY_TIMEOUTS[0], MIN_JSDELIVR_CONNECT_TIMEOUT_MS);
+const JSDELIVR_POOL_TIMEOUT_MS = toPositiveInteger(config_1.JSDELIVR_POOL_TIMEOUT) ?? DEFAULT_JSDELIVR_POOL_TIMEOUT_MS;
+const JSDELIVR_CONNECTIONS = toPositiveInteger(config_1.MAX_CONCURRENT_REQUESTS) ?? 1;
+// Create a persistent connection pool for jsDelivr CDN with optimal settings
+// This enables connection reuse and HTTP/1.1 keep-alive for blazing fast requests
+exports.jsdelivrPool = new undici_1.Pool('https://cdn.jsdelivr.net', {
+    connections: JSDELIVR_CONNECTIONS,
+    pipelining: 10,
+    keepAliveTimeout: JSDELIVR_POOL_TIMEOUT_MS,
+    keepAliveMaxTimeout: JSDELIVR_POOL_TIMEOUT_MS,
+    connectTimeout: JSDELIVR_CONNECT_TIMEOUT_MS,
+});
+const consumeBodySafely = async (body) => {
+    try {
+        await body.text();
+    }
+    catch {
+        // Ignore body read errors on non-200 responses because request will be retried/fallback.
+    }
+};
+async function fetchPackageManifestFromJsdelivr(packageName, versionTag) {
+    const url = `${config_1.JSDELIVR_CDN_URL}/${encodeURIComponent(packageName)}@${versionTag}/package.json`;
+    for (let attempt = 0; attempt < exports.RETRY_TIMEOUTS.length; attempt++) {
+        const timeout = exports.RETRY_TIMEOUTS[attempt];
+        const tReq = Date.now();
+        try {
+            const { statusCode, headers, body } = await (0, undici_1.request)(url, {
+                dispatcher: exports.jsdelivrPool,
+                method: 'GET',
+                headers: {
+                    accept: 'application/json',
+                },
+                headersTimeout: timeout,
+                bodyTimeout: timeout,
+            });
+            if (statusCode !== 200) {
+                // Consume body to prevent memory leaks
+                await consumeBodySafely(body);
+                if ((0, retry_1.isRetryableStatus)(statusCode) && attempt < exports.RETRY_TIMEOUTS.length - 1) {
+                    const delay = getRetryDelay(attempt, headers);
+                    utils_1.debugLog.warn('jsdelivr', `${packageName}@${versionTag} HTTP ${statusCode}, retry ${attempt + 1} in ${delay}ms`);
+                    if (delay > 0) {
+                        await (0, retry_1.sleep)(delay);
+                    }
+                    continue;
+                }
+                utils_1.debugLog.warn('jsdelivr', `${packageName}@${versionTag} HTTP ${statusCode}, no more retries`);
+                return null;
+            }
+            const text = await body.text();
+            const data = JSON.parse(text);
+            if (!data || typeof data !== 'object' || Array.isArray(data)) {
+                return null;
+            }
+            utils_1.debugLog.perf('jsdelivr', `fetch manifest ${packageName}@${versionTag}`, tReq);
+            return data;
+        }
+        catch (error) {
+            if ((0, retry_1.isTransientNetworkError)(error) && attempt < exports.RETRY_TIMEOUTS.length - 1) {
+                const delay = getRetryDelay(attempt);
+                utils_1.debugLog.warn('jsdelivr', `${packageName}@${versionTag} transient error on attempt ${attempt + 1}, retry in ${delay}ms`, error);
+                if (delay > 0) {
+                    await (0, retry_1.sleep)(delay);
+                }
+                continue;
+            }
+            if (!(0, retry_1.isTransientNetworkError)(error)) {
+                // Unexpected errors are logged for observability.
+                console.error(`jsDelivr fetch failed for ${packageName}@${versionTag} on attempt ${attempt + 1}/${exports.RETRY_TIMEOUTS.length}`, error);
+                utils_1.debugLog.error('jsdelivr', `unexpected error for ${packageName}@${versionTag} attempt ${attempt + 1}`, error);
+            }
+            else {
+                utils_1.debugLog.warn('jsdelivr', `${packageName}@${versionTag} exhausted retries`, error);
+            }
+            return null;
+        }
+    }
+    return null;
+}
+async function fetchPackageManifestFromNpmRegistry(packageName, version) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), config_1.REQUEST_TIMEOUT);
+    try {
+        const response = await fetch(`${config_1.NPM_REGISTRY_URL}/${encodeURIComponent(packageName)}/${encodeURIComponent(version)}`, {
+            method: 'GET',
+            headers: {
+                accept: 'application/json',
+            },
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            return null;
+        }
+        return (await response.json());
+    }
+    catch (error) {
+        utils_1.debugLog.warn('npm-registry', `exact manifest fallback failed for ${packageName}@${version}`, error);
+        return null;
+    }
+    finally {
+        clearTimeout(timeoutId);
+    }
+}
+//# sourceMappingURL=client.js.map

package/dist/services/jsdelivr/manifest.js

@@ -0,0 +1,136 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchExactPackageManifest = fetchExactPackageManifest;
+exports.getAllPackageDataFromJsdelivr = getAllPackageDataFromJsdelivr;
+exports.closeJsdelivrPool = closeJsdelivrPool;
+exports.clearExactManifestCache = clearExactManifestCache;
+const semver = __importStar(require("semver"));
+const utils_1 = require("../../utils");
+const version_1 = require("../../utils/version");
+const inflight_1 = require("../http/inflight");
+const client_1 = require("./client");
+const EXACT_VERSION_PATTERN = /^[0-9]+\.[0-9]+\.[0-9]+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
+const sortVersionsDescending = (versions) => {
+    const uniqueVersions = [];
+    const seenVersions = new Set();
+    for (const version of versions) {
+        const identity = (0, version_1.versionIdentity)(version);
+        if (!seenVersions.has(identity)) {
+            seenVersions.add(identity);
+            uniqueVersions.push(version);
+        }
+    }
+    return uniqueVersions.sort((a, b) => {
+        const comparableA = (0, version_1.toComparableVersion)(a);
+        const comparableB = (0, version_1.toComparableVersion)(b);
+        if (comparableA && comparableB) {
+            return semver.rcompare(comparableA, comparableB);
+        }
+        if (comparableA) {
+            return -1;
+        }
+        if (comparableB) {
+            return 1;
+        }
+        return b.localeCompare(a);
+    });
+};
+const inFlightManifests = new inflight_1.InflightMap();
+async function fetchExactPackageManifest(packageName, version) {
+    const normalizedVersion = version.trim();
+    if (!EXACT_VERSION_PATTERN.test(normalizedVersion) || !semver.valid(normalizedVersion)) {
+        utils_1.debugLog.warn('jsdelivr', `skipping non-exact version lookup for ${packageName}@${version}`);
+        return null;
+    }
+    const cacheKey = `${packageName}@${normalizedVersion}`;
+    return inFlightManifests.dedupe(cacheKey, async () => {
+        const jsdelivrManifest = await (0, client_1.fetchPackageManifestFromJsdelivr)(packageName, normalizedVersion);
+        if (jsdelivrManifest) {
+            return jsdelivrManifest;
+        }
+        return await (0, client_1.fetchPackageManifestFromNpmRegistry)(packageName, normalizedVersion);
+    });
+}
+async function getAllPackageDataFromJsdelivr(packageNames, currentVersions, onProgress) {
+    const packageData = new Map();
+    if (packageNames.length === 0) {
+        return packageData;
+    }
+    const total = packageNames.length;
+    let completedCount = 0;
+    const inFlightLookups = new inflight_1.InflightMap();
+    const fetchPackageData = async (packageName, currentVersion) => {
+        const latestManifest = await (0, client_1.fetchPackageManifestFromJsdelivr)(packageName, 'latest');
+        const latestVersion = typeof latestManifest?.version === 'string' ? latestManifest.version.trim() : '';
+        if (!latestVersion) {
+            return null;
+        }
+        const majorVersion = (0, version_1.extractMajorVersion)(currentVersion);
+        const latestMajorVersion = (0, version_1.extractMajorVersion)(latestVersion);
+        const shouldFetchMajorVersion = Boolean(majorVersion && (latestMajorVersion === null || latestMajorVersion !== majorVersion));
+        const majorManifest = shouldFetchMajorVersion
+            ? await (0, client_1.fetchPackageManifestFromJsdelivr)(packageName, majorVersion)
+            : null;
+        const majorResolvedVersion = typeof majorManifest?.version === 'string' ? majorManifest.version.trim() : '';
+        const sortedVersions = sortVersionsDescending([latestVersion, majorResolvedVersion].filter(Boolean));
+        const allVersions = sortedVersions[0] === latestVersion
+            ? sortedVersions
+            : [latestVersion, ...sortedVersions.filter((version) => version !== latestVersion)];
+        return { latestVersion, allVersions };
+    };
+    const getPackageData = (packageName, currentVersion) => inFlightLookups.dedupe(packageName, () => fetchPackageData(packageName, currentVersion));
+    await Promise.all(packageNames.map(async (packageName) => {
+        try {
+            const result = await getPackageData(packageName, currentVersions?.get(packageName));
+            if (result) {
+                packageData.set(packageName, result);
+            }
+        }
+        finally {
+            completedCount++;
+            onProgress?.(packageName, completedCount, total);
+        }
+    }));
+    return packageData;
+}
+async function closeJsdelivrPool() {
+    const { jsdelivrPool } = await Promise.resolve().then(() => __importStar(require('./client')));
+    await jsdelivrPool.close();
+}
+function clearExactManifestCache() {
+    inFlightManifests.clear();
+}
+//# sourceMappingURL=manifest.js.map