poe-code 4.0.15 → 4.0.17

package/packages/toolcraft-openapi/dist/spec-source.js

@@ -4,6 +4,18 @@ import { parse as parseYaml } from "yaml";
 import { UserError } from "toolcraft";
 import { renderSourceSnippet } from "toolcraft/source-snippet";
 import { classifyNetworkError } from "./network-error.js";
+import { redactSensitiveQueryValues } from "./redaction.js";
+export class OpenApiHttpStatusError extends UserError {
+}
+export class OpenApiTransportError extends UserError {
+}
+export class OpenApiTimeoutError extends OpenApiTransportError {
+    timeoutMs;
+    constructor(message, timeoutMs, options) {
+        super(message, options);
+        this.timeoutMs = timeoutMs;
+    }
+}
 export async function readOpenApiSourceText(input, services) {
     const inputUrl = input instanceof URL ? input : tryParseUrl(input);
     const sourceLabel = formatSourceLabel(input);
@@ -20,29 +32,118 @@ export async function readOpenApiSourceText(input, services) {
         if (inputUrl.protocol !== "http:" && inputUrl.protocol !== "https:") {
             throw new UserError(`Unsupported OpenAPI input URL protocol ${JSON.stringify(inputUrl.protocol)}.`);
         }
+        const result = await fetchOpenApiHttpSource(inputUrl, services.fetch);
+        if (result.status === "not-modified") {
+            throw new UserError(`Failed to fetch ${JSON.stringify(inputUrl.toString())}: received 304 without a cached document.`);
+        }
+        return result.sourceText;
+    }
+    catch (error) {
+        if (error instanceof UserError) {
+            throw error;
+        }
+        throw new UserError(`Failed to read OpenAPI document ${JSON.stringify(sourceLabel)}: ${getErrorMessage(error)}`);
+    }
+}
+export async function fetchOpenApiHttpSource(inputUrl, fetch, options = {}) {
+    validateTimeout(options.timeoutMs);
+    const url = inputUrl.toString();
+    const timeoutMs = options.timeoutMs;
+    const controller = timeoutMs === undefined || timeoutMs === 0 ? undefined : new AbortController();
+    const requestInit = createOpenApiRequestInit(options.etag, controller?.signal);
+    const request = async () => {
         let response;
         try {
-            response = await services.fetch(inputUrl.toString());
+            response = requestInit === undefined ? await fetch(url) : await fetch(url, requestInit);
         }
         catch (error) {
-            throw classifyNetworkError(error, inputUrl.toString()) ?? error;
+            throw toTransportError(error, url) ?? error;
+        }
+        if (response.status === 304) {
+            return {
+                status: "not-modified",
+                ...readResponseCacheHeaders(response)
+            };
         }
         if (!response.ok) {
             const contentType = response.headers.get("content-type") ?? "";
             const text = await response.text().catch(() => "");
             const snippet = text.length === 0 ? "" : `\n  body: ${truncate(text, 500)}`;
-            throw new UserError(`Failed to fetch ${JSON.stringify(inputUrl.toString())}: ` +
+            throw new OpenApiHttpStatusError(`Failed to fetch ${JSON.stringify(url)}: ` +
                 `${response.status} ${response.statusText}` +
                 (contentType ? ` (content-type: ${contentType})` : "") +
                 snippet);
         }
-        return await response.text();
+        try {
+            return {
+                status: "modified",
+                sourceText: await response.text(),
+                ...readResponseCacheHeaders(response)
+            };
+        }
+        catch (error) {
+            throw (toTransportError(error, url) ??
+                new OpenApiTransportError(`Failed to read the OpenAPI response body from ${JSON.stringify(redactSensitiveQueryValues(url))}.`, { cause: error }));
+        }
+    };
+    if (controller === undefined || timeoutMs === undefined) {
+        return await request();
     }
-    catch (error) {
-        if (error instanceof UserError) {
-            throw error;
+    const timeoutCause = Object.assign(new Error("OpenAPI request timed out"), {
+        code: "ETIMEDOUT",
+        timeout: timeoutMs
+    });
+    const classified = classifyNetworkError(timeoutCause, url);
+    const timeoutError = new OpenApiTimeoutError(classified?.message ?? `OpenAPI request timed out after ${timeoutMs}ms.`, timeoutMs, { cause: timeoutCause });
+    let timeout;
+    try {
+        return await Promise.race([
+            request(),
+            new Promise((_resolve, reject) => {
+                timeout = setTimeout(() => {
+                    reject(timeoutError);
+                    controller.abort(timeoutError);
+                }, timeoutMs);
+            })
+        ]);
+    }
+    finally {
+        if (timeout !== undefined) {
+            clearTimeout(timeout);
         }
-        throw new UserError(`Failed to read OpenAPI document ${JSON.stringify(sourceLabel)}: ${getErrorMessage(error)}`);
+    }
+}
+function toTransportError(error, url) {
+    if (error instanceof OpenApiTransportError) {
+        return error;
+    }
+    const classified = classifyNetworkError(error, url);
+    return classified === null
+        ? null
+        : new OpenApiTransportError(classified.message, { cause: error });
+}
+function createOpenApiRequestInit(etag, signal) {
+    if (etag === undefined && signal === undefined) {
+        return undefined;
+    }
+    return {
+        ...(etag === undefined ? {} : { headers: { "If-None-Match": etag } }),
+        ...(signal === undefined ? {} : { signal })
+    };
+}
+function readResponseCacheHeaders(response) {
+    const etag = response.headers.get("etag") ?? undefined;
+    const cacheControl = response.headers.get("cache-control") ?? undefined;
+    const age = response.headers.get("age") ?? undefined;
+    return {
+        ...(etag === undefined ? {} : { etag }),
+        ...(cacheControl === undefined ? {} : { cacheControl }),
+        ...(age === undefined ? {} : { age })
+    };
+}
+function validateTimeout(timeoutMs) {
+    if (timeoutMs !== undefined && (!Number.isFinite(timeoutMs) || timeoutMs < 0)) {
+        throw new UserError("OpenAPI fetch timeout must be a finite non-negative number.");
     }
 }
 export function parseOpenApiDocument(sourceText, input) {