@mintlify/prebuild 1.0.1186 → 1.0.1188

package/dist/prebuild/update/docsConfig/loadRemoteGraphqlSdl.js

@@ -0,0 +1,217 @@
+import { lookup } from 'node:dns/promises';
+import { request } from 'node:https';
+import { BlockList, isIP } from 'node:net';
+const MAX_REMOTE_REDIRECTS = 5;
+export const MAX_GRAPHQL_SCHEMA_BYTES = 5 * 1024 * 1024;
+const REMOTE_SCHEMA_TIMEOUT_MS = 10_000;
+const blockedAddresses = new BlockList();
+for (const [network, prefix] of [
+    ['0.0.0.0', 8],
+    ['10.0.0.0', 8],
+    ['100.64.0.0', 10],
+    ['127.0.0.0', 8],
+    ['169.254.0.0', 16],
+    ['172.16.0.0', 12],
+    ['192.0.0.0', 24],
+    ['192.0.2.0', 24],
+    ['192.88.99.0', 24],
+    ['192.168.0.0', 16],
+    ['198.18.0.0', 15],
+    ['198.51.100.0', 24],
+    ['203.0.113.0', 24],
+    ['224.0.0.0', 4],
+    ['240.0.0.0', 4],
+]) {
+    blockedAddresses.addSubnet(network, prefix, 'ipv4');
+}
+for (const [network, prefix] of [
+    ['::', 128],
+    ['::1', 128],
+    ['::', 96],
+    ['64:ff9b:1::', 48],
+    ['100::', 64],
+    ['2001::', 32],
+    ['2001:2::', 48],
+    ['2001:10::', 28],
+    ['2001:20::', 28],
+    ['2001:db8::', 32],
+    ['2002::', 16],
+    ['3fff::', 20],
+    ['5f00::', 16],
+    ['fc00::', 7],
+    ['fe80::', 10],
+    ['fec0::', 10],
+    ['ff00::', 8],
+]) {
+    blockedAddresses.addSubnet(network, prefix, 'ipv6');
+}
+export const isGlobalIpAddress = (address) => {
+    const family = isIP(address);
+    const normalized = address.toLowerCase();
+    if (family === 6 && normalized.startsWith('::ffff:')) {
+        const mappedAddress = normalized.slice('::ffff:'.length);
+        if (isIP(mappedAddress) === 4)
+            return isGlobalIpAddress(mappedAddress);
+        const [high, low] = mappedAddress.split(':').map((part) => Number.parseInt(part, 16));
+        if (high != null && low != null && Number.isFinite(high) && Number.isFinite(low)) {
+            return isGlobalIpAddress(`${high >> 8}.${high & 0xff}.${low >> 8}.${low & 0xff}`);
+        }
+        return false;
+    }
+    return family !== 0 && !blockedAddresses.check(address, family === 4 ? 'ipv4' : 'ipv6');
+};
+async function defaultResolveHostname(hostname) {
+    if (isIP(hostname))
+        return [{ address: hostname, family: isIP(hostname) }];
+    return (await lookup(hostname, { all: true }));
+}
+export function createPinnedLookup(resolved) {
+    return ((_hostname, _options, callback) => {
+        callback(null, resolved.address, resolved.family);
+    });
+}
+async function resolveAndValidate(url, resolveHostname) {
+    if (url.protocol !== 'https:') {
+        throw new Error(`GraphQL schema redirects must use HTTPS: ${url.href}`);
+    }
+    const hostname = url.hostname.toLowerCase().replace(/^\[|\]$/g, '');
+    if (hostname === 'localhost' || hostname.endsWith('.localhost')) {
+        throw new Error(`GraphQL schema host must be public: ${hostname}`);
+    }
+    let addresses;
+    try {
+        addresses = await resolveHostname(hostname);
+    }
+    catch (error) {
+        const detail = error instanceof Error ? `: ${error.message}` : '';
+        throw new Error(`Unable to resolve GraphQL schema host ${hostname}${detail}`);
+    }
+    // Reject ambiguous split-horizon answers so every address associated with the host is safe.
+    if (addresses.length === 0 || addresses.some(({ address }) => !isGlobalIpAddress(address))) {
+        throw new Error(`GraphQL schema host must resolve only to public addresses: ${hostname}`);
+    }
+    return addresses[0];
+}
+function requestPinned(url, resolved, requestImpl, timeoutMs, maxBytes) {
+    return new Promise((resolve, reject) => {
+        let responseRef;
+        let requestRef;
+        let settled = false;
+        const finish = (callback, value) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(deadlineTimer);
+            callback(value);
+        };
+        const hostname = url.hostname.replace(/^\[|\]$/g, '');
+        const options = {
+            agent: false,
+            lookup: createPinnedLookup(resolved),
+            servername: isIP(hostname) ? undefined : hostname,
+            headers: { Host: url.host },
+        };
+        const deadlineTimer = setTimeout(() => {
+            const error = new Error('timeout');
+            responseRef?.destroy(error);
+            requestRef.destroy(error);
+            finish(reject, error);
+        }, timeoutMs);
+        try {
+            requestRef = requestImpl(url, options, (response) => {
+                responseRef = response;
+                const chunks = [];
+                let totalBytes = 0;
+                const contentLength = Number(response.headers['content-length']);
+                if (Number.isFinite(contentLength) && contentLength > maxBytes) {
+                    response.destroy();
+                    finish(reject, new Error(`GraphQL schema ${url.href} exceeds the ${maxBytes} byte limit`));
+                    return;
+                }
+                response.on('data', (chunk) => {
+                    const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+                    totalBytes += bytes.byteLength;
+                    if (totalBytes > maxBytes) {
+                        response.destroy();
+                        finish(reject, new Error(`GraphQL schema ${url.href} exceeds the ${maxBytes} byte limit`));
+                        return;
+                    }
+                    chunks.push(new Uint8Array(bytes));
+                });
+                response.on('end', () => {
+                    finish(resolve, {
+                        statusCode: response.statusCode ?? 0,
+                        statusMessage: response.statusMessage ?? '',
+                        headers: response.headers,
+                        body: Buffer.concat(chunks).toString('utf8'),
+                    });
+                });
+                response.on('error', (error) => finish(reject, error));
+            });
+        }
+        catch (error) {
+            finish(reject, error);
+            return;
+        }
+        requestRef.on('error', (error) => finish(reject, error));
+        requestRef.end();
+    });
+}
+export async function loadRemoteGraphqlSdl(source, options = {}) {
+    const timeoutMs = options.timeoutMs ?? REMOTE_SCHEMA_TIMEOUT_MS;
+    const maxBytes = options.maxBytes ?? MAX_GRAPHQL_SCHEMA_BYTES;
+    const resolveHostname = options.resolveHostname ?? defaultResolveHostname;
+    const requestImpl = options.requestImpl ?? request;
+    const deadline = Date.now() + timeoutMs;
+    let currentUrl = new URL(source);
+    const withTimeout = async (pending, remainingMs) => {
+        let timeout;
+        try {
+            return await Promise.race([
+                pending,
+                new Promise((_resolve, reject) => {
+                    timeout = setTimeout(() => reject(new Error('timeout')), remainingMs);
+                }),
+            ]);
+        }
+        finally {
+            if (timeout)
+                clearTimeout(timeout);
+        }
+    };
+    for (let redirects = 0; redirects <= MAX_REMOTE_REDIRECTS; redirects++) {
+        let remainingMs = deadline - Date.now();
+        if (remainingMs <= 0)
+            throw new Error(`Timed out loading GraphQL schema ${source}`);
+        let response;
+        try {
+            const resolved = await withTimeout(resolveAndValidate(currentUrl, resolveHostname), remainingMs);
+            remainingMs = deadline - Date.now();
+            if (remainingMs <= 0)
+                throw new Error('timeout');
+            response = await requestPinned(currentUrl, resolved, requestImpl, remainingMs, maxBytes);
+        }
+        catch (error) {
+            if (Date.now() >= deadline || (error instanceof Error && error.message === 'timeout')) {
+                throw new Error(`Timed out loading GraphQL schema ${source}`);
+            }
+            throw error;
+        }
+        if (response.statusCode >= 300 && response.statusCode < 400) {
+            const location = response.headers.location;
+            if (typeof location !== 'string') {
+                throw new Error(`GraphQL schema redirect from ${currentUrl.href} has no location`);
+            }
+            if (redirects === MAX_REMOTE_REDIRECTS) {
+                throw new Error(`Too many redirects loading GraphQL schema ${source}`);
+            }
+            currentUrl = new URL(location, currentUrl);
+            continue;
+        }
+        if (response.statusCode < 200 || response.statusCode >= 300) {
+            throw new Error(`Unable to load GraphQL schema ${currentUrl.href}: ${response.statusCode} ${response.statusMessage}`);
+        }
+        return response.body;
+    }
+    throw new Error(`Too many redirects loading GraphQL schema ${source}`);
+}