spring-api-scanner 0.1.0 → 0.2.1

package/README.md

@@ -4,6 +4,7 @@ Scan a Spring Boot Kotlin service and generate:
 
 - `openapi.json` (OpenAPI 3.0)
 - A static API catalog UI (`index.html` + `ui-data.json`)
+- Structured warnings (`scan-warnings.json`)
 
 No code/dependency changes are required in the target Spring service.
 
@@ -28,8 +29,24 @@ node dist/index.js /path/to/spring-service --no-serve --output ./api-docs
 
 ## CLI
 
+```bash
+spring-api-scanner --help
+```
+
 ```text
-spring-api-scanner <projectPath> [--port] [--output] [--serve] [--no-serve] [--title] [--version]
+Usage: spring-api-scanner <projectPath> [options]
+
+Scan a Spring Boot Kotlin project and generate OpenAPI documentation and a static UI.
+
+Options:
+  --serve              Start a local server to serve the generated docs
+  --no-serve           Only generate static files (default)
+  --port <number>      Port for the server (default: 3000)
+  --output <path>      Output directory for generated files (default: ./api-docs)
+  --title <string>     API title for documentation (default: "Spring API Docs")
+  --version <string>   API version for documentation (default: 1.0.0)
+  --strict             Exit with non-zero code on unresolved critical issues
+  --help               Show this help message
 ```
 
 ## What It Extracts
