create-swagger-client 0.1.0

package/README.md

@@ -0,0 +1,208 @@
+# create-swagger-client
+
+A TypeScript tool that generates a fully type-safe REST API client from OpenAPI/Swagger specifications. Built with `openapi-typescript` and `ts-morph`, it creates a strongly-typed client class with autocomplete and compile-time type checking for all API endpoints.
+
+## Features
+
+- ✅ **Full Type Safety**: All endpoints, parameters, request bodies, and responses are type-checked
+- 🚀 **Auto-completion**: IDE autocomplete for paths, methods, and payloads
+- 🔄 **Multiple HTTP Methods**: Support for GET, POST, PUT, DELETE, and PATCH
+- 📝 **OpenAPI Spec Support**: Works with OpenAPI 3.x specifications (JSON or YAML)
+- 🌐 **URL or File Input**: Generate from remote URLs or local files
+- 🎯 **Type Inference**: Automatic extraction of path params, query params, headers, and request/response types
+
+
+## Usage
+
+### Generate API Client
+
+Run the generator with your OpenAPI specification:
+
+```bash
+# From a URL
+npx create-swagger-client https://api.example.com/openapi.json
+
+# From a local file
+npx create-swagger-client ./swagger.json
+
+# Specify custom output file
+npx create-swagger-client https://api.example.com/openapi.json my-api-client.ts
+```
+
+**Arguments:**
+- `source` (required): URL or file path to your OpenAPI/Swagger specification
+- `output` (optional): Output file name (default: `client-api.ts`)
+
+This will generate a file with:
+- All TypeScript types from your OpenAPI spec
+- A `RestApiClient` class with type-safe methods
+- Helper types for extracting parameters and responses
+
+### Using the Generated Client
+
+After generation, import and use the client:
+
+```typescript
+import { RestApiClient } from './client-api';
+
+// Initialize the client
+const api = new RestApiClient('https://api.example.com', {
+  headers: {
+    'Authorization': 'Bearer YOUR_TOKEN'
+  }
+});
+
+// Make type-safe requests
+// GET request with query parameters
+const users = await api.get('/users', {
+  query: { page: 1, limit: 10 }
+});
+
+// GET request with path parameters
+const user = await api.get('/users/{id}', {
+  path: { id: '123' }
+});
+
+// POST request with body
+const newUser = await api.post('/users', {
+  body: {
+    name: 'John Doe',
+    email: 'john@example.com'
+  }
+});
+
+// PUT request
+const updatedUser = await api.put('/users/{id}', {
+  path: { id: '123' },
+  body: {
+    name: 'Jane Doe',
+    email: 'jane@example.com'
+  }
+});
+
+// DELETE request
+await api.delete('/users/{id}', {
+  path: { id: '123' }
+});
+
+// PATCH request
+const patchedUser = await api.patch('/users/{id}', {
+  path: { id: '123' },
+  body: {
+    email: 'newemail@example.com'
+  }
+});
+```
+
+### Advanced Usage
+
+#### Custom Headers per Request
+
+```typescript
+const data = await api.get('/protected-endpoint', {
+  headers: {
+    'X-Custom-Header': 'value'
+  }
+});
+```
+
+#### Request with Multiple Parameter Types
+
+```typescript
+const result = await api.post('/projects/{projectId}/tasks', {
+  path: { projectId: 'proj-123' },
+  query: { notify: true },
+  headers: { 'X-Request-ID': 'req-456' },
+  body: {
+    title: 'New Task',
+    description: 'Task description'
+  }
+});
+```
+
+#### Custom Fetch Options
+
+```typescript
+const api = new RestApiClient('https://api.example.com', {
+  headers: {
+    'Authorization': 'Bearer TOKEN'
+  },
+  mode: 'cors',
+  credentials: 'include',
+  // Any other RequestInit options
+});
+```
+
+## Generated Types
+
+The generator creates several useful type utilities:
+
+- `RestMethod`: Union of HTTP methods (`"get" | "post" | "put" | "delete" | "patch"`)
+- `KeyPaths`: All available API paths
+- `ExtractPathParams<Path, Method>`: Extract path parameters for an endpoint
+- `ExtractQueryParams<Path, Method>`: Extract query parameters for an endpoint
+- `ExtractHeaderParams<Path, Method>`: Extract header parameters for an endpoint
+- `ExtractBody<Path, Method>`: Extract request body type for an endpoint
+- `APIResponse<Path, Method>`: Extract response type for an endpoint
+- `ApiPayload<Path, Method>`: Combined payload type for a request
+- `ApiClientType`: Type definition for the entire client
+
+## Example: Using Generated Types
+
+```typescript
+import { 
+  RestApiClient, 
+  ExtractBody, 
+  APIResponse 
+} from './client-api';
+
+// Use types in your code
+type CreateUserBody = ExtractBody<'/users', 'post'>;
+type UserResponse = APIResponse<'/users/{id}', 'get'>;
+
+const createUser = (data: CreateUserBody): Promise<UserResponse> => {
+  return api.post('/users', { body: data });
+};
+```
+
+## Error Handling
+
+The client throws errors for failed requests:
+
+```typescript
+try {
+  const user = await api.get('/users/{id}', {
+    path: { id: '123' }
+  });
+} catch (error) {
+  console.error('API request failed:', error.message);
+  // Error message includes status code, status text, and response body
+}
+```
+
+## Development
+
+### Build
+
+```bash
+bun run build
+```
+
+### Type Check
+
+```bash
+bun run typecheck
+```
+
+## Requirements
+
+- TypeScript 5.x
+- Node.js 16+ or Bun
+
+## License
+
+MIT
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.

