@j0hanz/superfetch 2.2.1 → 2.3.0

package/dist/fetch.js

@@ -8,14 +8,13 @@ import { Agent } from 'undici';
 import { config } from './config.js';
 import { createErrorWithCode, FetchError, isSystemError } from './errors.js';
 import { getOperationId, getRequestId, logDebug, logError, logWarn, redactUrl, } from './observability.js';
-import { isRecord } from './type-guards.js';
+import { isObject } from './type-guards.js';
 function buildIpv4(parts) {
     return parts.join('.');
 }
 function buildIpv6(parts) {
     return parts.map(String).join(':');
 }
-const BLOCK_LIST = new BlockList();
 const IPV6_ZERO = buildIpv6([0, 0, 0, 0, 0, 0, 0, 0]);
 const IPV6_LOOPBACK = buildIpv6([0, 0, 0, 0, 0, 0, 0, 1]);
 const IPV6_64_FF9B = buildIpv6(['64', 'ff9b', 0, 0, 0, 0, 0, 0]);
@@ -47,19 +46,22 @@ const BLOCKED_IPV6_SUBNETS = [
     { subnet: IPV6_FE80, prefix: 10 },
     { subnet: IPV6_FF00, prefix: 8 },
 ];
-for (const entry of BLOCKED_IPV4_SUBNETS) {
-    BLOCK_LIST.addSubnet(entry.subnet, entry.prefix, 'ipv4');
-}
-for (const entry of BLOCKED_IPV6_SUBNETS) {
-    BLOCK_LIST.addSubnet(entry.subnet, entry.prefix, 'ipv6');
-}
-function matchesBlockedIpPatterns(resolvedIp) {
-    for (const pattern of config.security.blockedIpPatterns) {
-        if (pattern.test(resolvedIp)) {
-            return true;
+let cachedBlockList;
+function getBlockList() {
+    if (!cachedBlockList) {
+        cachedBlockList = new BlockList();
+        for (const entry of BLOCKED_IPV4_SUBNETS) {
+            cachedBlockList.addSubnet(entry.subnet, entry.prefix, 'ipv4');
+        }
+        for (const entry of BLOCKED_IPV6_SUBNETS) {
+            cachedBlockList.addSubnet(entry.subnet, entry.prefix, 'ipv6');
         }
     }
-    return false;
+    return cachedBlockList;
+}
+function matchesBlockedIpPatterns(resolvedIp) {
+    return (config.security.blockedIpPattern.test(resolvedIp) ||
+        config.security.blockedIpv4MappedPattern.test(resolvedIp));
 }
 export function isBlockedIp(ip) {
     if (config.security.blockedHosts.has(ip)) {
@@ -78,10 +80,11 @@ function resolveIpType(ip) {
     return ipType === 4 || ipType === 6 ? ipType : null;
 }
 function isBlockedByList(ip, ipType) {
+    const blockList = getBlockList();
     if (ipType === 4) {
-        return BLOCK_LIST.check(ip, 'ipv4');
+        return blockList.check(ip, 'ipv4');
     }
-    return BLOCK_LIST.check(ip, 'ipv6');
+    return blockList.check(ip, 'ipv6');
 }
 export function normalizeUrl(urlString) {
     const trimmedUrl = requireTrimmedUrl(urlString);
@@ -217,28 +220,18 @@ const TRANSFORM_RULES = [
     GITLAB_BLOB_RULE,
     BITBUCKET_SRC_RULE,
 ];
+const BITBUCKET_RAW_RE = /bitbucket\.org\/[^/]+\/[^/]+\/raw\//;
 function isRawUrl(url) {
     const lowerUrl = url.toLowerCase();
     return (lowerUrl.includes('raw.githubusercontent.com') ||
         lowerUrl.includes('gist.githubusercontent.com') ||
         lowerUrl.includes('/-/raw/') ||
-        /bitbucket\.org\/[^/]+\/[^/]+\/raw\//.test(lowerUrl));
+        BITBUCKET_RAW_RE.test(lowerUrl));
 }
 function getUrlWithoutParams(url) {
     const hashIndex = url.indexOf('#');
     const queryIndex = url.indexOf('?');
-    let endIndex = url.length;
-    if (queryIndex !== -1) {
-        if (hashIndex !== -1) {
-            endIndex = Math.min(queryIndex, hashIndex);
-        }
-        else {
-            endIndex = queryIndex;
-        }
-    }
-    else if (hashIndex !== -1) {
-        endIndex = hashIndex;
-    }
+    const endIndex = Math.min(queryIndex === -1 ? url.length : queryIndex, hashIndex === -1 ? url.length : hashIndex);
     const hash = hashIndex !== -1 ? url.slice(hashIndex) : '';
     return {
         base: url.slice(0, endIndex),
@@ -314,6 +307,7 @@ function hasKnownRawTextExtension(urlBaseLower) {
     return false;
 }
 const DNS_LOOKUP_TIMEOUT_MS = 5000;
+const SLOW_REQUEST_THRESHOLD_MS = 5000;
 function normalizeLookupResults(addresses, family) {
     if (Array.isArray(addresses)) {
         return addresses;
@@ -422,7 +416,7 @@ function resolveResultOrder(options) {
     return DEFAULT_DNS_ORDER;
 }
 function getLegacyVerbatim(options) {
-    if (isRecord(options)) {
+    if (isObject(options)) {
         const { verbatim } = options;
         return typeof verbatim === 'boolean' ? verbatim : undefined;
     }
@@ -509,6 +503,12 @@ function createRateLimitError(url, headerValue) {
 function createHttpError(url, status, statusText) {
     return new FetchError(`HTTP ${status}: ${statusText}`, url, status);
 }
+function createTooManyRedirectsError(url) {
+    return new FetchError('Too many redirects', url);
+}
+function createMissingRedirectLocationError(url) {
+    return new FetchError('Redirect response missing Location header', url);
+}
 function createSizeLimitError(url, maxBytes) {
     return new FetchError(`Response exceeds maximum size of ${maxBytes} bytes`, url);
 }
@@ -533,28 +533,36 @@ function getRequestUrl(record) {
 function resolveErrorUrl(error, fallback) {
     if (error instanceof FetchError)
         return error.url;
-    if (!isRecord(error))
+    if (!isObject(error))
         return fallback;
     const requestUrl = getRequestUrl(error);
     if (requestUrl)
         return requestUrl;
     return fallback;
 }
-function mapFetchError(error, fallbackUrl, timeoutMs) {
-    if (error instanceof FetchError)
-        return error;
-    const url = resolveErrorUrl(error, fallbackUrl);
-    if (isAbortError(error)) {
-        if (isTimeoutError(error)) {
-            return createTimeoutError(url, timeoutMs);
-        }
-        return createCanceledError(url);
+function resolveAbortFetchError(error, url, timeoutMs) {
+    if (!isAbortError(error))
+        return null;
+    if (isTimeoutError(error)) {
+        return createTimeoutError(url, timeoutMs);
     }
+    return createCanceledError(url);
+}
+function resolveUnexpectedFetchError(error, url) {
     if (error instanceof Error) {
         return createNetworkError(url, error.message);
     }
     return createUnknownError(url, 'Unexpected error');
 }
+function mapFetchError(error, fallbackUrl, timeoutMs) {
+    if (error instanceof FetchError)
+        return error;
+    const url = resolveErrorUrl(error, fallbackUrl);
+    const abortError = resolveAbortFetchError(error, url, timeoutMs);
+    if (abortError)
+        return abortError;
+    return resolveUnexpectedFetchError(error, url);
+}
 const fetchChannel = diagnosticsChannel.channel('superfetch.fetch');
 function publishFetchEvent(event) {
     if (!fetchChannel.hasSubscribers)
@@ -589,7 +597,7 @@ function buildResponseMetadata(response, contentSize) {
     return metadata;
 }
 function logSlowRequest(context, duration, durationLabel, contextFields) {
-    if (duration <= 5000)
+    if (duration <= SLOW_REQUEST_THRESHOLD_MS)
         return;
     logWarn('Slow HTTP request detected', {
         requestId: context.requestId,
@@ -719,17 +727,17 @@ function assertRedirectWithinLimit(response, currentUrl, redirectLimit, redirect
     if (redirectCount < redirectLimit)
         return;
     cancelResponseBody(response);
-    throw new FetchError('Too many redirects', currentUrl);
+    throw createTooManyRedirectsError(currentUrl);
 }
 function getRedirectLocation(response, currentUrl) {
     const location = response.headers.get('location');
     if (location)
         return location;
     cancelResponseBody(response);
-    throw new FetchError('Redirect response missing Location header', currentUrl);
+    throw createMissingRedirectLocationError(currentUrl);
 }
 function annotateRedirectError(error, url) {
-    if (!isRecord(error))
+    if (!isObject(error))
         return;
     error.requestUrl = url;
 }
@@ -743,26 +751,26 @@ function resolveRedirectTarget(baseUrl, location) {
     }
     return validateAndNormalizeUrl(resolved.href);
 }
+async function withRedirectErrorContext(url, fn) {
+    try {
+        return await fn();
+    }
+    catch (error) {
+        annotateRedirectError(error, url);
+        throw error;
+    }
+}
 export async function fetchWithRedirects(url, init, maxRedirects) {
     let currentUrl = url;
     const redirectLimit = Math.max(0, maxRedirects);
     for (let redirectCount = 0; redirectCount <= redirectLimit; redirectCount += 1) {
-        const { response, nextUrl } = await performFetchCycleSafely(currentUrl, init, redirectLimit, redirectCount);
+        const { response, nextUrl } = await withRedirectErrorContext(currentUrl, () => performFetchCycle(currentUrl, init, redirectLimit, redirectCount));
         if (!nextUrl) {
             return { response, url: currentUrl };
         }
         currentUrl = nextUrl;
     }
-    throw new FetchError('Too many redirects', currentUrl);
-}
-async function performFetchCycleSafely(currentUrl, init, redirectLimit, redirectCount) {
-    try {
-        return await performFetchCycle(currentUrl, init, redirectLimit, redirectCount);
-    }
-    catch (error) {
-        annotateRedirectError(error, currentUrl);
-        throw error;
-    }
+    throw createTooManyRedirectsError(currentUrl);
 }
 function assertContentLengthWithinLimit(response, url, maxBytes) {
     const contentLengthHeader = response.headers.get('content-length');
@@ -847,15 +855,18 @@ async function readStreamWithLimit(stream, url, maxBytes, signal) {
     finalizeRead(state);
     return { text: state.parts.join(''), size: state.total };
 }
+async function readResponseTextFallback(response, url, maxBytes) {
+    const text = await response.text();
+    const size = Buffer.byteLength(text);
+    if (size > maxBytes) {
+        throw createSizeLimitError(url, maxBytes);
+    }
+    return { text, size };
+}
 export async function readResponseText(response, url, maxBytes, signal) {
     assertContentLengthWithinLimit(response, url, maxBytes);
     if (!response.body) {
-        const text = await response.text();
-        const size = Buffer.byteLength(text);
-        if (size > maxBytes) {
-            throw createSizeLimitError(url, maxBytes);
-        }
-        return { text, size };
+        return readResponseTextFallback(response, url, maxBytes);
     }
     return readStreamWithLimit(response.body, url, maxBytes, signal);
 }
@@ -931,4 +942,3 @@ export async function fetchNormalizedUrl(normalizedUrl, options) {
     const requestInit = buildRequestInit(headers, signal);
     return fetchWithTelemetry(normalizedUrl, requestInit, timeoutMs);
 }
-//# sourceMappingURL=fetch.js.map

package/dist/host-normalization.d.ts

@@ -0,0 +1 @@
+export declare function normalizeHost(value: string): string | null;

package/dist/host-normalization.js

@@ -0,0 +1,47 @@
+import { isIP } from 'node:net';
+export function normalizeHost(value) {
+    const trimmed = value.trim().toLowerCase();
+    if (!trimmed)
+        return null;
+    const first = takeFirstHostValue(trimmed);
+    if (!first)
+        return null;
+    const ipv6 = stripIpv6Brackets(first);
+    if (ipv6)
+        return stripTrailingDots(ipv6);
+    if (isIpV6Literal(first)) {
+        return stripTrailingDots(first);
+    }
+    return stripTrailingDots(stripPortIfPresent(first));
+}
+function takeFirstHostValue(value) {
+    const first = value.split(',')[0];
+    if (!first)
+        return null;
+    const trimmed = first.trim();
+    return trimmed ? trimmed : null;
+}
+function stripIpv6Brackets(value) {
+    if (!value.startsWith('['))
+        return null;
+    const end = value.indexOf(']');
+    if (end === -1)
+        return null;
+    return value.slice(1, end);
+}
+function stripPortIfPresent(value) {
+    const colonIndex = value.indexOf(':');
+    if (colonIndex === -1)
+        return value;
+    return value.slice(0, colonIndex);
+}
+function isIpV6Literal(value) {
+    return isIP(value) === 6;
+}
+function stripTrailingDots(value) {
+    let result = value;
+    while (result.endsWith('.')) {
+        result = result.slice(0, -1);
+    }
+    return result;
+}

package/dist/http-native.d.ts

@@ -0,0 +1,5 @@
+export declare function startHttpServer(): Promise<{
+    shutdown: (signal: string) => Promise<void>;
+    port: number;
+    host: string;
+}>;