api-sdk-gen 1.0.0

package/dist/index.d.mts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.js

@@ -0,0 +1,368 @@
+#!/usr/bin/env node
+"use strict";
+
+// src/generators/typescript/util.ts
+function pascalCase(str) {
+  return str.replace(/(^\w|-\w)/g, clearAndUpper).replace(/_/g, "");
+}
+function clearAndUpper(text) {
+  return text.replace(/-/, "").toUpperCase();
+}
+function resolveSchema(ref) {
+  const parts = ref.split("#/components/schemas/");
+  return pascalCase(parts[1]);
+}
+
+// src/generators/typescript/schema_to_ts.ts
+function schemaToTypeLiteral(schema, doc, refPrefix) {
+  return (writer) => {
+    if ("$ref" in schema) {
+      writer.write((refPrefix ?? "") + resolveSchema(schema.$ref));
+      return;
+    }
+    if (schema.enum) {
+      writer.write(schema.enum.map((value) => JSON.stringify(value)).join(" | "));
+      return;
+    }
+    if (schema.anyOf || schema.oneOf) {
+      (schema.anyOf || schema.oneOf)?.forEach((subSchema, index) => {
+        if (index > 0) {
+          writer.write(" | ");
+        }
+        schemaToTypeLiteral(subSchema, doc, refPrefix)(writer);
+      });
+      return;
+    }
+    if (schema.type) {
+      switch (schema.type) {
+        case "object": {
+          const requiredProps = new Set(schema.required || []);
+          writer.write("{").newLine();
+          for (const [propName, propSchema] of Object.entries(schema.properties || {})) {
+            writer.indent(() => {
+              writer.write(propName);
+              if (!requiredProps.has(propName)) {
+                writer.write("?");
+              }
+              writer.write(": ");
+              schemaToTypeLiteral(propSchema, doc, refPrefix)(writer);
+              writer.write(";").newLine();
+            });
+          }
+          writer.write("}");
+          break;
+        }
+        case "array":
+          if (Array.isArray(schema.items)) {
+            writer.write("[");
+            schema.items.forEach((itemSchema, index) => {
+              if (index > 0) {
+                writer.write(", ");
+              }
+              schemaToTypeLiteral(itemSchema, doc, refPrefix)(writer);
+            });
+            writer.write("]");
+          } else if (schema.items) {
+            writer.write("Array<");
+            schemaToTypeLiteral(schema.items, doc, refPrefix)(writer);
+            writer.write(">");
+          } else {
+            writer.write("any[]");
+          }
+          break;
+        case "string": {
+          const s = schema;
+          const isFile = s.format === "binary" || s.format === "base64" || s.contentMediaType;
+          if (isFile) {
+            writer.write("File | Blob");
+          } else {
+            writer.write(s.type);
+          }
+          break;
+        }
+        case "number":
+        case "boolean":
+        case "null":
+          writer.write(schema.type);
+          break;
+        case "integer":
+          writer.write("number");
+          break;
+        default:
+          writer.write("any");
+      }
+    }
+  };
+}
+
+// src/generators/typescript/models_generator.ts
+var jsonSchemaTags = [
+  "title",
+  "maxItems",
+  "minItems",
+  "maxLength",
+  "minLength",
+  "uniqueItems",
+  "maximum",
+  "minimum",
+  "exclusiveMaximum",
+  "exclusiveMinimum",
+  "pattern",
+  "format",
+  "example"
+];
+function createInterfaceModel(doc, file, name, schema) {
+  if (!schema.properties || Object.keys(schema.properties).length === 0) {
+    file.addTypeAlias({
+      name: pascalCase(name),
+      isExported: true,
+      type: "{}"
+    });
+    return;
+  }
+  const jsdocs = generateSchemaDocs(schema, doc);
+  const interfaceDeclaration = file.addInterface({
+    name: pascalCase(name),
+    isExported: true,
+    docs: jsdocs ? [jsdocs] : []
+  });
+  for (const [propName, propSchema] of Object.entries(schema.properties || {})) {
+    const prop = generatePropertySignature(doc, propName, propSchema);
+    prop.hasQuestionToken = !(schema.required || []).includes(propName);
+    interfaceDeclaration.addProperty(prop);
+  }
+  if (schema.additionalProperties) {
+    interfaceDeclaration.addIndexSignature({
+      keyName: "k",
+      keyType: "string",
+      returnType: "unknown"
+    });
+  }
+}
+function generateSchemaDocs(schema, doc) {
+  const jsdoc = {
+    description: schema.description || "",
+    tags: []
+  };
+  if ("$ref" in schema) {
+    jsdoc.tags?.push({
+      tagName: "see",
+      text: (writer) => {
+        writer.write("{@link ");
+        schemaToTypeLiteral(schema, doc)(writer);
+        writer.write("}");
+      }
+    });
+  }
+  for (const tagName of jsonSchemaTags) {
+    const value = schema[tagName];
+    if (value !== void 0) {
+      jsdoc.tags?.push({
+        tagName,
+        text: String(value)
+      });
+    }
+  }
+  if (!jsdoc.tags?.length && !jsdoc.description) {
+    return null;
+  }
+  return jsdoc;
+}
+function generatePropertySignature(doc, propName, propSchema) {
+  const jsdoc = generateSchemaDocs(propSchema, doc);
+  return {
+    name: propName,
+    type: schemaToTypeLiteral(propSchema, doc),
+    docs: jsdoc ? [jsdoc] : []
+  };
+}
+function createModel(doc, file, name, schema) {
+  if ("$ref" in schema) {
+    return;
+  }
+  if (schema.type === "object" && schema.properties) {
+    createInterfaceModel(doc, file, name, schema);
+    return;
+  }
+  const jsdoc = generateSchemaDocs(schema, doc);
+  file.addTypeAlias({
+    name: pascalCase(name),
+    isExported: true,
+    type: schemaToTypeLiteral(schema, doc),
+    docs: jsdoc ? [jsdoc] : []
+  });
+}
+async function generateModels(file, config, doc) {
+  const schemas = doc?.components?.schemas;
+  if (!schemas) {
+    return;
+  }
+  for (const [schemaName, schema] of Object.entries(schemas)) {
+    createModel(doc, file, schemaName, schema);
+  }
+}
+
+// src/index.ts
+var import_promises = require("fs/promises");
+var import_ts_morph = require("ts-morph");
+var import_node_path = require("path");
+
+// src/generators/typescript/api_generator.ts
+async function generateApiType(file, config, doc) {
+  file.addImportDeclaration({
+    moduleSpecifier: "./models",
+    namespaceImport: "Models",
+    isTypeOnly: true
+  });
+  file.addTypeAlias({
+    name: "Api",
+    isExported: true,
+    type: (writer) => {
+      writer.write("{").newLine();
+      for (const [path, pathItem] of Object.entries(doc.paths || {})) {
+        if (!pathItem) continue;
+        writer.indent(() => {
+          writer.write(`'${path}': {`).newLine();
+          writer.indent(() => {
+            const methods = ["get", "post", "put", "patch", "delete"];
+            for (const method of methods) {
+              const operation = pathItem[method];
+              if (!operation) continue;
+              writer.write(`${method}: {`).newLine();
+              writer.indent(() => {
+                const allParams = [...pathItem.parameters || [], ...operation.parameters || []];
+                const queryParams = allParams.filter((p) => !("$ref" in p) && p.in === "query");
+                const pathParams = allParams.filter((p) => !("$ref" in p) && p.in === "path");
+                const headerParams = allParams.filter((p) => !("$ref" in p) && p.in === "header");
+                if (queryParams.length || pathParams.length || headerParams.length) {
+                  writer.write("parameters: {").newLine();
+                  writer.indent(() => {
+                    if (pathParams.length) {
+                      writer.write("path: {").newLine();
+                      writer.indent(() => {
+                        for (const p of pathParams) {
+                          writer.write(`'${p.name}'${p.required ? "" : "?"}: `);
+                          if (p.schema) schemaToTypeLiteral(p.schema, doc, "Models.")(writer);
+                          else writer.write("any");
+                          writer.write(";").newLine();
+                        }
+                      });
+                      writer.write("},").newLine();
+                    }
+                    if (queryParams.length) {
+                      writer.write("query: {").newLine();
+                      writer.indent(() => {
+                        for (const p of queryParams) {
+                          writer.write(`'${p.name}'${p.required ? "" : "?"}: `);
+                          if (p.schema) schemaToTypeLiteral(p.schema, doc, "Models.")(writer);
+                          else writer.write("any");
+                          writer.write(";").newLine();
+                        }
+                      });
+                      writer.write("},").newLine();
+                    }
+                    if (headerParams.length) {
+                      writer.write("header: {").newLine();
+                      writer.indent(() => {
+                        for (const p of headerParams) {
+                          writer.write(`'${p.name}'${p.required ? "" : "?"}: `);
+                          if (p.schema) schemaToTypeLiteral(p.schema, doc, "Models.")(writer);
+                          else writer.write("any");
+                          writer.write(";").newLine();
+                        }
+                      });
+                      writer.write("},").newLine();
+                    }
+                  });
+                  writer.write("},").newLine();
+                }
+                if (operation.requestBody && !("$ref" in operation.requestBody)) {
+                  const rb = operation.requestBody;
+                  writer.write("requestBody: {").newLine();
+                  writer.indent(() => {
+                    for (const [contentType, mediaType] of Object.entries(rb.content || {})) {
+                      writer.write(`'${contentType}': `);
+                      const mt = mediaType;
+                      if (mt.schema) schemaToTypeLiteral(mt.schema, doc, "Models.")(writer);
+                      else writer.write("any");
+                      writer.write(";").newLine();
+                    }
+                  });
+                  writer.write("},").newLine();
+                }
+                if (operation.responses) {
+                  writer.write("responses: {").newLine();
+                  writer.indent(() => {
+                    for (const [status, response] of Object.entries(operation.responses)) {
+                      if ("$ref" in response) continue;
+                      const res = response;
+                      writer.write(`'${status}': {`).newLine();
+                      writer.indent(() => {
+                        if (res.content) {
+                          writer.write("content: {").newLine();
+                          writer.indent(() => {
+                            for (const [contentType, mediaType] of Object.entries(res.content || {})) {
+                              writer.write(`'${contentType}': `);
+                              const mt = mediaType;
+                              if (mt.schema) schemaToTypeLiteral(mt.schema, doc, "Models.")(writer);
+                              else writer.write("any");
+                              writer.write(";").newLine();
+                            }
+                          });
+                          writer.write("}").newLine();
+                        }
+                      });
+                      writer.write("},").newLine();
+                    }
+                  });
+                  writer.write("},").newLine();
+                }
+              });
+              writer.write("},").newLine();
+            }
+          });
+          writer.write("},").newLine();
+        });
+      }
+      writer.write("}");
+    }
+  });
+}
+
+// src/index.ts
+var import_commander = require("commander");
+var program = new import_commander.Command();
+program.name("api-sdk-gen").description("Generate TypeScript SDK from OpenAPI specification").version("1.0.0").requiredOption("-u, --url <url>", "URL of the OpenAPI JSON specification").requiredOption("-b, --base <url>", "Base URL for the API calls").option("-o, --output <dir>", "Output directory", "./output").action(async (options) => {
+  const config = {
+    url: options.url,
+    api_base: options.base,
+    outputDir: options.output
+  };
+  try {
+    console.log(`Fetching OpenAPI spec from: ${config.url}...`);
+    const res = await fetch(config.url);
+    if (!res.ok) {
+      throw new Error(`Failed to fetch OpenAPI spec: ${res.statusText}`);
+    }
+    const openapi = await res.json();
+    console.log(`Generating SDK to: ${config.outputDir}...`);
+    await (0, import_promises.mkdir)(config.outputDir, { recursive: true });
+    const project = new import_ts_morph.Project();
+    const modelsFile = project.createSourceFile((0, import_node_path.join)(config.outputDir, "models.ts"), "", { overwrite: true });
+    const apiFile = project.createSourceFile((0, import_node_path.join)(config.outputDir, "api.ts"), "", { overwrite: true });
+    const templatePath = (0, import_node_path.join)(__dirname, "../templates", "core.ts");
+    const coreFile = project.createSourceFile(
+      (0, import_node_path.join)(config.outputDir, "core.ts"),
+      await (0, import_promises.readFile)(templatePath, "utf-8"),
+      { overwrite: true }
+    );
+    await generateModels(modelsFile, config, openapi);
+    await generateApiType(apiFile, config, openapi);
+    await project.save();
+    console.log("SDK generated successfully!");
+  } catch (error) {
+    console.error("Error generating SDK:", error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+program.parse();

package/dist/index.mjs

@@ -0,0 +1,374 @@
+#!/usr/bin/env node
+
+// node_modules/.pnpm/tsup@8.5.1_tsx@4.21.0_typescript@5.9.3/node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var getFilename = () => fileURLToPath(import.meta.url);
+var getDirname = () => path.dirname(getFilename());
+var __dirname = /* @__PURE__ */ getDirname();
+
+// src/generators/typescript/util.ts
+function pascalCase(str) {
+  return str.replace(/(^\w|-\w)/g, clearAndUpper).replace(/_/g, "");
+}
+function clearAndUpper(text) {
+  return text.replace(/-/, "").toUpperCase();
+}
+function resolveSchema(ref) {
+  const parts = ref.split("#/components/schemas/");
+  return pascalCase(parts[1]);
+}
+
+// src/generators/typescript/schema_to_ts.ts
+function schemaToTypeLiteral(schema, doc, refPrefix) {
+  return (writer) => {
+    if ("$ref" in schema) {
+      writer.write((refPrefix ?? "") + resolveSchema(schema.$ref));
+      return;
+    }
+    if (schema.enum) {
+      writer.write(schema.enum.map((value) => JSON.stringify(value)).join(" | "));
+      return;
+    }
+    if (schema.anyOf || schema.oneOf) {
+      (schema.anyOf || schema.oneOf)?.forEach((subSchema, index) => {
+        if (index > 0) {
+          writer.write(" | ");
+        }
+        schemaToTypeLiteral(subSchema, doc, refPrefix)(writer);
+      });
+      return;
+    }
+    if (schema.type) {
+      switch (schema.type) {
+        case "object": {
+          const requiredProps = new Set(schema.required || []);
+          writer.write("{").newLine();
+          for (const [propName, propSchema] of Object.entries(schema.properties || {})) {
+            writer.indent(() => {
+              writer.write(propName);
+              if (!requiredProps.has(propName)) {
+                writer.write("?");
+              }
+              writer.write(": ");
+              schemaToTypeLiteral(propSchema, doc, refPrefix)(writer);
+              writer.write(";").newLine();
+            });
+          }
+          writer.write("}");
+          break;
+        }
+        case "array":
+          if (Array.isArray(schema.items)) {
+            writer.write("[");
+            schema.items.forEach((itemSchema, index) => {
+              if (index > 0) {
+                writer.write(", ");
+              }
+              schemaToTypeLiteral(itemSchema, doc, refPrefix)(writer);
+            });
+            writer.write("]");
+          } else if (schema.items) {
+            writer.write("Array<");
+            schemaToTypeLiteral(schema.items, doc, refPrefix)(writer);
+            writer.write(">");
+          } else {
+            writer.write("any[]");
+          }
+          break;
+        case "string": {
+          const s = schema;
+          const isFile = s.format === "binary" || s.format === "base64" || s.contentMediaType;
+          if (isFile) {
+            writer.write("File | Blob");
+          } else {
+            writer.write(s.type);
+          }
+          break;
+        }
+        case "number":
+        case "boolean":
+        case "null":
+          writer.write(schema.type);
+          break;
+        case "integer":
+          writer.write("number");
+          break;
+        default:
+          writer.write("any");
+      }
+    }
+  };
+}
+
+// src/generators/typescript/models_generator.ts
+var jsonSchemaTags = [
+  "title",
+  "maxItems",
+  "minItems",
+  "maxLength",
+  "minLength",
+  "uniqueItems",
+  "maximum",
+  "minimum",
+  "exclusiveMaximum",
+  "exclusiveMinimum",
+  "pattern",
+  "format",
+  "example"
+];
+function createInterfaceModel(doc, file, name, schema) {
+  if (!schema.properties || Object.keys(schema.properties).length === 0) {
+    file.addTypeAlias({
+      name: pascalCase(name),
+      isExported: true,
+      type: "{}"
+    });
+    return;
+  }
+  const jsdocs = generateSchemaDocs(schema, doc);
+  const interfaceDeclaration = file.addInterface({
+    name: pascalCase(name),
+    isExported: true,
+    docs: jsdocs ? [jsdocs] : []
+  });
+  for (const [propName, propSchema] of Object.entries(schema.properties || {})) {
+    const prop = generatePropertySignature(doc, propName, propSchema);
+    prop.hasQuestionToken = !(schema.required || []).includes(propName);
+    interfaceDeclaration.addProperty(prop);
+  }
+  if (schema.additionalProperties) {
+    interfaceDeclaration.addIndexSignature({
+      keyName: "k",
+      keyType: "string",
+      returnType: "unknown"
+    });
+  }
+}
+function generateSchemaDocs(schema, doc) {
+  const jsdoc = {
+    description: schema.description || "",
+    tags: []
+  };
+  if ("$ref" in schema) {
+    jsdoc.tags?.push({
+      tagName: "see",
+      text: (writer) => {
+        writer.write("{@link ");
+        schemaToTypeLiteral(schema, doc)(writer);
+        writer.write("}");
+      }
+    });
+  }
+  for (const tagName of jsonSchemaTags) {
+    const value = schema[tagName];
+    if (value !== void 0) {
+      jsdoc.tags?.push({
+        tagName,
+        text: String(value)
+      });
+    }
+  }
+  if (!jsdoc.tags?.length && !jsdoc.description) {
+    return null;
+  }
+  return jsdoc;
+}
+function generatePropertySignature(doc, propName, propSchema) {
+  const jsdoc = generateSchemaDocs(propSchema, doc);
+  return {
+    name: propName,
+    type: schemaToTypeLiteral(propSchema, doc),
+    docs: jsdoc ? [jsdoc] : []
+  };
+}
+function createModel(doc, file, name, schema) {
+  if ("$ref" in schema) {
+    return;
+  }
+  if (schema.type === "object" && schema.properties) {
+    createInterfaceModel(doc, file, name, schema);
+    return;
+  }
+  const jsdoc = generateSchemaDocs(schema, doc);
+  file.addTypeAlias({
+    name: pascalCase(name),
+    isExported: true,
+    type: schemaToTypeLiteral(schema, doc),
+    docs: jsdoc ? [jsdoc] : []
+  });
+}
+async function generateModels(file, config, doc) {
+  const schemas = doc?.components?.schemas;
+  if (!schemas) {
+    return;
+  }
+  for (const [schemaName, schema] of Object.entries(schemas)) {
+    createModel(doc, file, schemaName, schema);
+  }
+}
+
+// src/index.ts
+import { mkdir, readFile } from "fs/promises";
+import { Project } from "ts-morph";
+import { join } from "path";
+
+// src/generators/typescript/api_generator.ts
+async function generateApiType(file, config, doc) {
+  file.addImportDeclaration({
+    moduleSpecifier: "./models",
+    namespaceImport: "Models",
+    isTypeOnly: true
+  });
+  file.addTypeAlias({
+    name: "Api",
+    isExported: true,
+    type: (writer) => {
+      writer.write("{").newLine();
+      for (const [path2, pathItem] of Object.entries(doc.paths || {})) {
+        if (!pathItem) continue;
+        writer.indent(() => {
+          writer.write(`'${path2}': {`).newLine();
+          writer.indent(() => {
+            const methods = ["get", "post", "put", "patch", "delete"];
+            for (const method of methods) {
+              const operation = pathItem[method];
+              if (!operation) continue;
+              writer.write(`${method}: {`).newLine();
+              writer.indent(() => {
+                const allParams = [...pathItem.parameters || [], ...operation.parameters || []];
+                const queryParams = allParams.filter((p) => !("$ref" in p) && p.in === "query");
+                const pathParams = allParams.filter((p) => !("$ref" in p) && p.in === "path");
+                const headerParams = allParams.filter((p) => !("$ref" in p) && p.in === "header");
+                if (queryParams.length || pathParams.length || headerParams.length) {
+                  writer.write("parameters: {").newLine();
+                  writer.indent(() => {
+                    if (pathParams.length) {
+                      writer.write("path: {").newLine();
+                      writer.indent(() => {
+                        for (const p of pathParams) {
+                          writer.write(`'${p.name}'${p.required ? "" : "?"}: `);
+                          if (p.schema) schemaToTypeLiteral(p.schema, doc, "Models.")(writer);
+                          else writer.write("any");
+                          writer.write(";").newLine();
+                        }
+                      });
+                      writer.write("},").newLine();
+                    }
+                    if (queryParams.length) {
+                      writer.write("query: {").newLine();
+                      writer.indent(() => {
+                        for (const p of queryParams) {
+                          writer.write(`'${p.name}'${p.required ? "" : "?"}: `);
+                          if (p.schema) schemaToTypeLiteral(p.schema, doc, "Models.")(writer);
+                          else writer.write("any");
+                          writer.write(";").newLine();
+                        }
+                      });
+                      writer.write("},").newLine();
+                    }
+                    if (headerParams.length) {
+                      writer.write("header: {").newLine();
+                      writer.indent(() => {
+                        for (const p of headerParams) {
+                          writer.write(`'${p.name}'${p.required ? "" : "?"}: `);
+                          if (p.schema) schemaToTypeLiteral(p.schema, doc, "Models.")(writer);
+                          else writer.write("any");
+                          writer.write(";").newLine();
+                        }
+                      });
+                      writer.write("},").newLine();
+                    }
+                  });
+                  writer.write("},").newLine();
+                }
+                if (operation.requestBody && !("$ref" in operation.requestBody)) {
+                  const rb = operation.requestBody;
+                  writer.write("requestBody: {").newLine();
+                  writer.indent(() => {
+                    for (const [contentType, mediaType] of Object.entries(rb.content || {})) {
+                      writer.write(`'${contentType}': `);
+                      const mt = mediaType;
+                      if (mt.schema) schemaToTypeLiteral(mt.schema, doc, "Models.")(writer);
+                      else writer.write("any");
+                      writer.write(";").newLine();
+                    }
+                  });
+                  writer.write("},").newLine();
+                }
+                if (operation.responses) {
+                  writer.write("responses: {").newLine();
+                  writer.indent(() => {
+                    for (const [status, response] of Object.entries(operation.responses)) {
+                      if ("$ref" in response) continue;
+                      const res = response;
+                      writer.write(`'${status}': {`).newLine();
+                      writer.indent(() => {
+                        if (res.content) {
+                          writer.write("content: {").newLine();
+                          writer.indent(() => {
+                            for (const [contentType, mediaType] of Object.entries(res.content || {})) {
+                              writer.write(`'${contentType}': `);
+                              const mt = mediaType;
+                              if (mt.schema) schemaToTypeLiteral(mt.schema, doc, "Models.")(writer);
+                              else writer.write("any");
+                              writer.write(";").newLine();
+                            }
+                          });
+                          writer.write("}").newLine();
+                        }
+                      });
+                      writer.write("},").newLine();
+                    }
+                  });
+                  writer.write("},").newLine();
+                }
+              });
+              writer.write("},").newLine();
+            }
+          });
+          writer.write("},").newLine();
+        });
+      }
+      writer.write("}");
+    }
+  });
+}
+
+// src/index.ts
+import { Command } from "commander";
+var program = new Command();
+program.name("api-sdk-gen").description("Generate TypeScript SDK from OpenAPI specification").version("1.0.0").requiredOption("-u, --url <url>", "URL of the OpenAPI JSON specification").requiredOption("-b, --base <url>", "Base URL for the API calls").option("-o, --output <dir>", "Output directory", "./output").action(async (options) => {
+  const config = {
+    url: options.url,
+    api_base: options.base,
+    outputDir: options.output
+  };
+  try {
+    console.log(`Fetching OpenAPI spec from: ${config.url}...`);
+    const res = await fetch(config.url);
+    if (!res.ok) {
+      throw new Error(`Failed to fetch OpenAPI spec: ${res.statusText}`);
+    }
+    const openapi = await res.json();
+    console.log(`Generating SDK to: ${config.outputDir}...`);
+    await mkdir(config.outputDir, { recursive: true });
+    const project = new Project();
+    const modelsFile = project.createSourceFile(join(config.outputDir, "models.ts"), "", { overwrite: true });
+    const apiFile = project.createSourceFile(join(config.outputDir, "api.ts"), "", { overwrite: true });
+    const templatePath = join(__dirname, "../templates", "core.ts");
+    const coreFile = project.createSourceFile(
+      join(config.outputDir, "core.ts"),
+      await readFile(templatePath, "utf-8"),
+      { overwrite: true }
+    );
+    await generateModels(modelsFile, config, openapi);
+    await generateApiType(apiFile, config, openapi);
+    await project.save();
+    console.log("SDK generated successfully!");
+  } catch (error) {
+    console.error("Error generating SDK:", error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+program.parse();

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "api-sdk-gen",
+  "version": "1.0.0",
+  "description": "",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "api-sdk-gen": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "templates"
+  ],
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "commander": "^14.0.3",
+    "openapi-types": "^12.1.3",
+    "ts-morph": "^27.0.2",
+    "typescript": "^5.9.3"
+  },
+  "devDependencies": {
+    "@types/node": "^25.0.3",
+    "tsup": "^8.5.1",
+    "tsx": "^4.21.0"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --clean --format cjs,esm --dts --shims",
+    "dev": "tsup src/index.ts --watch",
+    "gen": "tsx src/index.ts",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  }
+}

package/templates/core.ts

@@ -0,0 +1,214 @@
+type HttpMethod = 'get' | 'post' | 'put' | 'patch' | 'delete';
+
+interface BaseOperation {
+  parameters?: {
+    query?: Record<string, unknown>;
+    path?: Record<string, string>;
+    header?: Record<string, string>;
+  }
+  requestBody?: Record<string, any>;
+  responses?: Record<string | number, {
+    headers?: Record<string, Record<string, any>>;
+    content?: Record<string, any>
+  }>;
+}
+
+type ApiDoc = Record<string, Partial<BaseOperation & Record<HttpMethod, BaseOperation>>>;
+
+type BaseRequest = {
+  path?: Record<string, string>;
+  query?: Record<string, string>;
+  header?: Record<string, string>;
+  contentType?: string;
+  body?: any;
+}
+
+type Pretty<T> = {
+  [K in keyof T]: T[K];
+};
+
+type DeepPretty<T> = T extends object ? Pretty<{
+  [K in keyof T]: DeepPretty<T[K]>;
+}> : T;
+
+type GetOp<T extends ApiDoc, P extends keyof T, M extends keyof T[P] & HttpMethod> =
+  T[P][M] extends infer Op ? (Op extends BaseOperation ? Op : never) : never;
+
+type RequiredKeys<T> = { [K in keyof T]-?: (Record<string, never>) extends Pick<T, K> ? never : K }[keyof T];
+
+type OptionalIfEmpty<K extends string, T> =
+  [T] extends [never] ? unknown :
+  [T] extends [undefined] ? unknown :
+  RequiredKeys<T> extends never
+  ? (keyof T extends never ? unknown : { [P in K]?: T })
+  : { [P in K]: T };
+
+type OpBody<Op extends BaseOperation> =
+  Op['requestBody'] extends infer RB
+  ? RB extends Record<string, unknown>
+  ? { [K in keyof RB]: {
+    contentType: K,
+    body: K extends 'multipart/form-data' ? (RB[K] | FormData) : RB[K]
+  } }[keyof RB]
+  : unknown
+  : unknown;
+
+type ToNumber<S> = S extends number ? S : S extends `${infer N extends number}` ? N : S;
+
+type ApiFetchResponse<Op extends BaseOperation> =
+  Op['responses'] extends infer R
+  ? R extends Record<string | number, any>
+  ? {
+    [S in keyof R]: S extends number | string
+    ? R[S] extends { content: infer C }
+    ? C extends Record<string, any>
+    ? { [CT in keyof C]: {
+      status: ToNumber<S>,
+      contentType: CT,
+      body: C[CT]
+    } }[keyof C]
+    : { status: ToNumber<S>, contentType: null, body: null }
+    : { status: ToNumber<S>, contentType: null, body: null }
+    : never
+  }[keyof R]
+  : { status: number; contentType: string; body: any }
+  : { status: number; contentType: string; body: any };
+
+type ApiFetchOptions<T extends ApiDoc, P extends keyof T, M extends keyof T[P] & HttpMethod, Op = GetOp<T, P, M>> =
+  { method: M } &
+  (Op extends BaseOperation ?
+    OptionalIfEmpty<'path', NonNullable<Op['parameters']>['path']> &
+    OptionalIfEmpty<'query', NonNullable<Op['parameters']>['query']> &
+    OptionalIfEmpty<'header', NonNullable<Op['parameters']>['header']> &
+    OpBody<Op>
+    : unknown);
+
+type ApiFetch<T extends ApiDoc> = <
+  P extends keyof T,
+  M extends keyof T[P] & HttpMethod
+>(
+  path: P,
+  options: ApiFetchOptions<T, P, M>
+) => Promise<DeepPretty<ApiFetchResponse<GetOp<T, P, M>>>>;
+
+export type Request = {
+  url: URL;
+  init: RequestInit;
+}
+
+export function buildApiRequest(
+  baseUrl: string | URL,
+  path: string,
+  options: BaseRequest
+): Request {
+  const headers = new Headers();
+  const opts = options as any;
+  let body: any = opts.body;
+  const url = new URL(path as string, baseUrl);
+
+  if (opts.header) {
+    Object.entries(opts.header).forEach(([key, value]) => {
+      if (Array.isArray(value)) {
+        value.forEach(v => {
+          headers.append(key, v)
+        });
+      } else {
+        headers.set(key, value as string);
+      }
+    });
+  }
+
+  if (opts.body) {
+    headers.append('Content-Type', opts.contentType);
+
+    if (opts.contentType === 'application/json') {
+      body = JSON.stringify(body);
+    } else if (opts.contentType === 'multipart/form-data' && !(body instanceof FormData)) {
+      const form = new FormData();
+
+      Object.entries(body).forEach(([key, value]) => {
+        if (Array.isArray(value)) {
+          value.forEach(v => {
+            form.append(key, v)
+          });
+        } else {
+          form.set(key, value as string);
+        }
+      });
+
+      body = form;
+    } else if (opts.contentType === 'application/x-www-form-urlencoded') {
+      body = new URLSearchParams(body);
+    }
+  }
+
+  if (opts.path) {
+    url.pathname = url.pathname.replace(/\{(.+?)\}/g, (text, key) => key in opts.path ? opts.path[key] : text);
+  }
+
+  if (opts.query) {
+    Object.entries(opts.query).forEach(([key, value]) => {
+      if (Array.isArray(value)) {
+        value.forEach(v => {
+          url.searchParams.append(key, v)
+        });
+      } else {
+        url.searchParams.set(key, value as string);
+      }
+    });
+  }
+
+  return {
+    url,
+    init: {
+      method: opts.method.toUpperCase(),
+      headers,
+      body,
+    }
+  };
+}
+
+export async function buildResponse<T extends ApiFetchResponse<any>>(response: Response): Promise<T> {
+  const contentType = response.headers.get('Content-Type') || null;
+
+  if (contentType?.startsWith('application/json')) {
+    return {
+      status: response.status,
+      contentType,
+      body: await response.json(),
+    } as T;
+  }
+
+  if (contentType?.startsWith('application/xml')) {
+    return {
+      status: response.status,
+      contentType,
+      body: new DOMParser().parseFromString(await response.text(), 'application/xml'),
+    } as T;
+  }
+
+  if (contentType?.startsWith('text/plain')) {
+    return {
+      status: response.status,
+      contentType,
+      body: await response.text(),
+    } as T;
+  }
+
+  return {
+    status: response.status,
+    contentType,
+    body: await response.blob(),
+  } as T;
+}
+
+export function createApi<T extends ApiDoc>(
+  baseUrl: string | URL,
+  adapter?: (request: Request) => Promise<Response>
+) {
+  adapter ??= (request) => fetch(request.url, request.init);
+
+  const api = async (path: string, options: any) => buildResponse(await adapter(buildApiRequest(baseUrl, path, options)));
+
+  return api as ApiFetch<T>;
+}