package/dist/index.js

@@ -0,0 +1,631 @@
+// index.ts
+import openapiTS, { astToString } from "openapi-typescript";
+
+// node:path
+function assertPath(path) {
+  if (typeof path !== "string")
+    throw TypeError("Path must be a string. Received " + JSON.stringify(path));
+}
+function normalizeStringPosix(path, allowAboveRoot) {
+  var res = "", lastSegmentLength = 0, lastSlash = -1, dots = 0, code;
+  for (var i = 0;i <= path.length; ++i) {
+    if (i < path.length)
+      code = path.charCodeAt(i);
+    else if (code === 47)
+      break;
+    else
+      code = 47;
+    if (code === 47) {
+      if (lastSlash === i - 1 || dots === 1)
+        ;
+      else if (lastSlash !== i - 1 && dots === 2) {
+        if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== 46 || res.charCodeAt(res.length - 2) !== 46) {
+          if (res.length > 2) {
+            var lastSlashIndex = res.lastIndexOf("/");
+            if (lastSlashIndex !== res.length - 1) {
+              if (lastSlashIndex === -1)
+                res = "", lastSegmentLength = 0;
+              else
+                res = res.slice(0, lastSlashIndex), lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+              lastSlash = i, dots = 0;
+              continue;
+            }
+          } else if (res.length === 2 || res.length === 1) {
+            res = "", lastSegmentLength = 0, lastSlash = i, dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          if (res.length > 0)
+            res += "/..";
+          else
+            res = "..";
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0)
+          res += "/" + path.slice(lastSlash + 1, i);
+        else
+          res = path.slice(lastSlash + 1, i);
+        lastSegmentLength = i - lastSlash - 1;
+      }
+      lastSlash = i, dots = 0;
+    } else if (code === 46 && dots !== -1)
+      ++dots;
+    else
+      dots = -1;
+  }
+  return res;
+}
+function _format(sep, pathObject) {
+  var dir = pathObject.dir || pathObject.root, base = pathObject.base || (pathObject.name || "") + (pathObject.ext || "");
+  if (!dir)
+    return base;
+  if (dir === pathObject.root)
+    return dir + base;
+  return dir + sep + base;
+}
+function resolve() {
+  var resolvedPath = "", resolvedAbsolute = false, cwd;
+  for (var i = arguments.length - 1;i >= -1 && !resolvedAbsolute; i--) {
+    var path;
+    if (i >= 0)
+      path = arguments[i];
+    else {
+      if (cwd === undefined)
+        cwd = process.cwd();
+      path = cwd;
+    }
+    if (assertPath(path), path.length === 0)
+      continue;
+    resolvedPath = path + "/" + resolvedPath, resolvedAbsolute = path.charCodeAt(0) === 47;
+  }
+  if (resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute), resolvedAbsolute)
+    if (resolvedPath.length > 0)
+      return "/" + resolvedPath;
+    else
+      return "/";
+  else if (resolvedPath.length > 0)
+    return resolvedPath;
+  else
+    return ".";
+}
+function normalize(path) {
+  if (assertPath(path), path.length === 0)
+    return ".";
+  var isAbsolute = path.charCodeAt(0) === 47, trailingSeparator = path.charCodeAt(path.length - 1) === 47;
+  if (path = normalizeStringPosix(path, !isAbsolute), path.length === 0 && !isAbsolute)
+    path = ".";
+  if (path.length > 0 && trailingSeparator)
+    path += "/";
+  if (isAbsolute)
+    return "/" + path;
+  return path;
+}
+function isAbsolute(path) {
+  return assertPath(path), path.length > 0 && path.charCodeAt(0) === 47;
+}
+function join() {
+  if (arguments.length === 0)
+    return ".";
+  var joined;
+  for (var i = 0;i < arguments.length; ++i) {
+    var arg = arguments[i];
+    if (assertPath(arg), arg.length > 0)
+      if (joined === undefined)
+        joined = arg;
+      else
+        joined += "/" + arg;
+  }
+  if (joined === undefined)
+    return ".";
+  return normalize(joined);
+}
+function relative(from, to) {
+  if (assertPath(from), assertPath(to), from === to)
+    return "";
+  if (from = resolve(from), to = resolve(to), from === to)
+    return "";
+  var fromStart = 1;
+  for (;fromStart < from.length; ++fromStart)
+    if (from.charCodeAt(fromStart) !== 47)
+      break;
+  var fromEnd = from.length, fromLen = fromEnd - fromStart, toStart = 1;
+  for (;toStart < to.length; ++toStart)
+    if (to.charCodeAt(toStart) !== 47)
+      break;
+  var toEnd = to.length, toLen = toEnd - toStart, length = fromLen < toLen ? fromLen : toLen, lastCommonSep = -1, i = 0;
+  for (;i <= length; ++i) {
+    if (i === length) {
+      if (toLen > length) {
+        if (to.charCodeAt(toStart + i) === 47)
+          return to.slice(toStart + i + 1);
+        else if (i === 0)
+          return to.slice(toStart + i);
+      } else if (fromLen > length) {
+        if (from.charCodeAt(fromStart + i) === 47)
+          lastCommonSep = i;
+        else if (i === 0)
+          lastCommonSep = 0;
+      }
+      break;
+    }
+    var fromCode = from.charCodeAt(fromStart + i), toCode = to.charCodeAt(toStart + i);
+    if (fromCode !== toCode)
+      break;
+    else if (fromCode === 47)
+      lastCommonSep = i;
+  }
+  var out = "";
+  for (i = fromStart + lastCommonSep + 1;i <= fromEnd; ++i)
+    if (i === fromEnd || from.charCodeAt(i) === 47)
+      if (out.length === 0)
+        out += "..";
+      else
+        out += "/..";
+  if (out.length > 0)
+    return out + to.slice(toStart + lastCommonSep);
+  else {
+    if (toStart += lastCommonSep, to.charCodeAt(toStart) === 47)
+      ++toStart;
+    return to.slice(toStart);
+  }
+}
+function _makeLong(path) {
+  return path;
+}
+function dirname(path) {
+  if (assertPath(path), path.length === 0)
+    return ".";
+  var code = path.charCodeAt(0), hasRoot = code === 47, end = -1, matchedSlash = true;
+  for (var i = path.length - 1;i >= 1; --i)
+    if (code = path.charCodeAt(i), code === 47) {
+      if (!matchedSlash) {
+        end = i;
+        break;
+      }
+    } else
+      matchedSlash = false;
+  if (end === -1)
+    return hasRoot ? "/" : ".";
+  if (hasRoot && end === 1)
+    return "//";
+  return path.slice(0, end);
+}
+function basename(path, ext) {
+  if (ext !== undefined && typeof ext !== "string")
+    throw TypeError('"ext" argument must be a string');
+  assertPath(path);
+  var start = 0, end = -1, matchedSlash = true, i;
+  if (ext !== undefined && ext.length > 0 && ext.length <= path.length) {
+    if (ext.length === path.length && ext === path)
+      return "";
+    var extIdx = ext.length - 1, firstNonSlashEnd = -1;
+    for (i = path.length - 1;i >= 0; --i) {
+      var code = path.charCodeAt(i);
+      if (code === 47) {
+        if (!matchedSlash) {
+          start = i + 1;
+          break;
+        }
+      } else {
+        if (firstNonSlashEnd === -1)
+          matchedSlash = false, firstNonSlashEnd = i + 1;
+        if (extIdx >= 0)
+          if (code === ext.charCodeAt(extIdx)) {
+            if (--extIdx === -1)
+              end = i;
+          } else
+            extIdx = -1, end = firstNonSlashEnd;
+      }
+    }
+    if (start === end)
+      end = firstNonSlashEnd;
+    else if (end === -1)
+      end = path.length;
+    return path.slice(start, end);
+  } else {
+    for (i = path.length - 1;i >= 0; --i)
+      if (path.charCodeAt(i) === 47) {
+        if (!matchedSlash) {
+          start = i + 1;
+          break;
+        }
+      } else if (end === -1)
+        matchedSlash = false, end = i + 1;
+    if (end === -1)
+      return "";
+    return path.slice(start, end);
+  }
+}
+function extname(path) {
+  assertPath(path);
+  var startDot = -1, startPart = 0, end = -1, matchedSlash = true, preDotState = 0;
+  for (var i = path.length - 1;i >= 0; --i) {
+    var code = path.charCodeAt(i);
+    if (code === 47) {
+      if (!matchedSlash) {
+        startPart = i + 1;
+        break;
+      }
+      continue;
+    }
+    if (end === -1)
+      matchedSlash = false, end = i + 1;
+    if (code === 46) {
+      if (startDot === -1)
+        startDot = i;
+      else if (preDotState !== 1)
+        preDotState = 1;
+    } else if (startDot !== -1)
+      preDotState = -1;
+  }
+  if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)
+    return "";
+  return path.slice(startDot, end);
+}
+function format(pathObject) {
+  if (pathObject === null || typeof pathObject !== "object")
+    throw TypeError('The "pathObject" argument must be of type Object. Received type ' + typeof pathObject);
+  return _format("/", pathObject);
+}
+function parse(path) {
+  assertPath(path);
+  var ret = { root: "", dir: "", base: "", ext: "", name: "" };
+  if (path.length === 0)
+    return ret;
+  var code = path.charCodeAt(0), isAbsolute2 = code === 47, start;
+  if (isAbsolute2)
+    ret.root = "/", start = 1;
+  else
+    start = 0;
+  var startDot = -1, startPart = 0, end = -1, matchedSlash = true, i = path.length - 1, preDotState = 0;
+  for (;i >= start; --i) {
+    if (code = path.charCodeAt(i), code === 47) {
+      if (!matchedSlash) {
+        startPart = i + 1;
+        break;
+      }
+      continue;
+    }
+    if (end === -1)
+      matchedSlash = false, end = i + 1;
+    if (code === 46) {
+      if (startDot === -1)
+        startDot = i;
+      else if (preDotState !== 1)
+        preDotState = 1;
+    } else if (startDot !== -1)
+      preDotState = -1;
+  }
+  if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
+    if (end !== -1)
+      if (startPart === 0 && isAbsolute2)
+        ret.base = ret.name = path.slice(1, end);
+      else
+        ret.base = ret.name = path.slice(startPart, end);
+  } else {
+    if (startPart === 0 && isAbsolute2)
+      ret.name = path.slice(1, startDot), ret.base = path.slice(1, end);
+    else
+      ret.name = path.slice(startPart, startDot), ret.base = path.slice(startPart, end);
+    ret.ext = path.slice(startDot, end);
+  }
+  if (startPart > 0)
+    ret.dir = path.slice(0, startPart - 1);
+  else if (isAbsolute2)
+    ret.dir = "/";
+  return ret;
+}
+var sep = "/";
+var delimiter = ":";
+var posix = ((p) => (p.posix = p, p))({ resolve, normalize, isAbsolute, join, relative, _makeLong, dirname, basename, extname, format, parse, sep, delimiter, win32: null, posix: null });
+
+// index.ts
+import * as tsMorph from "ts-morph";
+var args = process.argv.slice(2);
+var source = args[0];
+var outPut = args[1] || "client-api.ts";
+if (!source) {
+  console.error("Please provide a source URL or file path.");
+  process.exit(1);
+}
+var isUrl = (str) => {
+  try {
+    new URL(str);
+    return true;
+  } catch {
+    return false;
+  }
+};
+async function generate() {
+  if (!source)
+    return;
+  if (isUrl(source) === false) {
+    source = resolve(process.cwd(), source);
+  }
+  console.log(`Generating API client from ${source}...`);
+  const ast = await openapiTS(source);
+  const contents = astToString(ast);
+  const project = new tsMorph.Project;
+  const sourceFile = project.createSourceFile(resolve(process.cwd(), outPut), contents, {
+    overwrite: true
+  });
+  sourceFile.addTypeAlias({
+    name: "RestMethod",
+    isExported: true,
+    type: '"get" | "post" | "put" | "delete" | "patch"'
+  });
+  sourceFile.addTypeAlias({
+    name: "KeyPaths",
+    isExported: true,
+    type: "keyof paths"
+  });
+  sourceFile.addTypeAlias({
+    name: "ExtractPathParams",
+    isExported: true,
+    typeParameters: ["T extends KeyPaths", "K extends RestMethod"],
+    type: "paths[T][K] extends { parameters: { path?: infer P } } ? P : never"
+  });
+  sourceFile.addTypeAlias({
+    name: "ExtractQueryParams",
+    isExported: true,
+    typeParameters: ["T extends KeyPaths", "K extends RestMethod"],
+    type: "paths[T][K] extends { parameters: { query?: infer Q } } ? Q : never"
+  });
+  sourceFile.addTypeAlias({
+    name: "ExtractHeaderParams",
+    isExported: true,
+    typeParameters: ["T extends KeyPaths", "K extends RestMethod"],
+    type: "paths[T][K] extends { parameters: { header?: infer H } } ? H : never"
+  });
+  sourceFile.addTypeAlias({
+    name: "ExtractBody",
+    isExported: true,
+    typeParameters: ["T extends KeyPaths", "K extends RestMethod"],
+    type: `paths[T][K] extends {
+  requestBody: { content: { "application/json": infer B } };
+}
+  ? B
+  : never`
+  });
+  sourceFile.addTypeAlias({
+    name: "APIResponse",
+    isExported: true,
+    typeParameters: ["T extends KeyPaths", "K extends RestMethod"],
+    type: `paths[T][K] extends {
+  responses:
+    | { content: { "application/json": infer R } }
+    | { [code: number]: { content: { "application/json": infer R } } };
+}
+  ? R
+  : unknown`
+  });
+  sourceFile.addTypeAlias({
+    name: "ApiPayload",
+    isExported: true,
+    typeParameters: ["T extends KeyPaths", "K extends RestMethod"],
+    type: `{
+  path?: ExtractPathParams<T, K>;
+  query?: ExtractQueryParams<T, K>;
+  body?: K extends "post" | "put" | "patch" ? ExtractBody<T, K> : never;
+  headers?: ExtractHeaderParams<T, K>;
+}`
+  });
+  sourceFile.addTypeAlias({
+    name: "ApiClientType",
+    isExported: true,
+    type: `{
+  [K in RestMethod]: <T extends KeyPaths>(
+    path: T,
+    payload?: ApiPayload<T, K>,
+  ) => Promise<APIResponse<T, K>>;
+}`
+  });
+  sourceFile.addTypeAlias({
+    name: "TypePaths",
+    typeParameters: ["T extends RestMethod"],
+    type: `{
+  [K in KeyPaths]: paths[K] extends { [M in T]: unknown } ? K : never;
+}[KeyPaths]`
+  });
+  sourceFile.addClass({
+    name: "RestApiClient",
+    isExported: true,
+    ctors: [
+      {
+        parameters: [
+          { name: "basePath", type: "string", scope: tsMorph.Scope.Private },
+          {
+            name: "option",
+            type: "RequestInit",
+            hasQuestionToken: true,
+            scope: tsMorph.Scope.Private
+          }
+        ]
+      }
+    ],
+    methods: [
+      {
+        name: "fetcher",
+        scope: tsMorph.Scope.Public,
+        isAsync: true,
+        parameters: [
+          { name: "input", type: "RequestInfo" },
+          { name: "init", type: "RequestInit", hasQuestionToken: true }
+        ],
+        statements: `const headers = {
+      "Content-Type": "application/json",
+      ...init?.headers,
+    };
+
+    const response = await fetch(input, { ...init, headers });
+    if (!response.ok) {
+      const errorBody = await response.text();
+      throw new Error(
+        \`API request failed: \${response.status} \${response.statusText} - \${errorBody}\`,
+      );
+    }
+    return response.json();`
+      },
+      {
+        name: "request",
+        typeParameters: ["M extends RestMethod", "P extends TypePaths<M>"],
+        parameters: [
+          { name: "method", type: "M" },
+          { name: "path", type: "P" },
+          {
+            name: "init",
+            type: "ApiPayload<P, M>",
+            initializer: "{} as ApiPayload<P, M>"
+          }
+        ],
+        returnType: "Promise<APIResponse<P, M>>",
+        statements: `const url = new URL(this.basePath + String(path));
+
+    url.pathname = this.buildPathUrl(url.pathname, init.path);
+    this.appendQueryParams(url, init.query);
+
+    const requestInit: RequestInit = {
+      method: method.toUpperCase(),
+      ...this.option,
+      headers: {
+        ...(this.option?.headers ?? {}),
+        ...(init.headers ?? {}),
+      },
+      body: this.prepareBody(method, init.body),
+    };
+
+    return this.fetcher(url.toString(), requestInit) as Promise<
+      APIResponse<P, M>
+    >;`
+      },
+      {
+        name: "get",
+        scope: tsMorph.Scope.Public,
+        typeParameters: ['T extends TypePaths<"get">'],
+        parameters: [
+          { name: "path", type: "T" },
+          {
+            name: "payload",
+            type: 'ApiPayload<T, "get">',
+            hasQuestionToken: true
+          }
+        ],
+        returnType: 'Promise<APIResponse<T, "get">>',
+        statements: 'return this.request("get", path, payload);'
+      },
+      {
+        name: "post",
+        scope: tsMorph.Scope.Public,
+        typeParameters: ['T extends TypePaths<"post">'],
+        parameters: [
+          { name: "path", type: "T" },
+          {
+            name: "payload",
+            type: 'ApiPayload<T, "post">',
+            hasQuestionToken: true
+          }
+        ],
+        returnType: 'Promise<APIResponse<T, "post">>',
+        statements: 'return this.request("post", path, payload);'
+      },
+      {
+        name: "put",
+        scope: tsMorph.Scope.Public,
+        typeParameters: ['T extends TypePaths<"put">'],
+        parameters: [
+          { name: "path", type: "T" },
+          {
+            name: "payload",
+            type: 'ApiPayload<T, "put">',
+            hasQuestionToken: true
+          }
+        ],
+        returnType: 'Promise<APIResponse<T, "put">>',
+        statements: 'return this.request("put", path, payload);'
+      },
+      {
+        name: "delete",
+        scope: tsMorph.Scope.Public,
+        typeParameters: ['T extends TypePaths<"delete">'],
+        parameters: [
+          { name: "path", type: "T" },
+          {
+            name: "payload",
+            type: 'ApiPayload<T, "delete">',
+            hasQuestionToken: true
+          }
+        ],
+        returnType: 'Promise<APIResponse<T, "delete">>',
+        statements: 'return this.request("delete", path, payload);'
+      },
+      {
+        name: "patch",
+        scope: tsMorph.Scope.Public,
+        typeParameters: ['T extends TypePaths<"patch">'],
+        parameters: [
+          { name: "path", type: "T" },
+          {
+            name: "payload",
+            type: 'ApiPayload<T, "patch">',
+            hasQuestionToken: true
+          }
+        ],
+        returnType: 'Promise<APIResponse<T, "patch">>',
+        statements: 'return this.request("patch", path, payload);'
+      },
+      {
+        name: "buildPathUrl",
+        scope: tsMorph.Scope.Private,
+        parameters: [
+          { name: "basePath", type: "string" },
+          { name: "pathParams", type: "unknown", hasQuestionToken: true }
+        ],
+        returnType: "string",
+        statements: `let pathname = basePath;
+    if (pathParams != null) {
+      const params = pathParams as Record<string, unknown>;
+      pathname = decodeURIComponent(pathname).replace(/{(w+)}/g, (_, key) =>
+        encodeURIComponent(String(params[key])),
+      );
+    }
+    return pathname;`
+      },
+      {
+        name: "prepareBody",
+        scope: tsMorph.Scope.Private,
+        parameters: [
+          { name: "method", type: "RestMethod" },
+          { name: "body", type: "unknown", hasQuestionToken: true }
+        ],
+        returnType: "string | undefined",
+        statements: `if (body && ["post", "put", "patch"].includes(method)) {
+      return JSON.stringify(body);
+    }
+    return undefined;`
+      },
+      {
+        name: "appendQueryParams",
+        scope: tsMorph.Scope.Private,
+        parameters: [
+          { name: "url", type: "URL" },
+          { name: "queryParams", type: "unknown", hasQuestionToken: true }
+        ],
+        returnType: "void",
+        statements: `if (queryParams != null) {
+      const params = queryParams as Record<string, unknown>;
+      for (const [key, value] of Object.entries(params)) {
+        if (value !== undefined && value !== null) {
+          url.searchParams.append(key, String(value));
+        }
+      }
+    }`
+      }
+    ]
+  });
+  await sourceFile.formatText();
+  await project.save();
+  console.log(`API client generated at ${outPut}`);
+}
+generate();

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "create-swagger-client",
+  "version": "0.1.0",
+  "description": "Generate fully type-safe REST API clients from OpenAPI/Swagger specifications",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "type": "module",
+  "bin": {
+    "create-swagger-client": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "bun build index.ts --outdir dist --external openapi-typescript --external ts-morph",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "bun run build"
+  },
+  "keywords": [
+    "openapi",
+    "swagger",
+    "typescript",
+    "api-client",
+    "type-safe",
+    "rest-api",
+    "code-generator",
+    "openapi-generator",
+    "swagger-codegen"
+  ],
+  "author": "cuongboi",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cuongboi/create-swagger-client.git"
+  },
+  "bugs": {
+    "url": "https://github.com/cuongboi/create-swagger-client/issues"
+  },
+  "homepage": "https://github.com/cuongboi/create-swagger-client#readme",
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "devDependencies": {
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "dependencies": {
+    "openapi-typescript": "^7.10.1",
+    "ts-morph": "^27.0.2"
+  }
+}