@sebspark/openapi-typegen 0.2.0 → 1.1.0

package/dist/index.js

@@ -30,549 +30,821 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  generate: () => generate
+  generate: () => generate2,
+  generateTypescript: () => generateTypescript
 });
 module.exports = __toCommonJS(src_exports);
-
-// src/generator.ts
-var fastGlob = __toESM(require("fast-glob"));
-var import_promises = require("fs/promises");
 var import_path = require("path");
-var import_yaml = require("yaml");
-
-// src/shared/format.ts
-var prettier = require("prettier");
-var header = `/**
- * This file was auto-generated.
- * Do not make direct changes to the file.
- */
+var import_change_case2 = require("change-case");
+var import_promises = require("fs/promises");
+var YAML = __toESM(require("yaml"));
 
-import type {
-  APIServerDefinition,
-  BaseClient,
-  GenericRouteHandler,
-} from '@sebspark/openapi-core'
-import type { Request } from 'express'
+// src/generator/common.ts
+var import_change_case = require("change-case");
 
-type Req = Pick<Request, 'url' | 'baseUrl' | 'cookies' | 'hostname'>
- 
-/* tslint:disable */
-/* eslint-disable */`;
-var formatFile = async (rows) => {
-  const withHeader = [header, ...rows];
-  const code = withHeader.join("\n\n");
-  const formatted = await prettier.format(code, {
-    parser: "typescript",
-    singleQuote: true,
-    semi: false
-  });
-  return formatted;
+// src/generator/document.ts
+var document = ({ title, description }) => {
+  if (title || description) {
+    const tokens = [];
+    tokens.push("/**");
+    if (title)
+      tokens.push(` * ${title}`);
+    if (description)
+      tokens.push(` * ${description}`);
+    tokens.push(" */\n");
+    return tokens.join("\n");
+  }
+  return "";
 };
-
-// src/shared/imports/format.ts
-var formatImports = (imports) => {
-  const rows = [];
-  const importsMap = imports.reduce(
-    (map, it) => {
-      if (!map[it.file])
-        map[it.file] = /* @__PURE__ */ new Set();
-      map[it.file].add(it.type);
-      return map;
-    },
-    {}
+var documentClientPath = (path, responses) => documentPath(
+  path,
+  responses,
+  [param("url", "string")],
+  [param("opts", "RequestOptions", true)]
+);
+var documentServerPath = (path, responses) => documentPath(path, responses);
+var documentPath = (path, responses, argsBefore = [], argsAfter = []) => {
+  const tokens = [];
+  tokens.push("/**");
+  if (path.title)
+    tokens.push(` * ${path.title}`);
+  if (path.description)
+    tokens.push(` * ${path.description}`);
+  tokens.push(" *");
+  tokens.push(...argsBefore);
+  if (path.args)
+    tokens.push(...documentArgs(path.args));
+  tokens.push(...argsAfter);
+  tokens.push(` * @returns {Promise<${responses}>}`);
+  tokens.push(" */");
+  return tokens.join("\n");
+};
+var documentArgs = (args) => {
+  const tokens = [];
+  tokens.push(
+    param(
+      "args",
+      "Object",
+      argsOptional(args),
+      "The arguments for the request."
+    )
   );
-  Object.entries(importsMap).forEach(([file, types]) => {
-    rows.push(`import { ${Array.from(types).join(", ")} } from './${file}'`);
-  });
-  return rows;
+  tokens.push(...requestArgs(args.path, "params", "Path parameters"));
+  tokens.push(...requestArgs(args.query, "query", "Query parameters"));
+  tokens.push(...requestArgs(args.header, "headers", "Headers"));
+  tokens.push(...requestArgs(args.body, "body", "Request body"));
+  return tokens;
+};
+var buildPath = (path, property) => rxProperVariable.test(property) ? `${path}.${property}` : `${path}["${property}"]`;
+var requestArgs = (args, name, title) => {
+  if (!args)
+    return [];
+  const tokens = [];
+  const type = args.extends.map((e) => e.type).join(AND) || "Object";
+  tokens.push(
+    param(
+      buildPath("args", name),
+      type,
+      args.optional,
+      `${title} for the request.`
+    )
+  );
+  const properties = args.properties.flatMap(
+    (prop) => requestProperty(buildPath("args", name), prop)
+  );
+  tokens.push(...properties);
+  return tokens;
+};
+var requestProperty = (path, property) => {
+  const tokens = [];
+  const type = property.type.map((t) => t.type).join(OR);
+  tokens.push(
+    param(
+      buildPath(path, property.name),
+      type,
+      property.optional,
+      property.title,
+      property.description
+    )
+  );
+  return tokens;
+};
+var param = (name, type, optional = false, title = "", description = "") => {
+  const tokens = [];
+  tokens.push(
+    ` * @param {${type}} ${optional ? "[" : ""}${name}${optional ? "]" : ""}`
+  );
+  if (optional || title || description) {
+    tokens.push(" -");
+    if (optional)
+      tokens.push(" Optional.");
+    if (title)
+      tokens.push(` ${title}`);
+    if (description)
+      tokens.push(` ${description}`);
+  }
+  return tokens.join("");
 };
 
-// src/shared/schema/format.ts
-var formatDocs = (description) => {
-  if (description) {
-    return `
-/**
-* ${description}
- */
-`;
-  } else {
-    return "";
+// src/generator/common.ts
+var OR = " | ";
+var AND = " & ";
+var generateType = (parsed) => {
+  let type;
+  switch (parsed.type) {
+    case "enum": {
+      type = generateEnum(parsed);
+      break;
+    }
+    case "array": {
+      type = generateArray(parsed);
+      break;
+    }
+    case "object": {
+      type = generateObject(parsed);
+      break;
+    }
+    case "Date":
+    case "bigint":
+    case "boolean":
+    case "null":
+    case "number":
+    case "string":
+    case "symbol":
+    case "undefined":
+      type = generatePrimitive(parsed);
+      break;
+    default: {
+      type = generateCustom(parsed);
+    }
   }
+  return type.replace(/ & \{\s*\}/g, "");
 };
-var formatTypeName = (name) => {
-  return name.replace(/[^a-zA-Z0-9_$]/g, "_");
+var generateProperty = (property) => {
+  const types = property.type.map(generateType);
+  return `${document(property)}${propertyName(property.name)}${property.optional ? "?" : ""}: ${types.join(OR) || "unknown"}`;
 };
-var formatParsedType = (parsedType) => {
-  return `${formatDocs(parsedType.description)}export type ${parsedType.name} = ${parsedType.type}`;
+var preamble = (type) => type.name ? `${document(type)}export type ${typeName(type.name)} = ` : "";
+var typeName = (name) => {
+  if (rxProperVariable.test(name))
+    return name;
+  return (0, import_change_case.pascalCase)(name);
 };
-var formatParsedTypes = (types) => {
-  const rows = [];
-  Object.values(types).forEach((values) => rows.push(formatParsedType(values)));
-  return rows;
+var propertyName = (name) => {
+  if (rxProperVariable.test(name))
+    return name;
+  return `'${name}'`;
 };
-var formatProperties = (properties) => {
-  const allProps = properties.map(({ name, required, value, description }) => {
-    return `${formatDocs(description)}'${name}'${required ? "" : "?"}: ${value}`;
-  }).join(`; `);
-  return `{${allProps}}`;
+var rxProperVariable = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
+var extensions = (type) => type.extends.map(generateType).concat("").join(AND);
+var generatePrimitive = (parsed) => `${preamble(parsed)}${parsed.type}`;
+var generateCustom = (parsed) => `${preamble(parsed)}${typeName(parsed.type)}`;
+var generateObject = (parsed) => {
+  const lines = [];
+  lines.push(`${preamble(parsed)}${extensions(parsed)}{`);
+  lines.push(...parsed.properties.map(generateProperty));
+  lines.push("}");
+  return lines.join("\n");
 };
-
-// src/shared/schema/parser.ts
-var parseRefString = (refString, addImport) => {
-  const [file, rest] = refString.split("#");
-  const typeName = formatTypeName(rest.substring(rest.lastIndexOf("/") + 1));
-  if (file && file.length > 0) {
-    const [fileName] = file.split(".");
-    addImport({ file: fileName, type: typeName });
-  }
-  return typeName;
-};
-var parseTypes = (schemas) => {
-  const imports = [];
-  const types = Object.entries(schemas).map(([name, schema]) => {
-    const schemaObj = schema;
-    return {
-      name: formatTypeName(name),
-      type: generateFromSchemaObject(schemaObj, (importData) => {
-        imports.push(importData);
-      }),
-      description: schemaObj.description
-    };
-  });
-  return [types, imports];
-};
-var guessType = (schema) => {
-  if (schema.type) {
-    return schema.type;
-  } else if (schema.enum) {
-    return "string";
-  } else if (schema.properties) {
-    return "object";
-  } else {
-    return void 0;
+var generateArray = (parsed) => {
+  const lines = [];
+  lines.push(`${preamble(parsed)}${parsed.items.type}[]`);
+  return lines.join("\n");
+};
+var generateEnum = (parsed) => {
+  return `${preamble(parsed)}${parsed.values.map(serializeValue).join(OR)}`;
+};
+var generateHeader = (header) => {
+  return `${preamble(header)}{ ${propertyName(header.name)}${header.optional ? "?" : ""}: ${generateType(header.type)} }`;
+};
+var generateResponseBody = (type) => {
+  const customType = type.type;
+  if (customType)
+    return typeName(customType);
+  const body = type;
+  if (!body.data && !body.headers)
+    return "undefined";
+  const tokens = [];
+  tokens.push(preamble(body));
+  tokens.push("APIResponse<");
+  tokens.push(body.data ? generateType(body.data) : "undefined");
+  if (body.headers) {
+    tokens.push(", ");
+    tokens.push(body.headers ? generateHeaders(body.headers) : "undefined");
   }
+  tokens.push(">");
+  return tokens.join("");
 };
-var generateFromSchemaObject = (schema, addImport) => {
-  if ("$ref" in schema) {
-    const { $ref } = schema;
-    return parseRefString($ref, addImport);
-  }
-  const type = guessType(schema);
-  let schemaString = "";
-  if (type) {
-    if (type === "object") {
-      schemaString = generateObject(schema, addImport);
-    } else if (type === "array") {
-      const arrayType = generateFromSchemaObject(schema.items, addImport);
-      if (arrayType && arrayType.length) {
-        schemaString = `(${arrayType})[]`;
-      } else {
-        schemaString = "[]";
-      }
-    } else {
-      switch (type) {
-        case "integer":
-          schemaString = "number";
-          break;
-        case "string": {
-          if (schema.format === "date-time" || schema.format === "date") {
-            schemaString = "Date";
-          } else if (schema.enum) {
-            schemaString = schema.enum.map((it) => `'${it}'`).join(" | ");
-          } else {
-            schemaString = "string";
-          }
-          break;
-        }
-        default:
-          schemaString = type;
+var generateHeaders = (headers) => {
+  const tokens = [];
+  for (const header of headers) {
+    tokens.push(
+      `${propertyName(header.name)}${header.optional ? "?" : ""}: ${generateType(header.type)}`
+    );
+  }
+  return `{${tokens.join(", ")}}`;
+};
+var serializeValue = (value) => {
+  if (typeof value === "string")
+    return `'${value}'`;
+  return value;
+};
+
+// src/generator/args.ts
+var generateClientArgs = (args) => generateArgs(args, false);
+var generateServerArgs = (args) => args ? generateArgs(args, true) : "args: Req";
+var parts = ["body", "header", "path", "query"];
+var generateArgs = (args, extendsReq) => {
+  if (args) {
+    const tokens = [];
+    for (const part of parts) {
+      const arg = args[part];
+      if (arg) {
+        const partName = part === "path" ? "params" : part === "header" ? "headers" : part;
+        tokens.push(
+          `${partName}${arg.optional ? "?" : ""}: ${generateType(arg)}`
+        );
       }
     }
+    if (!tokens.length)
+      return "";
+    const optional = argsOptional(args);
+    return `args${optional ? "?" : ""}: ${extendsReq ? "Req & " : ""}{ ${tokens.join(", ")} }, `;
   }
-  if (schema.allOf) {
-    const allOfString = schema.allOf.map((it) => generateFromSchemaObject(it, addImport)).join(" & ");
-    if (allOfString.length > 0) {
-      schemaString = schemaString + " & " + allOfString;
+  return "";
+};
+var argsOptional = (args) => (
+  // biome-ignore lint/style/noNonNullAssertion: <explanation>
+  parts.reduce((o, p) => o && (!args[p] || args[p].optional), true)
+);
+
+// src/generator/client.ts
+var generateClient = (name, paths) => {
+  var _a;
+  const groupedCalls = {};
+  for (const path of paths) {
+    if (!groupedCalls[path.method]) {
+      groupedCalls[path.method] = [];
     }
+    (_a = groupedCalls[path.method]) == null ? void 0 : _a.push(generateCall(path));
   }
-  if (schema.anyOf) {
-    const anyOfString = schema.anyOf.map((it) => generateFromSchemaObject(it, addImport)).map((it) => `Partial<${it}>`).join(" & ");
-    if (anyOfString.length > 0) {
-      schemaString = schemaString + " & " + anyOfString;
-    }
+  const client = [];
+  const methods = Object.keys(groupedCalls).map(serializeValue).join(OR);
+  client.push(`export type ${name}Client = Pick<BaseClient, ${methods}> & {`);
+  Object.entries(groupedCalls).forEach(([method, calls]) => {
+    client.push(`${method}: {`);
+    client.push(...calls);
+    client.push("}");
+  });
+  client.push("}");
+  return client.join("\n");
+};
+var generateCall = (path) => {
+  const responses = generateResponses(path);
+  return `${documentClientPath(path, responses)}
+  (
+    url: '${path.url}', ${generateClientArgs(path.args)}opts?: RequestOptions,
+  ): Promise<${responses}>`;
+};
+var generateResponses = (path) => Object.entries(path.responses).filter(([code]) => parseInt(code, 10) < 400).map(([, type]) => generateResponseBody(type)).join(OR);
+
+// src/generator/server.ts
+var generateServer = (name, paths) => {
+  const tokens = [];
+  tokens.push(`export type ${name}Server = APIServerDefinition & {`);
+  for (const [url, methods] of Object.entries(groupPathsByUrl(paths))) {
+    tokens.push(generatePath(url, methods));
   }
-  if (schema.oneOf) {
-    const oneOfString = schema.oneOf.map((it) => generateFromSchemaObject(it, addImport)).join(" | ");
-    if (oneOfString.length > 0) {
-      schemaString = schemaString + " & (" + oneOfString + ")";
-    }
+  tokens.push("}");
+  return tokens.join("\n");
+};
+var groupPathsByUrl = (paths) => paths.reduce(
+  (group, path) => {
+    if (!group[path.url])
+      group[path.url] = [];
+    group[path.url].push(path);
+    return group;
+  },
+  {}
+);
+var generatePath = (url, methods) => `'${url}': {
+    ${methods.map(generateMethod).join("\n")}
+  }`;
+var generateMethod = (path) => {
+  const responses = generateResponses2(path.responses);
+  return `${path.method}: {
+      ${documentServerPath(path, responses)}
+      handler: (${generateServerArgs(path.args)}) => Promise<${responses}>
+      pre?: GenericRouteHandler | GenericRouteHandler[]
+    }`;
+};
+var generateResponses2 = (responses) => Object.entries(responses).filter(([code]) => parseInt(code, 10) < 400).map(([code, response]) => generateResponse(parseInt(code, 10), response)).join(OR);
+var generateResponse = (code, response) => `[${code}, ${generateResponseBody(response)}]`;
+
+// src/generator/generator.ts
+var generate = (name, doc) => `
+ /**
+  * This file was auto-generated.
+  * Do not make direct changes to the file.
+  */
+ 
+ import type {
+   APIResponse,
+   APIServerDefinition,
+   BaseClient,
+   GenericRouteHandler,
+   RequestOptions,
+ } from '@sebspark/openapi-core'
+ import type { Request } from 'express'
+ 
+ type Req = Pick<Request, 'url' | 'baseUrl' | 'cookies' | 'hostname'>
+ 
+ /* tslint:disable */
+ /* eslint-disable */
+ 
+ ${generateComponents(doc.components)}
+
+ ${generateServer(name, doc.paths)}
+
+ ${generateClient(name, doc.paths)}
+
+`;
+var generateComponents = (components) => {
+  const tokens = [];
+  for (const schema of components.schemas) {
+    tokens.push(generateType(schema));
   }
-  if (!schemaString || !schemaString.length) {
-    schemaString = "string";
-  }
-  return schemaString;
-};
-var generateObject = (schema, addImport) => {
-  const requiredFields = schema.required ?? [];
-  const properties = Object.entries(
-    schema.properties ?? []
-  ).map(([name, schema2]) => ({
-    [name]: {
-      name,
-      value: generateFromSchemaObject(schema2, addImport),
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      description: schema2["description"],
-      required: requiredFields.includes(name)
-    }
-  })).reduce((acc, current) => {
-    for (const key in current) {
-      acc[key] = current[key];
-    }
-    return acc;
-  }, {});
-  return formatProperties(Object.values(properties));
+  for (const header of components.headers) {
+    tokens.push(generateHeader(header));
+  }
+  for (const param2 of components.parameters) {
+    tokens.push(
+      generateType({
+        type: "object",
+        extends: [],
+        name: param2.name,
+        properties: [
+          {
+            name: param2.parameterName,
+            type: [param2.type],
+            optional: param2.optional
+          }
+        ]
+      })
+    );
+  }
+  for (const req of components.requestBodies) {
+    tokens.push(generateType(req));
+  }
+  for (const res of components.responseBodies) {
+    tokens.push(generateResponseBody(res));
+  }
+  return tokens.join("\n\n");
 };
 
-// src/shared/schema/generator.ts
-var generateSchemas = (components) => {
-  const [types, imports] = parseTypes(components.components.schemas);
-  return formatFile([...formatImports(imports), ...formatParsedTypes(types)]);
+// src/generator/formatter.ts
+var import_prettier = require("prettier");
+var options = {
+  parser: "typescript",
+  singleQuote: true,
+  semi: false,
+  trailingComma: "all"
 };
+var format = async (code) => (0, import_prettier.format)(code, options);
 
-// src/format.ts
-var formatTitle = (title) => {
-  return title.replace(/ /g, "").replace(/[^a-zA-Z0-9]/g, "_");
+// src/parser/common.ts
+var parseRef = (ref) => ref.substring(ref.lastIndexOf("/") + 1);
+var parseEnumType = (name, schema) => ({ name, type: "enum", values: schema.enum || [] });
+var findRef = (components, ref) => {
+  const [, , path, name] = ref.split("/");
+  const schemaPath = components[path];
+  if (!schemaPath || !schemaPath[name])
+    throw new Error(`Cannot find ref ${ref}`);
+  return schemaPath[name];
+};
+var parseDocumentation = (source) => {
+  const documented = {};
+  if (source.title)
+    documented.title = source.title;
+  if (source.description)
+    documented.description = source.description;
+  return documented;
 };
 
-// src/openapi/format.ts
-var import_change_case = require("change-case");
-var formatRoutes = (title, routes) => {
-  const formattedTitle = formatTitle(title);
-  const routeDefinitions = generateRouteDefinitions(routes);
-  const server = generateServerAPI(formattedTitle, routeDefinitions);
-  const client = generateClientAPI(formattedTitle, routeDefinitions);
-  return server.concat(client);
-};
-var generateServerAPI = (name, routes) => {
-  const map = generateServerType(routes);
-  const rows = [];
-  rows.push(
-    `export type ${name}Server = APIServerDefinition & {
-${Object.entries(map).map(
-      ([url, methods]) => `  '${url}': {
-${Object.entries(methods).map(
-        ([method, definition]) => `    '${method}': {
-    handler: (${serializeArgs(definition.args, true)}) => Promise<[${definition.response.code}, ${definition.response.type}]>
-    pre?: GenericRouteHandler | GenericRouteHandler[]
-  }`
-      ).join("\n")}
-  },`
-    ).join("\n")}
-}
-`
-  );
-  return rows;
-};
-var generateClientAPI = (name, routes) => {
-  const code = [];
-  const clientHandlers = [];
-  const verbMap = generateClientType(routes);
-  Object.entries(verbMap).forEach(([verb, definitions]) => {
-    const type = `${name}Client${(0, import_change_case.pascalCase)(verb)}`;
-    clientHandlers.push(`${verb}: ${type}`);
-    code.push(`type ${type} = {`);
-    definitions.forEach((def) => {
-      const args = serializeArgs(def.args);
-      const argsString = args ? `, ${args}` : "";
-      code.push(
-        `(url: '${def.url}'${argsString}): Promise<${def.response.type}>`
-      );
-    });
-    code.push("}");
-  });
-  code.push(
-    `export type ${name}Client = Pick<BaseClient, ${Object.keys(verbMap).map((v) => `'${v}'`).join(" | ")}> & {`
-  );
-  code.push(clientHandlers.join("\n"));
-  code.push("}");
-  return code;
-};
-var generateRouteDefinitions = (routes) => routes.map((route) => ({
-  method: route.method.toLowerCase(),
-  response: route.response,
-  url: route.url,
-  args: parseArgs(route)
-}));
-var generateClientType = (routes) => routes.reduce((router, routeDefinition) => {
-  if (!router[routeDefinition.method])
-    router[routeDefinition.method] = [];
-  router[routeDefinition.method].push(routeDefinition);
-  return router;
-}, {});
-var generateServerType = (routes) => routes.reduce((router, routeDefinition) => {
-  const route = router[routeDefinition.url] || {};
-  route[routeDefinition.method] = routeDefinition;
-  router[routeDefinition.url] = route;
-  return router;
-}, {});
-var parseArgs = (route) => {
-  const args = {};
-  if (route.requestParams !== "never")
-    args.params = route.requestParams;
-  if (route.requestQuery !== "never")
-    args.query = route.requestQuery;
-  if (route.requestHeaders !== "never")
-    args.headers = route.requestHeaders;
-  if (route.requestBody !== "never")
-    args.body = route.requestBody;
-  if (args.headers || args.params || args.query || args.body)
-    return args;
+// src/parser/schema.ts
+var parseSchemas = (schemas = {}) => Object.entries(schemas || {}).map(
+  ([name, schema]) => parseSchema(name, schema)
+);
+var parseSchema = (name, schemaOrRef) => {
+  const ref = schemaOrRef.$ref;
+  if (ref) {
+    return { name, type: parseRef(ref) };
+  }
+  const schema = schemaOrRef;
+  switch (schema.type) {
+    case "array":
+      return parseArraySchema(name, schema);
+    case "boolean":
+    case "integer":
+    case "number":
+    case "string":
+      return schema.enum ? parseEnumType(name, schema) : parsePropertyType(schema)[0];
+    default:
+      return parseObjectSchema(name, schema);
+  }
 };
-var optional = (params) => {
-  const rxRequiredParams = /(?<!\?\s*)\b['"]?\w+['"]?\s*:\s*\w+/gim;
-  const anyRequired = rxRequiredParams.test(params) || !params.includes(":");
-  return anyRequired ? "" : "?";
+var parseObjectSchema = (name, schema) => {
+  const type = {
+    name,
+    type: "object",
+    properties: [],
+    extends: [],
+    ...parseDocumentation(schema)
+  };
+  if (schema.properties) {
+    type.properties = Object.entries(schema.properties).map(
+      ([name2, property]) => parseProperty(name2, property, schema.required || [])
+    );
+  }
+  if (schema.allOf) {
+    type.extends = schema.allOf.flatMap(parsePropertyType);
+  }
+  return type;
 };
-var serializeArgs = (args, includeRequest = false) => {
-  if (!args)
-    return "";
-  const argsString = Object.entries(args).map(([key, value]) => {
-    return `${key}${optional(value)}: ${value}`;
-  }).join(",");
-  return `args${optional(argsString)}: ${includeRequest ? "Req & " : ""}{${argsString}}`;
+var parseArraySchema = (name, schema) => {
+  if (schema.type !== "array" || !schema.items)
+    throw new Error("Not an array");
+  return {
+    name,
+    type: "array",
+    items: parsePropertyType(schema.items)[0],
+    ...parseDocumentation(schema)
+  };
 };
-
-// src/openapi/parser.ts
-var parseReferencableObjects = (name, record) => {
-  const objects = {};
-  if (record) {
-    const allParameters = Object.entries(record);
-    const referenceParameters = allParameters.filter((it) => "$ref" in it[1]).map((it) => [it[0], it[1]]);
-    const normalParameters = allParameters.filter((it) => !("$ref" in it[1])).map((it) => [it[0], it[1]]);
-    normalParameters.forEach((it) => {
-      objects[`#/components/${name}/${it[0]}`] = it[1];
-    });
-    referenceParameters.forEach((it) => {
-      objects[`#/components/${name}/${it[0]}`] = objects[it[1].$ref];
+var parseProperty = (name, schema, required) => {
+  const property = {
+    name,
+    optional: !required.includes(name),
+    type: parsePropertyType(schema),
+    ...parseDocumentation(schema)
+  };
+  return property;
+};
+var parsePropertyType = (property) => {
+  const ref = property.$ref;
+  if (ref) {
+    return [{ type: parseRef(ref) }];
+  }
+  const schemaObject = property;
+  if (schemaObject.type) {
+    return (Array.isArray(schemaObject.type) ? schemaObject.type : [schemaObject.type]).map((type) => {
+      switch (type) {
+        case "array": {
+          return parseArraySchema(void 0, schemaObject);
+        }
+        case "object": {
+          return parseObjectSchema(void 0, schemaObject);
+        }
+        case "integer": {
+          return { type: "number", ...parseDocumentation(schemaObject) };
+        }
+        default: {
+          return { type, ...parseDocumentation(schemaObject) };
+        }
+      }
     });
   }
-  return objects;
+  if (schemaObject.allOf) {
+    const types = [];
+    for (const allOf of schemaObject.allOf) {
+      const type = parseSchema(void 0, allOf);
+      delete type.name;
+      types.push(type);
+    }
+    return types;
+  }
+  return [];
 };
 
-// src/openapi/paths.ts
-var pathGenerator = (globalParameters) => {
-  const expressifyPath = (path) => path.replace(/{/g, ":").replace(/}/g, "");
-  const parseResponse = (response, addImports) => {
-    var _a, _b;
-    const schema = (_b = (_a = response.content) == null ? void 0 : _a["application/json"]) == null ? void 0 : _b.schema;
-    if (!schema)
-      return "";
-    return generateFromSchemaObject(schema, addImports);
+// src/parser/headers.ts
+var parseHeaders = (schemas = {}) => Object.entries(schemas || {}).map(
+  ([name, schema]) => parseHeader(name, schema)
+);
+var parseHeader = (name, schema) => {
+  const header = {
+    name,
+    optional: !schema.required,
+    // biome-ignore lint/style/noNonNullAssertion: <explanation>
+    type: parseSchema(void 0, schema.schema),
+    ...parseDocumentation(schema)
   };
-  const getType = (param, addImport) => {
-    if (param.type)
-      param.type;
-    if (param.schema) {
-      if ("type" in param.schema)
-        return generateFromSchemaObject(param.schema, addImport);
-    }
-    return "any";
+  return header;
+};
+
+// src/parser/parameters.ts
+var parseParameters = (schemas = {}) => Object.entries(schemas || {}).map(
+  ([name, schema]) => parseParameter(name, schema)
+);
+var parseParameter = (name, schema) => {
+  const param2 = {
+    name,
+    in: schema.in,
+    parameterName: schema.name,
+    optional: !schema.required,
+    // biome-ignore lint/style/noNonNullAssertion: <explanation>
+    type: parseSchema(void 0, schema.schema),
+    ...parseDocumentation(schema)
   };
-  const propName = (name) => {
-    if (name.indexOf("-") === -1)
-      return name;
-    return `'${name}'`;
+  return param2;
+};
+
+// src/parser/args.ts
+var parseArgs = (path, components) => {
+  var _a;
+  if (!((_a = path.parameters) == null ? void 0 : _a.length) && !path.requestBody)
+    return void 0;
+  const args = {
+    ...parseParameters2(path.parameters, components),
+    ...parseRequestBody(path.requestBody, components)
   };
-  const generateProps = (params, filter, addImport) => {
-    const props = params.map((it) => {
-      if ("$ref" in it) {
-        return globalParameters[it.$ref];
-      } else {
-        return it;
+  return args;
+};
+var createArgs = (initializer = {}) => ({
+  type: "object",
+  extends: [],
+  properties: [],
+  optional: true,
+  ...initializer
+});
+var parseParameters2 = (parameters = [], components = {}) => {
+  const args = {};
+  for (const p of parameters) {
+    const ref = p.$ref;
+    if (ref) {
+      const part = ref.split("/")[2];
+      switch (part) {
+        case "parameters": {
+          const param2 = findRef(components, ref);
+          const arg = args[param2.in] || createArgs({ ...parseDocumentation(param2) });
+          arg.optional = arg.optional && !param2.required;
+          arg.extends.push({ type: parseRef(ref) });
+          args[param2.in] = arg;
+          break;
+        }
+        case "headers": {
+          const header = findRef(components, ref);
+          const arg = args.header || createArgs();
+          const name = parseRef(ref);
+          arg.properties.push({
+            name,
+            optional: !header.required,
+            // biome-ignore lint/style/noNonNullAssertion: <explanation>
+            type: [{ type: parseSchema(void 0, header.schema).type }],
+            ...parseDocumentation(header.schema || {})
+          });
+          args.header = arg;
+          break;
+        }
       }
-    }).filter((p) => p.in === filter).map(
-      (p) => `${propName(p.name)}${p.required ? "" : "?"}: ${getType(
-        p,
-        addImport
-      )}`
-    );
-    if (props.length)
-      return `{${props.join(", ")}}`;
-    return "never";
-  };
-  const generateBody = (body, addImport) => {
-    var _a, _b;
-    if ((_a = body == null ? void 0 : body.content) == null ? void 0 : _a["application/json"]) {
-      const content = (_b = body.content["application/json"]) == null ? void 0 : _b.schema;
-      return generateFromSchemaObject(content, addImport);
+    } else {
+      const param2 = p;
+      const arg = args[param2.in] || createArgs({ ...parseDocumentation(param2) });
+      arg.properties.push({
+        name: param2.name,
+        optional: !param2.required,
+        type: [parseSchema(void 0, param2.schema)]
+      });
+      arg.optional = arg.optional && !param2.required;
+      args[param2.in] = arg;
     }
-    return "never";
-  };
-  const generateResponses = (responses, addImport, errors = false) => {
-    const responseTypes = Object.entries(responses).map(([strCode, response]) => {
-      const code = parseInt(strCode, 10);
-      if (code >= 400 !== errors)
-        return;
-      if ("$ref" in response) {
-        return {
-          code,
-          type: parseRefString(response.$ref, addImport)
-        };
+  }
+  return args;
+};
+var parseRequestBody = (requestBody, components = {}) => {
+  const args = {};
+  if (!requestBody)
+    return args;
+  const ref = requestBody.$ref;
+  if (ref) {
+    const refBody = findRef(components, ref);
+    args.body = createArgs({
+      optional: !refBody.required,
+      extends: [{ type: parseRef(ref) }]
+    });
+  } else {
+    const body = requestBody;
+    const bodyArgs = args.body || createArgs({ optional: !body.required, ...parseDocumentation(body) });
+    if (body.content["application/json"]) {
+      const schema = body.content["application/json"].schema;
+      if (schema) {
+        const parsed = parseSchema(void 0, schema);
+        if (parsed.type === "object") {
+          args.body = {
+            ...parsed,
+            optional: !body.required
+          };
+        } else if (parsed.type) {
+          args.body = createArgs({
+            optional: !body.required,
+            extends: [parsed],
+            ...parseDocumentation(body)
+          });
+        }
       }
-      return {
-        code,
-        type: parseResponse(response, addImport) || "void"
-      };
-    }).filter((r) => r);
-    return responseTypes;
-  };
-  const generateRoutes = (path, item, addImport) => {
-    const verbs = ["get", "post", "put", "patch", "delete"];
-    const routes = verbs.map((verb) => {
-      const operation = item[verb];
-      if (!operation)
-        return void 0;
-      const route = {
-        url: expressifyPath(path),
-        method: verb,
-        requestBody: generateBody(
-          operation.requestBody,
-          addImport
-        ),
-        requestParams: generateProps(
-          operation.parameters || [],
-          "path",
-          addImport
-        ),
-        requestQuery: generateProps(
-          operation.parameters || [],
-          "query",
-          addImport
-        ),
-        requestHeaders: generateProps(
-          operation.parameters || [],
-          "header",
-          addImport
-        ),
-        response: generateResponses(operation.responses, addImport)[0],
-        errorResponses: generateResponses(
-          operation.responses,
-          addImport,
-          true
-        )
-      };
-      return route;
-    }).filter((r) => r);
-    return routes;
-  };
-  const generatePaths = (paths) => {
-    const imports = [];
-    const routes = Object.entries(paths).flatMap(
-      ([path, item]) => generateRoutes(path, item, (imp) => imports.push(imp))
-    );
-    return [routes, imports];
-  };
-  return {
-    generate: generatePaths
-  };
+    }
+    if (bodyArgs.extends.length || bodyArgs.properties.length) {
+      args.body = bodyArgs;
+    }
+  }
+  return args;
 };
 
-// src/openapi/generator.ts
-var generateData = (schema) => {
-  var _a, _b, _c;
-  const [types, importsFromTypes] = ((_a = schema.components) == null ? void 0 : _a.schemas) ? parseTypes(schema.components.schemas) : [[], []];
-  const parameters = parseReferencableObjects(
-    "parameters",
-    ((_b = schema.components) == null ? void 0 : _b.parameters) || {}
-  );
-  const [paths, importsFromPaths] = pathGenerator(parameters).generate(
-    schema.paths || {}
-  );
+// src/parser/responseBodies.ts
+var parseResponseBodies = (responses = {}) => {
+  const bodies = [];
+  for (const [name, b] of Object.entries(responses)) {
+    const body = parseResponseBody(name, b);
+    bodies.push(body);
+  }
+  return bodies;
+};
+var parseResponseBody = (name, response) => {
+  var _a, _b;
+  const ref = response.$ref;
+  if (ref)
+    return { type: parseRef(ref) };
+  const responseObject = response;
+  const body = {};
+  if (name)
+    body.name = name;
+  if (responseObject.description)
+    body.description = responseObject.description;
+  if ((_b = (_a = responseObject.content) == null ? void 0 : _a["application/json"]) == null ? void 0 : _b.schema) {
+    const schema = responseObject.content["application/json"].schema;
+    body.data = parseSchema(void 0, schema);
+  }
+  if (responseObject.headers) {
+    body.headers = [];
+    for (const [headerName, header] of Object.entries(responseObject.headers)) {
+      const ref2 = header.$ref;
+      if (ref2)
+        body.headers.push({
+          name: headerName,
+          optional: false,
+          type: { type: parseRef(ref2) },
+          ...parseDocumentation(header)
+        });
+      else
+        body.headers.push(parseHeader(headerName, header));
+    }
+  }
+  return body;
+};
+
+// src/parser/paths.ts
+var parsePaths = (doc) => Object.entries(doc.paths || {}).flatMap(
+  ([name, path]) => parsePath(name, path, doc.components)
+);
+var parsePath = (url, path, components) => {
+  const paths = [];
+  const methods = ["delete", "get", "patch", "post", "put"];
+  for (const method of methods) {
+    if (path[method]) {
+      paths.push(
+        parseMethod(url, method, path[method], components)
+      );
+    }
+  }
+  return paths;
+};
+var parseMethod = (url, method, operation, components) => {
   return {
-    types,
-    paths,
-    imports: importsFromPaths.concat(importsFromTypes),
-    title: ((_c = schema.info) == null ? void 0 : _c.title) ?? ""
+    method,
+    url: parseUrl(url),
+    responses: parseResponses(operation.responses),
+    args: parseArgs(operation, components),
+    ...parseDocumentation(operation)
   };
 };
-var generateFormattedString = async ({
-  title,
-  imports,
-  paths,
-  types
-}) => {
-  const formattedImports = formatImports(imports);
-  const formattedTypes = formatParsedTypes(types);
-  const formattedRoutes = formatRoutes(title, paths);
-  const formatted = await formatFile([
-    ...formattedImports,
-    ...formattedTypes,
-    ...formattedRoutes
-  ]);
-  return formatted;
-};
-var generateOpenApi = async (schema) => {
-  const data = generateData(schema);
-  const formatted = await generateFormattedString(data);
-  return formatted;
+var parseUrl = (url) => url.replace(/{([^}]+)}/g, ":$1");
+var parseResponses = (responses) => {
+  return Object.assign(
+    {},
+    ...Object.entries(responses).map(([code, response]) => {
+      return {
+        [parseInt(code, 10)]: parseResponseBody(void 0, response)
+      };
+    })
+  );
 };
 
-// src/generator.ts
-var getSchemas = async (input) => {
-  const schemas = {
-    openApi: {},
-    // asyncApi: {},
-    sharedTypes: {}
-  };
-  const files = fastGlob.sync(input, { globstar: true, dot: true });
-  for (const file of files) {
-    const { name } = (0, import_path.parse)(file);
-    const content = await (0, import_promises.readFile)(file, "utf-8");
-    const parsed = file.endsWith(".yaml") || file.endsWith(".yml") ? (0, import_yaml.parse)(content) : JSON.parse(content);
-    if (parsed["asyncapi"]) {
-    } else if (parsed["openapi"]) {
-      schemas.openApi[name] = parsed;
-    } else if (parsed["components"]) {
-      schemas.sharedTypes[name] = parsed;
+// src/parser/requestBodies.ts
+var parseRequestBodies = (requestBodies = {}) => {
+  const definitions = [];
+  for (const [name, requestBody] of Object.entries(requestBodies)) {
+    if (requestBody.content["application/json"].schema) {
+      definitions.push(
+        parseSchema(name, requestBody.content["application/json"].schema)
+      );
     }
   }
-  return schemas;
-};
-var generate = async ({
-  input,
-  output
-}) => {
-  if (!input)
-    throw new Error("You need to supply at least one schema");
-  const schemas = await getSchemas(input);
-  const generatedOpenApi = await Promise.all(
-    Object.entries(schemas.openApi).map(async ([name, schema]) => ({
-      name,
-      schema: await generateOpenApi(schema)
-    }))
-  );
-  const generatedSharedTypes = await Promise.all(
-    Object.entries(schemas.sharedTypes).map(async ([name, schema]) => ({
-      name,
-      schema: await generateSchemas(schema)
-    }))
-  );
+  return definitions;
+};
+
+// src/parser/index.ts
+var parseDocument = (schema) => ({
+  paths: parsePaths(schema),
+  components: parseComponents(schema.components)
+});
+var parseComponents = (components = {}) => ({
+  schemas: parseSchemas(components.schemas),
+  headers: parseHeaders(components.headers),
+  parameters: parseParameters(components.parameters),
+  requestBodies: parseRequestBodies(components.requestBodies),
+  responseBodies: parseResponseBodies(components.responses)
+});
+
+// src/index.ts
+var generateTypescript = async (name, doc) => {
+  const parsed = parseDocument(doc);
+  const generated = generate(name, parsed);
+  const formatted = await format(generated);
+  return formatted;
+};
+var generate2 = async (input, output) => {
+  const docs = await readDocs(input);
+  const generated = await generateDocs(docs);
   if (!output)
-    return generatedOpenApi.concat(generatedSharedTypes).map(
-      ({ name, schema }) => `/**
- * ${name}
- */
-${schema}
-`
-    ).join("\n");
-  await (0, import_promises.mkdir)(output, { recursive: true });
-  for (const { name, schema } of generatedOpenApi.concat(generatedSharedTypes)) {
-    const path = (0, import_path.join)(output, `${name}.ts`);
-    await (0, import_promises.writeFile)(path, schema, "utf-8");
-  }
-  return;
+    return generated.map((d) => d.ts).join("\n\n");
+  await saveDocs(output, generated);
+};
+var readDocs = async (input) => {
+  const path = (0, import_path.resolve)(input);
+  const stats = await (0, import_promises.stat)(path);
+  const filePaths = [];
+  if (stats.isFile())
+    filePaths.push(path);
+  if (stats.isDirectory()) {
+    const files = await (0, import_promises.readdir)(path);
+    filePaths.push(...files.map((f) => (0, import_path.resolve)(path, f)));
+  }
+  const readFiles = [];
+  for (const p of filePaths) {
+    const { name, ext } = (0, import_path.parse)(p);
+    let doc;
+    switch (ext) {
+      case ".json": {
+        console.log(`Reading ${p}`);
+        const txt = await (0, import_promises.readFile)(p, "utf8");
+        doc = JSON.parse(txt);
+        break;
+      }
+      case ".yml":
+      case ".yaml": {
+        console.log(`Reading ${p}`);
+        const txt = await (0, import_promises.readFile)(p, "utf8");
+        doc = YAML.parse(txt);
+        break;
+      }
+      default:
+        continue;
+    }
+    readFiles.push({
+      doc,
+      name: formatName(name)
+    });
+  }
+  return readFiles;
+};
+var generateDocs = async (files) => {
+  const generated = [];
+  for (const doc of files) {
+    console.log(`Generating ${doc.name}`);
+    const ts = await generateTypescript(doc.name, doc.doc);
+    generated.push({
+      ...doc,
+      ts
+    });
+  }
+  return generated;
+};
+var saveDocs = async (output, docs) => {
+  const stats = await (0, import_promises.stat)(output);
+  const dir = stats.isDirectory() ? output : (0, import_path.parse)(output).dir;
+  await (0, import_promises.mkdir)(dir, { recursive: true });
+  for (const doc of docs) {
+    const path = (0, import_path.resolve)(dir, `${doc.name}.ts`);
+    console.log(`Writing ${path}`);
+    await (0, import_promises.writeFile)(path, doc.ts, "utf8");
+  }
+};
+var formatName = (name) => {
+  if (name[0].toUpperCase() === name[0])
+    return name;
+  return (0, import_change_case2.pascalCase)(name);
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  generate
+  generate,
+  generateTypescript
 });