@tahanabavi/typefetch 1.5.6 → 1.6.0

package/dist/index.mjs

@@ -1,13 +1,17 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
 // src/client.ts
 import { z } from "zod";
 var RichError = class extends Error {
-  status;
-  code;
-  title;
-  detail;
-  errors;
   constructor(error) {
     super(error.message);
+    __publicField(this, "status");
+    __publicField(this, "code");
+    __publicField(this, "title");
+    __publicField(this, "detail");
+    __publicField(this, "errors");
     Object.assign(this, error);
   }
 };
@@ -20,23 +24,21 @@ var REQUEST_PART_KEYS = /* @__PURE__ */ new Set([
 ]);
 var ApiClient = class {
   constructor(config, contracts) {
-    this.config = config;
-    this.contracts = contracts;
+    __publicField(this, "config", config);
+    __publicField(this, "contracts", contracts);
+    __publicField(this, "middlewares", []);
+    __publicField(this, "errorHandler");
+    __publicField(this, "responseTransform", (d) => d);
+    __publicField(this, "useMockData", false);
+    __publicField(this, "mockDelay", { min: 100, max: 1e3 });
+    __publicField(this, "responseWrapper");
+    __publicField(this, "tokenProvider");
+    __publicField(this, "retryConfig");
+    __publicField(this, "_modules");
     this.useMockData = config.useMockData || false;
     this.mockDelay = config.mockDelay || { min: 100, max: 1e3 };
     this.tokenProvider = config.tokenProvider;
   }
-  config;
-  contracts;
-  middlewares = [];
-  errorHandler;
-  responseTransform = (d) => d;
-  useMockData = false;
-  mockDelay = { min: 100, max: 1e3 };
-  responseWrapper;
-  tokenProvider;
-  retryConfig;
-  _modules;
   init() {
     const modules = {};
     for (const moduleName in this.contracts) {
@@ -265,17 +267,22 @@ var ApiClient = class {
   isObjectRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
   }
-  applyPathParams(url, pathParams) {
-    return url.replace(/:([A-Za-z0-9_]+)/g, (_, key) => {
-      const value = pathParams?.[key];
-      if (value === void 0 || value === null) {
-        throw this.createError({
-          message: `Missing path param "${key}"`,
-          code: "MISSING_PATH_PARAM"
-        });
+  applyPathParams(fullUrl, pathParams) {
+    const url = new URL(fullUrl);
+    const replacedPathname = url.pathname.replace(
+      /:([A-Za-z0-9_]+)/g,
+      (_, key) => {
+        const value = pathParams?.[key];
+        if (value === void 0 || value === null) {
+          throw this.createError({
+            message: `Missing path param "${key}"`,
+            code: "MISSING_PATH_PARAM"
+          });
+        }
+        return encodeURIComponent(String(value));
       }
-      return encodeURIComponent(String(value));
-    });
+    );
+    return `${url.origin}${replacedPathname}${url.search}${url.hash}`;
   }
   appendQueryParams(url, query) {
     if (!query) return url;
@@ -691,12 +698,698 @@ var makeRequestSchema = () => (defs = {}) => {
     headers: headersSchema
   });
 };
+
+// src/modules/tester/context.ts
+var TypeFetchTestContext = class {
+  constructor(initialData = {}) {
+    __publicField(this, "data");
+    this.data = { ...initialData };
+  }
+  get(key) {
+    return this.data[key];
+  }
+  set(key, value) {
+    this.data[key] = value;
+  }
+  has(key) {
+    return Object.prototype.hasOwnProperty.call(this.data, key);
+  }
+};
+
+// src/modules/tester/generate-input.ts
+var DEFAULT_MAX_DEPTH = 5;
+function generateInput(schema, options = {}) {
+  return generateValue(schema, options, [], 0);
+}
+function generateValue(schema, options, path, depth) {
+  const override = resolveOverride(options, path);
+  if (override.exists) return override.value;
+  const maxDepth = options.maxDepth ?? DEFAULT_MAX_DEPTH;
+  if (depth > maxDepth) return null;
+  const kind = getKind(schema);
+  const def = getDef(schema);
+  switch (kind) {
+    case "optional":
+      if (options.includeOptional === false) return void 0;
+      return generateValue(getInnerType(schema, def), options, path, depth + 1);
+    case "nullable":
+      return generateValue(getInnerType(schema, def), options, path, depth + 1);
+    case "default":
+      return getDefaultValue(def) ?? generateValue(getInnerType(schema, def), options, path, depth + 1);
+    case "catch":
+    case "readonly":
+    case "branded":
+    case "promise":
+      return generateValue(getInnerType(schema, def), options, path, depth + 1);
+    case "effects":
+    case "pipeline":
+    case "pipe":
+      return generateValue(
+        def.schema ?? def.in ?? def.out,
+        options,
+        path,
+        depth + 1
+      );
+    case "object":
+      return generateObject(schema, options, path, depth);
+    case "array": {
+      if (options.includeArrayItems === false) return [];
+      const itemSchema = def.type ?? def.element ?? def.innerType;
+      return itemSchema ? [generateValue(itemSchema, options, path.concat("0"), depth + 1)] : [];
+    }
+    case "tuple": {
+      const items = def.items ?? [];
+      return items.map(
+        (item, index) => generateValue(item, options, path.concat(String(index)), depth + 1)
+      );
+    }
+    case "record": {
+      const valueType = def.valueType ?? def.valueSchema ?? def.value;
+      return {
+        key: valueType ? generateValue(valueType, options, path.concat("key"), depth + 1) : "value"
+      };
+    }
+    case "union": {
+      const optionsList = def.options ?? [];
+      return optionsList.length ? generateValue(optionsList[0], options, path, depth + 1) : null;
+    }
+    case "discriminatedunion":
+    case "discriminated_union": {
+      const optionsMap = def.optionsMap;
+      const first = optionsMap?.values().next().value ?? def.options?.[0];
+      return first ? generateValue(first, options, path, depth + 1) : null;
+    }
+    case "intersection": {
+      const left = generateValue(def.left, options, path, depth + 1);
+      const right = generateValue(def.right, options, path, depth + 1);
+      if (isObject(left) && isObject(right)) return { ...left, ...right };
+      return right ?? left;
+    }
+    case "literal": {
+      const values = def.values ?? ("value" in def ? [def.value] : void 0);
+      return Array.isArray(values) ? values[0] : values?.values?.().next?.().value;
+    }
+    case "enum":
+    case "nativeenum":
+    case "native_enum": {
+      const values = getEnumValues(schema, def);
+      return values[0] ?? "value";
+    }
+    case "string":
+      return generateString(path, def, options);
+    case "number":
+      return generateNumber(def);
+    case "bigint":
+      return BigInt(1);
+    case "boolean":
+      return true;
+    case "date":
+      return /* @__PURE__ */ new Date("2026-01-01T00:00:00.000Z");
+    case "null":
+      return null;
+    case "undefined":
+    case "void":
+      return void 0;
+    case "nan":
+      return Number.NaN;
+    case "any":
+    case "unknown":
+      return guessByPath(path, options);
+    case "never":
+      throw new Error(
+        `Cannot generate input for never schema at ${path.join(".") || "root"}`
+      );
+    default:
+      return guessByPath(path, options);
+  }
+}
+function generateObject(schema, options, path, depth) {
+  const shape = getShape(schema);
+  const output = {};
+  for (const [key, childSchema] of Object.entries(shape)) {
+    const value = generateValue(
+      childSchema,
+      options,
+      path.concat(key),
+      depth + 1
+    );
+    if (value !== void 0 || options.includeOptional !== false)
+      output[key] = value;
+  }
+  return output;
+}
+function generateString(path, def, options) {
+  const key = path[path.length - 1]?.toLowerCase() ?? "";
+  const fullPath = path.join(".").toLowerCase();
+  const minLength = getStringMinLength(def);
+  const ensureMinLength = (value) => minLength && value.length < minLength ? value.padEnd(minLength, "x") : value;
+  if (isFileField(key, fullPath))
+    return options.fileFactory?.() ?? defaultFileValue();
+  if (key.includes("email")) {
+    const base = "test@example.com";
+    if (!minLength || base.length >= minLength) return base;
+    return `test${"x".repeat(minLength - base.length)}@example.com`;
+  }
+  if (key.includes("url") || key.includes("website")) {
+    const base = "https://example.com";
+    if (!minLength || base.length >= minLength) return base;
+    return `${base}/${"x".repeat(minLength - base.length)}`;
+  }
+  if (key === "uuid" || key.endsWith("uuid")) {
+    return "550e8400-e29b-41d4-a716-446655440000";
+  }
+  if (key === "id" || key.endsWith("id") || fullPath.endsWith(".path.id")) {
+    return ensureMinLength("1");
+  }
+  if (key.includes("phone")) return ensureMinLength("+10000000000");
+  if (key.includes("name")) return ensureMinLength("Test Name");
+  if (key.includes("password")) return ensureMinLength("StrongPass123!");
+  if (key.includes("token")) return ensureMinLength("test-token");
+  return ensureMinLength("test-string");
+}
+function generateNumber(def) {
+  const min = getNumberMin(def);
+  if (typeof min === "number") return min;
+  return 1;
+}
+function guessByPath(path, options) {
+  const key = path[path.length - 1]?.toLowerCase() ?? "";
+  const fullPath = path.join(".").toLowerCase();
+  if (isFileField(key, fullPath))
+    return options.fileFactory?.() ?? defaultFileValue();
+  if (key.includes("count") || key.includes("page") || key.includes("limit"))
+    return 1;
+  if (key.startsWith("is") || key.startsWith("has") || key.includes("active"))
+    return true;
+  return "test-value";
+}
+function resolveOverride(options, path) {
+  const values = options.values ?? {};
+  const candidates = [
+    path.join("."),
+    path.slice(-2).join("."),
+    path[path.length - 1] ?? ""
+  ];
+  for (const key of candidates) {
+    if (key && Object.prototype.hasOwnProperty.call(values, key)) {
+      const raw = values[key];
+      return {
+        exists: true,
+        value: typeof raw === "function" ? raw(path.join(".")) : raw
+      };
+    }
+  }
+  return { exists: false, value: void 0 };
+}
+function getDef(schema) {
+  return schema._def ?? schema.def ?? {};
+}
+function getKind(schema) {
+  const def = getDef(schema);
+  const raw = def.typeName ?? def.type ?? schema.constructor?.name ?? "unknown";
+  return String(raw).replace(/^Zod/, "").replace(/-/g, "_").toLowerCase();
+}
+function getInnerType(schema, def = getDef(schema)) {
+  return schema.unwrap?.() ?? def.innerType ?? def.schema ?? def.type;
+}
+function getShape(schema) {
+  const def = getDef(schema);
+  const shape = schema.shape ?? def.shape;
+  return typeof shape === "function" ? shape() : shape ?? {};
+}
+function getDefaultValue(def) {
+  const value = def.defaultValue;
+  return typeof value === "function" ? value() : value;
+}
+function getEnumValues(schema, def) {
+  if (Array.isArray(schema.options)) return schema.options;
+  if (Array.isArray(def.values)) return def.values;
+  if (def.entries && typeof def.entries === "object")
+    return Object.values(def.entries);
+  if (def.values && typeof def.values === "object")
+    return Object.values(def.values);
+  return [];
+}
+function getStringMinLength(def) {
+  for (const check of def.checks ?? []) {
+    const c = check?._zod?.def ?? check;
+    if ((c.kind === "min" || c.check === "min_length" || c.type === "min") && typeof c.value === "number")
+      return c.value;
+    if (typeof c.minimum === "number") return c.minimum;
+  }
+  return void 0;
+}
+function getNumberMin(def) {
+  for (const check of def.checks ?? []) {
+    const c = check?._zod?.def ?? check;
+    if ((c.kind === "min" || c.check === "greater_than" || c.type === "min") && typeof c.value === "number")
+      return c.value;
+    if (typeof c.minimum === "number") return c.minimum;
+  }
+  return void 0;
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isFileField(key, fullPath) {
+  return key === "file" || key.endsWith("file") || key.includes("avatar") || fullPath.includes("formdata");
+}
+function defaultFileValue() {
+  if (typeof Blob !== "undefined") {
+    return new Blob(["typefetch-test-file"], { type: "text/plain" });
+  }
+  return "typefetch-test-file";
+}
+
+// src/modules/tester/reporter.ts
+function createMarkdownReport(report) {
+  const lines = [];
+  lines.push("# TypeFetch API Test Report");
+  lines.push("");
+  lines.push(`Generated at: ${report.generatedAt}`);
+  lines.push(`Mode: ${report.mode}`);
+  lines.push("");
+  lines.push("## Summary");
+  lines.push("");
+  lines.push("| Total | Passed | Failed | Skipped | Duration |");
+  lines.push("|---:|---:|---:|---:|---:|");
+  lines.push(
+    `| ${report.summary.total} | ${report.summary.passed} | ${report.summary.failed} | ${report.summary.skipped} | ${formatMs(report.summary.durationMs)} |`
+  );
+  lines.push("");
+  const failed = report.results.filter((item) => item.status === "failed");
+  if (failed.length) {
+    lines.push("## Failed Endpoints");
+    lines.push("");
+    for (const item of failed) {
+      lines.push(`### ${item.module}.${item.endpoint} \u2014 ${item.caseName}`);
+      lines.push("");
+      lines.push(`- Phase: ${item.phase}`);
+      lines.push(`- Method: ${item.method}`);
+      lines.push(`- Path: ${item.path}`);
+      lines.push(`- Duration: ${formatMs(item.durationMs)}`);
+      if (item.error?.status) lines.push(`- HTTP Status: ${item.error.status}`);
+      if (item.error?.code) lines.push(`- Code: ${item.error.code}`);
+      lines.push(`- Error: ${escapeMarkdown(item.error?.message ?? "Unknown error")}`);
+      if (item.error?.issues) {
+        lines.push("");
+        lines.push("```json");
+        lines.push(JSON.stringify(item.error.issues, null, 2));
+        lines.push("```");
+      }
+      lines.push("");
+    }
+  }
+  lines.push("## All Results");
+  lines.push("");
+  lines.push("| Status | Endpoint | Case | Phase | Method | Path | Duration |");
+  lines.push("|---|---|---|---|---|---|---:|");
+  for (const item of report.results) {
+    lines.push(
+      `| ${item.status} | ${item.module}.${item.endpoint} | ${escapeTable(item.caseName)} | ${item.phase} | ${item.method} | ${escapeTable(item.path)} | ${formatMs(item.durationMs)} |`
+    );
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function createHtmlReport(report) {
+  const rows = report.results.map(
+    (item) => `
+        <tr class="${item.status}">
+          <td>${escapeHtml(item.status)}</td>
+          <td>${escapeHtml(`${item.module}.${item.endpoint}`)}</td>
+          <td>${escapeHtml(item.caseName)}</td>
+          <td>${escapeHtml(item.phase)}</td>
+          <td>${escapeHtml(item.method)}</td>
+          <td>${escapeHtml(item.path)}</td>
+          <td>${formatMs(item.durationMs)}</td>
+          <td>${escapeHtml(item.error?.message ?? "")}</td>
+        </tr>`
+  ).join("\n");
+  return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>TypeFetch API Test Report</title>
+  <style>
+    body { font-family: Inter, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; margin: 32px; background: #0f1115; color: #f4f4f5; }
+    .cards { display: flex; gap: 12px; flex-wrap: wrap; margin: 24px 0; }
+    .card { background: #181b22; border: 1px solid #2a2f3a; border-radius: 14px; padding: 16px 18px; min-width: 120px; }
+    .card strong { display: block; font-size: 24px; margin-top: 6px; }
+    table { width: 100%; border-collapse: collapse; background: #181b22; border-radius: 14px; overflow: hidden; }
+    th, td { padding: 11px 12px; border-bottom: 1px solid #2a2f3a; text-align: left; vertical-align: top; }
+    th { color: #a1a1aa; font-size: 13px; }
+    tr.passed td:first-child { color: #34d399; }
+    tr.failed td:first-child { color: #fb7185; }
+    tr.skipped td:first-child { color: #fbbf24; }
+    code { background: #272b35; padding: 2px 5px; border-radius: 6px; }
+  </style>
+</head>
+<body>
+  <h1>TypeFetch API Test Report</h1>
+  <p>Generated at: <code>${escapeHtml(report.generatedAt)}</code> \xB7 Mode: <code>${escapeHtml(report.mode)}</code></p>
+  <section class="cards">
+    <div class="card">Total<strong>${report.summary.total}</strong></div>
+    <div class="card">Passed<strong>${report.summary.passed}</strong></div>
+    <div class="card">Failed<strong>${report.summary.failed}</strong></div>
+    <div class="card">Skipped<strong>${report.summary.skipped}</strong></div>
+    <div class="card">Duration<strong>${formatMs(report.summary.durationMs)}</strong></div>
+  </section>
+  <table>
+    <thead>
+      <tr><th>Status</th><th>Endpoint</th><th>Case</th><th>Phase</th><th>Method</th><th>Path</th><th>Duration</th><th>Error</th></tr>
+    </thead>
+    <tbody>${rows}</tbody>
+  </table>
+</body>
+</html>`;
+}
+function formatMs(ms) {
+  return ms < 1e3 ? `${ms}ms` : `${(ms / 1e3).toFixed(2)}s`;
+}
+function escapeTable(value) {
+  return value.replace(/\|/g, "\\|");
+}
+function escapeMarkdown(value) {
+  return value.replace(/`/g, "\\`");
+}
+function escapeHtml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+}
+
+// src/modules/tester/runner.ts
+import { z as z3 } from "zod";
+var DEFAULT_OPTIONS = {
+  mode: "live",
+  timeout: 1e4,
+  concurrency: 1,
+  stopOnFail: false,
+  includeDestructive: false
+};
+function createApiTestRunner(config) {
+  return new ApiTestRunner(config);
+}
+var ApiTestRunner = class {
+  constructor(config) {
+    __publicField(this, "config", config);
+    __publicField(this, "ctx");
+    __publicField(this, "options");
+    this.ctx = new TypeFetchTestContext(config.context);
+    this.options = {
+      ...DEFAULT_OPTIONS,
+      ...config.options ?? {}
+    };
+  }
+  async run() {
+    const startedAt = Date.now();
+    const endpoints = this.discoverEndpoints();
+    const results = [];
+    for (const item of endpoints) {
+      const endpointResults = await this.runEndpoint(item);
+      results.push(...endpointResults);
+      if (this.options.stopOnFail && endpointResults.some((result) => result.status === "failed")) {
+        break;
+      }
+    }
+    const durationMs = Date.now() - startedAt;
+    return {
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      mode: this.options.mode,
+      summary: {
+        total: results.length,
+        passed: results.filter((item) => item.status === "passed").length,
+        failed: results.filter((item) => item.status === "failed").length,
+        skipped: results.filter((item) => item.status === "skipped").length,
+        durationMs
+      },
+      results
+    };
+  }
+  discoverEndpoints() {
+    const endpoints = [];
+    for (const moduleName of Object.keys(this.config.contracts)) {
+      const module = this.config.contracts[moduleName];
+      for (const endpointName of Object.keys(module)) {
+        endpoints.push({
+          moduleName,
+          endpointName,
+          endpoint: module[endpointName]
+        });
+      }
+    }
+    return endpoints;
+  }
+  async runEndpoint(item) {
+    const { endpoint } = item;
+    const testConfig = endpoint.test;
+    const tags = [...testConfig?.tags ?? []];
+    const destructive = Boolean(testConfig?.destructive);
+    const baseMeta = {
+      module: item.moduleName,
+      endpoint: item.endpointName,
+      method: endpoint.method,
+      path: endpoint.path,
+      tags,
+      destructive
+    };
+    const skipReason = this.getEndpointSkipReason(testConfig);
+    if (skipReason) {
+      return [
+        {
+          ...baseMeta,
+          caseName: "default",
+          phase: this.options.mode,
+          status: "skipped",
+          durationMs: 0,
+          skipReason
+        }
+      ];
+    }
+    try {
+      await testConfig?.setup?.(this.ctx);
+    } catch (error) {
+      return [
+        {
+          ...baseMeta,
+          caseName: "setup",
+          phase: this.options.mode,
+          status: "failed",
+          durationMs: 0,
+          error: normalizeError(error)
+        }
+      ];
+    }
+    const cases = this.getCases(endpoint, testConfig);
+    const results = [];
+    for (let index = 0; index < cases.length; index++) {
+      const testCase = cases[index];
+      const caseName = testCase.name ?? `case-${index + 1}`;
+      if (testCase.skip) {
+        results.push({
+          ...baseMeta,
+          caseName,
+          phase: this.options.mode,
+          status: "skipped",
+          durationMs: 0,
+          skipReason: typeof testCase.skip === "string" ? testCase.skip : "Case skipped"
+        });
+        continue;
+      }
+      const phases = this.getPhases(endpoint);
+      for (const phase of phases) {
+        const result = await this.runCasePhase(item, testCase, caseName, phase);
+        results.push(result);
+        if (this.options.stopOnFail && result.status === "failed") break;
+      }
+    }
+    try {
+      await testConfig?.teardown?.(this.ctx);
+    } catch (error) {
+      results.push({
+        ...baseMeta,
+        caseName: "teardown",
+        phase: this.options.mode,
+        status: "failed",
+        durationMs: 0,
+        error: normalizeError(error)
+      });
+    }
+    return results;
+  }
+  getEndpointSkipReason(testConfig) {
+    if (testConfig?.enabled === false) return "Endpoint tests disabled";
+    if (testConfig?.destructive && !this.options.includeDestructive) return "Destructive endpoint skipped";
+    const tags = testConfig?.tags ?? [];
+    if (this.options.includeTags?.length && !tags.some((tag) => this.options.includeTags.includes(tag))) {
+      return "Endpoint does not match includeTags";
+    }
+    if (this.options.excludeTags?.length && tags.some((tag) => this.options.excludeTags.includes(tag))) {
+      return "Endpoint matches excludeTags";
+    }
+    return void 0;
+  }
+  getCases(endpoint, testConfig) {
+    if (testConfig?.cases?.length) return testConfig.cases;
+    if (testConfig?.input) return [{ name: "default", input: testConfig.input }];
+    return [
+      {
+        name: "auto-generated",
+        input: generateInput(endpoint.request, this.options.autoInput)
+      }
+    ];
+  }
+  getPhases(endpoint) {
+    switch (this.options.mode) {
+      case "schema":
+        return ["schema"];
+      case "mock":
+        return ["mock"];
+      case "full":
+        return endpoint.mockData ? ["schema", "mock", "live"] : ["schema", "live"];
+      case "live":
+      default:
+        return ["live"];
+    }
+  }
+  async runCasePhase(item, testCase, caseName, phase) {
+    const { endpoint, moduleName, endpointName } = item;
+    const startedAt = Date.now();
+    let input;
+    const meta = {
+      module: moduleName,
+      endpoint: endpointName,
+      caseName,
+      phase,
+      method: endpoint.method,
+      path: endpoint.path,
+      tags: endpoint.test?.tags ?? [],
+      destructive: Boolean(endpoint.test?.destructive)
+    };
+    try {
+      input = await resolveInput(endpoint, testCase, this.ctx, this.options.autoInput);
+      const parsedInput = endpoint.request.parse(input);
+      if (phase === "schema") {
+        return {
+          ...meta,
+          status: "passed",
+          durationMs: Date.now() - startedAt,
+          input: parsedInput
+        };
+      }
+      if (phase === "mock") {
+        if (!endpoint.mockData) {
+          return {
+            ...meta,
+            status: "skipped",
+            durationMs: Date.now() - startedAt,
+            input: parsedInput,
+            skipReason: "No mockData configured for endpoint"
+          };
+        }
+        const mockResponse = typeof endpoint.mockData === "function" ? endpoint.mockData() : endpoint.mockData;
+        const parsedResponse = endpoint.response.parse(mockResponse);
+        await testCase.expect?.({ input: parsedInput, response: parsedResponse, ctx: this.ctx });
+        return {
+          ...meta,
+          status: "passed",
+          durationMs: Date.now() - startedAt,
+          input: parsedInput,
+          response: parsedResponse
+        };
+      }
+      const response = await this.callClient(moduleName, endpointName, parsedInput, testCase);
+      await testCase.expect?.({ input: parsedInput, response, ctx: this.ctx });
+      return {
+        ...meta,
+        status: "passed",
+        durationMs: Date.now() - startedAt,
+        input: parsedInput,
+        response
+      };
+    } catch (error) {
+      const normalized = normalizeError(error);
+      const expectedStatuses = toStatusList(testCase.expectStatus);
+      const expectedErrorStatus = normalized.status && expectedStatuses.includes(normalized.status);
+      if (expectedErrorStatus) {
+        return {
+          ...meta,
+          status: "passed",
+          durationMs: Date.now() - startedAt,
+          input,
+          error: normalized
+        };
+      }
+      return {
+        ...meta,
+        status: "failed",
+        durationMs: Date.now() - startedAt,
+        input,
+        error: normalized
+      };
+    }
+  }
+  async callClient(moduleName, endpointName, input, testCase) {
+    const fn = this.config.client.modules[moduleName]?.[endpointName];
+    if (!fn) throw new Error(`Client method not found: ${moduleName}.${endpointName}`);
+    const requestOptions = {
+      ...this.options.requestOptions ?? {},
+      timeout: testCase.timeout ?? this.options.timeout
+    };
+    return fn(input, requestOptions);
+  }
+};
+async function resolveInput(endpoint, testCase, ctx, autoInputOptions) {
+  if (typeof testCase.input === "function") return testCase.input(ctx);
+  if (testCase.input !== void 0) return testCase.input;
+  return generateInput(endpoint.request, autoInputOptions);
+}
+function normalizeError(error) {
+  if (error instanceof z3.ZodError) {
+    const zodError = error;
+    return {
+      name: zodError.name,
+      message: `Validation error: ${zodError.issues.map((issue) => issue.message).join(", ")}`,
+      code: "VALIDATION_ERROR",
+      issues: zodError.issues,
+      stack: zodError.stack
+    };
+  }
+  if (error instanceof Error) {
+    const anyError = error;
+    return {
+      name: error.name,
+      message: error.message,
+      status: anyError.status,
+      code: anyError.code,
+      issues: anyError.issues ?? anyError.errors,
+      stack: error.stack
+    };
+  }
+  return { message: String(error) };
+}
+function toStatusList(status) {
+  if (status === void 0) return [];
+  return Array.isArray(status) ? status : [status];
+}
+
+// src/cli/config.ts
+function defineTypeFetchTestConfig(config) {
+  return config;
+}
 export {
   ApiClient,
+  ApiTestRunner,
   RichError,
+  TypeFetchTestContext,
   authMiddleware,
   cacheMiddleware,
+  createApiTestRunner,
+  createHtmlReport,
+  createMarkdownReport,
+  defineTypeFetchTestConfig,
   encryptionMiddleware,
+  generateInput,
   loggingMiddleware,
   makeRequestSchema,
   processDeep,