toolcraft-openapi 0.0.26 → 0.0.33

package/dist/http.d.ts

@@ -1,6 +1,10 @@
 import type { TokenSource } from "./auth/types.js";
 type QueryScalar = string | number | boolean | null | undefined;
-export type QueryValue = QueryScalar | QueryScalar[];
+type QueryObject = {
+    readonly [key: string]: QueryValue;
+};
+type HeaderScalar = string | number | boolean | undefined;
+export type QueryValue = QueryScalar | QueryValue[] | QueryObject;
 export interface HttpRequestOptions {
     baseUrl: string;
     path: string;
@@ -10,7 +14,13 @@ export interface HttpRequestOptions {
     fetch?: typeof globalThis.fetch;
     pathParams?: Record<string, string | number | boolean>;
     query?: Record<string, QueryValue>;
+    headers?: Record<string, HeaderScalar>;
     body?: unknown;
+    bodyMode?: "json" | "form" | "raw" | "base64" | "multipart";
+    contentType?: string;
+    multipartBinaryFields?: readonly string[];
+    responseMode?: "json" | "text" | "binary";
+    accept?: string;
     dryRun?: boolean;
     verbose?: boolean;
     signal?: AbortSignal;
@@ -29,6 +39,12 @@ export interface HttpErrorResponse {
     headers: Record<string, string>;
     body: unknown;
 }
+export interface BinaryHttpResponse {
+    contentType: string;
+    encoding: "base64";
+    byteLength: number;
+    data: string;
+}
 export declare class HttpError extends Error {
     readonly status: number;
     readonly statusText: string;

package/dist/http.js

@@ -1,4 +1,4 @@
-import { text as designText } from "@poe-code/design-system";
+import { text as designText } from "toolcraft-design";
 import { UserError } from "toolcraft";
 import { classifyNetworkError } from "./network-error.js";
 import { redactHeaders, redactHeaderValue, redactSensitiveQueryValues } from "./redaction.js";
@@ -25,9 +25,19 @@ export async function requestJson(options) {
     const token = options.auth === "none" ? undefined : await options.tokenSource.getToken();
     const method = options.method.toUpperCase();
     const hasBody = options.body !== undefined;
-    const serializedBody = hasBody ? JSON.stringify(options.body) : undefined;
+    const serializedBody = hasBody
+        ? options.bodyMode === "form"
+            ? serializeFormBody(options.body)
+            : options.bodyMode === "raw"
+                ? serializeRawBody(options.body)
+                : options.bodyMode === "base64"
+                    ? decodeBase64Body(options.body)
+                    : options.bodyMode === "multipart"
+                        ? serializeMultipartBody(options.body, options.multipartBinaryFields)
+                        : JSON.stringify(options.body)
+        : undefined;
     const url = buildRequestUrl(options);
-    const headers = createHeaders(token, hasBody);
+    const headers = createHeaders(token, hasBody, options.headers, options.accept, options.bodyMode, options.contentType);
     const writeStdout = options.writeStdout ?? process.stdout.write.bind(process.stdout);
     const writeStderr = options.writeStderr ?? process.stderr.write.bind(process.stderr);
     const requestLine = `${method} ${redactSensitiveQueryValues(url)}`;
@@ -50,10 +60,29 @@ export async function requestJson(options) {
     catch (error) {
         throw classifyNetworkError(error, url) ?? error;
     }
-    const text = await response.text();
     const contentType = response.headers.get("content-type");
     const request = createHttpErrorRequest(method, url, headers, options.body);
     const responseHeaders = redactHeaders(serializeHeaders(response.headers));
+    if (response.ok && options.responseMode === "binary") {
+        const bytes = new Uint8Array(await response.arrayBuffer());
+        if (bytes.byteLength === 0) {
+            if (options.verbose) {
+                writeStderr(formatTranscriptLines(formatVerboseResponseTranscript(response, responseHeaders)));
+            }
+            return undefined;
+        }
+        const body = {
+            contentType: contentType ?? options.accept ?? "application/octet-stream",
+            encoding: "base64",
+            byteLength: bytes.byteLength,
+            data: Buffer.from(bytes).toString("base64")
+        };
+        if (options.verbose) {
+            writeStderr(formatTranscriptLines(formatVerboseResponseTranscript(response, responseHeaders, body)));
+        }
+        return body;
+    }
+    const text = await response.text();
     if (response.ok) {
         if (text.length === 0) {
             if (options.verbose) {
@@ -61,6 +90,12 @@ export async function requestJson(options) {
             }
             return undefined;
         }
+        if (options.responseMode === "text") {
+            if (options.verbose) {
+                writeStderr(formatTranscriptLines(formatVerboseResponseTranscript(response, responseHeaders, text)));
+            }
+            return text;
+        }
         if (!isJsonContentType(contentType)) {
             if (options.verbose) {
                 writeStderr(formatTranscriptLines(formatVerboseResponseTranscript(response, responseHeaders, text)));
@@ -146,18 +181,89 @@ function substitutePathParams(path, pathParams) {
     return resolvedPath;
 }
 function appendQueryValue(searchParams, key, value) {
+    if (isQueryObject(value)) {
+        for (const [childKey, childValue] of Object.entries(value)) {
+            appendQueryValue(searchParams, `${key}[${childKey}]`, childValue);
+        }
+        return;
+    }
     const values = Array.isArray(value) ? value : [value];
-    for (const entry of values) {
+    for (const [index, entry] of values.entries()) {
         if (entry === undefined) {
             continue;
         }
+        if (isQueryObject(entry)) {
+            for (const [childKey, childValue] of Object.entries(entry)) {
+                appendQueryValue(searchParams, `${key}[${Array.isArray(value) ? `${index}][` : ""}${childKey}]`, childValue);
+            }
+            continue;
+        }
         searchParams.append(key, entry === null ? "" : String(entry));
     }
 }
-function createHeaders(token, hasBody) {
+function serializeFormBody(body) {
+    if (body === null || typeof body !== "object" || Array.isArray(body)) {
+        throw new UserError("URL-encoded form bodies must be objects.");
+    }
+    const searchParams = new URLSearchParams();
+    for (const [key, value] of Object.entries(body)) {
+        appendQueryValue(searchParams, key, value);
+    }
+    return searchParams.toString();
+}
+function serializeRawBody(body) {
+    if (typeof body !== "string") {
+        throw new UserError("Raw request bodies must be strings.");
+    }
+    return body;
+}
+function decodeBase64Body(body) {
+    if (typeof body !== "string") {
+        throw new UserError("Base64 request bodies must be strings.");
+    }
+    return Uint8Array.from(Buffer.from(body, "base64")).buffer;
+}
+function serializeMultipartBody(body, binaryFields = []) {
+    if (body === null || typeof body !== "object" || Array.isArray(body)) {
+        throw new UserError("Multipart request bodies must be objects.");
+    }
+    const binary = new Set(binaryFields);
+    const form = new FormData();
+    for (const [key, value] of Object.entries(body)) {
+        if (value === undefined)
+            continue;
+        if (binary.has(key)) {
+            form.append(key, new Blob([decodeBase64Body(value)]), key);
+        }
+        else if (Array.isArray(value)) {
+            for (const item of value)
+                form.append(key, String(item));
+        }
+        else {
+            form.append(key, String(value));
+        }
+    }
+    return form;
+}
+function isQueryObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function createHeaders(token, hasBody, customHeaders, accept = "application/json", bodyMode = "json", contentType) {
+    const headers = Object.fromEntries(Object.entries(customHeaders ?? {})
+        .filter(([name, value]) => value !== undefined &&
+        !["accept", "content-type"].includes(name.toLowerCase()) &&
+        !(token !== undefined && name.toLowerCase() === "authorization"))
+        .map(([name, value]) => [name, String(value)]));
     return {
+        ...headers,
+        Accept: accept,
         ...(token === undefined ? {} : { Authorization: `Bearer ${token}` }),
-        ...(hasBody ? { "Content-Type": "application/json" } : {})
+        ...(hasBody && bodyMode !== "multipart"
+            ? {
+                "Content-Type": contentType ??
+                    (bodyMode === "form" ? "application/x-www-form-urlencoded" : "application/json")
+            }
+            : {})
     };
 }
 function createHttpErrorRequest(method, url, headers, body) {

package/dist/index.d.ts

@@ -2,6 +2,11 @@ export { defineApiCommand } from "./api-command.js";
 export { defineClient } from "./define-client.js";
 export { generate } from "./generate.js";
 export type { GenerateOptions, GeneratedFile, OpenApiDocument } from "./generate.js";
+export { inspectOpenApiDocument } from "./inspect.js";
+export type { OpenApiInspectionOperation, OpenApiInspectionReport } from "./inspect.js";
+export { inspectOpenApiSource } from "./inspect-source.js";
+export type { InspectOpenApiSourceOptions, OpenApiInspectionSource } from "./inspect-source.js";
+export { renderOpenApiInspection } from "./render-inspection.js";
 export { commandsFromSpec, defineClientFromSpec } from "./runtime.js";
 export type { CommandsFromSpecOptions, DefineClientFromSpecOptions, OpenApiDocumentSource } from "./runtime.js";
 export type { DefineClientOptions, DefinedClient, OpenApiClientServices } from "./define-client.js";
@@ -9,4 +14,4 @@ export type { AuthProvider, CommandContributor, TokenSource } from "./auth/types
 export { bearerTokenAuth } from "./auth/bearer-token-auth.js";
 export type { BearerTokenAuthOptions } from "./auth/bearer-token-auth.js";
 export { HttpError, requestJson } from "./http.js";
-export type { HttpErrorRequest, HttpErrorResponse, HttpRequestOptions, QueryValue } from "./http.js";
+export type { BinaryHttpResponse, HttpErrorRequest, HttpErrorResponse, HttpRequestOptions, QueryValue } from "./http.js";

package/dist/index.js

@@ -1,6 +1,9 @@
 export { defineApiCommand } from "./api-command.js";
 export { defineClient } from "./define-client.js";
 export { generate } from "./generate.js";
+export { inspectOpenApiDocument } from "./inspect.js";
+export { inspectOpenApiSource } from "./inspect-source.js";
+export { renderOpenApiInspection } from "./render-inspection.js";
 export { commandsFromSpec, defineClientFromSpec } from "./runtime.js";
 export { bearerTokenAuth } from "./auth/bearer-token-auth.js";
 export { HttpError, requestJson } from "./http.js";

package/dist/inspect-source.d.ts

@@ -0,0 +1,10 @@
+import { type OpenApiInspectionReport } from "./inspect.js";
+import type { OpenApiDocument } from "./generate.js";
+import { type OpenApiSourceFileSystem } from "./spec-source.js";
+export type OpenApiInspectionSource = OpenApiDocument | string | URL;
+export interface InspectOpenApiSourceOptions {
+    cwd?: string;
+    fetch?: typeof globalThis.fetch;
+    fs?: OpenApiSourceFileSystem;
+}
+export declare function inspectOpenApiSource(source: OpenApiInspectionSource, options?: InspectOpenApiSourceOptions): Promise<OpenApiInspectionReport>;

package/dist/inspect-source.js

@@ -0,0 +1,14 @@
+import fs from "node:fs/promises";
+import { inspectOpenApiDocument } from "./inspect.js";
+import { parseOpenApiDocument, readOpenApiSourceText } from "./spec-source.js";
+export async function inspectOpenApiSource(source, options = {}) {
+    if (typeof source !== "string" && !(source instanceof URL)) {
+        return inspectOpenApiDocument(source);
+    }
+    const sourceText = await readOpenApiSourceText(source, {
+        cwd: options.cwd ?? process.cwd(),
+        fetch: options.fetch ?? globalThis.fetch,
+        fs: options.fs ?? fs
+    });
+    return inspectOpenApiDocument(parseOpenApiDocument(sourceText, source));
+}

package/dist/inspect.d.ts

@@ -0,0 +1,22 @@
+import { type OpenApiDocument } from "./generate.js";
+declare const HTTP_METHOD_ORDER: readonly ["get", "post", "put", "patch", "delete", "head", "options", "trace"];
+type InspectedHttpMethod = (typeof HTTP_METHOD_ORDER)[number];
+export interface OpenApiInspectionOperation {
+    method: Uppercase<InspectedHttpMethod>;
+    path: string;
+    operationId: string;
+    summary?: string;
+    status: "supported" | "unsupported";
+    commandPath?: string;
+    reason?: string;
+}
+export interface OpenApiInspectionReport {
+    title?: string;
+    version?: string;
+    operationCount: number;
+    supportedCount: number;
+    unsupportedCount: number;
+    operations: OpenApiInspectionOperation[];
+}
+export declare function inspectOpenApiDocument(document: OpenApiDocument): OpenApiInspectionReport;
+export {};

package/dist/inspect.js

@@ -0,0 +1,171 @@
+import { UserError } from "toolcraft";
+import { collectGeneratedCommand } from "./generate.js";
+import { normalizeOpenApiDocument } from "./normalize-swagger.js";
+import { deriveDisambiguatedVerb, derivePathDisambiguatedVerb } from "./naming.js";
+const HTTP_METHOD_ORDER = [
+    "get",
+    "post",
+    "put",
+    "patch",
+    "delete",
+    "head",
+    "options",
+    "trace"
+];
+export function inspectOpenApiDocument(document) {
+    const normalizedDocument = normalizeOpenApiDocument(document);
+    if (normalizedDocument.paths === undefined) {
+        throw new UserError('OpenAPI document must define a top-level "paths" object.');
+    }
+    const operations = collectInspectionOperations(normalizedDocument);
+    markCommandPathCollisions(operations);
+    const supportedCount = operations.filter((operation) => operation.status === "supported").length;
+    return {
+        ...(normalizedDocument.info?.title === undefined ? {} : { title: normalizedDocument.info.title }),
+        ...(normalizedDocument.info?.version === undefined ? {} : { version: normalizedDocument.info.version }),
+        operationCount: operations.length,
+        supportedCount,
+        unsupportedCount: operations.length - supportedCount,
+        operations
+    };
+}
+function collectInspectionOperations(document) {
+    return Object.entries(document.paths ?? {})
+        .sort(([left], [right]) => left.localeCompare(right))
+        .flatMap(([path, pathItem]) => {
+        if (pathItem === undefined) {
+            return [];
+        }
+        return HTTP_METHOD_ORDER.flatMap((method) => {
+            const operation = pathItem[method];
+            if (operation === undefined) {
+                return [];
+            }
+            return [inspectOperation(document, path, pathItem, method, operation)];
+        });
+    });
+}
+function inspectOperation(document, path, pathItem, method, operation) {
+    const metadata = readOperationMetadata(path, method, operation);
+    try {
+        const command = method === "trace"
+            ? undefined
+            : collectGeneratedCommand(document, path, method);
+        if (command === undefined) {
+            throw new UserError(`Operation ${JSON.stringify(metadata.operationId)} uses unsupported HTTP method ${JSON.stringify(method.toUpperCase())}. Supported in v1: GET, POST, PUT, PATCH, DELETE.`);
+        }
+        return createSupportedOperation(metadata, command);
+    }
+    catch (error) {
+        return {
+            ...metadata,
+            status: "unsupported",
+            reason: error instanceof Error ? error.message : String(error)
+        };
+    }
+}
+function createSupportedOperation(metadata, command) {
+    return {
+        ...metadata,
+        status: "supported",
+        commandPath: `${command.noun} ${command.verb}`
+    };
+}
+function readOperationMetadata(path, method, operation) {
+    const operationObject = isObject(operation) ? operation : {};
+    const operationId = typeof operationObject.operationId === "string"
+        ? operationObject.operationId
+        : `${method.toUpperCase()} ${path}`;
+    const summary = typeof operationObject.summary === "string"
+        ? operationObject.summary
+        : typeof operationObject.description === "string"
+            ? operationObject.description
+            : undefined;
+    return {
+        method: method.toUpperCase(),
+        path,
+        operationId,
+        ...(summary === undefined ? {} : { summary })
+    };
+}
+function markCommandPathCollisions(operations) {
+    const byCommandPath = new Map();
+    for (const operation of operations) {
+        if (operation.status !== "supported" || operation.commandPath === undefined) {
+            continue;
+        }
+        const collisions = byCommandPath.get(operation.commandPath) ?? [];
+        collisions.push(operation);
+        byCommandPath.set(operation.commandPath, collisions);
+    }
+    for (const collisions of byCommandPath.values()) {
+        if (collisions.length < 2) {
+            continue;
+        }
+        const existingPaths = new Set(operations
+            .filter((operation) => !collisions.includes(operation) && operation.commandPath !== undefined)
+            .map((operation) => operation.commandPath));
+        const operationIdCandidates = collisions.map((operation) => {
+            const noun = operation.commandPath?.split(" ")[0] ?? "";
+            return { operation, commandPath: `${noun} ${deriveDisambiguatedVerb(operation.operationId, noun)}` };
+        });
+        if (applyInspectionCommandPaths(operationIdCandidates, existingPaths)) {
+            continue;
+        }
+        const pathCandidates = collisions.map((operation) => {
+            const [noun = "", verb = ""] = operation.commandPath?.split(" ") ?? [];
+            const pathVerb = derivePathDisambiguatedVerb(operation.method.toLowerCase(), operation.path, noun, verb);
+            return { operation, commandPath: `${noun} ${pathVerb}` };
+        });
+        if (applyInspectionCommandPaths(pathCandidates, existingPaths)) {
+            continue;
+        }
+        if (applyInspectionCommandPaths(collisions.map((operation) => {
+            const [noun = "", verb = ""] = operation.commandPath?.split(" ") ?? [];
+            const pathVerb = derivePathDisambiguatedVerb(operation.method.toLowerCase(), operation.path, noun, verb, true);
+            return { operation, commandPath: `${noun} ${pathVerb}` };
+        }), existingPaths)) {
+            continue;
+        }
+        applyInspectionCommandPaths(collisions.map((operation) => {
+            const [noun = "", verb = ""] = operation.commandPath?.split(" ") ?? [];
+            const pathVerb = derivePathDisambiguatedVerb(operation.method.toLowerCase(), operation.path, noun, verb, true, true);
+            return { operation, commandPath: `${noun} ${pathVerb}` };
+        }), existingPaths);
+    }
+    const remainingByCommandPath = new Map();
+    for (const operation of operations) {
+        if (operation.status !== "supported" || operation.commandPath === undefined) {
+            continue;
+        }
+        remainingByCommandPath.set(operation.commandPath, [
+            ...(remainingByCommandPath.get(operation.commandPath) ?? []),
+            operation
+        ]);
+    }
+    for (const [commandPath, collisions] of remainingByCommandPath) {
+        if (collisions.length < 2) {
+            continue;
+        }
+        const reason = `Generated command path ${JSON.stringify(commandPath)} is defined more than once (${collisions.map((operation) => JSON.stringify(operation.operationId)).join(" and ")}).`;
+        for (const operation of collisions) {
+            operation.status = "unsupported";
+            operation.reason = reason;
+        }
+    }
+}
+function applyInspectionCommandPaths(candidates, existingPaths) {
+    const candidatePaths = candidates.map(({ commandPath }) => commandPath);
+    if (candidates.some(({ commandPath }) => commandPath.endsWith(" ")) ||
+        new Set(candidatePaths).size !== candidates.length ||
+        candidatePaths.some((commandPath) => existingPaths.has(commandPath))) {
+        return false;
+    }
+    for (const { operation, commandPath } of candidates) {
+        operation.commandPath = commandPath;
+    }
+    return true;
+}
+function isObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}

package/dist/interpreter.js

@@ -16,6 +16,10 @@ const VALUE_REFERENCE_OPERATIONS = {
     }
 };
 const VALUE_EXPRESSION_OPERATIONS = {
+    emptyObject: {
+        render: (_value) => "{}",
+        evaluate: (_value) => ({})
+    },
     reference: {
         render: (value) => renderValueReference(value.reference),
         evaluate: (value, context) => evaluateValueReference(value.reference, context)
@@ -270,13 +274,13 @@ function evaluateValueExpression(value, context) {
     return VALUE_EXPRESSION_OPERATIONS[value.kind].evaluate(value, context);
 }
 function renderSerializedQueryArray(reference, serialization) {
-    if (serialization === "repeat") {
+    if (serialization === "repeat" || serialization === "brackets") {
         return reference;
     }
     return `${reference} === undefined || ${reference} === null ? ${reference} : ${reference}.join(${JSON.stringify(QUERY_ARRAY_SERIALIZATION_SEPARATORS[serialization])})`;
 }
 function serializeQueryArrayValue(value, serialization) {
-    if (serialization === "repeat" || value === undefined || value === null) {
+    if (serialization === "repeat" || serialization === "brackets" || value === undefined || value === null) {
         return value;
     }
     return Array.isArray(value) ? value.join(QUERY_ARRAY_SERIALIZATION_SEPARATORS[serialization]) : value;

package/dist/mock/fetch.js

@@ -1,8 +1,9 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import { UserError } from "toolcraft";
+import { hasOwnErrorCode } from "../error-codes.js";
 import { parseOpenApiDocument, readOpenApiSourceText } from "../spec-source.js";
-const HTTP_METHOD_NAMES = ["get", "post", "put", "patch", "delete"];
+const HTTP_METHOD_NAMES = ["get", "post", "put", "patch", "delete", "head", "options"];
 export async function mockFetch(options) {
     const document = await resolveSpec(options);
     const operations = compileOperations(document);
@@ -15,7 +16,7 @@ export async function mockFetch(options) {
         const method = (init?.method ?? getRequestMethod(input) ?? "GET").toUpperCase();
         const headers = collectHeaders(input, init);
         const bodyText = await readRequestBody(input, init);
-        const parsedBody = parseJsonOrUndefined(bodyText);
+        const parsedBody = parseRequestBody(bodyText, headers["content-type"]);
         const matchingPath = operations.filter((op) => op.pathRegex.test(requestUrl.pathname));
         if (matchingPath.length === 0) {
             throw new MockFetchError(`mockFetch: no operation in the spec matches ${method} ${requestUrl.pathname}.`);
@@ -223,7 +224,7 @@ function extractExample(response, document) {
     }
     if (media.examples !== undefined) {
         for (const value of Object.values(media.examples)) {
-            if (value !== undefined && "value" in value) {
+            if (value !== undefined && Object.prototype.hasOwnProperty.call(value, "value")) {
                 return value.value;
             }
         }
@@ -244,7 +245,7 @@ function pickJsonMediaType(content) {
         return undefined;
     }
     for (const [type, media] of Object.entries(content)) {
-        if (media !== undefined && /application\/json|\+json/i.test(type)) {
+        if (media !== undefined && (type === "*/*" || /application\/json|\+json/i.test(type))) {
             return media;
         }
     }
@@ -253,7 +254,7 @@ function pickJsonMediaType(content) {
 function isReference(value) {
     return (typeof value === "object" &&
         value !== null &&
-        "$ref" in value &&
+        Object.prototype.hasOwnProperty.call(value, "$ref") &&
         typeof value.$ref === "string");
 }
 function resolveReference(reference, document) {
@@ -270,6 +271,9 @@ function resolveReference(reference, document) {
         if (current === null || typeof current !== "object") {
             throw new UserError(`mockFetch: failed to resolve $ref ${JSON.stringify(ref)}.`);
         }
+        if (!Object.prototype.hasOwnProperty.call(current, segment)) {
+            throw new UserError(`mockFetch: failed to resolve $ref ${JSON.stringify(ref)}.`);
+        }
         current = current[segment];
     }
     if (current === undefined) {
@@ -394,6 +398,9 @@ function collectHeaders(input, init) {
     const requestHeaders = typeof input !== "string" && !(input instanceof URL) ? input.headers : undefined;
     appendHeaders(headers, requestHeaders);
     appendHeaders(headers, initHeaders);
+    if (init?.body instanceof FormData && headers["content-type"] === undefined) {
+        appendHeaders(headers, new Request("https://mock.invalid", { method: "POST", body: init.body }).headers);
+    }
     return headers;
 }
 function appendHeaders(target, source) {
@@ -433,10 +440,18 @@ async function readRequestBody(input, init) {
     }
     return undefined;
 }
-function parseJsonOrUndefined(text) {
+function parseRequestBody(text, contentType) {
     if (text === undefined || text.length === 0) {
         return undefined;
     }
+    if (contentType?.toLowerCase().includes("application/x-www-form-urlencoded") === true) {
+        const body = {};
+        for (const [key, value] of new URLSearchParams(text)) {
+            const existing = body[key];
+            body[key] = existing === undefined ? value : Array.isArray(existing) ? [...existing, value] : [existing, value];
+        }
+        return body;
+    }
     try {
         return JSON.parse(text);
     }
@@ -447,7 +462,12 @@ function parseJsonOrUndefined(text) {
 function buildResponse(fixture, defaultStatus) {
     const status = fixture.status ?? defaultStatus;
     const headers = new Headers(fixture.headers ?? { "content-type": "application/json" });
-    const body = fixture.body === undefined ? null : fixture.body === null ? null : JSON.stringify(fixture.body);
+    const contentType = headers.get("content-type")?.toLowerCase();
+    const body = fixture.body === undefined || fixture.body === null
+        ? null
+        : contentType?.includes("json") === true
+            ? JSON.stringify(fixture.body)
+            : String(fixture.body);
     return new Response(body, { status, headers });
 }
 function jsonResponse(status, body) {
@@ -507,9 +527,5 @@ function formatList(values) {
     return values.map((value) => JSON.stringify(value)).join(", ");
 }
 function isNotFoundError(error) {
-    if (typeof error !== "object" || error === null) {
-        return false;
-    }
-    const code = error.code;
-    return code === "ENOENT" || code === "ENOTDIR";
+    return hasOwnErrorCode(error, "ENOENT") || hasOwnErrorCode(error, "ENOTDIR");
 }

package/dist/mock/forgeyard.d.ts

@@ -0,0 +1,4 @@
+import type { OpenApiDocument } from "../generate.js";
+export declare const FORGEYARD_BASE_URL = "https://api.forgeyard.invalid";
+export declare const FORGEYARD_RESOURCES: readonly ["artifacts", "audits", "automations", "branches", "builds", "checks", "changes", "comments", "commits", "deployments", "discussions", "environments", "events", "files", "hooks", "identities", "integrations", "invitations", "jobs", "keys", "labels", "licenses", "members", "milestones", "notifications", "organizations", "packages", "pages", "permissions", "pipelines", "policies", "projects", "releases", "repositories", "reviews", "runners", "secrets", "sessions", "settings", "snapshots", "statuses", "tags", "teams", "templates", "tokens", "topics", "variables", "webhooks", "workflows", "workspaces", "approvals", "archives", "attestations", "billing-accounts", "codespaces", "dependencies", "exports", "imports", "mirrors", "rulesets", "security-alerts", "service-accounts", "signatures", "sponsors"];
+export declare function createForgeyardSpec(): OpenApiDocument;