spring-api-scanner 0.2.1 → 0.2.2

package/dist/openapi.d.ts

@@ -7,6 +7,7 @@ export interface OpenApiSchema {
     properties?: Record<string, OpenApiSchema>;
     required?: string[];
     $ref?: string;
+    enum?: string[];
 }
 export interface OpenApiParameter {
     in: "path" | "query" | "header";

package/dist/ui.js

@@ -26,7 +26,7 @@ export function buildUiModel(input) {
             })),
             requestSchema,
             responseSchema,
-            curl: buildCurl(endpoint)
+            curl: buildCurl(endpoint, requestSchema, input.openapi.components.schemas)
         };
     });
     return {
@@ -474,16 +474,107 @@ function pickResponseSchema(responses, openapi) {
     const best = responses["200"] ?? responses["201"];
     return deref(best?.content?.["application/json"]?.schema, openapi);
 }
-function buildCurl(endpoint) {
-    const parts = [`curl -X ${endpoint.httpMethod} "http://localhost:3000${endpoint.fullPath}"`];
+function buildCurl(endpoint, requestSchema, schemas) {
+    // Build URL with query parameters
+    let urlPath = endpoint.fullPath;
+    // Replace path variables with placeholder values
+    for (const pv of endpoint.pathVariables) {
+        const placeholder = getExampleValueForType(pv.type);
+        urlPath = urlPath.replace(`{${pv.name}}`, String(placeholder));
+    }
+    // Add query parameters to URL
+    const queryParts = [];
+    for (const qp of endpoint.queryParams) {
+        const exampleValue = getExampleValueForType(qp.type);
+        queryParts.push(`${qp.name}=${encodeURIComponent(String(exampleValue))}`);
+    }
+    if (queryParts.length > 0) {
+        urlPath += `?${queryParts.join("&")}`;
+    }
+    const parts = [`curl -X ${endpoint.httpMethod} "http://localhost:3000${urlPath}"`];
+    // Add headers
     for (const header of endpoint.headers) {
-        parts.push(`-H "${header.name}: <${header.name}>"`);
+        const exampleValue = getExampleValueForType(header.type);
+        parts.push(`-H "${header.name}: ${exampleValue}"`);
     }
+    // Add request body with generated example
     if (endpoint.requestBody) {
         parts.push('-H "Content-Type: application/json"');
-        parts.push("-d '{ }'");
+        const exampleBody = generateExampleFromSchema(requestSchema, schemas);
+        const bodyJson = JSON.stringify(exampleBody, null, 2);
+        // Escape the JSON for shell
+        const escapedBody = bodyJson.replace(/'/g, "'\"'\"'");
+        parts.push(`-d '${escapedBody}'`);
+    }
+    return parts.join(" \\\n  ");
+}
+function getExampleValueForType(type) {
+    const cleanType = type.replace("?", "").trim();
+    switch (cleanType) {
+        case "String":
+            return "example";
+        case "Long":
+        case "Int":
+            return 123;
+        case "Boolean":
+            return true;
+        case "Double":
+        case "Float":
+            return 123.45;
+        default:
+            return "<value>";
+    }
+}
+function generateExampleFromSchema(schema, schemas, visited = new Set()) {
+    if (!schema) {
+        return {};
+    }
+    // Handle $ref references
+    if (schema.$ref) {
+        const refName = schema.$ref.split("/").pop();
+        if (refName && schemas && !visited.has(refName)) {
+            visited.add(refName);
+            const resolved = schemas[refName];
+            if (resolved) {
+                return generateExampleFromSchema(resolved, schemas, visited);
+            }
+        }
+        return {};
+    }
+    // Handle enums - use first enum value
+    if (schema.enum && schema.enum.length > 0) {
+        return schema.enum[0];
+    }
+    // Handle arrays
+    if (schema.type === "array" && schema.items) {
+        return [generateExampleFromSchema(schema.items, schemas, visited)];
+    }
+    // Handle objects
+    if (schema.type === "object" || schema.properties) {
+        const result = {};
+        if (schema.properties) {
+            for (const [key, propSchema] of Object.entries(schema.properties)) {
+                result[key] = generateExampleFromSchema(propSchema, schemas, visited);
+            }
+        }
+        return result;
+    }
+    // Handle primitives based on type and format
+    switch (schema.type) {
+        case "string":
+            if (schema.format === "date-time") {
+                return "2026-01-01T00:00:00Z";
+            }
+            return "example";
+        case "integer":
+            return 123;
+        case "number":
+            return 123.45;
+        case "boolean":
+            return true;
+        default:
+            return null;
     }
-    return parts.join(" \\\n+");
 }
 function guessController(sourceFile) {
     const file = sourceFile.replaceAll("\\", "/").split("/").at(-1) ?? sourceFile;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spring-api-scanner",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "CLI for scanning Spring Boot Kotlin APIs and generating OpenAPI + UI output",
   "type": "module",
   "bin": {