swgto-ts 0.1.0

package/README.md

@@ -0,0 +1,86 @@
+# swgto
+
+`swgto` 是一个把 `OpenAPI 3.x` 文档转换成项目内请求函数的 Node.js 库和 CLI。
+
+安装后会注册一个 `swgto` 命令。执行时它会在当前目录查找 `.swaggerts.config.ts` 或 `.swaggerts.config.js`，然后生成：
+
+- 按路径前缀分组的请求文件
+- 按文档模块输出请求文件。单文档默认输出到 `services/`，多文档时多个模块目录平级
+- `outputDir/index.ts` 或 `outputDir/index.js`
+- 聚合声明文件 `outputDir/api.d.ts`
+- 类型文件 `outputDir/types.ts` 或带 JSDoc 的 `outputDir/types.js`
+
+## 安装
+
+```bash
+npm install swgto
+```
+
+## 配置
+
+在项目根目录创建 `.swaggerts.config.ts`：
+
+```ts
+import type { SwaggerTsConfig } from 'swgto';
+
+const config: SwaggerTsConfig = {
+  docUrls: 'https://example.com/openapi.json',
+  httpClientPath: '@/utils/request',
+  outputDir: 'src/api',
+  outputType: 'ts',
+  typeName: 'types',
+  cleanOutput: true,
+  renameMethod: (apiPath, method) => `${method}_${apiPath.replace(/[\\/{}]/g, '_')}`,
+  resolveRequestPath: (apiPath, method) => `/proxy${apiPath}`,
+};
+
+export default config;
+```
+
+多文档模式下需要提供 `moduleName`：
+
+```ts
+export default {
+  docUrls: [
+    'https://example.com/user-openapi.json',
+    'https://example.com/order-openapi.json',
+  ],
+  httpClientPath: '@/utils/request',
+  outputDir: 'src/api',
+  moduleName: (docUrl) => docUrl.includes('user') ? 'user' : 'order',
+};
+```
+
+## 使用
+
+```bash
+swgto
+```
+
+## 输出示例
+
+```text
+src/api/
+  api.d.ts
+  index.ts
+  types.ts
+  services/
+    get_user_list.ts
+    post_user_create.ts
+```
+
+## 配置项
+
+```ts
+export interface SwaggerTsConfig {
+  docUrls: string | string[];
+  httpClientPath: string;
+  renameMethod?: (path: string, method: string) => string;
+  resolveRequestPath?: (path: string, method: string, docUrl: string) => string;
+  outputDir?: string;
+  moduleName?: (docUrl: string) => string;
+  outputType?: 'ts' | 'js';
+  typeName?: string;
+  cleanOutput?: boolean;
+}
+```

package/dist/chunk-RRFCLHNU.js

