swagshot 0.1.0

package/src/lib/codeGenerator.ts

@@ -0,0 +1,376 @@
+import { SwaggerSpec, SchemaObject, Operation, Parameter } from "./types.js";
+import { SwagShotConfig } from "./types.js";
+
+// ── Schema → TypeScript type ──────────────────────────────────────────────
+
+export function schemaToTS(
+  schema: SchemaObject,
+  schemas: Record<string, SchemaObject> = {},
+  indent = 0
+): string {
+  if (schema.$ref) {
+    const name = schema.$ref.split("/").pop()!;
+    return toPascalCase(name);
+  }
+
+  if (schema.allOf) {
+    return schema.allOf.map((s) => schemaToTS(s, schemas, indent)).join(" & ");
+  }
+
+  if (schema.oneOf || schema.anyOf) {
+    const arr = schema.oneOf ?? schema.anyOf!;
+    return arr.map((s) => schemaToTS(s, schemas, indent)).join(" | ");
+  }
+
+  if (schema.enum) {
+    return schema.enum.map((v) => JSON.stringify(v)).join(" | ");
+  }
+
+  switch (schema.type) {
+    case "string":
+      return "string";
+    case "number":
+    case "integer":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "array":
+      return schema.items ? `${schemaToTS(schema.items, schemas, indent)}[]` : "unknown[]";
+    case "object": {
+      if (!schema.properties) {
+        if (schema.additionalProperties) {
+          const valType =
+            typeof schema.additionalProperties === "object"
+              ? schemaToTS(schema.additionalProperties, schemas, indent)
+              : "unknown";
+          return `Record<string, ${valType}>`;
+        }
+        return "Record<string, unknown>";
+      }
+      const pad = "  ".repeat(indent + 1);
+      const required = new Set(schema.required ?? []);
+      const props = Object.entries(schema.properties)
+        .map(([k, v]) => {
+          const optional = !required.has(k) ? "?" : "";
+          const nullable = v.nullable ? " | null" : "";
+          return `${pad}${k}${optional}: ${schemaToTS(v, schemas, indent + 1)}${nullable};`;
+        })
+        .join("\n");
+      return `{\n${props}\n${"  ".repeat(indent)}}`;
+    }
+    default:
+      return "unknown";
+  }
+}
+
+// Swagger 2.0은 definitions, OpenAPI 3.0은 components.schemas
+function getSchemas(spec: SwaggerSpec): Record<string, SchemaObject> {
+  return spec.components?.schemas ?? spec.definitions ?? {};
+}
+
+export function generateTypes(spec: SwaggerSpec, tag: string): string {
+  const schemas = getSchemas(spec);
+  const lines: string[] = [
+    `// Auto-generated by swagshot`,
+    `// Tag: ${tag}`,
+    `// Do not edit manually`,
+    "",
+  ];
+
+  // Collect referenced schemas from this tag's paths
+  const referencedSchemas = collectReferencedSchemas(spec, tag);
+
+  for (const schemaName of referencedSchemas) {
+    const schema = schemas[schemaName];
+    if (!schema) continue;
+
+    lines.push(`export interface ${toPascalCase(schemaName)} ${schemaToTS(schema, schemas)}`);
+    lines.push("");
+  }
+
+  // Generate request/response types per operation
+  for (const [, pathItem] of Object.entries(spec.paths)) {
+    for (const [, op] of Object.entries(pathItem)) {
+      if (!op?.tags?.includes(tag) || !op.operationId) continue;
+
+      // Query params type
+      const queryParams = (op.parameters ?? []).filter((p: Parameter) => p.in === "query");
+      if (queryParams.length > 0) {
+        const typeName = `${toPascalCase(op.operationId)}Params`;
+        const props = queryParams
+          .map((p: Parameter) => {
+            const optional = !p.required ? "?" : "";
+            const tsType = schemaToTS(paramToSchema(p), schemas);
+            return `  ${p.name}${optional}: ${tsType};`;
+          })
+          .join("\n");
+        lines.push(`export interface ${typeName} {`);
+        lines.push(props);
+        lines.push("}");
+        lines.push("");
+      }
+
+      // Inline response type (응답 스키마가 $ref 없는 inline object일 때)
+      const okRes = op.responses["200"] ?? op.responses["201"];
+      if (okRes) {
+        const resSchema = getResponseSchema(okRes);
+        if (resSchema && !resSchema.$ref) {
+          const typeName = `${toPascalCase(op.operationId)}Response`;
+          lines.push(`export interface ${typeName} ${schemaToTS(resSchema, schemas)}`);
+          lines.push("");
+        }
+      }
+
+      // Inline request body type (Swagger 2.0 body param 또는 OpenAPI 3.0 inline requestBody)
+      const bodyType = extractBodyType(op, schemas);
+      if (bodyType && bodyType.startsWith("{")) {
+        // inline object → named interface
+        const typeName = `${toPascalCase(op.operationId)}Request`;
+        lines.push(`export interface ${typeName} ${bodyType}`);
+        lines.push("");
+      }
+    }
+  }
+
+  return lines.join("\n");
+}
+
+// ── API function generator ────────────────────────────────────────────────
+
+export function generateApiFile(
+  spec: SwaggerSpec,
+  tag: string,
+  config: SwagShotConfig
+): string {
+  const schemas = getSchemas(spec);
+  const { httpClient, axiosInstance, queryLibrary } = config.style;
+  const tagCamel = toCamelCase(tag.replace(/-controller$/, "").replace(/-/g, " "));
+  const typesImportPath = `../types/${tagCamel}`;
+
+  // Suppress unused variable warning for queryLibrary
+  void queryLibrary;
+
+  const lines: string[] = [
+    `// Auto-generated by swagshot`,
+    `// Tag: ${tag}`,
+    `// Do not edit manually`,
+    "",
+  ];
+
+  // Imports
+  if (httpClient === "axios" && axiosInstance) {
+    lines.push(`import api from '${axiosInstance.replace(/\.ts$/, "")}';`);
+  } else if (httpClient === "axios") {
+    lines.push(`import axios from 'axios';`);
+    lines.push(`const api = axios.create({ baseURL: '' });`);
+  }
+
+  // Collect type imports
+  const typeImports = new Set<string>();
+  for (const [, pathItem] of Object.entries(spec.paths)) {
+    for (const [, op] of Object.entries(pathItem)) {
+      if (!op?.tags?.includes(tag) || !op.operationId) continue;
+      const queryParams = (op.parameters ?? []).filter((p: Parameter) => p.in === "query");
+      if (queryParams.length > 0) {
+        typeImports.add(`${toPascalCase(op.operationId)}Params`);
+      }
+      // Response type
+      const responseType = extractResponseType(op, schemas);
+      if (responseType && !isPrimitive(responseType)) {
+        typeImports.add(responseType);
+      }
+      // Request body type
+      const bodyType = extractBodyType(op, schemas);
+      if (bodyType && !isPrimitive(bodyType)) {
+        typeImports.add(bodyType);
+      }
+    }
+  }
+
+  if (typeImports.size > 0) {
+    lines.push(`import type { ${Array.from(typeImports).join(", ")} } from '${typesImportPath}';`);
+  }
+
+  lines.push("");
+
+  // Generate functions
+  for (const [pathKey, pathItem] of Object.entries(spec.paths)) {
+    for (const [method, op] of Object.entries(pathItem)) {
+      if (!op?.tags?.includes(tag) || !op.operationId) continue;
+
+      const fnName = toCamelCase(op.operationId);
+      const pathParams = (op.parameters ?? []).filter((p: Parameter) => p.in === "path");
+      const queryParams = (op.parameters ?? []).filter((p: Parameter) => p.in === "query");
+      const bodyType = extractBodyType(op, schemas);
+      const responseType = extractResponseType(op, schemas) ?? "void";
+
+      // Build function signature
+      const params: string[] = [];
+      for (const p of pathParams) {
+        params.push(`${p.name}: ${p.schema ? schemaToTS(p.schema, schemas) : "string"}`);
+      }
+      if (queryParams.length > 0) {
+        const paramsType = `${toPascalCase(op.operationId)}Params`;
+        params.push(`params: ${paramsType}`);
+      }
+      if (bodyType && ["post", "put", "patch"].includes(method)) {
+        params.push(`data: ${bodyType}`);
+      }
+
+      if (op.summary) {
+        lines.push(`/** ${op.summary} */`);
+      }
+
+      const url = pathKey.replace(/{(\w+)}/g, "${$1}");
+      const hasQuery = queryParams.length > 0;
+
+      if (httpClient === "axios") {
+        lines.push(
+          `export const ${fnName} = (${params.join(", ")}) =>`,
+          `  api.${method}<${responseType}>(\`${url}\`${
+            hasQuery ? ", { params }" : bodyType ? ", data" : ""
+          });`
+        );
+      } else {
+        // fetch
+        lines.push(
+          `export const ${fnName} = async (${params.join(", ")}): Promise<${responseType}> => {`,
+          `  const url = new URL(\`${url}\`, window.location.origin);`
+        );
+        if (hasQuery) {
+          lines.push(
+            `  Object.entries(params).forEach(([k, v]) => v != null && url.searchParams.set(k, String(v)));`
+          );
+        }
+        lines.push(
+          `  const res = await fetch(url.toString()${
+            bodyType ? `, { method: '${method.toUpperCase()}', body: JSON.stringify(data), headers: { 'Content-Type': 'application/json' } }` : ""
+          });`,
+          `  return res.json();`,
+          `};`
+        );
+      }
+
+      lines.push("");
+    }
+  }
+
+  return lines.join("\n");
+}
+
+// ── Helpers ───────────────────────────────────────────────────────────────
+
+/** Swagger 2.0 파라미터는 schema 없이 type/items를 직접 가짐 → 통일된 SchemaObject로 변환 */
+function paramToSchema(p: Parameter): SchemaObject {
+  if (p.schema) return p.schema; // OpenAPI 3.0
+  return {
+    type: p.type,
+    items: p.items,
+    enum: p.enum,
+    format: p.format,
+  };
+}
+
+/** Swagger 2.0 / OpenAPI 3.0 응답 스키마 추출 */
+function getResponseSchema(res: { schema?: SchemaObject; content?: Record<string, { schema?: SchemaObject }> }): SchemaObject | null {
+  if (res.content) return res.content["application/json"]?.schema ?? null; // OpenAPI 3.0
+  return res.schema ?? null; // Swagger 2.0
+}
+
+function toPascalCase(str: string): string {
+  return str
+    .replace(/[-_\s]+(.)/g, (_, c: string) => c.toUpperCase())
+    .replace(/^(.)/, (c: string) => c.toUpperCase());
+}
+
+function toCamelCase(str: string): string {
+  const pascal = toPascalCase(str);
+  return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+
+function isPrimitive(type: string): boolean {
+  return ["string", "number", "boolean", "void", "unknown"].includes(type);
+}
+
+function extractResponseType(op: Operation, schemas: Record<string, SchemaObject>): string | null {
+  const ok = op.responses["200"] ?? op.responses["201"];
+  if (!ok) return null;
+  const schema = getResponseSchema(ok);
+  if (!schema) return null;
+  if (schema.$ref) return toPascalCase(schema.$ref.split("/").pop()!);
+  if (schema.type === "array" && schema.items?.$ref) {
+    return `${toPascalCase(schema.items.$ref.split("/").pop()!)}[]`;
+  }
+  if (schema.type === "object" || schema.properties) {
+    // inline object → use named response type
+    return `${toPascalCase(op.operationId ?? "unknown")}Response`;
+  }
+  return schemaToTS(schema, schemas);
+}
+
+function extractBodyType(op: Operation, schemas: Record<string, SchemaObject>): string | null {
+  // OpenAPI 3.0
+  if (op.requestBody?.content) {
+    const schema = op.requestBody.content["application/json"]?.schema;
+    if (!schema) return null;
+    if (schema.$ref) return toPascalCase(schema.$ref.split("/").pop()!);
+    return schemaToTS(schema, schemas);
+  }
+  // Swagger 2.0: body parameter
+  const bodyParam = (op.parameters ?? []).find((p: Parameter) => p.in === "body");
+  if (bodyParam?.schema) {
+    if (bodyParam.schema.$ref) return toPascalCase(bodyParam.schema.$ref.split("/").pop()!);
+    return schemaToTS(bodyParam.schema, schemas);
+  }
+  return null;
+}
+
+function collectReferencedSchemas(spec: SwaggerSpec, tag: string): string[] {
+  const refs = new Set<string>();
+  const allSchemas = getSchemas(spec);
+
+  function collectFromSchema(schema: SchemaObject): void {
+    if (schema.$ref) {
+      const name = schema.$ref.split("/").pop()!;
+      if (refs.has(name)) return; // 순환 참조 방지
+      refs.add(name);
+      // Recurse into the referenced schema
+      const nested = allSchemas[name];
+      if (nested) collectFromSchema(nested);
+    }
+    if (schema.properties) {
+      Object.values(schema.properties).forEach(collectFromSchema);
+    }
+    if (schema.items) collectFromSchema(schema.items);
+    if (schema.allOf) schema.allOf.forEach(collectFromSchema);
+    if (schema.oneOf) schema.oneOf.forEach(collectFromSchema);
+    if (schema.anyOf) schema.anyOf.forEach(collectFromSchema);
+  }
+
+  for (const [, pathItem] of Object.entries(spec.paths)) {
+    for (const [, op] of Object.entries(pathItem)) {
+      if (!op?.tags?.includes(tag)) continue;
+
+      // Check parameters (OpenAPI 3.0: schema / Swagger 2.0: direct fields)
+      for (const p of op.parameters ?? []) {
+        collectFromSchema(paramToSchema(p));
+      }
+
+      // Check request body (OpenAPI 3.0)
+      if (op.requestBody?.content) {
+        for (const mediaType of Object.values(op.requestBody.content)) {
+          const mt = mediaType as { schema?: SchemaObject };
+          if (mt.schema) collectFromSchema(mt.schema);
+        }
+      }
+
+      // Check responses (OpenAPI 3.0 + Swagger 2.0)
+      for (const responseValue of Object.values(op.responses)) {
+        const schema = getResponseSchema(responseValue as { schema?: SchemaObject; content?: Record<string, { schema?: SchemaObject }> });
+        if (schema) collectFromSchema(schema);
+      }
+    }
+  }
+
+  return Array.from(refs);
+}

package/src/lib/configManager.ts

@@ -0,0 +1,54 @@
+import fs from "fs/promises";
+import path from "path";
+import { SwagShotConfig } from "./types.js";
+
+export const CONFIG_FILE = ".swagshot.json";
+
+export async function fileExists(filePath: string): Promise<boolean> {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function dirExists(dirPath: string): Promise<boolean> {
+  try {
+    const stat = await fs.stat(dirPath);
+    return stat.isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+export async function readConfig(root: string): Promise<SwagShotConfig | null> {
+  const configPath = path.join(root, CONFIG_FILE);
+  if (!(await fileExists(configPath))) return null;
+  const raw = await fs.readFile(configPath, "utf-8");
+  return JSON.parse(raw) as SwagShotConfig;
+}
+
+export async function writeConfig(root: string, config: SwagShotConfig): Promise<void> {
+  const configPath = path.join(root, CONFIG_FILE);
+  await fs.writeFile(configPath, JSON.stringify(config, null, 2), "utf-8");
+}
+
+export async function updateConfig(
+  root: string,
+  updates: Record<string, string | null>
+): Promise<SwagShotConfig> {
+  const config = await readConfig(root);
+  if (!config) throw new Error("설정 파일이 없습니다. swagger_setup을 먼저 실행하세요.");
+
+  for (const [key, value] of Object.entries(updates)) {
+    if (key in config.project) {
+      (config.project as Record<string, unknown>)[key] = value;
+    } else if (key in config.style) {
+      (config.style as Record<string, unknown>)[key] = value;
+    }
+  }
+
+  await writeConfig(root, config);
+  return config;
+}

package/src/lib/detectStructure.ts

@@ -0,0 +1,66 @@
+import fs from "fs/promises";
+import path from "path";
+import { DetectedStructure } from "./types.js";
+import { dirExists, fileExists } from "./configManager.js";
+
+export async function detectProjectStructure(root: string): Promise<DetectedStructure> {
+  const candidates = {
+    apiDir:   ["api", "apis", "src/api", "src/apis", "src/services", "src/lib/api", "src/fetchers"],
+    typesDir: ["types", "types/api", "src/types/api", "src/types", "src/@types", "src/models", "src/interfaces"],
+    hooksDir: ["hooks", "hooks/api", "src/hooks/api", "src/hooks/queries", "src/hooks", "src/queries"],
+  };
+
+  const detected: DetectedStructure = {
+    apiDir: null,
+    typesDir: null,
+    hooksDir: null,
+    httpClient: null,
+    queryLibrary: null,
+    axiosInstance: null,
+  };
+
+  for (const [key, paths] of Object.entries(candidates)) {
+    for (const p of paths) {
+      if (await dirExists(path.join(root, p))) {
+        (detected as unknown as Record<string, unknown>)[key] = p;
+        break;
+      }
+    }
+  }
+
+  // Detect from package.json
+  const pkgPath = path.join(root, "package.json");
+  if (await fileExists(pkgPath)) {
+    const pkg = JSON.parse(await fs.readFile(pkgPath, "utf-8"));
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+
+    detected.httpClient = "axios" in deps ? "axios" : "fetch";
+    detected.queryLibrary =
+      "@tanstack/react-query" in deps
+        ? "react-query"
+        : "react-query" in deps
+        ? "react-query"
+        : "swr" in deps
+        ? "swr"
+        : null;
+  }
+
+  // Try to find axios instance file
+  if (detected.httpClient === "axios") {
+    const axiosCandidates = [
+      "src/lib/axios.ts",
+      "src/lib/api.ts",
+      "src/utils/axios.ts",
+      "src/api/client.ts",
+      "src/config/axios.ts",
+    ];
+    for (const p of axiosCandidates) {
+      if (await fileExists(path.join(root, p))) {
+        detected.axiosInstance = p;
+        break;
+      }
+    }
+  }
+
+  return detected;
+}

package/src/lib/fetchSwagger.ts

@@ -0,0 +1,52 @@
+import axios from "axios";
+import fs from "fs/promises";
+import { fileExists } from "./configManager.js";
+import { SwaggerSpec } from "./types.js";
+
+export async function fetchSwaggerSpec(input: string): Promise<SwaggerSpec> {
+  // Local file
+  if (!input.startsWith("http")) {
+    if (!(await fileExists(input))) {
+      throw new Error(`파일을 찾을 수 없습니다: ${input}`);
+    }
+    const raw = await fs.readFile(input, "utf-8");
+    return JSON.parse(raw) as SwaggerSpec;
+  }
+
+  // Remote URL
+  const response = await axios.get<SwaggerSpec>(input, {
+    headers: { Accept: "application/json" },
+    timeout: 10000,
+  });
+  return response.data;
+}
+
+export function getControllerTags(spec: SwaggerSpec): string[] {
+  const tags = new Set<string>();
+  for (const pathItem of Object.values(spec.paths)) {
+    for (const op of Object.values(pathItem)) {
+      if (op?.tags) {
+        for (const tag of op.tags) tags.add(tag);
+      }
+    }
+  }
+  return Array.from(tags);
+}
+
+export function filterByTag(spec: SwaggerSpec, tag: string, includeDeprecated = false): SwaggerSpec {
+  const filteredPaths: SwaggerSpec["paths"] = {};
+
+  for (const [pathKey, pathItem] of Object.entries(spec.paths)) {
+    const filteredItem: typeof pathItem = {};
+    for (const [method, op] of Object.entries(pathItem)) {
+      if (!op?.tags?.includes(tag)) continue;
+      if (!includeDeprecated && op.deprecated) continue;
+      (filteredItem as Record<string, unknown>)[method] = op;
+    }
+    if (Object.keys(filteredItem).length > 0) {
+      filteredPaths[pathKey] = filteredItem;
+    }
+  }
+
+  return { ...spec, paths: filteredPaths };
+}

package/src/lib/types.ts

@@ -0,0 +1,102 @@
+export interface SwagShotConfig {
+  version: string;
+  project: {
+    root: string;
+    apiDir: string;
+    typesDir: string;
+    hooksDir: string | null;
+    outputDir: string;
+  };
+  style: {
+    httpClient: "axios" | "fetch";
+    axiosInstance: string | null;
+    queryLibrary: "react-query" | "swr" | null;
+    namingConvention: "camelCase" | "snake_case";
+  };
+  swagger?: {
+    url: string | null;
+  };
+}
+
+export interface DetectedStructure {
+  apiDir: string | null;
+  typesDir: string | null;
+  hooksDir: string | null;
+  httpClient: "axios" | "fetch" | null;
+  queryLibrary: "react-query" | "swr" | null;
+  axiosInstance: string | null;
+}
+
+export interface SwaggerSpec {
+  openapi?: string;
+  swagger?: string;
+  info: { title: string; version: string };
+  paths: Record<string, PathItem>;
+  // OpenAPI 3.0
+  components?: {
+    schemas?: Record<string, SchemaObject>;
+  };
+  // Swagger 2.0 (Spring Boot / springfox)
+  definitions?: Record<string, SchemaObject>;
+  tags?: Array<{ name: string; description?: string }>;
+}
+
+export interface PathItem {
+  get?: Operation;
+  post?: Operation;
+  put?: Operation;
+  patch?: Operation;
+  delete?: Operation;
+}
+
+export interface Operation {
+  tags?: string[];
+  operationId?: string;
+  summary?: string;
+  deprecated?: boolean;
+  parameters?: Parameter[];
+  requestBody?: RequestBody;
+  responses: Record<string, Response>;
+}
+
+export interface Parameter {
+  name: string;
+  in: "query" | "path" | "header" | "cookie" | "body" | "formData";
+  required?: boolean;
+  description?: string;
+  // OpenAPI 3.0
+  schema?: SchemaObject;
+  // Swagger 2.0 direct fields (no nested schema)
+  type?: string;
+  format?: string;
+  items?: SchemaObject;
+  enum?: unknown[];
+  collectionFormat?: string;
+}
+
+export interface RequestBody {
+  required?: boolean;
+  content?: Record<string, { schema?: SchemaObject }>;
+}
+
+export interface Response {
+  description?: string;
+  schema?: SchemaObject; // Swagger 2.0
+  content?: Record<string, { schema?: SchemaObject }>; // OpenAPI 3.0
+}
+
+export interface SchemaObject {
+  type?: string;
+  format?: string;
+  $ref?: string;
+  items?: SchemaObject;
+  properties?: Record<string, SchemaObject>;
+  required?: string[];
+  enum?: unknown[];
+  description?: string;
+  nullable?: boolean;
+  allOf?: SchemaObject[];
+  oneOf?: SchemaObject[];
+  anyOf?: SchemaObject[];
+  additionalProperties?: boolean | SchemaObject;
+}