@minkinad/api-sdk-generator-core 0.2.0

package/dist/index.cjs

@@ -0,0 +1,1093 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ApiSdkGeneratorError: () => ApiSdkGeneratorError,
+  OutputWriteError: () => OutputWriteError,
+  SchemaLoadError: () => SchemaLoadError,
+  SchemaValidationError: () => SchemaValidationError,
+  UnsupportedSchemaError: () => UnsupportedSchemaError,
+  createFunctionName: () => createFunctionName,
+  createLogger: () => createLogger,
+  deriveSdkName: () => deriveSdkName,
+  generateSdk: () => generateSdk,
+  getReferenceName: () => getReferenceName,
+  isReferenceObject: () => isReferenceObject,
+  isSchemaObject: () => isSchemaObject,
+  loadOpenApiDocument: () => loadOpenApiDocument,
+  loadOpenApiDocumentFromFile: () => loadOpenApiDocumentFromFile,
+  loadOpenApiDocumentFromUrl: () => loadOpenApiDocumentFromUrl,
+  noopLogger: () => noopLogger,
+  parseDocument: () => parseDocument,
+  resolveLocalComponent: () => resolveLocalComponent,
+  resolveSchema: () => resolveSchema,
+  sanitizeIdentifier: () => sanitizeIdentifier,
+  toCamelCase: () => toCamelCase,
+  toPascalCase: () => toPascalCase,
+  toPropertyAccessor: () => toPropertyAccessor,
+  toTypeName: () => toTypeName,
+  validateOpenApiDocument: () => validateOpenApiDocument
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors.ts
+var ApiSdkGeneratorError = class extends Error {
+  code;
+  constructor(message, code = "API_SDK_GENERATOR_ERROR", cause) {
+    super(message, cause instanceof Error ? { cause } : void 0);
+    this.name = new.target.name;
+    this.code = code;
+  }
+};
+var SchemaLoadError = class extends ApiSdkGeneratorError {
+  constructor(message, cause) {
+    super(message, "SCHEMA_LOAD_ERROR", cause);
+  }
+};
+var SchemaValidationError = class extends ApiSdkGeneratorError {
+  constructor(message, cause) {
+    super(message, "SCHEMA_VALIDATION_ERROR", cause);
+  }
+};
+var UnsupportedSchemaError = class extends ApiSdkGeneratorError {
+  constructor(message, cause) {
+    super(message, "UNSUPPORTED_SCHEMA_ERROR", cause);
+  }
+};
+var OutputWriteError = class extends ApiSdkGeneratorError {
+  constructor(message, cause) {
+    super(message, "OUTPUT_WRITE_ERROR", cause);
+  }
+};
+
+// src/generate-sdk.ts
+var import_node_path3 = __toESM(require("path"), 1);
+
+// src/formatter.ts
+var import_prettier = __toESM(require("prettier"), 1);
+var GENERATED_FORMAT_OPTIONS = {
+  printWidth: 100,
+  semi: true,
+  singleQuote: true,
+  trailingComma: "all"
+};
+function getParser(filePath) {
+  return filePath.endsWith(".md") ? "markdown" : "typescript";
+}
+async function formatGeneratedFiles(files) {
+  return Promise.all(
+    files.map(async (file) => ({
+      ...file,
+      content: await import_prettier.default.format(file.content, {
+        ...GENERATED_FORMAT_OPTIONS,
+        parser: getParser(file.path)
+      })
+    }))
+  );
+}
+
+// src/naming.ts
+var RESERVED_WORDS = /* @__PURE__ */ new Set([
+  "default",
+  "function",
+  "class",
+  "switch",
+  "case",
+  "var",
+  "const",
+  "let",
+  "new",
+  "delete",
+  "return"
+]);
+function splitWords(input) {
+  return input.replace(/([a-z0-9])([A-Z])/g, "$1 $2").split(/[^A-Za-z0-9]+/).map((part) => part.trim()).filter(Boolean);
+}
+function capitalize(value) {
+  return value.charAt(0).toUpperCase() + value.slice(1);
+}
+function toPascalCase(input) {
+  const words = splitWords(input);
+  const pascal = words.map((word) => capitalize(word.toLowerCase())).join("");
+  return pascal || "GeneratedType";
+}
+function toCamelCase(input) {
+  const pascal = toPascalCase(input);
+  return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+function sanitizeIdentifier(input) {
+  const camel = toCamelCase(input).replace(/[^A-Za-z0-9_$]/g, "");
+  const normalized = camel.match(/^[A-Za-z_$]/) ? camel : `_${camel}`;
+  return RESERVED_WORDS.has(normalized) ? `${normalized}Value` : normalized;
+}
+function toTypeName(input) {
+  const pascal = toPascalCase(input).replace(/[^A-Za-z0-9_$]/g, "");
+  return pascal.match(/^[A-Za-z_$]/) ? pascal : `T${pascal}`;
+}
+function toPropertyAccessor(name) {
+  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name) ? name : JSON.stringify(name);
+}
+function createFunctionName(method, path4, operationId) {
+  if (operationId) {
+    return sanitizeIdentifier(operationId);
+  }
+  const segments = path4.split("/").filter(Boolean);
+  const pieces = [method.toLowerCase()];
+  const paramNames = [];
+  for (const segment of segments) {
+    const match = segment.match(/^\{(.+)\}$/);
+    if (match) {
+      paramNames.push(toPascalCase(match[1]));
+      continue;
+    }
+    pieces.push(toPascalCase(segment));
+  }
+  if (paramNames.length > 0) {
+    pieces.push(`By${paramNames.join("And")}`);
+  }
+  return sanitizeIdentifier(pieces.join(" "));
+}
+function deriveSdkName(input) {
+  return input ? toTypeName(input) : "GeneratedSdk";
+}
+
+// src/generator/client-generator.ts
+function renderTemplatePath(path4, operation) {
+  const parts = [];
+  let offset = 0;
+  for (const match of path4.matchAll(/\{([^}]+)\}/g)) {
+    const parameter = operation.pathParameters.find((item) => item.name === match[1]);
+    if (!parameter) continue;
+    parts.push(JSON.stringify(path4.slice(offset, match.index)));
+    parts.push(`encodeURIComponent(String(request[${JSON.stringify(parameter.name)}]))`);
+    offset = match.index + match[0].length;
+  }
+  parts.push(JSON.stringify(path4.slice(offset)));
+  return parts.join(" + ");
+}
+function renderQueryLines(operation) {
+  return operation.queryParameters.map((parameter) => {
+    const style = parameter.style ?? "form";
+    const explode = parameter.explode ?? style === "form";
+    const separator = style === "spaceDelimited" ? " " : style === "pipeDelimited" ? "|" : ",";
+    return `      appendQueryParameter(searchParams, ${JSON.stringify(parameter.name)}, request[${JSON.stringify(parameter.name)}], ${explode}, ${JSON.stringify(separator)});`;
+  });
+}
+function renderMethodSignature(operation) {
+  if (!operation.hasRequestShape) {
+    return `${operation.functionName}(init?: RequestInit): Promise<${operation.responseTypeName}>;`;
+  }
+  if (operation.hasRequiredRequestFields) {
+    return `${operation.functionName}(request: ${operation.requestTypeName}, init?: RequestInit): Promise<${operation.responseTypeName}>;`;
+  }
+  return `${operation.functionName}(request?: ${operation.requestTypeName}, init?: RequestInit): Promise<${operation.responseTypeName}>;`;
+}
+function renderMethodImplementation(operation) {
+  const requestParameter = operation.hasRequestShape ? operation.hasRequiredRequestFields ? "request" : "request = {}" : "";
+  const queryLines = renderQueryLines(operation);
+  const bodyContent = operation.requestBody?.contentType === "application/json" || operation.requestBody?.contentType?.endsWith("+json") ? [
+    "      const body = request.body !== undefined ? JSON.stringify(request.body) : undefined;",
+    '      if (body !== undefined && !headers.has("content-type")) {',
+    `        headers.set("content-type", ${JSON.stringify(operation.requestBody.contentType)});`,
+    "      }"
+  ].join("\n") : "      const body = undefined;";
+  return [
+    `    async ${operation.functionName}(${requestParameter}${requestParameter ? ", " : ""}init?: RequestInit): Promise<${operation.responseTypeName}> {`,
+    `      const url = resolveRequestUrl(resolveBaseUrl(config.baseUrl), ${renderTemplatePath(operation.path, operation)});`,
+    "      const searchParams = url.searchParams;",
+    ...queryLines.length > 0 ? queryLines : ["      void searchParams;"],
+    "      const headers = new Headers(config.headers);",
+    bodyContent,
+    "      const response = await runtimeFetch(url, {",
+    "        ...init,",
+    `        method: ${JSON.stringify(operation.method.toUpperCase())},`,
+    "        body,",
+    "        headers: mergeHeaders(headers, init?.headers),",
+    "      });",
+    "",
+    "      if (!response.ok) {",
+    "        throw await ApiError.fromResponse(response);",
+    "      }",
+    "",
+    `      return parseResponse<${operation.responseTypeName}>(response);`,
+    "    },"
+  ].join("\n");
+}
+function generateClientSource(parsed) {
+  const clientName = `${toTypeName(parsed.sdkName)}Client`;
+  const interfaceLines = parsed.operations.map(
+    (operation) => `  ${renderMethodSignature(operation)}`
+  );
+  const methodLines = parsed.operations.map((operation) => renderMethodImplementation(operation));
+  return [
+    "/* eslint-disable */",
+    "/**",
+    " * Auto-generated by api-sdk-generator.",
+    " * Do not edit manually.",
+    " */",
+    "",
+    ...parsed.operations.length > 0 ? [
+      "import type {",
+      ...parsed.operations.flatMap((operation) => [
+        ...operation.hasRequestShape ? [`  ${operation.requestTypeName},`] : [],
+        `  ${operation.responseTypeName},`
+      ]),
+      "} from './types.js';",
+      ""
+    ] : [],
+    "export interface ClientConfig {",
+    "  baseUrl?: string;",
+    "  fetch?: typeof fetch;",
+    "  headers?: HeadersInit;",
+    "}",
+    "",
+    `export interface ${clientName} {`,
+    ...interfaceLines,
+    "}",
+    "",
+    "export class ApiError extends Error {",
+    "  public readonly body: unknown;",
+    "  public readonly status: number;",
+    "  public readonly headers: Headers;",
+    "",
+    "  public constructor(status: number, message: string, body: unknown, headers: Headers = new Headers()) {",
+    "    super(message);",
+    '    this.name = "ApiError";',
+    "    this.status = status;",
+    "    this.body = body;",
+    "    this.headers = headers;",
+    "  }",
+    "",
+    "  public static async fromResponse(response: Response): Promise<ApiError> {",
+    "    const body = await parseResponseBody(response.clone()).catch(() => response.text());",
+    "    return new ApiError(response.status, `Request failed with status ${response.status}`, body, response.headers);",
+    "  }",
+    "}",
+    "",
+    "export function createClient(config: ClientConfig = {}): " + clientName + " {",
+    "  const runtimeFetch = config.fetch ?? globalThis.fetch;",
+    "",
+    "  if (!runtimeFetch) {",
+    '    throw new Error("Fetch API is not available in the current runtime.");',
+    "  }",
+    "",
+    "  return {",
+    ...methodLines,
+    "  };",
+    "}",
+    "",
+    ...parsed.operations.length > 0 ? [
+      "function resolveBaseUrl(baseUrl?: string): string {",
+      `  return baseUrl ?? ${JSON.stringify(parsed.defaultBaseUrl ?? "http://localhost")};`,
+      "}",
+      "",
+      "function resolveRequestUrl(baseUrl: string, requestPath: string): URL {",
+      '  const normalizedBaseUrl = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;',
+      '  return new URL(requestPath.replace(/^\\/+/, ""), normalizedBaseUrl);',
+      "}",
+      "",
+      "async function parseResponse<T>(response: Response): Promise<T> {",
+      "  return (await parseResponseBody(response)) as T;",
+      "}",
+      ""
+    ] : [],
+    "async function parseResponseBody(response: Response): Promise<unknown> {",
+    "  if (response.status === 204 || response.status === 205) {",
+    "    return undefined;",
+    "  }",
+    "",
+    "  const body = await response.text();",
+    "",
+    "  if (!body) {",
+    "    return undefined;",
+    "  }",
+    "",
+    '  const contentType = response.headers.get("content-type") ?? "";',
+    "  return isJsonContentType(contentType) ? (JSON.parse(body) as unknown) : body;",
+    "}",
+    "",
+    "function isJsonContentType(contentType: string): boolean {",
+    '  const mediaType = contentType.split(";", 1)[0].trim().toLowerCase();',
+    '  return mediaType === "application/json" || mediaType.endsWith("+json");',
+    "}",
+    "",
+    ...parsed.operations.some((operation) => operation.queryParameters.length > 0) ? [
+      "function appendQueryParameter(params: URLSearchParams, name: string, value: unknown, explode: boolean, separator: string): void {",
+      "  if (value === undefined) return;",
+      "  if (Array.isArray(value)) {",
+      "    if (explode) {",
+      "      for (const item of value) params.append(name, String(item));",
+      "    } else {",
+      "      params.set(name, value.map(String).join(separator));",
+      "    }",
+      "  } else {",
+      "    params.set(name, String(value));",
+      "  }",
+      "}",
+      ""
+    ] : [],
+    ...parsed.operations.length > 0 ? [
+      "function mergeHeaders(baseHeaders: Headers, initHeaders?: HeadersInit): Headers {",
+      "  const merged = new Headers(baseHeaders);",
+      "",
+      "  if (initHeaders) {",
+      "    const overlay = new Headers(initHeaders);",
+      "    overlay.forEach((value, key) => merged.set(key, value));",
+      "  }",
+      "",
+      "  return merged;",
+      "}",
+      ""
+    ] : []
+  ].join("\n");
+}
+
+// src/generator/index-generator.ts
+function generateIndexSource() {
+  return ["export * from './types.js';", "export * from './client.js';", ""].join("\n");
+}
+
+// src/generator/readme-generator.ts
+function generateGeneratedReadme(parsed) {
+  const exampleOperation = parsed.operations[0];
+  const exampleCall = exampleOperation?.hasRequestShape ? `${exampleOperation.functionName}({ /* request */ })` : `${exampleOperation?.functionName ?? "listResources"}()`;
+  return [
+    `# ${parsed.sdkName}`,
+    "",
+    "This SDK was generated by `api-sdk-generator`.",
+    "",
+    "## Usage",
+    "",
+    "```ts",
+    "import { createClient } from './index';",
+    "",
+    "const client = createClient({",
+    `  baseUrl: ${JSON.stringify(parsed.defaultBaseUrl ?? "https://api.example.com")},`,
+    "});",
+    "",
+    `await client.${exampleCall};`,
+    "```",
+    ""
+  ].join("\n");
+}
+
+// src/resolver.ts
+function isReferenceObject(schema) {
+  return "$ref" in schema;
+}
+function getReferenceName(ref) {
+  const match = ref.match(/^#\/components\/schemas\/(.+)$/);
+  if (!match) {
+    throw new SchemaValidationError(
+      `Only local component schema refs are supported. Received "${ref}".`
+    );
+  }
+  return decodePointerToken(match[1]);
+}
+function resolveSchema(document, schema) {
+  if (!isReferenceObject(schema)) {
+    return schema;
+  }
+  return resolveLocalComponent(
+    schema,
+    document.components?.schemas,
+    "schemas"
+  );
+}
+function decodePointerToken(token) {
+  return token.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+function resolveLocalComponent(reference, collection, section) {
+  const seen = /* @__PURE__ */ new Set();
+  let current = reference;
+  const prefix = `#/components/${section}/`;
+  for (; ; ) {
+    if (!current.$ref.startsWith(prefix)) {
+      throw new SchemaValidationError(
+        `Only local ${section} refs are supported. Received "${current.$ref}".`
+      );
+    }
+    if (seen.has(current.$ref)) {
+      throw new SchemaValidationError(`Circular component reference "${current.$ref}".`);
+    }
+    seen.add(current.$ref);
+    const name = decodePointerToken(current.$ref.slice(prefix.length));
+    const resolved = collection && Object.hasOwn(collection, name) ? collection[name] : void 0;
+    if (!resolved) {
+      throw new SchemaValidationError(`Unable to resolve ${section} reference "${current.$ref}".`);
+    }
+    if ("$ref" in resolved) {
+      current = resolved;
+    } else {
+      return resolved;
+    }
+  }
+}
+
+// src/validator.ts
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function validateOpenApiDocument(value) {
+  if (!isObject(value)) {
+    throw new SchemaValidationError("OpenAPI document must be a JSON object.");
+  }
+  if (typeof value.openapi !== "string" || !value.openapi.startsWith("3.")) {
+    throw new SchemaValidationError("Only OpenAPI 3.x documents are supported.");
+  }
+  if (!isObject(value.info) || typeof value.info.title !== "string") {
+    throw new SchemaValidationError("OpenAPI document must contain info.title.");
+  }
+  if (!isObject(value.paths)) {
+    throw new SchemaValidationError("OpenAPI document must contain a paths object.");
+  }
+  return value;
+}
+function isSchemaObject(value) {
+  return isObject(value) && !("$ref" in value);
+}
+
+// src/generator/type-generator.ts
+function quoteEnumValue(value) {
+  return typeof value === "string" ? JSON.stringify(value) : String(value);
+}
+function normalizeNullable(rendered, schema) {
+  return schema.nullable ? `${rendered} | null` : rendered;
+}
+function renderObjectType(schema, context) {
+  const required = new Set(schema.required ?? []);
+  const properties = schema.properties ?? {};
+  const propertyEntries = Object.entries(properties);
+  if (propertyEntries.length === 0) {
+    if (schema.additionalProperties && typeof schema.additionalProperties === "object") {
+      return `Record<string, ${renderSchema(schema.additionalProperties, context)}>`;
+    }
+    return schema.additionalProperties === false ? "Record<string, never>" : "Record<string, unknown>";
+  }
+  const lines = propertyEntries.map(([name, propertySchema]) => {
+    const propertyType = renderSchema(propertySchema, context);
+    const optionalToken = required.has(name) ? "" : "?";
+    return `  ${toPropertyAccessor(name)}${optionalToken}: ${propertyType};`;
+  });
+  const objectType = ["{", ...lines, "}"].join("\n");
+  if (schema.additionalProperties) {
+    const valueType = schema.additionalProperties === true ? "unknown" : renderSchema(schema.additionalProperties, context);
+    return `${objectType} & Record<string, ${valueType}>`;
+  }
+  return objectType;
+}
+function renderSchema(schema, context) {
+  if (isReferenceObject(schema)) {
+    resolveSchema(context.document, schema);
+    return toTypeName(getReferenceName(schema.$ref));
+  }
+  if (schema.enum && schema.enum.length > 0) {
+    return normalizeNullable(schema.enum.map(quoteEnumValue).join(" | "), schema);
+  }
+  if (schema.oneOf && schema.oneOf.length > 0) {
+    return normalizeNullable(
+      schema.oneOf.map((item) => renderSchema(item, context)).join(" | "),
+      schema
+    );
+  }
+  if (schema.anyOf && schema.anyOf.length > 0) {
+    return normalizeNullable(
+      schema.anyOf.map((item) => `(${renderSchema(item, context)})`).join(" | "),
+      schema
+    );
+  }
+  if (schema.allOf && schema.allOf.length > 0) {
+    return normalizeNullable(
+      schema.allOf.map((item) => `(${renderSchema(item, context)})`).join(" & "),
+      schema
+    );
+  }
+  if (schema.type === "array") {
+    if (!schema.items) {
+      throw new UnsupportedSchemaError("Array schema must define items.");
+    }
+    return normalizeNullable(`Array<${renderSchema(schema.items, context)}>`, schema);
+  }
+  if (schema.type === "object" || schema.properties || schema.additionalProperties) {
+    return normalizeNullable(renderObjectType(schema, context), schema);
+  }
+  if (schema.type === "string") {
+    return normalizeNullable("string", schema);
+  }
+  if (schema.type === "number" || schema.type === "integer") {
+    return normalizeNullable("number", schema);
+  }
+  if (schema.type === "boolean") {
+    return normalizeNullable("boolean", schema);
+  }
+  return "unknown";
+}
+function renderNamedSchemaExport(name, schema, context) {
+  if (isReferenceObject(schema)) {
+    return `export type ${toTypeName(name)} = ${renderSchema(schema, context)};`;
+  }
+  const resolved = resolveSchema(context.document, schema);
+  const rendered = renderSchema(resolved, context);
+  if (rendered.startsWith("{") && rendered.endsWith("}") && !resolved.nullable && !resolved.allOf && !resolved.oneOf && !resolved.anyOf && !resolved.additionalProperties) {
+    return `export interface ${toTypeName(name)} ${rendered}`;
+  }
+  return `export type ${toTypeName(name)} = ${rendered};`;
+}
+function createRequestSchema(operation) {
+  const properties = /* @__PURE__ */ Object.create(null);
+  const required = [];
+  for (const parameter of [...operation.pathParameters, ...operation.queryParameters]) {
+    properties[parameter.name] = parameter.schema;
+    if (parameter.required) {
+      required.push(parameter.name);
+    }
+  }
+  if (operation.requestBody) {
+    properties.body = operation.requestBody.schema;
+    if (operation.requestBody.required) {
+      required.push("body");
+    }
+  }
+  if (Object.keys(properties).length === 0) {
+    return void 0;
+  }
+  return {
+    properties,
+    required,
+    type: "object"
+  };
+}
+function createResponseSchema(operation) {
+  return operation.response.schema;
+}
+function renderOperationTypes(parsed, context) {
+  const blocks = [];
+  for (const operation of parsed.operations) {
+    const requestSchema = createRequestSchema(operation);
+    if (requestSchema) {
+      blocks.push(renderNamedSchemaExport(operation.requestTypeName, requestSchema, context));
+    } else {
+      blocks.push(`export type ${operation.requestTypeName} = void;`);
+    }
+    const responseSchema = createResponseSchema(operation);
+    if (responseSchema) {
+      blocks.push(renderNamedSchemaExport(operation.responseTypeName, responseSchema, context));
+    } else {
+      blocks.push(`export type ${operation.responseTypeName} = void;`);
+    }
+  }
+  return blocks;
+}
+function generateTypesSource(parsed) {
+  const context = {
+    document: parsed.document
+  };
+  const componentBlocks = Object.entries(parsed.componentSchemas).sort(([left], [right]) => left.localeCompare(right)).filter(([, schema]) => isReferenceObject(schema) || isSchemaObject(schema)).map(([name, schema]) => renderNamedSchemaExport(name, schema, context));
+  const operationBlocks = renderOperationTypes(parsed, context);
+  return [
+    "/* eslint-disable */",
+    "/**",
+    " * Auto-generated by api-sdk-generator.",
+    " * Do not edit manually.",
+    " */",
+    "",
+    "export {};",
+    "",
+    ...componentBlocks,
+    "",
+    ...operationBlocks,
+    ""
+  ].join("\n");
+}
+
+// src/loader.ts
+var import_promises = require("fs/promises");
+var import_node_path = __toESM(require("path"), 1);
+var import_yaml = require("yaml");
+function parseSchema(content) {
+  const parsed = (0, import_yaml.parseDocument)(content, { uniqueKeys: true });
+  if (parsed.errors.length > 0) {
+    throw new SchemaLoadError(`Invalid JSON or YAML: ${parsed.errors[0].message}`);
+  }
+  return validateOpenApiDocument(parsed.toJS({ maxAliasCount: 100 }));
+}
+async function loadOpenApiDocument(input, options = {}) {
+  const sources = [input.file, input.url].filter(Boolean);
+  if (sources.length !== 1) {
+    throw new SchemaLoadError("Exactly one input source must be provided: either file or url.");
+  }
+  if (input.file) {
+    return loadOpenApiDocumentFromFile(input.file, options.logger);
+  }
+  return loadOpenApiDocumentFromUrl(input.url, options.fetchImplementation, options.logger);
+}
+async function loadOpenApiDocumentFromFile(filePath, logger) {
+  try {
+    logger?.debug(`Loading OpenAPI schema from file: ${filePath}`);
+    const content = await (0, import_promises.readFile)(filePath, "utf8");
+    return parseSchema(content);
+  } catch (error) {
+    if (error instanceof ApiSdkGeneratorError) {
+      throw error;
+    }
+    throw new SchemaLoadError(
+      `Failed to load OpenAPI schema from file "${import_node_path.default.resolve(filePath)}".`,
+      error
+    );
+  }
+}
+async function loadOpenApiDocumentFromUrl(url, fetchImplementation, logger) {
+  const runtimeFetch = fetchImplementation ?? globalThis.fetch;
+  if (!runtimeFetch) {
+    throw new SchemaLoadError("Fetch API is not available in the current runtime.");
+  }
+  try {
+    logger?.debug(`Loading OpenAPI schema from URL: ${url}`);
+    const response = await runtimeFetch(url);
+    if (!response.ok) {
+      throw new SchemaLoadError(
+        `Failed to fetch OpenAPI schema from "${url}". HTTP ${response.status}.`
+      );
+    }
+    return parseSchema(await response.text());
+  } catch (error) {
+    if (error instanceof ApiSdkGeneratorError) {
+      throw error;
+    }
+    throw new SchemaLoadError(`Failed to load OpenAPI schema from URL "${url}".`, error);
+  }
+}
+
+// src/logger.ts
+var NoopLogger = class {
+  info() {
+  }
+  warn() {
+  }
+  error() {
+  }
+  debug() {
+  }
+};
+var noopLogger = new NoopLogger();
+function createLogger(options = {}) {
+  const sink = options.sink ?? console;
+  const verbose = options.verbose ?? false;
+  return {
+    debug(message) {
+      if (verbose) {
+        sink.info(message);
+      }
+    },
+    error(message) {
+      sink.error(message);
+    },
+    info(message) {
+      sink.info(message);
+    },
+    warn(message) {
+      sink.warn(message);
+    }
+  };
+}
+
+// src/parser.ts
+var SUPPORTED_METHODS = [
+  "get",
+  "post",
+  "put",
+  "patch",
+  "delete",
+  "head",
+  "options"
+];
+function getParameterSchema(document, parameter) {
+  if (!parameter.schema) {
+    throw new UnsupportedSchemaError(
+      `Parameter "${parameter.name}" in "${parameter.in}" is missing schema definition.`
+    );
+  }
+  resolveSchema(document, parameter.schema);
+  return parameter.schema;
+}
+function dereferenceParameter(document, parameter) {
+  if (!("$ref" in parameter)) {
+    return parameter;
+  }
+  return resolveLocalComponent(parameter, document.components?.parameters, "parameters");
+}
+function extractParameters(document, parameters) {
+  return (parameters ?? []).map((parameter) => dereferenceParameter(document, parameter)).filter((parameter) => parameter.in === "path" || parameter.in === "query").map((parameter) => ({
+    description: parameter.description,
+    explode: parameter.explode,
+    style: parameter.style,
+    in: parameter.in === "path" ? "path" : "query",
+    name: parameter.name,
+    required: parameter.in === "path" ? true : parameter.required ?? false,
+    schema: getParameterSchema(document, parameter)
+  }));
+}
+function mergeParameters(document, pathParameters, operationParameters) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const parameter of extractParameters(document, pathParameters)) {
+    merged.set(`${parameter.in}:${parameter.name}`, parameter);
+  }
+  for (const parameter of extractParameters(document, operationParameters)) {
+    merged.set(`${parameter.in}:${parameter.name}`, parameter);
+  }
+  return [...merged.values()];
+}
+function getJsonContent(container) {
+  const content = container.content ?? {};
+  const entries = Object.entries(content);
+  for (const [contentType, value] of entries) {
+    if (contentType === "application/json" || contentType.endsWith("+json")) {
+      return { contentType, value };
+    }
+  }
+  return null;
+}
+function extractRequestBody(document, requestBody) {
+  if (!requestBody) {
+    return void 0;
+  }
+  const resolved = "$ref" in requestBody ? resolveRequestBody(document, requestBody) : requestBody;
+  const jsonContent = getJsonContent(resolved);
+  if (!jsonContent) {
+    throw new UnsupportedSchemaError("Only JSON request bodies are supported.");
+  }
+  const schema = jsonContent.value.schema;
+  if (!schema) {
+    throw new UnsupportedSchemaError("JSON request body must include a schema.");
+  }
+  return {
+    contentType: jsonContent.contentType,
+    required: resolved.required ?? false,
+    schema
+  };
+}
+function resolveRequestBody(document, requestBody) {
+  return resolveLocalComponent(requestBody, document.components?.requestBodies, "requestBodies");
+}
+function extractResponse(operation) {
+  const entries = Object.entries(operation.responses ?? {});
+  const successfulEntry = entries.find(([status]) => /^2(?:\d\d|XX)$/i.test(status)) ?? entries[0];
+  if (!successfulEntry) {
+    return {
+      response: {
+        description: "No content"
+      },
+      statusCode: "204"
+    };
+  }
+  return {
+    response: successfulEntry[1],
+    statusCode: successfulEntry[0]
+  };
+}
+function resolveResponse(document, response) {
+  if (!("$ref" in response)) {
+    return response;
+  }
+  return resolveLocalComponent(response, document.components?.responses, "responses");
+}
+function parseResponse(document, operation) {
+  const { response, statusCode } = extractResponse(operation);
+  const resolved = resolveResponse(document, response);
+  const jsonContent = getJsonContent(resolved);
+  return {
+    contentType: jsonContent?.contentType,
+    description: resolved.description,
+    schema: jsonContent?.value.schema,
+    statusCode
+  };
+}
+function hasRequiredRequestFields(parameters, requestBody) {
+  return parameters.some((parameter) => parameter.required) || Boolean(requestBody?.required);
+}
+function parseDocument(document, options = {}) {
+  const operations = [];
+  const functionNames = /* @__PURE__ */ new Set();
+  const typeNames = /* @__PURE__ */ new Set([
+    "ClientConfig",
+    "ApiError",
+    `${deriveSdkName(options.sdkName ?? document.info.title)}Client`
+  ]);
+  for (const name of Object.keys(document.components?.schemas ?? {})) {
+    const typeName = toTypeName(name);
+    if (typeNames.has(typeName)) {
+      throw new SchemaValidationError(`Duplicate or reserved generated type name "${typeName}".`);
+    }
+    typeNames.add(typeName);
+  }
+  for (const [pathKey, pathItem] of Object.entries(document.paths ?? {})) {
+    if (!pathItem || "$ref" in pathItem) {
+      throw new UnsupportedSchemaError(`Path-level $ref is not supported for path "${pathKey}".`);
+    }
+    if (pathItem.trace) {
+      throw new UnsupportedSchemaError("TRACE operations are not supported by the Fetch API.");
+    }
+    for (const method of SUPPORTED_METHODS) {
+      const operation = pathItem[method];
+      if (!operation) {
+        continue;
+      }
+      const functionName = createFunctionName(method, pathKey, operation.operationId);
+      if (functionNames.has(functionName)) {
+        throw new SchemaValidationError(
+          `Duplicate generated operation name "${functionName}". Use unique operationId values.`
+        );
+      }
+      functionNames.add(functionName);
+      const allocateTypeName = (base) => {
+        let name = base;
+        let suffix = 2;
+        while (typeNames.has(name)) name = `${base}${suffix++}`;
+        typeNames.add(name);
+        return name;
+      };
+      const requestTypeName = allocateTypeName(`${toTypeName(functionName)}Request`);
+      const responseTypeName = allocateTypeName(`${toTypeName(functionName)}Response`);
+      const mergedParameters = mergeParameters(document, pathItem.parameters, operation.parameters);
+      const queryParameters = mergedParameters.filter((parameter) => parameter.in === "query");
+      const extractedPathParameters = mergedParameters.filter(
+        (parameter) => parameter.in === "path"
+      );
+      const requestBody = extractRequestBody(document, operation.requestBody);
+      const response = parseResponse(document, operation);
+      const requestNames = /* @__PURE__ */ new Set();
+      for (const parameter of mergedParameters) {
+        if (requestNames.has(parameter.name) || parameter.name === "body" && requestBody) {
+          throw new UnsupportedSchemaError(
+            `Request field "${parameter.name}" collides in ${method.toUpperCase()} ${pathKey}.`
+          );
+        }
+        requestNames.add(parameter.name);
+        if (parameter.in === "query") {
+          const schema = resolveSchema(document, parameter.schema);
+          const style = parameter.style ?? "form";
+          if (schema.type === "object" || schema.properties || !["form", "spaceDelimited", "pipeDelimited"].includes(style)) {
+            throw new UnsupportedSchemaError(
+              `Unsupported query serialization for "${parameter.name}": ${style}.`
+            );
+          }
+        }
+      }
+      for (const match of pathKey.matchAll(/\{([^}]+)\}/g)) {
+        if (!extractedPathParameters.some((parameter) => parameter.name === match[1])) {
+          throw new SchemaValidationError(
+            `Missing path parameter "${match[1]}" in ${method.toUpperCase()} ${pathKey}.`
+          );
+        }
+      }
+      const hasRequestShape = extractedPathParameters.length + queryParameters.length > 0 || Boolean(requestBody);
+      operations.push({
+        description: operation.description,
+        functionName,
+        hasRequiredRequestFields: hasRequiredRequestFields(mergedParameters, requestBody),
+        hasRequestShape,
+        method,
+        operationId: operation.operationId,
+        path: pathKey,
+        pathParameters: extractedPathParameters,
+        queryParameters,
+        requestBody,
+        requestTypeName,
+        response,
+        responseTypeName,
+        summary: operation.summary
+      });
+    }
+  }
+  const sdkName = deriveSdkName(options.sdkName ?? document.info.title);
+  const defaultBaseUrl = options.baseUrl ?? document.servers?.[0]?.url;
+  return {
+    componentSchemas: document.components?.schemas ?? {},
+    defaultBaseUrl,
+    document,
+    operations,
+    sdkName
+  };
+}
+
+// src/writer.ts
+var import_promises2 = require("fs/promises");
+var import_node_os = __toESM(require("os"), 1);
+var import_node_path2 = __toESM(require("path"), 1);
+function resolveGeneratedFiles(outputDir, files) {
+  const outputRoot = import_node_path2.default.resolve(outputDir);
+  const seenPaths = /* @__PURE__ */ new Set();
+  return files.map((file) => {
+    const fullPath = import_node_path2.default.resolve(outputRoot, file.path);
+    const relativePath = import_node_path2.default.relative(outputRoot, fullPath);
+    if (!relativePath || relativePath === ".." || relativePath.startsWith(`..${import_node_path2.default.sep}`) || import_node_path2.default.isAbsolute(relativePath)) {
+      throw new OutputWriteError(
+        `Generated file path "${file.path}" must stay within the output directory.`
+      );
+    }
+    if (seenPaths.has(fullPath)) {
+      throw new OutputWriteError(`Duplicate generated file path "${file.path}".`);
+    }
+    seenPaths.add(fullPath);
+    return { ...file, fullPath };
+  });
+}
+async function writeGeneratedFiles(outputDir, files, clean = false) {
+  try {
+    const resolvedFiles = resolveGeneratedFiles(outputDir, files);
+    if (clean) {
+      const outputRoot = import_node_path2.default.resolve(outputDir);
+      const relativeCwd = import_node_path2.default.relative(outputRoot, process.cwd());
+      if (outputRoot === import_node_os.default.homedir() || relativeCwd === "" || relativeCwd !== ".." && !relativeCwd.startsWith(`..${import_node_path2.default.sep}`) && !import_node_path2.default.isAbsolute(relativeCwd)) {
+        throw new OutputWriteError(
+          "Refusing to clean the home directory, working directory, or its ancestors."
+        );
+      }
+      await (0, import_promises2.rm)(outputDir, { force: true, recursive: true });
+    }
+    await (0, import_promises2.mkdir)(outputDir, { recursive: true });
+    await Promise.all(
+      resolvedFiles.map(async (file) => {
+        await (0, import_promises2.mkdir)(import_node_path2.default.dirname(file.fullPath), { recursive: true });
+        await (0, import_promises2.writeFile)(file.fullPath, file.content, "utf8");
+      })
+    );
+  } catch (error) {
+    if (error instanceof OutputWriteError) {
+      throw error;
+    }
+    throw new OutputWriteError(`Failed to write generated SDK to "${outputDir}".`, error);
+  }
+}
+async function compareGeneratedFiles(outputDir, files) {
+  const changedFiles = [];
+  for (const file of resolveGeneratedFiles(outputDir, files)) {
+    try {
+      if (await (0, import_promises2.readFile)(file.fullPath, "utf8") !== file.content) {
+        changedFiles.push(file.path);
+      }
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        changedFiles.push(file.path);
+      } else {
+        throw new OutputWriteError(`Failed to compare generated file "${file.fullPath}".`, error);
+      }
+    }
+  }
+  return changedFiles;
+}
+
+// src/generate-sdk.ts
+async function generateSdk(options) {
+  const logger = options.logger ?? noopLogger;
+  if (options.check && options.dryRun) {
+    throw new OutputWriteError("The check and dryRun options cannot be combined.");
+  }
+  if (options.clean && !options.check && !options.dryRun && options.input.file) {
+    const relative = import_node_path3.default.relative(
+      import_node_path3.default.resolve(options.outputDir),
+      import_node_path3.default.resolve(options.input.file)
+    );
+    if (relative !== ".." && !relative.startsWith(`..${import_node_path3.default.sep}`) && !import_node_path3.default.isAbsolute(relative)) {
+      throw new OutputWriteError("Cannot clean an output directory containing the input schema.");
+    }
+  }
+  logger.info("Loading OpenAPI document");
+  const document = await loadOpenApiDocument(options.input, {
+    fetchImplementation: options.fetchImplementation,
+    logger
+  });
+  logger.info("Parsing OpenAPI document");
+  const parsed = parseDocument(document, {
+    baseUrl: options.baseUrl,
+    sdkName: options.sdkName
+  });
+  logger.info(`Generating SDK for ${parsed.operations.length} operations`);
+  const files = await formatGeneratedFiles([
+    {
+      content: generateTypesSource(parsed),
+      path: "types.ts"
+    },
+    {
+      content: generateClientSource(parsed),
+      path: "client.ts"
+    },
+    {
+      content: generateIndexSource(),
+      path: "index.ts"
+    },
+    {
+      content: generateGeneratedReadme(parsed),
+      path: "README.md"
+    }
+  ]);
+  const changedFiles = options.check ? await compareGeneratedFiles(options.outputDir, files) : [];
+  if (!options.check && !options.dryRun) {
+    logger.info(`Writing SDK to ${options.outputDir}`);
+    await writeGeneratedFiles(options.outputDir, files, options.clean);
+  }
+  return {
+    changedFiles,
+    files,
+    operations: parsed.operations.length,
+    outputDir: options.outputDir,
+    sdkName: parsed.sdkName
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApiSdkGeneratorError,
+  OutputWriteError,
+  SchemaLoadError,
+  SchemaValidationError,
+  UnsupportedSchemaError,
+  createFunctionName,
+  createLogger,
+  deriveSdkName,
+  generateSdk,
+  getReferenceName,
+  isReferenceObject,
+  isSchemaObject,
+  loadOpenApiDocument,
+  loadOpenApiDocumentFromFile,
+  loadOpenApiDocumentFromUrl,
+  noopLogger,
+  parseDocument,
+  resolveLocalComponent,
+  resolveSchema,
+  sanitizeIdentifier,
+  toCamelCase,
+  toPascalCase,
+  toPropertyAccessor,
+  toTypeName,
+  validateOpenApiDocument
+});
+//# sourceMappingURL=index.cjs.map