swgto-ts 0.1.0 → 0.1.1

package/dist/{chunk-RRFCLHNU.js → chunk-5JY6MCOD.js}

@@ -53,6 +53,66 @@ function groupByPrefix(operations) {
   }, {});
 }
 
+// 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/utils/naming.ts
 function toPascalCase(value) {
   return value.split(/[^a-zA-Z0-9]+/).filter(Boolean).map((segment) => segment[0].toUpperCase() + segment.slice(1)).join("");
@@ -77,6 +137,36 @@ function buildTypeName(functionName, suffix) {
 
 // src/core/parsePaths.ts
 var HTTP_METHODS = ["get", "post", "put", "patch", "delete", "options", "head"];
+function collectReferencedTypeNames(schema, collected = /* @__PURE__ */ new Set()) {
+  if (!schema) {
+    return [...collected];
+  }
+  if (schema.$ref) {
+    const typeName = schema.$ref.split("/").pop();
+    if (typeName) {
+      collected.add(typeName);
+    }
+  }
+  for (const child of schema.anyOf ?? []) {
+    collectReferencedTypeNames(child, collected);
+  }
+  for (const child of schema.oneOf ?? []) {
+    collectReferencedTypeNames(child, collected);
+  }
+  for (const child of schema.allOf ?? []) {
+    collectReferencedTypeNames(child, collected);
+  }
+  if (schema.items) {
+    collectReferencedTypeNames(schema.items, collected);
+  }
+  for (const property of Object.values(schema.properties ?? {})) {
+    collectReferencedTypeNames(property, collected);
+  }
+  if (schema.additionalProperties && schema.additionalProperties !== true) {
+    collectReferencedTypeNames(schema.additionalProperties, collected);
+  }
+  return [...collected];
+}
 function getPrimarySchema(content) {
   if (!content) {
     return void 0;
@@ -108,7 +198,21 @@ function parsePaths(document, docUrl, config) {
       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;
+      const bodyType = requestBodySchema ? schemaToTs(requestBodySchema) : void 0;
+      const requestImportTypes = collectReferencedTypeNames(requestBodySchema);
+      const pathFields = pathParams.map((param) => `${param.name}: ${schemaToTs(param.schema)};`);
+      const queryFields = queryParams.map((param) => `${param.name}${param.required ? "" : "?"}: ${schemaToTs(param.schema)};`);
+      const requestTypeParts = [];
+      if (bodyType) {
+        requestTypeParts.push(bodyType);
+      }
+      if (pathFields.length) {
+        requestTypeParts.push(`{ path: { ${pathFields.join(" ")} } }`);
+      }
+      if (queryFields.length) {
+        requestTypeParts.push(`{ query: { ${queryFields.join(" ")} } }`);
+      }
+      const requestTypeExpression = hasRequestParams ? requestTypeParts.join(" & ") || "unknown" : void 0;
       operations.push({
         docUrl,
         moduleName,
@@ -123,7 +227,8 @@ function parsePaths(document, docUrl, config) {
         pathParams,
         requestBodySchema,
         responseSchema,
-        requestTypeName,
+        requestTypeExpression,
+        requestImportTypes,
         responseTypeName: responseSchema ? buildTypeName(functionName, "Response") : void 0,
         fileBaseName: functionName
       });
@@ -178,9 +283,11 @@ function buildFunctionDoc(operation, typeImportPath, requestParamType) {
   return ["/**", ...lines.map((line) => ` * ${line}`), " */"].join("\n");
 }
 function generateJsRequestFile(operation, httpClientPath, typeImportPath) {
-  const requestParamType = operation.requestTypeName ?? "void";
+  const requestParamType = operation.requestTypeExpression ?? "void";
   const queryLine = operation.queryParams.length ? "    params: params?.query,\n" : "";
-  const bodyLine = operation.requestBodySchema ? "    data: params?.body,\n" : "";
+  const bodyOnly = Boolean(operation.requestBodySchema) && !operation.queryParams.length && !operation.pathParams.length;
+  const bodyLine = operation.requestBodySchema ? `    data: ${bodyOnly ? "params" : "params?.body"},
+` : "";
   const pathLine = operation.pathParams.length ? "    url: buildUrl(params?.path),\n" : `    url: ${JSON.stringify(operation.requestPath)},
 `;
   const buildUrlHelper = operation.pathParams.length ? `
@@ -219,15 +326,17 @@ function buildFunctionDoc2(operation) {
 }
 function generateTsRequestFile(operation, httpClientPath, typeImportPath) {
   const importTypes = [
-    operation.requestTypeName,
+    ...operation.requestImportTypes,
     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 requestArg = operation.requestTypeExpression ? `params: ${operation.requestTypeExpression}, config?: RequestConfig` : "params?: void, config?: RequestConfig";
   const defaultResponseType = operation.responseTypeName ?? "unknown";
-  const bodyLine = operation.requestBodySchema ? "    data: params?.body,\n" : "";
+  const bodyOnly = Boolean(operation.requestBodySchema) && !operation.queryParams.length && !operation.pathParams.length;
+  const bodyLine = operation.requestBodySchema ? `    data: ${bodyOnly ? "params" : "params?.body"},
+` : "";
   const queryLine = operation.queryParams.length ? "    params: params?.query,\n" : "";
   const pathLine = operation.pathParams.length ? "    url: buildUrl(params?.path),\n" : `    url: ${JSON.stringify(operation.requestPath)},
 `;
@@ -251,66 +360,6 @@ ${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) {
@@ -328,16 +377,6 @@ function buildSchemaDoc(schema) {
   }
   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) {
@@ -370,56 +409,6 @@ ${body}
 }
 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}
@@ -450,13 +439,6 @@ function generateTypesFile(documentMap, operations, config) {
       }
     }
     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} */`);
       }
@@ -484,7 +466,7 @@ function generateTypesFile(documentMap, operations, config) {
 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 paramsType = operation.requestTypeExpression ?? "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>;`);
   }

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   generateFromConfig
-} from "./chunk-RRFCLHNU.js";
+} from "./chunk-5JY6MCOD.js";
 
 // src/cli.ts
 async function main() {

package/dist/index.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "swgto-ts",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Generate API request files from OpenAPI 3.x documents.",
   "license": "MIT",
   "type": "module",