OpenAPI 3.2 API Debugger & Request Runner

import { createClient } from "@powerduck/openapi-request";

// CreateClientOptions: { writeBack?, response? } — both optional
const client = createClient({
  writeBack: { strategy: "merge" },  // WriteBackOptions: strategy/keepExistingDescription/allowedStatusCodes
});

// Full SendOptions — all fields shown
const response = await client.send({
  spec: openApiDocument,                    // REQUIRED: OpenAPI 3.2 document
  target: { operationId: "getUserById" }, // REQUIRED: { operationId? } or { path?, method? }
  values: {                                  // RequestValues: path/query/header/cookie/querystring/body/contentType
    path: { id: "123" },
    query: { verbose: true },
    header: { "X-Request-Id": "abc-123" },
    body: { name: "John" },
    contentType: "application/json",
  },
  serverUrl: "https://api.example.com/v1",  // Override servers[0].url
  serverVariables: { host: "api", port: "443" },
  variables: { baseUrl: "https://api.example.com" }, // {{name}} env vars
  auth: { type: "bearer", token: "my-token" }, // AuthConfig: bearer/basic/apikey/none
  timeout: 30000,                           // Request timeout in ms
  maxResponseSize: 10 * 1024 * 1024,       // Max response body size (10 MB)
  writeBack: true,                        // Write response back into spec
  signal: abortController.signal,            // AbortSignal for cancellation
  onEvent: (event) => console.log(event.type), // Streaming event callback
});

console.log(result.response.status, result.response.body);

import { createDebugger } from "@powerduck/openapi-request";

// Create a scripted debugger for batch execution
const debugger = createDebugger();

// Send a single request (spec + target object required)
const result = await debugger.send({
  spec: openApiDocument,
  target: { method: "POST", path: "/users" },
  values: { body: { name: "John", email: "john@example.com" } },
});

// Batch replay multiple operations (target must be object)
const results = await debugger.sendMany(openApiDocument, [
  { target: { operationId: "getUser" } },
  { target: { operationId: "listUsers" } },
]);

console.log(result.response.status, results.length);

import { inferSchema, inferSchemaFromMany, mergeSchema, sampleFromSchema } from "@powerduck/openapi-request";

// Infer schema from a single response
const schema = inferSchema({
  id: 1, name: "John", email: "john@example.com",
  active: true, tags: ["admin", "user"],
});

// Infer from multiple responses and merge
const schemas = responses.map(r => inferSchema(r.body));
const merged = mergeSchema(schemas);

// Or use the convenience function
const inferred = inferSchemaFromMany(responses.map(r => r.body));

// Generate sample data from a schema
const sample = sampleFromSchema(schema);

import { writeBackResponse, toResponseObject } from "@powerduck/openapi-request";

// After making a request, write the response back to the OpenAPI spec
const result = await client.send({ spec: openApiDocument, target: { operationId: "getUser" } });

// Normalize result to OpenAPI response fragment: { statusCode, response }
const fragment = toResponseObject(result, {
  includeHeaders: true,
  includeBody: true,
});

// Write back to the operation in the spec (path + method required)
const updatedSpec = writeBackResponse(openApiDocument, "/users/{id}", "get", fragment, {
  strategy: "merge",
  overwriteExamples: true,
});