@@ -0,0 +1,560 @@
+// src/generate.ts
+import path3 from "path";
+
+// src/config/loadConfig.ts
+import { existsSync } from "fs";
+import path from "path";
+import { pathToFileURL } from "url";
+import { createJiti } from "jiti";
+var CONFIG_FILES = [".swaggerts.config.ts", ".swaggerts.config.js"];
+function assertConfig(config) {
+  if (!config || typeof config !== "object") {
+    throw new Error("`.swaggerts.config` must export a config object.");
+  }
+  if (!config.docUrls || typeof config.docUrls !== "string" && !Array.isArray(config.docUrls)) {
+    throw new Error("`docUrls` must be a string or string array.");
+  }
+  if (!config.httpClientPath) {
+    throw new Error("`httpClientPath` is required.");
+  }
+  if (Array.isArray(config.docUrls) && config.docUrls.length > 1 && typeof config.moduleName !== "function") {
+    throw new Error("`moduleName(docUrl)` is required when `docUrls` contains multiple documents.");
+  }
+}
+async function loadConfig(cwd) {
+  const configPath = CONFIG_FILES.map((fileName) => path.join(cwd, fileName)).find((filePath) => existsSync(filePath));
+  if (!configPath) {
+    throw new Error("Cannot find `.swaggerts.config.ts` or `.swaggerts.config.js` in current directory.");
+  }
+  const jiti = createJiti(pathToFileURL(configPath).href, {
+    interopDefault: true
+  });
+  const loaded = await jiti.import(configPath);
+  const rawConfig = loaded?.default ?? loaded;
+  assertConfig(rawConfig);
+  const docUrls = Array.isArray(rawConfig.docUrls) ? rawConfig.docUrls : [rawConfig.docUrls];
+  const config = {
+    ...rawConfig,
+    docUrls,
+    outputDir: rawConfig.outputDir ?? "src/api",
+    outputType: rawConfig.outputType ?? "ts",
+    typeName: rawConfig.typeName ?? "types",
+    cleanOutput: rawConfig.cleanOutput ?? false
+  };
+  return { configPath, config };
+}
+
+// src/core/groupByPrefix.ts
+function groupByPrefix(operations) {
+  return operations.reduce((acc, operation) => {
+    acc[operation.moduleName] ??= [];
+    acc[operation.moduleName].push(operation);
+    return acc;
+  }, {});
+}
+
+// src/utils/naming.ts
+function toPascalCase(value) {
+  return value.split(/[^a-zA-Z0-9]+/).filter(Boolean).map((segment) => segment[0].toUpperCase() + segment.slice(1)).join("");
+}
+function sanitizePathSegment(value) {
+  return value.replace(/^\//, "").replace(/\{|\}/g, "").replace(/[^a-zA-Z0-9/_-]/g, "").replace(/\/+/g, "/");
+}
+function sanitizeIdentifier(value) {
+  const normalized = value.replace(/[^a-zA-Z0-9_$]+/g, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "");
+  if (!normalized) {
+    return "generated_api";
+  }
+  return /^[0-9]/.test(normalized) ? `api_${normalized}` : normalized;
+}
+function buildDefaultMethodName(apiPath, method) {
+  const cleaned = sanitizePathSegment(apiPath).replace(/\//g, "_").replace(/_+/g, "_");
+  return sanitizeIdentifier([method.toLowerCase(), cleaned || "root"].join("_"));
+}
+function buildTypeName(functionName, suffix) {
+  return `${toPascalCase(functionName)}${suffix}`;
+}
+
+// src/core/parsePaths.ts
+var HTTP_METHODS = ["get", "post", "put", "patch", "delete", "options", "head"];
+function getPrimarySchema(content) {
+  if (!content) {
+    return void 0;
+  }
+  const jsonLikeKey = Object.keys(content).find((key) => key.includes("json")) ?? Object.keys(content)[0];
+  return jsonLikeKey ? content[jsonLikeKey]?.schema : void 0;
+}
+function getSuccessResponse(responses) {
+  if (!responses) {
+    return void 0;
+  }
+  const successCode = ["200", "201", "202", "default"].find((code) => responses[code]);
+  return successCode ? getPrimarySchema(responses[successCode]?.content) : void 0;
+}
+function parsePaths(document, docUrl, config) {
+  const operations = [];
+  for (const [apiPath, pathItem] of Object.entries(document.paths ?? {})) {
+    for (const [method, operation] of Object.entries(pathItem ?? {})) {
+      if (!HTTP_METHODS.includes(method) || !operation) {
+        continue;
+      }
+      const moduleName = config.moduleName?.(docUrl) ?? "services";
+      const functionName = sanitizeIdentifier(
+        config.renameMethod?.(apiPath, method) ?? buildDefaultMethodName(apiPath, method)
+      );
+      const requestPath = config.resolveRequestPath?.(apiPath, method, docUrl) ?? apiPath;
+      const queryParams = (operation.parameters ?? []).filter((item) => item?.in === "query");
+      const pathParams = (operation.parameters ?? []).filter((item) => item?.in === "path");
+      const requestBodySchema = getPrimarySchema(operation.requestBody?.content);
+      const responseSchema = getSuccessResponse(operation.responses);
+      const hasRequestParams = queryParams.length > 0 || pathParams.length > 0 || Boolean(requestBodySchema);
+      const requestTypeName = hasRequestParams ? buildTypeName(functionName, "Request") : void 0;
+      operations.push({
+        docUrl,
+        moduleName,
+        path: apiPath,
+        requestPath,
+        method,
+        functionName,
+        operationId: operation.operationId,
+        summary: operation.summary,
+        description: operation.description,
+        queryParams,
+        pathParams,
+        requestBodySchema,
+        responseSchema,
+        requestTypeName,
+        responseTypeName: responseSchema ? buildTypeName(functionName, "Response") : void 0,
+        fileBaseName: functionName
+      });
+    }
+  }
+  return operations;
+}
+
+// src/fetch/loadOpenApi.ts
+async function loadOpenApiDocument(docUrl) {
+  const response = await fetch(docUrl);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch OpenAPI document: ${docUrl} (${response.status})`);
+  }
+  const document = await response.json();
+  if (!document.openapi?.startsWith("3.")) {
+    throw new Error(`Only OpenAPI 3.x is supported: ${docUrl}`);
+  }
+  if (!document.paths || typeof document.paths !== "object") {
+    throw new Error(`OpenAPI document does not contain valid paths: ${docUrl}`);
+  }
+  return document;
+}
+
+// src/generators/genIndex.ts
+function generateIndexFile(operations, config) {
+  const exports = operations.map((operation) => {
+    return `export * from "./${operation.moduleName}/${operation.fileBaseName}";`;
+  });
+  return `/* eslint-disable */
+// Auto-generated by swgto.
+${exports.join("\n")}
+`;
+}
+
+// src/generators/genRequestJs.ts
+function buildFunctionDoc(operation, typeImportPath, requestParamType) {
+  const lines = [];
+  if (operation.summary) {
+    lines.push(operation.summary);
+  }
+  if (operation.description) {
+    lines.push(operation.description);
+  }
+  lines.push(`@path ${operation.path}`);
+  lines.push(`@requestPath ${operation.requestPath}`);
+  lines.push(`@method ${operation.method.toUpperCase()}`);
+  lines.push("@template T");
+  lines.push(`@param ${requestParamType === "void" ? "[params]" : `{import(${JSON.stringify(typeImportPath)}).${requestParamType}} params`}`);
+  lines.push("@param [config]");
+  lines.push("@returns {Promise<T>}");
+  return ["/**", ...lines.map((line) => ` * ${line}`), " */"].join("\n");
+}
+function generateJsRequestFile(operation, httpClientPath, typeImportPath) {
+  const requestParamType = operation.requestTypeName ?? "void";
+  const queryLine = operation.queryParams.length ? "    params: params?.query,\n" : "";
+  const bodyLine = operation.requestBodySchema ? "    data: params?.body,\n" : "";
+  const pathLine = operation.pathParams.length ? "    url: buildUrl(params?.path),\n" : `    url: ${JSON.stringify(operation.requestPath)},
+`;
+  const buildUrlHelper = operation.pathParams.length ? `
+function buildUrl(path) {
+  return ${JSON.stringify(operation.requestPath)}.replace(/\\{([^}]+)\\}/g, (_, key) => String(path?.[key] ?? ''));
+}
+` : "";
+  return `/* eslint-disable */
+// Auto-generated by swgto.
+import request from ${JSON.stringify(httpClientPath)};
+${buildUrlHelper}
+
+${buildFunctionDoc(operation, typeImportPath, requestParamType)}
+export async function ${operation.functionName}(params, config) {
+  return request({
+${pathLine}    method: ${JSON.stringify(operation.method)},
+${queryLine}${bodyLine}    ...config,
+  });
+}
+`;
+}
+
+// src/generators/genRequestTs.ts
+function buildFunctionDoc2(operation) {
+  const lines = [
+    operation.summary,
+    operation.description,
+    `@path ${operation.path}`,
+    `@requestPath ${operation.requestPath}`,
+    `@method ${operation.method.toUpperCase()}`
+  ].filter((value) => Boolean(value));
+  if (!lines.length) {
+    return "";
+  }
+  return ["/**", ...lines.map((line) => ` * ${line}`), " */", ""].join("\n");
+}
+function generateTsRequestFile(operation, httpClientPath, typeImportPath) {
+  const importTypes = [
+    operation.requestTypeName,
+    operation.responseTypeName,
+    "RequestConfig"
+  ].filter((value, index, array) => Boolean(value) && array.indexOf(value) === index);
+  const importLine = importTypes.length ? `import type { ${importTypes.join(", ")} } from ${JSON.stringify(typeImportPath)};
+` : "";
+  const requestArg = operation.requestTypeName ? `params: ${operation.requestTypeName}, config?: RequestConfig` : "params?: void, config?: RequestConfig";
+  const defaultResponseType = operation.responseTypeName ?? "unknown";
+  const bodyLine = operation.requestBodySchema ? "    data: params?.body,\n" : "";
+  const queryLine = operation.queryParams.length ? "    params: params?.query,\n" : "";
+  const pathLine = operation.pathParams.length ? "    url: buildUrl(params?.path),\n" : `    url: ${JSON.stringify(operation.requestPath)},
+`;
+  const buildUrlHelper = operation.pathParams.length ? `
+function buildUrl(path?: Record<string, unknown>): string {
+  return ${JSON.stringify(operation.requestPath)}.replace(/\\{([^}]+)\\}/g, (_, key) => String(path?.[key] ?? ''));
+}
+` : "";
+  return `/* eslint-disable */
+// Auto-generated by swgto.
+import request from ${JSON.stringify(httpClientPath)};
+${importLine}
+${buildUrlHelper}
+${buildFunctionDoc2(operation)}
+export async function ${operation.functionName}<T = ${defaultResponseType}>(${requestArg}): Promise<T> {
+  return request<T>({
+${pathLine}    method: ${JSON.stringify(operation.method)},
+${queryLine}${bodyLine}    ...config,
+  });
+}
+`;
+}
+
+// src/generators/schemaToTs.ts
+function formatPropertyName(name) {
+  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name) ? name : JSON.stringify(name);
+}
+function refToTypeName(ref) {
+  const parts = ref.split("/");
+  return parts[parts.length - 1] || "unknown";
+}
+function schemaToTs(schema) {
+  if (!schema) {
+    return "unknown";
+  }
+  if (schema.$ref) {
+    return refToTypeName(schema.$ref);
+  }
+  if (schema.enum?.length) {
+    return schema.enum.map((item) => JSON.stringify(item)).join(" | ");
+  }
+  if (schema.anyOf?.length) {
+    return schema.anyOf.map((item) => schemaToTs(item)).join(" | ");
+  }
+  if (schema.oneOf?.length) {
+    return schema.oneOf.map((item) => schemaToTs(item)).join(" | ");
+  }
+  if (schema.allOf?.length) {
+    return schema.allOf.map((item) => schemaToTs(item)).join(" & ");
+  }
+  if (schema.type === "array") {
+    return `${schemaToTs(schema.items)}[]`;
+  }
+  if (schema.type === "object" || schema.properties) {
+    const requiredSet = new Set(schema.required ?? []);
+    const properties = Object.entries(schema.properties ?? {}).map(([key, value]) => {
+      const optional = requiredSet.has(key) ? "" : "?";
+      return `${formatPropertyName(key)}${optional}: ${schemaToTs(value)};`;
+    });
+    if (!properties.length && schema.additionalProperties) {
+      const valueType = schema.additionalProperties === true ? "unknown" : schemaToTs(schema.additionalProperties);
+      return `{ [key: string]: ${valueType} }`;
+    }
+    return `{ ${properties.join(" ")} }`;
+  }
+  switch (schema.type) {
+    case "integer":
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "string":
+      return "string";
+    case "null":
+      return "null";
+    default:
+      return "unknown";
+  }
+}
+function toTypePropertyName(name) {
+  return formatPropertyName(name);
+}
+
+// src/generators/genTypes.ts
+function formatDocLines(lines) {
+  if (!lines.length) {
+    return "";
+  }
+  return ["/**", ...lines.map((line) => ` * ${line}`), " */"].join("\n");
+}
+function buildSchemaDoc(schema) {
+  const lines = [];
+  if (schema?.description) {
+    lines.push(schema.description);
+  }
+  if (schema && schema.example !== void 0) {
+    lines.push(`@example ${JSON.stringify(schema.example)}`);
+  }
+  return formatDocLines(lines);
+}
+function buildParameterDoc(parameter, fallback) {
+  const lines = [parameter.description ?? fallback];
+  if (parameter.required) {
+    lines.push("@required");
+  }
+  if (parameter.example !== void 0) {
+    lines.push(`@example ${JSON.stringify(parameter.example)}`);
+  }
+  return formatDocLines(lines);
+}
+function renderObjectFields(fields, indent = "") {
+  const lines = [];
+  for (const field of fields) {
+    if (field.doc) {
+      lines.push(...field.doc.split("\n").map((line) => `${indent}${line}`));
+    }
+    lines.push(`${indent}${field.name}${field.optional ? "?" : ""}: ${field.type};`);
+  }
+  return lines;
+}
+function renderComponentSchema(name, schema) {
+  const typedSchema = schema;
+  const doc = buildSchemaDoc(typedSchema);
+  if (typedSchema.type === "object" || typedSchema.properties) {
+    const requiredSet = new Set(typedSchema.required ?? []);
+    const fields = Object.entries(typedSchema.properties ?? {}).map(([key, value]) => ({
+      name: toTypePropertyName(key),
+      type: schemaToTs(value),
+      optional: !requiredSet.has(key),
+      doc: buildSchemaDoc(value)
+    }));
+    const body = renderObjectFields(fields, "  ").join("\n");
+    return `${doc ? `${doc}
+` : ""}export interface ${name} {
+${body}
+}`;
+  }
+  return `${doc ? `${doc}
+` : ""}export type ${name} = ${schemaToTs(schema)};`;
+}
+function renderOperationTypes(operation) {
+  const blocks = [];
+  if (operation.requestTypeName) {
+    const fields = [];
+    const pathFields = [];
+    const queryFields = [];
+    for (const param of operation.pathParams) {
+      pathFields.push({
+        name: toTypePropertyName(param.name),
+        type: schemaToTs(param.schema),
+        optional: false,
+        doc: buildParameterDoc(param, `Path parameter: ${param.name}`)
+      });
+    }
+    for (const param of operation.queryParams) {
+      queryFields.push({
+        name: toTypePropertyName(param.name),
+        type: schemaToTs(param.schema),
+        optional: !param.required,
+        doc: buildParameterDoc(param, `Query parameter: ${param.name}`)
+      });
+    }
+    if (operation.requestBodySchema) {
+      const doc = buildSchemaDoc(operation.requestBodySchema);
+      if (doc) {
+        fields.push(...doc.split("\n"));
+      }
+      fields.push(`body${operation.requestBodySchema.nullable ? "?" : ""}: ${schemaToTs(operation.requestBodySchema)};`);
+    }
+    if (pathFields.length) {
+      fields.push("/** Path parameters */");
+      fields.push("path: {");
+      fields.push(...renderObjectFields(pathFields, "  "));
+      fields.push("};");
+    }
+    if (queryFields.length) {
+      fields.push("/** Query parameters */");
+      fields.push("query: {");
+      fields.push(...renderObjectFields(queryFields, "  "));
+      fields.push("};");
+    }
+    const requestDoc = formatDocLines(
+      [
+        operation.summary,
+        operation.description
+      ].filter((value) => Boolean(value))
+    );
+    blocks.push(`${requestDoc ? `${requestDoc}
+` : ""}export interface ${operation.requestTypeName} {
+${fields.map((line) => `  ${line}`).join("\n")}
+}`);
+  }
+  if (operation.responseTypeName) {
+    const responseDoc = buildSchemaDoc(operation.responseSchema);
+    blocks.push(`${responseDoc ? `${responseDoc}
+` : ""}export type ${operation.responseTypeName} = ${schemaToTs(operation.responseSchema)};`);
+  }
+  return blocks;
+}
+function renderComponentSchemas(document) {
+  return Object.entries(document.components?.schemas ?? {}).map(([name, schema]) => {
+    return renderComponentSchema(name, schema);
+  });
+}
+function toJSDocType(typeText) {
+  return typeText.replace(/;/g, "").replace(/\?/g, "=");
+}
+function generateTypesFile(documentMap, operations, config) {
+  if (config.outputType === "js") {
+    const parts2 = [
+      "/* eslint-disable */",
+      "// Auto-generated by swgto.",
+      "/** @typedef {Record<string, unknown>} RequestConfig */"
+    ];
+    for (const [docUrl, document] of documentMap.entries()) {
+      const moduleName = config.moduleName?.(docUrl) ?? "services";
+      parts2.push(`// Types from ${moduleName}`);
+      for (const [name, schema] of Object.entries(document.components?.schemas ?? {})) {
+        parts2.push(`/** @typedef {${toJSDocType(schemaToTs(schema))}} ${name} */`);
+      }
+    }
+    for (const operation of operations) {
+      if (operation.requestTypeName) {
+        const rendered = renderOperationTypes(operation).find((line) => line.startsWith(`export interface ${operation.requestTypeName}`));
+        if (rendered) {
+          const body = rendered.replace(`export interface ${operation.requestTypeName} `, "").trim();
+          parts2.push(`/** @typedef ${body} ${operation.requestTypeName} */`);
+        }
+      }
+      if (operation.responseTypeName) {
+        parts2.push(`/** @typedef {${toJSDocType(schemaToTs(operation.responseSchema))}} ${operation.responseTypeName} */`);
+      }
+    }
+    parts2.push("export {};");
+    return `${parts2.filter(Boolean).join("\n\n")}
+`;
+  }
+  const parts = [
+    "/* eslint-disable */",
+    "// Auto-generated by swgto.",
+    "export type RequestConfig = Record<string, unknown>;"
+  ];
+  for (const [docUrl, document] of documentMap.entries()) {
+    const moduleName = config.moduleName?.(docUrl) ?? "services";
+    parts.push(`// Types from ${moduleName}`);
+    parts.push(...renderComponentSchemas(document));
+  }
+  for (const operation of operations) {
+    parts.push(...renderOperationTypes(operation));
+  }
+  return `${parts.filter(Boolean).join("\n\n")}
+`;
+}
+function generateApiDtsContent(operations, config) {
+  const lines = ["// Auto-generated by swgto.", 'export * from "./index";', `export * from "./${config.typeName}";`];
+  for (const operation of operations) {
+    const paramsType = operation.requestTypeName ?? "void";
+    const responseType = operation.responseTypeName ?? "unknown";
+    lines.push(`export declare function ${operation.functionName}<T = ${responseType}>(params${paramsType === "void" ? "?" : ""}: ${paramsType}, config?: import("./index").RequestConfig): Promise<T>;`);
+  }
+  return `${lines.join("\n")}
+`;
+}
+
+// src/utils/fs.ts
+import { mkdir, rm, writeFile } from "fs/promises";
+import path2 from "path";
+async function ensureDir(dirPath) {
+  await mkdir(dirPath, { recursive: true });
+}
+async function writeTextFile(filePath, content) {
+  await ensureDir(path2.dirname(filePath));
+  await writeFile(filePath, content, "utf8");
+}
+async function removeDir(dirPath) {
+  await rm(dirPath, { recursive: true, force: true });
+}
+
+// src/generate.ts
+function getRootImportPath(fileKind, typeName) {
+  return fileKind === "types" ? `../${typeName}` : "../api";
+}
+async function generateFromConfig(cwd = process.cwd()) {
+  const { configPath, config } = await loadConfig(cwd);
+  const documentMap = /* @__PURE__ */ new Map();
+  const operations = [];
+  if (config.cleanOutput) {
+    await removeDir(path3.join(cwd, config.outputDir));
+  }
+  for (const docUrl of config.docUrls) {
+    const document = await loadOpenApiDocument(docUrl);
+    documentMap.set(docUrl, document);
+    operations.push(...parsePaths(document, docUrl, config));
+  }
+  const grouped = groupByPrefix(operations);
+  const files = [];
+  for (const [moduleName, moduleOperations] of Object.entries(grouped)) {
+    for (const operation of moduleOperations) {
+      const relativeFile = path3.join(config.outputDir, moduleName, `${operation.fileBaseName}.${config.outputType}`);
+      const absoluteFile = path3.join(cwd, relativeFile);
+      const content = config.outputType === "ts" ? generateTsRequestFile(operation, config.httpClientPath, getRootImportPath("types", config.typeName)) : generateJsRequestFile(operation, config.httpClientPath, getRootImportPath("api", config.typeName));
+      await writeTextFile(absoluteFile, content);
+      files.push(relativeFile);
+    }
+  }
+  const typesContent = generateTypesFile(documentMap, operations, config);
+  const apiDtsContent = generateApiDtsContent(operations, config);
+  const indexContent = generateIndexFile(operations, config);
+  const typesFile = path3.join(cwd, config.outputDir, `${config.typeName}.${config.outputType === "ts" ? "ts" : "js"}`);
+  const apiDtsFile = path3.join(cwd, config.outputDir, "api.d.ts");
+  const indexFile = path3.join(cwd, config.outputDir, `index.${config.outputType}`);
+  await writeTextFile(typesFile, typesContent);
+  await writeTextFile(apiDtsFile, apiDtsContent);
+  await writeTextFile(indexFile, indexContent);
+  files.push(
+    path3.relative(cwd, typesFile),
+    path3.relative(cwd, apiDtsFile),
+    path3.relative(cwd, indexFile)
+  );
+  return {
+    configPath,
+    files,
+    operationCount: operations.length,
+    moduleCount: Object.keys(grouped).length
+  };
+}
+
+export {
+  generateFromConfig
+};

