@igniter-js/cli 0.4.93 → 0.4.95

package/README.md

@@ -1,14 +1,14 @@
-# @igniter-js/new-cli
+# @igniter-js/cli
 
 The official Igniter.js command-line interface for scaffolding projects, generating features, wiring add-ons, and keeping your API docs in sync. It is designed for a fast developer experience, type-safe defaults, and seamless automation.
 
 ## Highlights
 
-- 🚀 **Project bootstrapper** with interactive wizards, starter templates, and add-on setup (store, jobs, auth, bots, telemetry, MCP, database, Shadcn/UI).
-- 🛠️ **Code generators** for features, controllers, procedures, schemas, and OpenAPI specs, all backed by Handlebars templates.
-- 🧠 **Schema-aware workflow** with pluggable providers (Prisma out of the box) that produce strongly typed controllers, procedures, and interfaces.
-- 👀 **Development dashboard** powered by Ink that automatically regenerates schema/docs and streams app logs in a split view.
-- 🧩 **Template engine + registries** to extend starters, add-ons, and schema providers without touching the core.
+- **Project bootstrapper** with interactive wizards, starter templates, and add-on setup (store, jobs, auth, bots, telemetry, MCP, database, Shadcn/UI).
+- **Code generators** for features, controllers, procedures, schemas, and OpenAPI specs, all backed by Handlebars templates.
+- **Schema-aware workflow** with pluggable providers (Prisma out of the box) that produce strongly typed controllers, procedures, and interfaces.
+- **Development dashboard** powered by Ink that automatically regenerates schema/docs and streams app logs in a split view.
+- **Template engine + registries** to extend starters, add-ons, and schema providers without touching the core.
 
 ---
 
@@ -131,7 +131,7 @@ Generates a TypeScript client schema (const assertion + type) that mirrors your
 
 ### `igniter generate caller`
 
-Generate Zod schemas and a ready-to-use Igniter Caller from an OpenAPI 3 spec.
+Generate an `IgniterCallerSchema` builder plus a ready-to-use Igniter Caller from an OpenAPI 3 spec.
 
 ```
 # Remote spec
@@ -141,7 +141,19 @@ igniter generate caller --name facebook --url https://api.example.com/openapi.js
 igniter generate caller --name billing --path ./openapi.yaml --output src/callers/billing
 ```
 
-Outputs `schema.ts` (Zod schemas with the provided prefix) and `index.ts` (preconfigured caller) under `src/callers/<hostname>` by default, ready to use with `@igniter-js/caller`.
+Outputs `schema.ts` (path-first schema builder with registry, `$Infer` helpers, and derived types) and
+`index.ts` (preconfigured caller) under `src/callers/<hostname>` by default, ready to use with
+`@igniter-js/caller`.
+
+Example usage:
+
+```
+import { facebookCallerSchemas } from "./src/callers/api.example.com/schema"
+
+type ProductsResponse = ReturnType<
+  typeof facebookCallerSchemas.$Infer.Response<"/products", "GET", 200>
+>
+```
 
 ### `igniter dev`
 
@@ -258,5 +270,3 @@ MIT © Felipe Barcelos and the Igniter.js contributors.
 
 
 
-
-

package/dist/index.mjs

@@ -3552,7 +3552,7 @@ import path23 from "path";
 import * as p13 from "@clack/prompts";
 import yaml from "js-yaml";
 import SwaggerParser from "@apidevtools/swagger-parser";
