toolcraft-openapi 0.0.67 → 0.0.69

package/dist/generate.js

@@ -20,19 +20,6 @@ const NULL_HELPER_SUPPORT = {
     // keeps null-helper flags body-only until a real query-null convention lands.
     query: { array: false, scalar: false }
 };
-const TRANSPORT_PARAMS = [
-    {
-        paramName: "verbose",
-        sourceName: "verbose",
-        location: "transport",
-        description: "Log the request line to stderr.",
-        shortFlag: "v",
-        scope: ["cli", "sdk"],
-        global: true,
-        optional: true,
-        definition: { kind: "boolean" }
-    }
-];
 const BINARY_OUTPUT_PARAM = {
     paramName: "output",
     sourceName: "output",
@@ -347,7 +334,7 @@ function resolveOperationBaseUrl(operation, operationId) {
     }
 }
 function collectParams(document, entry, operation, operationId, auth, responseMode) {
-    const transportParams = responseMode === "binary" ? [...TRANSPORT_PARAMS, BINARY_OUTPUT_PARAM] : TRANSPORT_PARAMS;
+    const transportParams = responseMode === "binary" ? [BINARY_OUTPUT_PARAM] : [];
     const operationParams = collectOperationParameters(document, entry.path, entry.pathItem.parameters ?? [], operation.parameters ?? [], operationId, auth);
     const requestBodyParams = collectRequestBodyParams(document, operation, operationId, entry.method);
     const qualifiedRequestBodyParams = qualifyBodyParamCollisions(requestBodyParams, new Set([...operationParams.params, ...transportParams].map((param) => param.paramName)));
@@ -1550,8 +1537,8 @@ function createCommandFile(options) {
         ? "  }, { additionalProperties: false }),"
         : "  }),");
     lines.push(usesRequestShapeVariable
-        ? "  handler: async ({ params, baseUrl, tokenSource, fetch, fs, env }) => {"
-        : "  handler: async ({ params, baseUrl, tokenSource, fetch }) => {");
+        ? "  handler: async ({ params, baseUrl, tokenSource, fetch, fs, env, diagnostics }) => {"
+        : "  handler: async ({ params, baseUrl, tokenSource, fetch, diagnostics }) => {");
     lines.push(...options.preflightBlocks.flatMap((block) => renderPreflightBlock(block)));
     if (usesRequestShapeVariable) {
         lines.push("    const requestShape = {");
@@ -1605,7 +1592,7 @@ function createCommandFile(options) {
     }
     lines.push("      tokenSource,");
     lines.push("      fetch,");
-    lines.push("      verbose: params.verbose,");
+    lines.push("      diagnostics,");
     if (options.rawResponse === true) {
         lines.push("      rawResponse: params.rawResponse,");
     }

package/dist/http.d.ts

@@ -1,4 +1,4 @@
-import { HttpError, type HandlerEnv, type HandlerFs, type HttpErrorRequest, type HttpErrorResponse } from "toolcraft";
+import { HttpError, type HandlerEnv, type HandlerFs, type HttpErrorRequest, type HttpErrorResponse, type RuntimeLogger } from "toolcraft";
 import type { TokenSource } from "./auth/types.js";
 export { HttpError };
 export type { HttpErrorRequest, HttpErrorResponse };
@@ -24,7 +24,7 @@ export interface HttpRequestOptions {
     multipartBinaryFields?: readonly string[];
     responseMode?: "json" | "text" | "binary";
     accept?: string;
-    verbose?: boolean;
+    diagnostics?: RuntimeLogger;
     signal?: AbortSignal;
     rawResponse?: boolean;
     retries?: {
@@ -40,7 +40,6 @@ export interface HttpRequestOptions {
         key?: string;
         createKey?: () => string;
     };
-    writeStderr?: (chunk: string) => void;
 }
 export interface BinaryHttpResponse {
     contentType: string;

package/dist/http.js

@@ -28,10 +28,8 @@ export async function requestJson(options) {
         }
         : {};
     const headers = createHeaders(token, hasBody, { ...options.headers, ...idempotencyHeader }, options.accept, options.bodyMode, options.contentType);
-    const writeStderr = options.writeStderr ?? process.stderr.write.bind(process.stderr);
-    if (options.verbose) {
-        writeStderr(formatTranscriptLines(formatVerboseRequestTranscript(method, url, headers, options.body)));
-    }
+    emitHttpDebug(options, `${method} ${url}`, { method, url });
+    emitHttpTrace(options, "HTTP request transcript", formatVerboseRequestTranscript(method, url, headers, options.body));
     const response = await fetchWithRetries(options, url, {
         method,
         headers,
@@ -44,9 +42,7 @@ export async function requestJson(options) {
     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)));
-            }
+            emitHttpTrace(options, "HTTP response transcript", formatVerboseResponseTranscript(response, responseHeaders));
             return formatRawResponseResult(undefined, response, options.rawResponse);
         }
         const body = {
@@ -55,29 +51,20 @@ export async function requestJson(options) {
             byteLength: bytes.byteLength,
             data: Buffer.from(bytes).toString("base64")
         };
-        if (options.verbose) {
-            writeStderr(formatTranscriptLines(formatVerboseResponseTranscript(response, responseHeaders, body)));
-        }
+        emitHttpTrace(options, "HTTP response transcript", formatVerboseResponseTranscript(response, responseHeaders, body));
         return formatRawResponseResult(body, response, options.rawResponse);
     }
     const text = await response.text();
     if (response.ok) {
         if (text.length === 0) {
-            if (options.verbose) {
-                writeStderr(formatTranscriptLines(formatVerboseResponseTranscript(response, responseHeaders)));
-            }
+            emitHttpTrace(options, "HTTP response transcript", formatVerboseResponseTranscript(response, responseHeaders));
             return formatRawResponseResult(undefined, response, options.rawResponse);
         }
         if (options.responseMode === "text") {
-            if (options.verbose) {
-                writeStderr(formatTranscriptLines(formatVerboseResponseTranscript(response, responseHeaders, text)));
-            }
+            emitHttpTrace(options, "HTTP response transcript", formatVerboseResponseTranscript(response, responseHeaders, text));
             return formatRawResponseResult(text, response, options.rawResponse);
         }
         if (!isJsonContentType(contentType)) {
-            if (options.verbose) {
-                writeStderr(formatTranscriptLines(formatVerboseResponseTranscript(response, responseHeaders, text)));
-            }
             throw createHttpError({
                 request,
                 response: {
@@ -94,9 +81,6 @@ export async function requestJson(options) {
             body = JSON.parse(text);
         }
         catch {
-            if (options.verbose) {
-                writeStderr(formatTranscriptLines(formatVerboseResponseTranscript(response, responseHeaders, text)));
-            }
             throw createHttpError({
                 request,
                 response: {
@@ -108,18 +92,13 @@ export async function requestJson(options) {
                 message: "Expected a valid JSON response body but received malformed JSON."
             });
         }
-        if (options.verbose) {
-            writeStderr(formatTranscriptLines(formatVerboseResponseTranscript(response, responseHeaders, body)));
-        }
+        emitHttpTrace(options, "HTTP response transcript", formatVerboseResponseTranscript(response, responseHeaders, body));
         return formatRawResponseResult(body, response, options.rawResponse);
     }
     if (response.status === 401 && options.auth === "required") {
         await options.tokenSource.invalidate?.(token).catch(() => undefined);
     }
     const body = parseResponseBody(text, contentType);
-    if (options.verbose) {
-        writeStderr(formatTranscriptLines(formatVerboseResponseTranscript(response, responseHeaders, body)));
-    }
     throw createHttpError({
         request,
         response: {
@@ -145,6 +124,10 @@ async function fetchWithRetries(options, url, init) {
                 !shouldRetryStatus(response.status, retries.retryOn)) {
                 return response;
             }
+            emitHttpDebug(options, `Retrying ${String(init.method ?? "GET")} ${url}`, {
+                attempt: attempt + 1,
+                status: response.status
+            });
             await sleepBeforeRetry(response, retries, attempt);
             attempt += 1;
         }
@@ -153,11 +136,33 @@ async function fetchWithRetries(options, url, init) {
             if (attempt >= maxRetries || retries === undefined) {
                 throw classified;
             }
+            emitHttpDebug(options, `Retrying ${String(init.method ?? "GET")} ${url}`, {
+                attempt: attempt + 1,
+                error: classified instanceof Error ? classified.message : String(classified)
+            });
             await sleepBeforeRetry(undefined, retries, attempt);
             attempt += 1;
         }
     }
 }
+function emitHttpDebug(options, message, data) {
+    options.diagnostics?.emit({
+        level: "debug",
+        message,
+        category: "http",
+        data
+    });
+}
+function emitHttpTrace(options, message, lines) {
+    options.diagnostics?.emit({
+        level: "trace",
+        message,
+        category: "http",
+        data: {
+            transcript: formatTranscriptLines(lines)
+        }
+    });
+}
 function shouldRetryStatus(status, retryOn) {
     return retryOn?.includes(status) === true;
 }

package/dist/runtime.js

@@ -68,7 +68,7 @@ function createRuntimeCommand(command) {
     });
 }
 function createRuntimeHandler(command) {
-    return async ({ params, baseUrl, tokenSource, fetch, fs, env }) => {
+    return async ({ params, baseUrl, tokenSource, fetch, fs, env, diagnostics }) => {
         const resolvedValues = executePreflightBlocks(command.preflightBlocks, params);
         const requestShape = buildRequestShape(command.requestFields, command.sectionRenders, command.optionalSections, params, resolvedValues);
         const preparedRequestShape = await prepareMultipartFileInputs(requestShape, {
@@ -89,7 +89,7 @@ function createRuntimeHandler(command) {
             multipartBinaryFields: command.multipartBinaryFields,
             tokenSource,
             fetch,
-            verbose: params.verbose,
+            diagnostics,
             ...preparedRequestShape
         });
         return writeBinaryResponseOutput(result, command.responseMode === "binary" ? params.output : undefined, { fs, env });
@@ -108,10 +108,10 @@ const RUNTIME_DEFINITION_BUILDERS = {
         const itemDefinition = createRuntimeDefinition(definition.itemDefinition, undefined, undefined, undefined);
         return options === undefined ? S.Array(itemDefinition) : S.Array(itemDefinition, options);
     },
-    boolean: (_definition, options) => options === undefined ? S.Boolean() : S.Boolean(options),
+    boolean: (_definition, options) => (options === undefined ? S.Boolean() : S.Boolean(options)),
     enum: (definition, options) => options === undefined ? S.Enum(definition.enumValues) : S.Enum(definition.enumValues, options),
     json: (_definition) => S.Json(),
-    number: (_definition, options) => options === undefined ? S.Number() : S.Number(options),
+    number: (_definition, options) => (options === undefined ? S.Number() : S.Number(options)),
     object: (definition, options) => {
         const shape = Object.fromEntries(definition.properties.map((property) => {
             const propertySchema = createRuntimeDefinition(property.definition, undefined, undefined, undefined);
@@ -119,7 +119,7 @@ const RUNTIME_DEFINITION_BUILDERS = {
         }));
         return options === undefined ? S.Object(shape) : S.Object(shape, options);
     },
-    string: (_definition, options) => options === undefined ? S.String() : S.String(options)
+    string: (_definition, options) => (options === undefined ? S.String() : S.String(options))
 };
 function createRuntimeSchemaOptions(definition, description, shortFlag, scope, global) {
     const options = Object.fromEntries(collectSchemaOptionEntries({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolcraft-openapi",
-  "version": "0.0.67",
+  "version": "0.0.69",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -28,7 +28,7 @@
     "toolcraft-openapi-generate": "dist/bin/generate.js"
   },
   "dependencies": {
-    "toolcraft": "0.0.67",
+    "toolcraft": "0.0.69",
     "auth-store": "^0.0.1",
     "fast-string-width": "^3.0.2",
     "fast-wrap-ansi": "^0.2.0",