package/dist/cli.d.ts

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

package/dist/cli.js

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+import {
+  generateFromConfig
+} from "./chunk-RRFCLHNU.js";
+
+// src/cli.ts
+async function main() {
+  const startedAt = Date.now();
+  try {
+    const result = await generateFromConfig(process.cwd());
+    const elapsedMs = Date.now() - startedAt;
+    console.log(`swgto loaded config: ${result.configPath}`);
+    console.log(`Generated ${result.operationCount} API files in ${result.moduleCount} module(s).`);
+    console.log(`Wrote ${result.files.length} files, including index and api.d.ts.`);
+    console.log(`Done in ${elapsedMs}ms.`);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`swgto failed: ${message}`);
+    process.exitCode = 1;
+  }
+}
+void main();

package/dist/index.d.ts

@@ -0,0 +1,23 @@
+interface GenerateResult {
+    configPath: string;
+    files: string[];
+    operationCount: number;
+    moduleCount: number;
+}
+declare function generateFromConfig(cwd?: string): Promise<GenerateResult>;
+
+type OutputType = 'ts' | 'js';
+type RequestConfig = Record<string, unknown>;
+interface SwaggerTsConfig {
+    docUrls: string | string[];
+    httpClientPath: string;
+    renameMethod?: (path: string, method: string) => string;
+    resolveRequestPath?: (path: string, method: string, docUrl: string) => string;
+    outputDir?: string;
+    moduleName?: (docUrl: string) => string;
+    outputType?: OutputType;
+    typeName?: string;
+    cleanOutput?: boolean;
+}
+
+export { type GenerateResult, type RequestConfig, type SwaggerTsConfig, generateFromConfig };

package/dist/index.js

@@ -0,0 +1,6 @@
+import {
+  generateFromConfig
+} from "./chunk-RRFCLHNU.js";
+export {
+  generateFromConfig
+};

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "swgto-ts",
+  "version": "0.1.0",
+  "description": "Generate API request files from OpenAPI 3.x documents.",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "swgto": "./dist/cli.js"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts src/cli.ts --format esm --dts --clean",
+    "dev": "tsup src/index.ts src/cli.ts --format esm --dts --watch",
+    "test": "vitest run"
+  },
+  "keywords": [
+    "openapi",
+    "swagger",
+    "typescript",
+    "generator",
+    "cli"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "jiti": "^2.4.2"
+  },
+  "devDependencies": {
+    "@types/node": "^24.6.0",
+    "tsup": "^8.5.0",
+    "typescript": "^5.9.3",
+    "vitest": "^3.2.4"
+  }
+}