-var SUPPORTED_METHODS = ["get", "post", "put", "patch", "delete"];
+var SUPPORTED_METHODS = ["get", "post", "put", "patch", "delete", "head"];
 async function handleGenerateCallerAction(options) {
   p13.intro("Generate Igniter Caller");
   try {
@@ -3568,26 +3568,28 @@ async function handleGenerateCallerAction(options) {
     );
     const prefix = Casing.toPascalCase(callerName);
     const converter = new SchemaConverter(prefix, parsedDoc.components);
-    const pathsCode = buildSchemasObject(parsedDoc, converter);
     const componentsCode = converter.renderComponentSchemas();
-    const schemaConstName = `${prefix}Schema`;
-    const schemaTypeName = `${prefix}SchemaType`;
+    const schemaConstName = `${Casing.toCamelCase(callerName)}CallerSchemas`;
+    const schemaTypeName = `${prefix}CallerSchemas`;
+    const { builderCode, typeAliases } = buildSchemaBuilder(
+      parsedDoc,
+      converter,
+      schemaConstName
+    );
     const schemaFileContents = [
       "/* eslint-disable */",
       "/* prettier-ignore */",
-      "",
       "/**",
       " * @generated by @igniter-js/cli",
       " * This file was automatically created from your OpenAPI spec.",
       " * Do not edit manually; regenerate via `igniter generate caller`.",
       " */",
-      "",
       'import { z } from "zod";',
+      'import { IgniterCallerSchema } from "@igniter-js/caller";',
       componentsCode,
-      `const schemas = ${pathsCode};`,
-      "",
-      `export const ${schemaConstName} = schemas;`,
+      builderCode,
       `export type ${schemaTypeName} = typeof ${schemaConstName};`,
+      typeAliases,
       ""
     ].filter(Boolean).join("\n");
     const baseUrl = inferBaseUrl(source, parsedDoc);
@@ -3613,9 +3615,7 @@ async function handleGenerateCallerAction(options) {
     p13.log.success(
       `Schemas and caller created at ${path23.relative(process.cwd(), outputDir)}`
     );
-    p13.log.info(
-      `Exported caller: ${callerVar} (schemas: ${schemaConstName})`
-    );
+    p13.log.info(`Exported caller: ${callerVar} (schemas: ${schemaConstName})`);
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     p13.log.error(message);
@@ -3684,13 +3684,12 @@ async function resolveSource(options) {
 async function loadOpenApiDocument(source) {
   const raw = await loadRawContent(source);
   const parsed = parseOpenApi(raw);
-  if (!parsed.openapi || !parsed.openapi.startsWith("3.")) {
+  const version = parsed.openapi ?? "";
+  if (typeof version !== "string" || !version.startsWith("3.")) {
     throw new Error("Only OpenAPI 3.x documents are supported.");
   }
-  const dereferenced = await SwaggerParser.dereference(
-    parsed
-  );
-  return dereferenced;
+  const bundled = await SwaggerParser.bundle(parsed);
+  return bundled;
 }
 async function loadRawContent(source) {
   if (source.type === "url") {
@@ -3756,15 +3755,34 @@ var SchemaConverter = class {
   }
   renderComponentSchemas() {
     const entries = [];
-    const names = Object.keys(this.components?.schemas ?? {}).sort();
+    const names = this.listComponents();
     for (const name of names) {
       const identifier = this.componentIdentifier(name);
       const expression = this.convertWithCache(name);
-      entries.push(`const ${identifier} = ${expression};`);
+      const registryKey = this.registryKey(name);
+      entries.push(
+        [
+          "/**",
+          ` * Schema: ${registryKey}`,
+          ` * Source: openapi#/components/schemas/${name}`,
+          " */",
+          `const ${identifier} = ${expression};`,
+          ""
+        ].join("\n")
+      );
     }
     return entries.length ? `${entries.join("\n")}
 ` : "";
   }
+  listComponents() {
+    return Object.keys(this.components?.schemas ?? {}).sort();
+  }
+  registryKey(name) {
+    return Casing.toPascalCase(name);
+  }
+  componentName(name) {
+    return this.componentIdentifier(name);
+  }
   convert(schema) {
     if ("$ref" in schema) {
       const refName = this.refName(schema.$ref);
@@ -3772,13 +3790,15 @@ var SchemaConverter = class {
       this.convertWithCache(refName);
       return this.wrapLazyIfNeeded(refName, identifier);
     }
+    const schemaType = Array.isArray(schema.type) ? schema.type[0] : schema.type;
+    const nullable = isNullable(schema);
     if (schema.oneOf?.length) {
       const parts = schema.oneOf.map((item) => this.convert(item));
-      return `z.union([${parts.join(", ")}])${schema.nullable ? ".nullable()" : ""}`;
+      return wrapNullable(`z.union([${parts.join(", ")}])`, nullable);
     }
     if (schema.anyOf?.length) {
       const parts = schema.anyOf.map((item) => this.convert(item));
-      return `z.union([${parts.join(", ")}])${schema.nullable ? ".nullable()" : ""}`;
+      return wrapNullable(`z.union([${parts.join(", ")}])`, nullable);
     }
     if (schema.allOf?.length) {
       const [first, ...rest] = schema.allOf;
@@ -3786,31 +3806,29 @@ var SchemaConverter = class {
       for (const part of rest) {
         expr = `z.intersection(${expr}, ${this.convert(part)})`;
       }
-      return schema.nullable ? `${expr}.nullable()` : expr;
+      return wrapNullable(expr, nullable);
     }
-    switch (schema.type) {
+    switch (schemaType) {
       case "string":
         if (schema.enum) {
           const values = schema.enum.map((v) => JSON.stringify(String(v)));
-          return `z.enum([${values.join(", ")}])${schema.nullable ? ".nullable()" : ""}`;
+          return wrapNullable(`z.enum([${values.join(", ")}])`, nullable);
         }
-        return `z.string()${schema.nullable ? ".nullable()" : ""}`;
+        return wrapNullable("z.string()", nullable);
       case "number":
       case "integer": {
         let expr = "z.number()";
-        if (schema.type === "integer") {
+        if (schemaType === "integer") {
           expr = `${expr}.int()`;
         }
-        if (schema.nullable) {
-          expr = `${expr}.nullable()`;
-        }
-        return expr;
+        return wrapNullable(expr, nullable);
       }
       case "boolean":
-        return `z.boolean()${schema.nullable ? ".nullable()" : ""}`;
+        return wrapNullable("z.boolean()", nullable);
       case "array": {
-        const items = schema.items ? this.convert(schema.items) : "z.unknown()";
-        return `z.array(${items})${schema.nullable ? ".nullable()" : ""}`;
+        const arraySchema = schema;
+        const items = arraySchema.items ? this.convert(arraySchema.items) : "z.unknown()";
+        return wrapNullable(`z.array(${items})`, nullable);
       }
       case "object": {
         const properties = schema.properties ?? {};
@@ -3824,10 +3842,7 @@ var SchemaConverter = class {
           const apValue = schema.additionalProperties === true ? "z.unknown()" : this.convert(schema.additionalProperties);
           base = `${base}.catchall(${apValue})`;
         }
-        if (schema.nullable) {
-          base = `${base}.nullable()`;
-        }
-        return base;
+        return wrapNullable(base, nullable);
       }
       default:
         return "z.unknown()";
@@ -3848,9 +3863,8 @@ var SchemaConverter = class {
     this.inProgress.add(name);
     const expression = this.convert(schema);
     this.inProgress.delete(name);
-    const finalized = expression.startsWith("z.lazy(") ? expression : expression;
-    this.generated.set(name, finalized);
-    return finalized;
+    this.generated.set(name, expression);
+    return expression;
   }
   componentIdentifier(name) {
     return `${this.prefix}${Casing.toPascalCase(name)}Schema`;
@@ -3869,71 +3883,271 @@ var SchemaConverter = class {
     return identifier;
   }
 };
-function buildSchemasObject(doc, converter) {
-  const pathEntries = [];
+function buildSchemaBuilder(doc, converter, schemaConstName) {
+  const usedNames = /* @__PURE__ */ new Map();
+  const operations = [];
+  const pathBlocks = [];
+  let needsVoid = false;
   const sortedPaths = Object.keys(doc.paths || {}).sort();
   for (const rawPath of sortedPaths) {
     const pathItem = doc.paths?.[rawPath];
     if (!pathItem) continue;
-    const methodEntries = [];
+    const methodBlocks = [];
     for (const method of SUPPORTED_METHODS) {
       const operation = pathItem[method];
       if (!operation) continue;
-      const responses = buildResponses(operation.responses, converter);
-      const requestBody = buildRequestBody(operation.requestBody, converter);
-      const segments = [];
-      if (requestBody) {
-        segments.push(`request: ${requestBody}`);
-      }
-      segments.push(`responses: ${responses}`);
-      const methodBlock = [
-        `${method.toUpperCase()}: {`,
-        indentLines(segments.join(",\n"), 2),
-        "}"
-      ].join("\n");
-      methodEntries.push(indentLines(methodBlock, 2));
+      const normalizedPath2 = normalizePath(rawPath);
+      const requestBody = buildRequestBody(
+        operation.requestBody,
+        converter,
+        doc
+      );
+      const responses = buildResponses(operation.responses, converter, doc);
+      const typeBaseName = ensureUniqueTypeName(
+        buildOperationTypeName(rawPath, method, operation.operationId),
+        usedNames
+      );
+      operations.push({
+        path: normalizedPath2,
+        method: method.toUpperCase(),
+        request: Boolean(requestBody),
+        responses: responses.entries,
+        typeName: typeBaseName
+      });
+      const docBlock = buildMethodDocBlock({
+        method: method.toUpperCase(),
+        path: normalizedPath2,
+        summary: operation.summary ?? operation.description,
+        tags: operation.tags,
+        operationId: operation.operationId,
+        requestLabel: requestBody?.label,
+        responses: responses.entries,
+        source: `openapi#/paths/${encodeJsonPointerPath(rawPath)}/${method}`
+      });
+      const methodCall = buildMethodCall(method, {
+        request: requestBody?.expression,
+        responses: responses.code,
+        doc: operation.summary ?? operation.description,
+        tags: operation.tags,
+        operationId: operation.operationId
+      });
+      methodBlocks.push(indent(`${docBlock}
+${methodCall}`, 3));
+      needsVoid = needsVoid || responses.usesVoid;
     }
-    if (!methodEntries.length) continue;
+    if (!methodBlocks.length) continue;
     const normalizedPath = normalizePath(rawPath);
-    const pathBlock = [
-      `${JSON.stringify(normalizedPath)}: {`,
-      methodEntries.join(",\n"),
-      "}"
-    ].join("\n");
-    pathEntries.push(indentLines(pathBlock, 1));
-  }
-  return `{
-${pathEntries.join(",\n")}
-}`;
+    const pathLines = [
+      `  .path(${JSON.stringify(normalizedPath)}, (path) =>`,
+      "    path",
+      methodBlocks.join("\n"),
+      "  )"
+    ];
+    pathBlocks.push(pathLines.join("\n"));
+  }
+  const builderLines = [];
+  builderLines.push(`export const ${schemaConstName} = IgniterCallerSchema.create()`);
+  const componentNames = converter.listComponents();
+  for (const name of componentNames) {
+    const registryKey = converter.registryKey(name);
+    const identifier = converter.componentName(name);
+    builderLines.push(`  .schema(${JSON.stringify(registryKey)}, ${identifier})`);
+  }
+  if (needsVoid) {
+    builderLines.push(`  .schema("Void", z.void(), { internal: true })`);
+  }
+  if (pathBlocks.length) {
+    builderLines.push(pathBlocks.join("\n"));
+  }
+  builderLines.push("  .build()");
+  return {
+    builderCode: `${builderLines.join("\n")}
+`,
+    typeAliases: buildTypeAliases(operations, schemaConstName)
+  };
 }
-function buildResponses(responses, converter) {
-  if (!responses || !Object.keys(responses).length) {
-    return "{ }";
+function buildMethodDocBlock(params) {
+  const lines = [];
+  lines.push("/**");
+  lines.push(` * ${params.method} ${params.path}`);
+  if (params.summary) {
+    lines.push(` * Summary: ${params.summary}`);
+  }
+  if (params.tags?.length) {
+    lines.push(` * Tags: ${params.tags.join(", ")}`);
+  }
+  if (params.operationId) {
+    lines.push(` * OperationId: ${params.operationId}`);
+  }
+  if (params.requestLabel) {
+    lines.push(` * Request: ${params.requestLabel}`);
+  }
+  if (params.responses.length) {
+    lines.push(" * Responses:");
+    for (const response of params.responses) {
+      lines.push(` *  - ${response.status}: ${response.label}`);
+    }
   }
+  lines.push(` * Source: ${params.source}`);
+  lines.push(" */");
+  return lines.join("\n");
+}
+function buildMethodCall(method, params) {
+  const lines = [];
+  lines.push(`.${method}({`);
+  if (params.request) {
+    lines.push(`  request: ${params.request},`);
+  }
+  lines.push("  responses: {");
+  lines.push(params.responses);
+  lines.push("  },");
+  if (params.doc) {
+    lines.push(`  doc: ${JSON.stringify(params.doc)},`);
+  }
+  if (params.tags?.length) {
+    lines.push(`  tags: ${JSON.stringify(params.tags)},`);
+  }
+  if (params.operationId) {
+    lines.push(`  operationId: ${JSON.stringify(params.operationId)},`);
+  }
+  lines.push("})");
+  return lines.join("\n");
+}
+function buildResponses(responses, converter, doc) {
+  const builder = new CodeBuilder();
   const entries = [];
+  let usesVoid = false;
+  if (!responses || !Object.keys(responses).length) {
+    const expression = `path.ref("Void").schema`;
+    builder.line(indent(`200: ${expression},`, 2));
+    entries.push({
+      status: "200",
+      statusLiteral: "200",
+      label: "Void"
+    });
+    return { code: builder.toString(), entries, usesVoid: true };
+  }
   const sorted = Object.keys(responses).sort();
   for (const status of sorted) {
     const responseOrRef = responses[status];
     if (!responseOrRef) continue;
-    const response = "$ref" in responseOrRef ? void 0 : responseOrRef;
-    const schema = resolveSchemaFromResponse(response);
-    const expression = schema ? converter.convert(schema) : "z.unknown()";
-    entries.push(`${status}: ${expression}`);
-  }
-  if (!entries.length) {
-    return "{ }";
+    const resolved = resolveResponse(responseOrRef, doc);
+    const schema = resolveSchemaFromResponse(resolved);
+    const resolvedSchema = resolveSchemaExpression(schema, converter);
+    builder.line(indent(`${formatStatusKey(status)}: ${resolvedSchema.expression},`, 2));
+    entries.push({
+      status: String(status),
+      statusLiteral: formatStatusType(status),
+      label: resolvedSchema.label
+    });
+    usesVoid = usesVoid || resolvedSchema.usesVoid;
   }
-  return `{
-${indentLines(entries.join(",\n"), 2)}
-  }`;
+  return { code: builder.toString(), entries, usesVoid };
 }
-function buildRequestBody(requestBody, converter) {
+function buildRequestBody(requestBody, converter, doc) {
   if (!requestBody) return null;
-  const resolved = "$ref" in requestBody ? null : requestBody;
+  const resolved = "$ref" in requestBody ? resolveRequestBody(requestBody, doc) : requestBody;
   if (!resolved?.content) return null;
   const schema = selectJsonSchema(resolved.content);
   if (!schema) return null;
-  return converter.convert(schema);
+  return resolveSchemaExpression(schema, converter);
+}
+function resolveSchemaExpression(schema, converter) {
+  if (!schema) {
+    return {
+      expression: `path.ref("Void").schema`,
+      label: "Void",
+      usesVoid: true
+    };
+  }
+  const refName = extractSchemaRef(schema);
+  if (refName) {
+    const registryKey = converter.registryKey(refName);
+    const base = `path.ref(${JSON.stringify(registryKey)}).schema`;
+    return {
+      expression: wrapNullable(base, isNullable(schema)),
+      label: registryKey,
+      usesVoid: false
+    };
+  }
+  const arrayRefName = extractArraySchemaRef(schema);
+  if (arrayRefName) {
+    const registryKey = converter.registryKey(arrayRefName);
+    const base = `path.ref(${JSON.stringify(registryKey)}).array()`;
+    return {
+      expression: wrapNullable(base, isNullable(schema)),
+      label: `${registryKey}[]`,
+      usesVoid: false
+    };
+  }
+  return {
+    expression: converter.convert(schema),
+    label: "InlineSchema",
+    usesVoid: false
+  };
+}
+function buildTypeAliases(operations, schemaConstName) {
+  if (!operations.length) return "";
+  const lines = [];
+  lines.push("// Derived types");
+  for (const operation of operations) {
+    const pathLiteral = JSON.stringify(operation.path);
+    const methodLiteral = JSON.stringify(operation.method);
+    if (operation.request) {
+      lines.push(
+        `export type ${operation.typeName}Request = ReturnType<typeof ${schemaConstName}.$Infer.Request<${pathLiteral}, ${methodLiteral}>>;`
+      );
+    }
+    lines.push(
+      `export type ${operation.typeName}Responses = ReturnType<typeof ${schemaConstName}.$Infer.Responses<${pathLiteral}, ${methodLiteral}>>;`
+    );
+    for (const response of operation.responses) {
+      const suffix = formatStatusSuffix(response.status);
+      lines.push(
+        `export type ${operation.typeName}Response${suffix} = ReturnType<typeof ${schemaConstName}.$Infer.Response<${pathLiteral}, ${methodLiteral}, ${response.statusLiteral}>>;`
+      );
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function buildOperationTypeName(rawPath, method, operationId) {
+  if (operationId) {
+    return Casing.toPascalCase(operationId);
+  }
+  const normalizedPath = normalizePath(rawPath);
+  const segments = normalizedPath.split("/").filter(Boolean).map((segment) => segment.startsWith(":") ? `by-${segment.slice(1)}` : segment);
+  return Casing.toPascalCase([...segments, method].join("-"));
+}
+function ensureUniqueTypeName(baseName, used) {
+  const count = used.get(baseName) ?? 0;
+  if (count === 0) {
+    used.set(baseName, 1);
+    return baseName;
+  }
+  const next = `${baseName}${count + 1}`;
+  used.set(baseName, count + 1);
+  return next;
+}
+function encodeJsonPointerPath(pathname) {
+  return pathname.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+function extractSchemaRef(schema) {
+  if (!schema || typeof schema !== "object") return null;
+  if (!("$ref" in schema)) return null;
+  return extractComponentSchemaName(schema.$ref);
+}
+function extractArraySchemaRef(schema) {
+  if (!schema || typeof schema !== "object") return null;
+  if (schema.type !== "array") return null;
+  const items = schema.items;
+  if (!items || typeof items !== "object") return null;
+  if (!("$ref" in items)) return null;
+  return extractComponentSchemaName(items.$ref);
+}
+function extractComponentSchemaName(ref) {
+  const match = ref.match(/^#\/components\/schemas\/(.+)$/);
+  return match ? match[1] : null;
 }
 function selectJsonSchema(content) {
   if (content["application/json"]?.schema) {
@@ -3951,10 +4165,61 @@ function resolveSchemaFromResponse(response) {
 function normalizePath(pathname) {
   return pathname.replace(/{(.*?)}/g, ":$1");
 }
-function indentLines(value, depth) {
+function indent(value, depth) {
   const pad = "  ".repeat(depth);
   return value.split("\n").map((line) => line ? pad + line : line).join("\n");
 }
+function isNullable(schema) {
+  if (!schema || typeof schema !== "object") return false;
+  return Boolean(schema.nullable);
+}
+function wrapNullable(expr, nullable) {
+  return nullable ? `${expr}.nullable()` : expr;
+}
+function formatStatusKey(status) {
+  const trimmed = String(status).trim();
+  const numeric = Number(trimmed);
+  if (!Number.isNaN(numeric) && `${numeric}` === trimmed) {
+    return trimmed;
+  }
+  return JSON.stringify(trimmed);
+}
+function formatStatusType(status) {
+  return formatStatusKey(status);
+}
+function formatStatusSuffix(status) {
+  const safe = String(status).replace(/[^a-zA-Z0-9]+/g, "-");
+  const pascal = Casing.toPascalCase(safe);
+  return pascal || "Unknown";
+}
+function resolveResponse(response, doc) {
+  if ("$ref" in response) {
+    return getComponent(doc, response.$ref, "responses");
+  }
+  return response;
+}
+function resolveRequestBody(requestBody, doc) {
+  return getComponent(doc, requestBody.$ref, "requestBodies");
+}
+function getComponent(doc, ref, type) {
+  const match = ref.match(/^#\/components\/([^/]+)\/(.+)$/);
+  if (!match) return void 0;
+  const [, category, name] = match;
+  if (category !== type) return void 0;
+  const component = doc.components?.[type]?.[name];
+  return component;
+}
+var CodeBuilder = class {
+  constructor() {
+    this.lines = [];
+  }
+  line(text4) {
+    this.lines.push(text4);
+  }
+  toString() {
+    return this.lines.join("\n");
+  }
+};
 
 // src/commands/generate/caller/index.ts
 var callerCommand = new Command7().command("caller").description("Generate Igniter Caller schemas from an OpenAPI spec").option("--name <name>", "Name used to prefix generated schemas and caller export").option("--url <url>", "URL to the OpenAPI document").option("--path <path>", "Local path to the OpenAPI document").option(