@@ -42,6 +59,18 @@ spring-api-scanner <projectPath> [--port] [--output] [--serve] [--no-serve] [--t
 - Parameters:
   - `@PathVariable`, `@RequestParam`, `@RequestHeader`, `@RequestBody`
 - Return type and DTO schemas from Kotlin `data class`
+- Enum schemas from Kotlin `enum class`
+- Validation hints from common annotations (`@NotNull`, `@Size`)
+
+## UI Features
+
+The generated UI includes:
+- **Search** with keyboard shortcut (`/`) - Press `/` to focus the search box
+- **Deep-linking** - Copy and share direct links to endpoints
+- **Filter persistence** - Filter selections are saved to localStorage
+- **Collapsible schemas** - Expand/collapse request/response body schemas
+- **Copy curl** - One-click copy for curl commands
+- **Download** - Export OpenAPI JSON
 
 ## Naming Strategy Notes
 
@@ -58,3 +87,7 @@ npm run build
 ```
 
 Integration + golden-file tests are under `tests/integration.test.ts` and `tests/golden/openapi.sample-service.json`.
+
+## Roadmap
+
+See `docs/ROADMAP.md` for phased priorities (`v0.2`, `v0.3`, `v1.0`).

package/dist/args.d.ts

@@ -5,5 +5,7 @@ export interface CliOptions {
     serve: boolean;
     title: string;
     version: string;
+    strict: boolean;
 }
+export declare function showHelp(): string;
 export declare function parseCliArgs(argv: string[]): CliOptions;

package/dist/args.js

@@ -2,8 +2,31 @@ const DEFAULT_PORT = 3000;
 const DEFAULT_OUTPUT = "./api-docs";
 const DEFAULT_TITLE = "Spring API Docs";
 const DEFAULT_VERSION = "1.0.0";
+export function showHelp() {
+    return `Usage: spring-api-scanner <projectPath> [options]
+
+Scan a Spring Boot Kotlin project and generate OpenAPI documentation and a static UI.
+
+Options:
+  --serve              Start a local server to serve the generated docs
+  --no-serve           Only generate static files (default)
+  --port <number>      Port for the server (default: ${DEFAULT_PORT})
+  --output <path>      Output directory for generated files (default: ${DEFAULT_OUTPUT})
+  --title <string>     API title for documentation (default: "${DEFAULT_TITLE}")
+  --version <string>   API version for documentation (default: ${DEFAULT_VERSION})
+  --strict             Exit with non-zero code on unresolved critical issues
+  --help               Show this help message
+
+Examples:
+  spring-api-scanner /path/to/project --serve --port 8080
+  spring-api-scanner ./my-service --output ./docs --title "My API"
+  spring-api-scanner /path/to/project --strict  # Fail on warnings`;
+}
 export function parseCliArgs(argv) {
     if (argv.length === 0 || argv[0].startsWith("--")) {
+        if (argv[0] === "--help") {
+            throw new Error(showHelp());
+        }
         throw new Error("A project path is required: spring-api-scanner <projectPath>");
     }
     const projectPath = argv[0];
@@ -13,7 +36,8 @@ export function parseCliArgs(argv) {
         output: DEFAULT_OUTPUT,
         serve: false,
         title: DEFAULT_TITLE,
-        version: DEFAULT_VERSION
+        version: DEFAULT_VERSION,
+        strict: false
     };
     for (let i = 1; i < argv.length; i += 1) {
         const token = argv[i];
@@ -36,8 +60,13 @@ export function parseCliArgs(argv) {
             case "--version":
                 options.version = parseStringFlag("--version", argv[++i]);
                 break;
+            case "--strict":
+                options.strict = true;
+                break;
+            case "--help":
+                throw new Error(showHelp());
             default:
-                throw new Error(`Unknown argument: ${token}`);
+                throw new Error(`Unknown argument: ${token}\n\n${showHelp()}`);
         }
     }
     return options;

package/dist/index.js

@@ -3,20 +3,35 @@ import { stat } from "node:fs/promises";
 import { createServer } from "node:http";
 import { readFile } from "node:fs/promises";
 import path from "node:path";
-import { parseCliArgs } from "./args.js";
+import { parseCliArgs, showHelp } from "./args.js";
 import { writePlaceholderArtifacts } from "./output.js";
 import { scanDataClasses } from "./resolver.js";
-import { scanSpringProject } from "./scanner.js";
+import { scanSpringProjectArtifacts } from "./scanner.js";
 async function main() {
-    const options = parseCliArgs(process.argv.slice(2));
+    const args = process.argv.slice(2);
+    // Handle --help before everything else
+    if (args.includes("--help") || args.includes("-h")) {
+        console.log(showHelp());
+        return 0;
+    }
+    const options = parseCliArgs(args);
     await validateProjectPath(options.projectPath);
-    const endpoints = await scanSpringProject(options.projectPath);
+    const scan = await scanSpringProjectArtifacts(options.projectPath);
     const types = await scanDataClasses(options.projectPath);
-    const output = await writePlaceholderArtifacts(options, endpoints, types);
-    printSummary(options, endpoints.length, output.warnings);
+    const output = await writePlaceholderArtifacts(options, scan.endpoints, types, scan.parserWarnings);
+    printSummary(options, scan.endpoints.length, output.warnings);
     if (options.serve) {
         await serveOutput(options.output, options.port);
     }
+    // Return non-zero exit code in strict mode if there are warnings
+    if (options.strict) {
+        const totalWarnings = output.warnings.parser.length + output.warnings.unresolvedTypes.length;
+        if (totalWarnings > 0) {
+            console.error(`\nExiting with error: ${totalWarnings} warning(s) found in strict mode`);
+            return 1;
+        }
+    }
+    return 0;
 }
 async function validateProjectPath(projectPath) {
     const result = await stat(projectPath).catch(() => null);
@@ -25,16 +40,22 @@ async function validateProjectPath(projectPath) {
     }
 }
 function printSummary(options, endpointCount, warnings) {
+    const allWarnings = [...warnings.parser, ...warnings.unresolvedTypes];
     console.log("Spring API Scanner");
     console.log(`- Project: ${path.resolve(options.projectPath)}`);
     console.log(`- Output: ${path.resolve(options.output)}`);
     console.log(`- Endpoints discovered: ${endpointCount}`);
     console.log("- OpenAPI: openapi.json written");
-    console.log(`- Warnings: ${warnings.length}`);
-    for (const warning of warnings.slice(0, 5)) {
+    console.log(`- Warnings: ${allWarnings.length}`);
+    console.log(`  - Parser warnings: ${warnings.parser.length}`);
+    console.log(`  - Unresolved type warnings: ${warnings.unresolvedTypes.length}`);
+    for (const warning of allWarnings.slice(0, 5)) {
         console.log(`  - ${warning}`);
     }
     console.log(`- Serve mode: ${options.serve ? "enabled" : "disabled"}`);
+    if (options.strict) {
+        console.log("- Strict mode: enabled (will exit non-zero on warnings)");
+    }
 }
 async function serveOutput(outputDir, port) {
     const root = path.resolve(outputDir);
@@ -60,7 +81,11 @@ async function serveOutput(outputDir, port) {
         console.log(`Serving docs at http://localhost:${port}`);
     });
 }
-main().catch((error) => {
+main()
+    .then((exitCode) => {
+    process.exitCode = exitCode;
+})
+    .catch((error) => {
     const message = error instanceof Error ? error.message : String(error);
     console.error(`Error: ${message}`);
     process.exitCode = 1;

package/dist/output.d.ts

@@ -1,6 +1,10 @@
 import type { CliOptions } from "./args.js";
 import type { KotlinTypeRegistry } from "./resolver.js";
 import type { ExtractedEndpoint } from "./scanner.js";
-export declare function writePlaceholderArtifacts(options: CliOptions, endpoints: ExtractedEndpoint[], types: KotlinTypeRegistry): Promise<{
-    warnings: string[];
+export interface ScanWarnings {
+    parser: string[];
+    unresolvedTypes: string[];
+}
+export declare function writePlaceholderArtifacts(options: CliOptions, endpoints: ExtractedEndpoint[], types: KotlinTypeRegistry, parserWarnings?: string[]): Promise<{
+    warnings: ScanWarnings;
 }>;

package/dist/output.js

@@ -2,11 +2,12 @@ import { mkdir, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { buildOpenApiArtifacts } from "./openapi.js";
 import { buildUiModel, renderUiHtml } from "./ui.js";
-export async function writePlaceholderArtifacts(options, endpoints, types) {
+export async function writePlaceholderArtifacts(options, endpoints, types, parserWarnings = []) {
     const outputDir = path.resolve(options.output);
     const openApiPath = path.join(outputDir, "openapi.json");
     const uiDataPath = path.join(outputDir, "ui-data.json");
     const indexPath = path.join(outputDir, "index.html");
+    const warningsPath = path.join(outputDir, "scan-warnings.json");
     const artifacts = buildOpenApiArtifacts({
         title: options.title,
         version: options.version,
@@ -21,5 +22,11 @@ export async function writePlaceholderArtifacts(options, endpoints, types) {
     await writeFile(openApiPath, JSON.stringify(artifacts.document, null, 2), "utf8");
     await writeFile(uiDataPath, JSON.stringify(uiModel, null, 2), "utf8");
     await writeFile(indexPath, renderUiHtml(options.title, uiModel), "utf8");
-    return { warnings: artifacts.warnings };
+    await writeFile(warningsPath, JSON.stringify({ parser: parserWarnings, unresolvedTypes: artifacts.warnings }, null, 2), "utf8");
+    return {
+        warnings: {
+            parser: parserWarnings,
+            unresolvedTypes: artifacts.warnings
+        }
+    };
 }

package/dist/resolver.d.ts

@@ -2,11 +2,18 @@ export interface KotlinProperty {
     name: string;
     type: string;
     nullable: boolean;
+    hints?: {
+        minLength?: number;
+        maxLength?: number;
+        minItems?: number;
+        maxItems?: number;
+    };
 }
 export interface KotlinDataClass {
     name: string;
     namingStrategy: "snake_case" | "camelCase";
     properties: KotlinProperty[];
+    enumValues?: string[];
 }
 export type KotlinTypeRegistry = Record<string, KotlinDataClass>;
 export interface ResolutionContext {

package/dist/resolver.js

@@ -12,11 +12,10 @@ export async function scanDataClasses(projectPath) {
 }
 export function parseDataClassesFromSource(source) {
     const registry = {};
-    const matches = source.matchAll(/((?:\s*@[^\n]+\n)*)\s*data\s+class\s+([A-Za-z_][A-Za-z0-9_]*)\s*\(([\s\S]*?)\)/g);
-    for (const match of matches) {
-        const annotationBlock = match[1] ?? "";
-        const name = match[2] ?? "";
-        const rawProperties = match[3] ?? "";
+    for (const declaration of extractDataClassDeclarations(source)) {
+        const annotationBlock = declaration.annotationBlock;
+        const name = declaration.name;
+        const rawProperties = declaration.rawProperties;
         const properties = splitTopLevel(rawProperties)
             .map((value) => value.trim())
             .filter((value) => value.length > 0)
@@ -28,6 +27,24 @@ export function parseDataClassesFromSource(source) {
             properties
         };
     }
+    const enumMatches = source.matchAll(/enum\s+class\s+([A-Za-z_][A-Za-z0-9_]*)\s*\{([\s\S]*?)\}/g);
+    for (const match of enumMatches) {
+        const name = match[1] ?? "";
+        const body = match[2] ?? "";
+        const values = body
+            .split(",")
+            .map((value) => value.replace(/\/\/.*$/g, "").trim())
+            .map((value) => value.match(/^([A-Z][A-Z0-9_]*)/)?.[1] ?? "")
+            .filter((value) => value.length > 0);
+        if (name && values.length > 0) {
+            registry[name] = {
+                name,
+                namingStrategy: "snake_case",
+                properties: [],
+                enumValues: values
+            };
+        }
+    }
     return registry;
 }
 export function resolveSchemaForType(rawType, registry, components, seen = new Set(), context) {
@@ -40,6 +57,14 @@ export function resolveSchemaForType(rawType, registry, components, seen = new S
             items: resolveSchemaForType(inner, registry, components, seen, context)
         };
     }
+    if (isMapLike(unwrapped)) {
+        const args = extractGenericArguments(unwrapped);
+        const valueType = args[1] ?? "Any";
+        return {
+            type: "object",
+            additionalProperties: resolveSchemaForType(valueType, registry, components, seen, context)
+        };
+    }
     const primitive = mapPrimitive(unwrapped);
     if (primitive) {
         return primitive;
@@ -62,12 +87,19 @@ function ensureComponent(typeName, registry, components, seen, context) {
     if (!dto) {
         return;
     }
+    if (dto.enumValues && dto.enumValues.length > 0) {
+        components[typeName] = {
+            type: "string",
+            enum: dto.enumValues
+        };
+        return;
+    }
     const properties = {};
     const required = [];
     for (const property of dto.properties) {
         const clean = cleanType(property.type);
         const serializedName = serializePropertyName(dto.namingStrategy, property.name);
-        properties[serializedName] = resolveSchemaForType(clean, registry, components, seen, context);
+        properties[serializedName] = applyPropertyHints(resolveSchemaForType(clean, registry, components, seen, context), property.hints);
         if (!property.nullable) {
             required.push(serializedName);
         }
@@ -79,13 +111,16 @@ function ensureComponent(typeName, registry, components, seen, context) {
     };
 }
 function parseProperty(raw) {
-    const parsed = raw.match(/(?:val|var)\s+([A-Za-z_][A-Za-z0-9_]*)\s*:\s*([^=]+?)(?:\s*=.*)?$/);
+    const parsed = raw.match(/([\s\S]*?)(?:val|var)\s+([A-Za-z_][A-Za-z0-9_]*)\s*:\s*([^=]+?)(?:\s*=.*)?$/);
     if (!parsed) {
         return null;
     }
-    const name = parsed[1] ?? "";
-    const type = cleanType(parsed[2] ?? "Any");
-    return { name, type, nullable: type.endsWith("?") };
+    const annotations = parsed[1] ?? "";
+    const name = parsed[2] ?? "";
+    const type = cleanType(parsed[3] ?? "Any");
+    const hints = parseValidationHints(annotations, type);
+    const nullable = hints.forceRequired ? false : type.endsWith("?");
+    return { name, type, nullable, hints: hints.hints };
 }
 function cleanType(rawType) {
     return rawType.trim();
@@ -104,17 +139,29 @@ function isListLike(typeName) {
     const outer = outerType(typeName);
     return outer === "List" || outer === "MutableList" || outer === "Page";
 }
+function isMapLike(typeName) {
+    const outer = outerType(typeName);
+    return outer === "Map" || outer === "MutableMap";
+}
 function outerType(typeName) {
     const idx = typeName.indexOf("<");
     return idx < 0 ? typeName.replace("?", "") : typeName.slice(0, idx).trim();
 }
 function extractSingleGeneric(typeName) {
+    const args = extractGenericArguments(typeName);
+    if (args.length === 0) {
+        return "Any";
+    }
+    return args[0] ?? "Any";
+}
+function extractGenericArguments(typeName) {
     const start = typeName.indexOf("<");
     const end = typeName.lastIndexOf(">");
     if (start < 0 || end < 0 || end <= start + 1) {
-        return "Any";
+        return [];
     }
-    return typeName.slice(start + 1, end).trim();
+    const inner = typeName.slice(start + 1, end).trim();
+    return splitTopLevel(inner).map((value) => value.trim()).filter((value) => value.length > 0);
 }
 function mapPrimitive(typeName) {
     const withoutNullable = typeName.endsWith("?") ? typeName.slice(0, -1) : typeName;
@@ -183,6 +230,79 @@ function splitTopLevel(input) {
     }
     return parts;
 }
+function applyPropertyHints(schema, hints) {
+    if (!hints || Object.keys(hints).length === 0) {
+        return schema;
+    }
+    if ("$ref" in schema) {
+        return schema;
+    }
+    return { ...schema, ...hints };
+}
+function parseValidationHints(annotationBlock, type) {
+    const forceRequired = /@(?:field:)?NotNull\b/.test(annotationBlock);
+    const sizeMatch = annotationBlock.match(/@(?:field:)?Size\s*\(([^)]*)\)/);
+    if (!sizeMatch) {
+        return { forceRequired };
+    }
+    const args = sizeMatch[1] ?? "";
+    const min = parseNumberArg(args, "min");
+    const max = parseNumberArg(args, "max");
+    const clean = normalizeNullableType(cleanType(type));
+    const hints = {};
+    if (outerType(clean) === "String") {
+        if (min !== undefined)
+            hints.minLength = min;
+        if (max !== undefined)
+            hints.maxLength = max;
+    }
+    else if (isListLike(clean)) {
+        if (min !== undefined)
+            hints.minItems = min;
+        if (max !== undefined)
+            hints.maxItems = max;
+    }
+    return { forceRequired, hints: Object.keys(hints).length > 0 ? hints : undefined };
+}
+function parseNumberArg(args, key) {
+    const match = args.match(new RegExp(`${key}\\s*=\\s*(\\d+)`));
+    if (!match?.[1]) {
+        return undefined;
+    }
+    return Number.parseInt(match[1], 10);
+}
+function extractDataClassDeclarations(source) {
+    const declarations = [];
+    const header = /((?:\s*@[^\n]+\n)*)\s*data\s+class\s+([A-Za-z_][A-Za-z0-9_]*)\s*\(/g;
+    for (const match of source.matchAll(header)) {
+        const annotationBlock = match[1] ?? "";
+        const name = match[2] ?? "";
+        const openParenIndex = (match.index ?? 0) + match[0].length - 1;
+        const closeParenIndex = findMatchingParen(source, openParenIndex);
+        if (closeParenIndex <= openParenIndex) {
+            continue;
+        }
+        const rawProperties = source.slice(openParenIndex + 1, closeParenIndex);
+        declarations.push({ annotationBlock, name, rawProperties });
+    }
+    return declarations;
+}
+function findMatchingParen(source, openParenIndex) {
+    let depth = 0;
+    for (let i = openParenIndex; i < source.length; i += 1) {
+        const char = source[i];
+        if (char === "(") {
+            depth += 1;
+        }
+        else if (char === ")") {
+            depth -= 1;
+            if (depth === 0) {
+                return i;
+            }
+        }
+    }
+    return -1;
+}
 function parseNamingStrategy(annotationBlock) {
     if (!/@JsonNaming\s*\(/.test(annotationBlock)) {
         return "snake_case";

package/dist/scanner.d.ts

@@ -18,5 +18,14 @@ export interface ExtractedEndpoint {
     headers: EndpointField[];
     requestBody?: EndpointBody;
 }
+export interface ScanArtifacts {
+    endpoints: ExtractedEndpoint[];
+    parserWarnings: string[];
+}
 export declare function scanSpringProject(projectPath: string): Promise<ExtractedEndpoint[]>;
+export declare function scanSpringProjectArtifacts(projectPath: string): Promise<ScanArtifacts>;
 export declare function parseKotlinControllerFile(source: string, sourceFile: string): ExtractedEndpoint[];
+export declare function parseKotlinControllerFileArtifacts(source: string, sourceFile: string): {
+    endpoints: ExtractedEndpoint[];
+    warnings: string[];
+};

package/dist/scanner.js

@@ -1,30 +1,42 @@
 import { readdir, readFile } from "node:fs/promises";
 import path from "node:path";
 export async function scanSpringProject(projectPath) {
+    return (await scanSpringProjectArtifacts(projectPath)).endpoints;
+}
+export async function scanSpringProjectArtifacts(projectPath) {
     const kotlinRoot = path.join(projectPath, "src", "main", "kotlin");
     const files = (await listKotlinFiles(kotlinRoot)).sort();
     const endpoints = [];
+    const parserWarnings = [];
     for (const filePath of files) {
         const source = await readFile(filePath, "utf8");
-        endpoints.push(...parseKotlinControllerFile(source, filePath));
+        const artifacts = parseKotlinControllerFileArtifacts(source, filePath);
+        endpoints.push(...artifacts.endpoints);
+        parserWarnings.push(...artifacts.warnings);
     }
-    return endpoints.sort((a, b) => {
-        const byPath = a.fullPath.localeCompare(b.fullPath);
-        if (byPath !== 0)
-            return byPath;
-        const byMethod = a.httpMethod.localeCompare(b.httpMethod);
-        if (byMethod !== 0)
-            return byMethod;
-        return a.operationName.localeCompare(b.operationName);
-    });
+    return {
+        endpoints: endpoints.sort((a, b) => {
+            const byPath = a.fullPath.localeCompare(b.fullPath);
+            if (byPath !== 0)
+                return byPath;
+            const byMethod = a.httpMethod.localeCompare(b.httpMethod);
+            if (byMethod !== 0)
+                return byMethod;
+            return a.operationName.localeCompare(b.operationName);
+        }),
+        parserWarnings
+    };
 }
 export function parseKotlinControllerFile(source, sourceFile) {
+    return parseKotlinControllerFileArtifacts(source, sourceFile).endpoints;
+}
+export function parseKotlinControllerFileArtifacts(source, sourceFile) {
     if (!/@RestController\b/.test(source)) {
-        return [];
+        return { endpoints: [], warnings: [] };
     }
     const classPrefixes = extractClassPrefixes(source);
     const classRequestMappingArgs = extractClassRequestMappingArgs(source);
-    const methods = source.matchAll(/((?:\s*@[A-Za-z_][A-Za-z0-9_]*(?:\((?:[\s\S]*?)\))?\s*)+)fun\s+([A-Za-z_][A-Za-z0-9_]*)\s*\(([\s\S]*?)\)\s*:\s*([^\n{=]+)/g);
+    const methods = source.matchAll(/((?:\s*@[A-Za-z_][A-Za-z0-9_]*(?:\((?:[\s\S]*?)\))?\s*)+)(?:suspend\s+)?fun\s+([A-Za-z_][A-Za-z0-9_]*)\s*\(([\s\S]*?)\)\s*:\s*([^\n{=]+)/g);
     const endpoints = [];
     for (const match of methods) {
         const annotationBlock = match[1] ?? "";
@@ -52,7 +64,13 @@ export function parseKotlinControllerFile(source, sourceFile) {
             }
         }
     }
-    return endpoints;
+    const hasSpringMapping = /@(GetMapping|PostMapping|PutMapping|DeleteMapping|PatchMapping|RequestMapping)\b/.test(source);
+    const warnings = endpoints.length === 0 && hasSpringMapping
+        ? [
+            `Parser warning in ${sourceFile}: found Spring mapping annotations but no handler methods were extracted`
+        ]
+        : [];
+    return { endpoints, warnings };
 }
 async function listKotlinFiles(root) {
     const entries = (await readdir(root, { withFileTypes: true }).catch(() => [])).sort((a, b) => a.name.localeCompare(b.name));
@@ -200,6 +218,7 @@ function parseAnnotatedParameter(chunk) {
     const type = (shape[4] ?? "Any").trim();
     const alias = parseAlias(annotationArgs);
     const requiredFlag = parseRequiredFlag(annotationArgs);
+    const hasDefaultValue = /defaultValue\s*=/.test(annotationArgs);
     const isNullable = type.endsWith("?");
     const hasExplicitAlias = alias !== undefined;
     if (annotation === "PathVariable") {
@@ -215,7 +234,7 @@ function parseAnnotatedParameter(chunk) {
             kind: "query",
             name: hasExplicitAlias ? alias : toSnakeCase(variableName),
             type,
-            required: requiredFlag ?? !isNullable
+            required: requiredFlag ?? (!isNullable && !hasDefaultValue)
         };
     }
     if (annotation === "RequestHeader") {
@@ -247,7 +266,10 @@ function parseAlias(annotationArgs) {
     if (keyed) {
         return keyed;
     }
-    return annotationArgs.match(/"([^"]+)"/)?.[1];
+    if (!annotationArgs.includes("=")) {
+        return annotationArgs.match(/"([^"]+)"/)?.[1];
+    }
+    return undefined;
 }
 function splitTopLevel(input) {
     const parts = [];