shokupan 0.10.4 → 0.11.0

package/dist/{analyzer.impl-D9Yi1Hax.cjs → analyzer.impl-CfpMu4-g.cjs}

@@ -14,6 +14,8 @@ class OpenAPIAnalyzer {
   applications = [];
   program;
   entrypoint;
+  // Track imports per file: filePath -> { importedName -> { modulePath, exportName } }
+  imports = /* @__PURE__ */ new Map();
   /**
    * Main analysis entry point
    */
@@ -23,6 +25,7 @@ class OpenAPIAnalyzer {
   async analyze() {
     await this.parseTypeScriptFiles();
     await this.processSourceMaps();
+    await this.collectImports();
     await this.findApplications();
     await this.extractRoutes();
     this.pruneApplications();
@@ -101,6 +104,43 @@ class OpenAPIAnalyzer {
       }
     }
   }
+  /**
+   * Collect all imports from source files for later resolution
+   */
+  async collectImports() {
+    if (!this.program) return;
+    for (const sourceFile of this.program.getSourceFiles()) {
+      if (sourceFile.fileName.includes("node_modules")) continue;
+      if (sourceFile.isDeclarationFile) continue;
+      const fileImports = /* @__PURE__ */ new Map();
+      ts.forEachChild(sourceFile, (node) => {
+        if (ts.isImportDeclaration(node)) {
+          const moduleSpecifier = node.moduleSpecifier;
+          if (ts.isStringLiteral(moduleSpecifier)) {
+            const modulePath = moduleSpecifier.text;
+            if (node.importClause?.name) {
+              const importedName = node.importClause.name.getText(sourceFile);
+              fileImports.set(importedName, { modulePath, exportName: "default" });
+            }
+            if (node.importClause?.namedBindings && ts.isNamedImports(node.importClause.namedBindings)) {
+              for (const element of node.importClause.namedBindings.elements) {
+                const importedName = element.name.getText(sourceFile);
+                const exportName = element.propertyName?.getText(sourceFile) || importedName;
+                fileImports.set(importedName, { modulePath, exportName });
+              }
+            }
+            if (node.importClause?.namedBindings && ts.isNamespaceImport(node.importClause.namedBindings)) {
+              const importedName = node.importClause.namedBindings.name.getText(sourceFile);
+              fileImports.set(importedName, { modulePath, exportName: "*" });
+            }
+          }
+        }
+      });
+      if (fileImports.size > 0) {
+        this.imports.set(sourceFile.fileName, fileImports);
+      }
+    }
+  }
   /**
    * Parse TypeScript files and create AST
    */
@@ -205,7 +245,8 @@ class OpenAPIAnalyzer {
           className: "Controller",
           controllerPrefix,
           routes: [],
-          mounted: []
+          mounted: [],
+          middleware: []
         });
       }
     }
@@ -220,7 +261,8 @@ class OpenAPIAnalyzer {
             filePath: sourceFile.fileName,
             className,
             routes: [],
-            mounted: []
+            mounted: [],
+            middleware: []
           });
         }
       }
@@ -237,7 +279,8 @@ class OpenAPIAnalyzer {
               filePath: sourceFile.fileName,
               className: "Shokupan",
               routes: [],
-              mounted: []
+              mounted: [],
+              middleware: []
             });
           }
         }
@@ -295,6 +338,7 @@ class OpenAPIAnalyzer {
           requestTypes: analysis.requestTypes,
           responseType: analysis.responseType,
           responseSchema: analysis.responseSchema,
+          hasUnknownFields: analysis.hasUnknownFields,
           emits: analysis.emits,
           sourceContext: {
             file: sourceFile.fileName,
@@ -333,6 +377,14 @@ class OpenAPIAnalyzer {
                 if (mount) {
                   app.mounted.push(mount);
                 }
+              } else if (methodName === "use") {
+                const middleware = this.extractMiddlewareFromCall(node, sourceFile);
+                if (middleware) {
+                  if (app.className === "Shokupan") {
+                    middleware.scope = "global";
+                  }
+                  app.middleware.push(middleware);
+                }
               }
             }
           }
@@ -342,6 +394,47 @@ class OpenAPIAnalyzer {
       ts.forEachChild(sourceFile, visit);
     }
   }
+  /**
+   * Resolve string value from expression (literals, concatenation, templates, constants)
+   */
+  resolveStringValue(node, sourceFile) {
+    if (ts.isStringLiteral(node)) {
+      return node.text;
+    }
+    if (ts.isNoSubstitutionTemplateLiteral(node)) {
+      return node.text;
+    }
+    if (ts.isTemplateExpression(node)) {
+      let result = node.head.text;
+      for (const span of node.templateSpans) {
+        const val = this.resolveStringValue(span.expression, sourceFile);
+        if (val === null) return null;
+        result += val + span.literal.text;
+      }
+      return result;
+    }
+    if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.PlusToken) {
+      const left = this.resolveStringValue(node.left, sourceFile);
+      const right = this.resolveStringValue(node.right, sourceFile);
+      if (left !== null && right !== null) {
+        return left + right;
+      }
+      return null;
+    }
+    if (ts.isParenthesizedExpression(node)) {
+      return this.resolveStringValue(node.expression, sourceFile);
+    }
+    if (ts.isIdentifier(node)) {
+      if (this.program) {
+        const checker = this.program.getTypeChecker();
+        const symbol = checker.getSymbolAtLocation(node);
+        if (symbol && symbol.valueDeclaration && ts.isVariableDeclaration(symbol.valueDeclaration) && symbol.valueDeclaration.initializer) {
+          return this.resolveStringValue(symbol.valueDeclaration.initializer, sourceFile);
+        }
+      }
+    }
+    return null;
+  }
   /**
    * Extract route information from a route call (e.g., app.get('/path', handler))
    */
@@ -349,11 +442,21 @@ class OpenAPIAnalyzer {
     const args = node.arguments;
     if (args.length < 2) return null;
     const pathArg = args[0];
-    let routePath = "/";
-    if (ts.isStringLiteral(pathArg)) {
-      routePath = pathArg.text;
-    } else {
-      routePath = "__DYNAMIC_EVENT__";
+    let routePath = this.resolveStringValue(pathArg, sourceFile);
+    let dynamicHighlights = [];
+    if (!routePath) {
+      if (["EVENT", "ON"].includes(method.toUpperCase())) {
+        routePath = "__DYNAMIC_EVENT__";
+      } else {
+        routePath = "__DYNAMIC_ROUTE__";
+      }
+      const start = sourceFile.getLineAndCharacterOfPosition(pathArg.getStart());
+      const end = sourceFile.getLineAndCharacterOfPosition(pathArg.getEnd());
+      dynamicHighlights.push({
+        startLine: start.line + 1,
+        endLine: end.line + 1,
+        type: "dynamic-path"
+      });
     }
     const normalizedPath = routePath.replace(/:([a-zA-Z0-9_]+)/g, "{$1}");
     let metadata = {};
@@ -392,7 +495,7 @@ class OpenAPIAnalyzer {
         file: sourceFile.fileName,
         startLine: sourceFile.getLineAndCharacterOfPosition(handlerArg.getStart()).line + 1,
         endLine: sourceFile.getLineAndCharacterOfPosition(handlerArg.getEnd()).line + 1,
-        highlights: handlerInfo.highlights
+        highlights: [...handlerInfo.highlights || [], ...dynamicHighlights]
       }
     };
   }
@@ -400,9 +503,10 @@ class OpenAPIAnalyzer {
    * Analyze a route handler to extract type information
    */
   analyzeHandler(handler, sourceFile) {
+    const typeChecker = this.program?.getTypeChecker();
     const requestTypes = {};
     let responseType;
-    let responseSchema;
+    let responseSchemas = [];
     let hasExplicitReturnType = false;
     const emits = [];
     const highlights = [];
@@ -420,7 +524,7 @@ class OpenAPIAnalyzer {
       if (handler.type) {
         const returnSchema = this.convertTypeNodeToSchema(handler.type, sourceFile);
         if (returnSchema) {
-          responseSchema = returnSchema;
+          responseSchemas.push(returnSchema);
           responseType = returnSchema.type;
           hasExplicitReturnType = true;
         }
@@ -437,7 +541,8 @@ class OpenAPIAnalyzer {
         if (callObj === "ctx" || callObj.endsWith(".ctx")) {
           if (callProp === "json") {
             if (node.arguments.length > 0) {
-              responseSchema = this.convertExpressionToSchema(node.arguments[0], sourceFile, scope);
+              const schema = this.convertExpressionToSchema(node.arguments[0], sourceFile, scope, typeChecker);
+              responseSchemas.push(schema);
               responseType = "object";
             }
             return;
@@ -450,14 +555,14 @@ class OpenAPIAnalyzer {
           }
         }
       }
-      if (!hasExplicitReturnType && (!responseSchema || responseSchema.type === "object")) {
-        const schema = this.convertExpressionToSchema(node, sourceFile, scope);
+      if (!hasExplicitReturnType && responseSchemas.length === 0) {
+        const schema = this.convertExpressionToSchema(node, sourceFile, scope, typeChecker);
         if (schema && (schema.type !== "object" || Object.keys(schema.properties || {}).length > 0)) {
-          responseSchema = schema;
+          responseSchemas.push(schema);
           responseType = schema.type;
         }
       }
-      if (!responseSchema && !responseType) {
+      if (responseSchemas.length === 0 && !responseType) {
         const returnText = node.getText(sourceFile);
         if (returnText.startsWith("{")) {
           responseType = "object";
@@ -473,23 +578,64 @@ class OpenAPIAnalyzer {
       body = handler.body;
       const visit = (node) => {
         if (ts.isVariableDeclaration(node)) {
-          if (node.initializer && ts.isIdentifier(node.name)) {
-            const varName = node.name.getText(sourceFile);
-            let initializer = node.initializer;
-            if (ts.isAsExpression(initializer)) {
-              if (this.isCtxBodyCall(initializer.expression, sourceFile)) {
-                const schema = this.convertTypeNodeToSchema(initializer.type, sourceFile);
-                if (schema) {
-                  requestTypes.body = schema;
+          if (node.initializer) {
+            if (ts.isIdentifier(node.name)) {
+              const varName = node.name.getText(sourceFile);
+              let initializer = node.initializer;
+              if (ts.isAsExpression(initializer)) {
+                if (this.isCtxBodyCall(initializer.expression, sourceFile)) {
+                  const schema = this.convertTypeNodeToSchema(initializer.type, sourceFile);
+                  if (schema) {
+                    requestTypes.body = schema;
+                    scope.set(varName, schema);
+                  }
+                } else {
+                  const schema = this.convertExpressionToSchema(initializer, sourceFile, scope, typeChecker);
                   scope.set(varName, schema);
                 }
               } else {
-                const schema = this.convertExpressionToSchema(initializer, sourceFile, scope);
+                const schema = this.convertExpressionToSchema(initializer, sourceFile, scope, typeChecker);
                 scope.set(varName, schema);
               }
-            } else {
-              const schema = this.convertExpressionToSchema(initializer, sourceFile, scope);
-              scope.set(varName, schema);
+            } else if (ts.isArrayBindingPattern(node.name)) {
+              const initializerSchema = this.convertExpressionToSchema(node.initializer, sourceFile, scope, typeChecker);
+              if (initializerSchema?.type === "array" && initializerSchema.items) {
+                for (let i = 0; i < node.name.elements.length; i++) {
+                  const element = node.name.elements[i];
+                  if (ts.isBindingElement(element) && ts.isIdentifier(element.name)) {
+                    const elementName = element.name.getText(sourceFile);
+                    scope.set(elementName, initializerSchema.items);
+                  }
+                }
+              } else {
+                for (let i = 0; i < node.name.elements.length; i++) {
+                  const element = node.name.elements[i];
+                  if (ts.isBindingElement(element) && ts.isIdentifier(element.name)) {
+                    const elementName = element.name.getText(sourceFile);
+                    scope.set(elementName, { "x-unknown": true });
+                  }
+                }
+              }
+            } else if (ts.isObjectBindingPattern(node.name)) {
+              const initializerSchema = this.convertExpressionToSchema(node.initializer, sourceFile, scope, typeChecker);
+              if (initializerSchema?.type === "object" && initializerSchema.properties) {
+                for (let i = 0; i < node.name.elements.length; i++) {
+                  const element = node.name.elements[i];
+                  if (ts.isBindingElement(element) && ts.isIdentifier(element.name)) {
+                    const elementName = element.name.getText(sourceFile);
+                    const propertySchema = initializerSchema.properties[elementName];
+                    scope.set(elementName, propertySchema || { "x-unknown": true });
+                  }
+                }
+              } else {
+                for (let i = 0; i < node.name.elements.length; i++) {
+                  const element = node.name.elements[i];
+                  if (ts.isBindingElement(element) && ts.isIdentifier(element.name)) {
+                    const elementName = element.name.getText(sourceFile);
+                    scope.set(elementName, { "x-unknown": true });
+                  }
+                }
+              }
             }
           }
         }
@@ -516,7 +662,7 @@ class OpenAPIAnalyzer {
             } else if (propText === "json") {
               let isStatic = false;
               if (node.arguments.length > 0) {
-                const schema = this.convertExpressionToSchema(node.arguments[0], sourceFile, scope);
+                const schema = this.convertExpressionToSchema(node.arguments[0], sourceFile, scope, typeChecker);
                 if (schema && (schema.type !== "object" || schema.properties && Object.keys(schema.properties).length > 0)) {
                   isStatic = true;
                 }
@@ -549,8 +695,9 @@ class OpenAPIAnalyzer {
           const endLine = sourceFile.getLineAndCharacterOfPosition(node.getEnd()).line + 1;
           let isStatic = false;
           if (node.expression) {
+            const schemasBeforeReturn = responseSchemas.length;
             analyzeReturnExpression(node.expression);
-            if (responseSchema && (responseSchema.type !== "object" || responseSchema.properties && Object.keys(responseSchema.properties).length > 0)) {
+            if (responseSchemas.length > schemasBeforeReturn) {
               isStatic = true;
             }
           } else if (hasExplicitReturnType) {
@@ -561,9 +708,10 @@ class OpenAPIAnalyzer {
         if (ts.isArrowFunction(node) && !ts.isBlock(node.body)) {
           const startLine = sourceFile.getLineAndCharacterOfPosition(node.body.getStart()).line + 1;
           const endLine = sourceFile.getLineAndCharacterOfPosition(node.body.getEnd()).line + 1;
+          const schemasBeforeReturn = responseSchemas.length;
           analyzeReturnExpression(node.body);
           let isStatic = false;
-          if (responseSchema && (responseSchema.type !== "object" || responseSchema.properties && Object.keys(responseSchema.properties).length > 0)) {
+          if (responseSchemas.length > schemasBeforeReturn) {
             isStatic = true;
           }
           highlights.push({ startLine, endLine, type: isStatic ? "return-success" : "return-warning" });
@@ -582,7 +730,7 @@ class OpenAPIAnalyzer {
                     const eventName = eventNameArg.text;
                     let payload = { type: "object" };
                     if (expr.arguments.length >= 2) {
-                      payload = this.convertExpressionToSchema(expr.arguments[1], sourceFile, scope);
+                      payload = this.convertExpressionToSchema(expr.arguments[1], sourceFile, scope, typeChecker);
                     }
                     const emitLoc = {
                       startLine: sourceFile.getLineAndCharacterOfPosition(expr.getStart()).line + 1,
@@ -610,12 +758,32 @@ class OpenAPIAnalyzer {
         ts.forEachChild(body, visit);
       }
     }
-    return { requestTypes, responseType, responseSchema, emits, highlights };
+    let finalResponseSchema;
+    if (responseSchemas.length > 1) {
+      const uniqueSchemas = this.deduplicateSchemas(responseSchemas);
+      if (uniqueSchemas.length === 1) {
+        finalResponseSchema = uniqueSchemas[0];
+      } else {
+        finalResponseSchema = {
+          oneOf: uniqueSchemas
+        };
+      }
+    } else if (responseSchemas.length === 1) {
+      finalResponseSchema = responseSchemas[0];
+    }
+    return {
+      requestTypes,
+      responseType,
+      responseSchema: finalResponseSchema,
+      hasUnknownFields: finalResponseSchema ? this.hasUnknownFields(finalResponseSchema) : false,
+      emits,
+      highlights
+    };
   }
   /**
    * Convert an Expression node to an OpenAPI schema (best effort)
    */
-  convertExpressionToSchema(node, sourceFile, scope) {
+  convertExpressionToSchema(node, sourceFile, scope, typeChecker) {
     if (ts.isObjectLiteralExpression(node)) {
       const schema = {
         type: "object",
@@ -626,7 +794,7 @@ class OpenAPIAnalyzer {
         const prop = node.properties[i];
         if (ts.isPropertyAssignment(prop)) {
           const name = prop.name.getText(sourceFile);
-          const valueSchema = this.convertExpressionToSchema(prop.initializer, sourceFile, scope);
+          const valueSchema = this.convertExpressionToSchema(prop.initializer, sourceFile, scope, typeChecker);
           schema.properties[name] = valueSchema;
           schema.required.push(name);
         } else if (ts.isShorthandPropertyAssignment(prop)) {
@@ -644,29 +812,130 @@ class OpenAPIAnalyzer {
     if (ts.isArrayLiteralExpression(node)) {
       const schema = { type: "array" };
       if (node.elements.length > 0) {
-        schema.items = this.convertExpressionToSchema(node.elements[0], sourceFile, scope);
+        schema.items = this.convertExpressionToSchema(node.elements[0], sourceFile, scope, typeChecker);
       } else {
         schema.items = {};
       }
       return schema;
     }
     if (ts.isConditionalExpression(node)) {
-      const trueSchema = this.convertExpressionToSchema(node.whenTrue, sourceFile, scope);
+      const trueSchema = this.convertExpressionToSchema(node.whenTrue, sourceFile, scope, typeChecker);
       return trueSchema;
     }
     if (ts.isTemplateExpression(node)) {
       return { type: "string" };
     }
+    if (ts.isAwaitExpression(node)) {
+      return this.convertExpressionToSchema(node.expression, sourceFile, scope, typeChecker);
+    }
+    if (ts.isCallExpression(node)) {
+      const callText = node.getText(sourceFile);
+      if (callText.startsWith("Date.now()") || callText.startsWith("Math.") || callText.startsWith("Number(") || callText.startsWith("parseInt(") || callText.startsWith("parseFloat(")) {
+        return { type: "number" };
+      }
+      if (callText.startsWith("String(") || callText.endsWith(".toString()") || callText.endsWith(".join(")) {
+        return { type: "string" };
+      }
+      if (callText.startsWith("Boolean(")) {
+        return { type: "boolean" };
+      }
+      if (callText.endsWith(".split(") || callText.endsWith(".map(") || callText.endsWith(".filter(")) {
+        return { type: "array", items: {} };
+      }
+      return { "x-unknown": true };
+    }
+    if (ts.isBinaryExpression(node)) {
+      const operator = node.operatorToken.kind;
+      if (operator === ts.SyntaxKind.PlusToken || operator === ts.SyntaxKind.MinusToken || operator === ts.SyntaxKind.AsteriskToken || operator === ts.SyntaxKind.SlashToken || operator === ts.SyntaxKind.PercentToken || operator === ts.SyntaxKind.AsteriskAsteriskToken) {
+        if (operator === ts.SyntaxKind.PlusToken) {
+          const leftSchema = this.convertExpressionToSchema(node.left, sourceFile, scope, typeChecker);
+          const rightSchema = this.convertExpressionToSchema(node.right, sourceFile, scope, typeChecker);
+          if (leftSchema.type === "string" || rightSchema.type === "string") {
+            return { type: "string" };
+          }
+        }
+        return { type: "number" };
+      }
+      if (operator === ts.SyntaxKind.GreaterThanToken || operator === ts.SyntaxKind.LessThanToken || operator === ts.SyntaxKind.GreaterThanEqualsToken || operator === ts.SyntaxKind.LessThanEqualsToken || operator === ts.SyntaxKind.EqualsEqualsToken || operator === ts.SyntaxKind.EqualsEqualsEqualsToken || operator === ts.SyntaxKind.ExclamationEqualsToken || operator === ts.SyntaxKind.ExclamationEqualsEqualsToken) {
+        return { type: "boolean" };
+      }
+      if (operator === ts.SyntaxKind.AmpersandAmpersandToken || operator === ts.SyntaxKind.BarBarToken) {
+        const leftSchema = this.convertExpressionToSchema(node.left, sourceFile, scope, typeChecker);
+        const rightSchema = this.convertExpressionToSchema(node.right, sourceFile, scope, typeChecker);
+        if (operator === ts.SyntaxKind.BarBarToken && rightSchema.type === "string") {
+          return { type: "string" };
+        }
+        if (leftSchema.type && leftSchema.type !== "boolean") {
+          return leftSchema;
+        }
+        if (rightSchema.type && rightSchema.type !== "boolean") {
+          return rightSchema;
+        }
+        return { type: "boolean" };
+      }
+      if (operator === ts.SyntaxKind.AmpersandToken || operator === ts.SyntaxKind.BarToken || operator === ts.SyntaxKind.CaretToken || operator === ts.SyntaxKind.LessThanLessThanToken || operator === ts.SyntaxKind.GreaterThanGreaterThanToken || operator === ts.SyntaxKind.GreaterThanGreaterThanGreaterThanToken) {
+        return { type: "number" };
+      }
+    }
+    if (ts.isPropertyAccessExpression(node) && typeChecker) {
+      try {
+        const type = typeChecker.getTypeAtLocation(node);
+        const schema = this.convertTypeToSchema(type, typeChecker);
+        if (schema && (schema.type !== "object" || schema.properties)) {
+          return schema;
+        }
+      } catch (e) {
+      }
+    }
     if (ts.isIdentifier(node)) {
       const name = node.getText(sourceFile);
       const scopedSchema = scope.get(name);
       if (scopedSchema) return scopedSchema;
-      return { type: "object" };
+      if (typeChecker) {
+        try {
+          const type = typeChecker.getTypeAtLocation(node);
+          const schema = this.convertTypeToSchema(type, typeChecker);
+          if (schema && (schema.type !== "object" || schema.properties)) {
+            return schema;
+          }
+        } catch (e) {
+        }
+      }
+      return { type: "object", "x-unknown": true };
     }
     if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) return { type: "string" };
     if (ts.isNumericLiteral(node)) return { type: "number" };
     if (node.kind === ts.SyntaxKind.TrueKeyword || node.kind === ts.SyntaxKind.FalseKeyword) return { type: "boolean" };
-    return { type: "object" };
+    return { type: "object", "x-unknown": true };
+  }
+  /**
+   * Deduplicate schemas by comparing their JSON representations
+   */
+  deduplicateSchemas(schemas) {
+    const seen = /* @__PURE__ */ new Map();
+    for (const schema of schemas) {
+      const key = JSON.stringify(schema);
+      if (!seen.has(key)) {
+        seen.set(key, schema);
+      }
+    }
+    return Array.from(seen.values());
+  }
+  /**
+   * Check if a schema contains fields with unknown types
+   */
+  hasUnknownFields(schema) {
+    if (!schema) return false;
+    if (schema["x-unknown"]) return true;
+    if (schema.type === "object" && schema.properties) {
+      return Object.values(schema.properties).some(
+        (prop) => this.hasUnknownFields(prop)
+      );
+    }
+    if (schema.type === "array" && schema.items) {
+      return this.hasUnknownFields(schema.items);
+    }
+    return false;
   }
   /**
    * Check if an expression is a call to ctx.body()
@@ -748,6 +1017,82 @@ class OpenAPIAnalyzer {
         return { type: "object" };
     }
   }
+  /**
+   * Convert a TypeScript Type (from type checker) to an OpenAPI schema
+   */
+  convertTypeToSchema(type, typeChecker, depth = 0) {
+    if (depth > 5) {
+      return { type: "object", description: "Complex type (max depth reached)" };
+    }
+    if (type.flags & ts.TypeFlags.String) return { type: "string" };
+    if (type.flags & ts.TypeFlags.Number) return { type: "number" };
+    if (type.flags & ts.TypeFlags.Boolean) return { type: "boolean" };
+    if (type.flags & ts.TypeFlags.Null) return { type: "null" };
+    if (type.flags & ts.TypeFlags.Undefined) return { type: "object", nullable: true };
+    if (type.flags & ts.TypeFlags.Any || type.flags & ts.TypeFlags.Unknown) return {};
+    if (type.flags & ts.TypeFlags.StringLiteral) {
+      const literalType = type;
+      return { type: "string", enum: [literalType.value] };
+    }
+    if (type.flags & ts.TypeFlags.NumberLiteral) {
+      const literalType = type;
+      return { type: "number", enum: [literalType.value] };
+    }
+    if (type.flags & ts.TypeFlags.BooleanLiteral) {
+      const intrinsicName = type.intrinsicName;
+      return { type: "boolean", enum: [intrinsicName === "true"] };
+    }
+    if (type.flags & ts.TypeFlags.Union) {
+      const unionType = type;
+      const schemas = unionType.types.map((t) => this.convertTypeToSchema(t, typeChecker, depth + 1));
+      const uniqueTypes = new Set(schemas.map((s) => s.type));
+      if (uniqueTypes.size === 1 && schemas[0].type !== "object") {
+        return schemas[0];
+      }
+      return { oneOf: schemas };
+    }
+    if (typeChecker.isArrayType(type)) {
+      const typeArgs = type.typeArguments || type.resolvedTypeArguments;
+      if (typeArgs && typeArgs.length > 0) {
+        return {
+          type: "array",
+          items: this.convertTypeToSchema(typeArgs[0], typeChecker, depth + 1)
+        };
+      }
+      return { type: "array", items: {} };
+    }
+    if (type.flags & ts.TypeFlags.Object) {
+      const properties = {};
+      const required = [];
+      const props = typeChecker.getPropertiesOfType(type);
+      const maxProps = 50;
+      const propsToProcess = props.slice(0, maxProps);
+      for (const prop of propsToProcess) {
+        const propName = prop.getName();
+        const propType = typeChecker.getTypeOfSymbol(prop);
+        const signatures = propType.getCallSignatures();
+        if (signatures && signatures.length > 0) {
+          continue;
+        }
+        properties[propName] = this.convertTypeToSchema(propType, typeChecker, depth + 1);
+        if (!(prop.flags & ts.SymbolFlags.Optional)) {
+          required.push(propName);
+        }
+      }
+      const schema = { type: "object" };
+      if (Object.keys(properties).length > 0) {
+        schema.properties = properties;
+        if (required.length > 0) {
+          schema.required = required;
+        }
+      }
+      if (props.length > maxProps) {
+        schema.description = `Type with ${props.length} properties (showing ${maxProps})`;
+      }
+      return schema;
+    }
+    return { type: "object", description: "Complex type" };
+  }
   /**
    * Extract mount information from mount call
    */
@@ -816,6 +1161,207 @@ class OpenAPIAnalyzer {
       }
     };
   }
+  /**
+   * Extract middleware information from .use() call
+   */
+  extractMiddlewareFromCall(node, sourceFile) {
+    const args = node.arguments;
+    if (args.length < 1) return null;
+    const middlewareArg = args[0];
+    let middlewareName = "anonymous";
+    let isImportedIdentifier = false;
+    if (ts.isIdentifier(middlewareArg)) {
+      middlewareName = middlewareArg.getText(sourceFile);
+      isImportedIdentifier = true;
+    } else if (ts.isCallExpression(middlewareArg) && ts.isIdentifier(middlewareArg.expression)) {
+      middlewareName = middlewareArg.expression.getText(sourceFile);
+      isImportedIdentifier = true;
+    } else if (ts.isFunctionExpression(middlewareArg) || ts.isArrowFunction(middlewareArg)) {
+      middlewareName = "inline-middleware";
+    }
+    let analysis = this.analyzeMiddleware(middlewareArg, sourceFile);
+    if (isImportedIdentifier) {
+      const resolvedAnalysis = this.resolveImportedMiddlewareDefinition(middlewareName, sourceFile);
+      if (resolvedAnalysis.responseTypes) {
+        analysis.responseTypes = { ...resolvedAnalysis.responseTypes, ...analysis.responseTypes };
+      }
+      if (resolvedAnalysis.headers) {
+        analysis.headers = [...resolvedAnalysis.headers || [], ...analysis.headers || []];
+        analysis.headers = Array.from(new Set(analysis.headers));
+      }
+    }
+    return {
+      name: middlewareName,
+      file: sourceFile.fileName,
+      startLine: sourceFile.getLineAndCharacterOfPosition(middlewareArg.getStart()).line + 1,
+      endLine: sourceFile.getLineAndCharacterOfPosition(middlewareArg.getEnd()).line + 1,
+      handlerSource: middlewareArg.getText(sourceFile),
+      responseTypes: analysis.responseTypes,
+      headers: analysis.headers,
+      scope: "router",
+      // Will be updated during collection based on context
+      sourceContext: {
+        file: sourceFile.fileName,
+        startLine: sourceFile.getLineAndCharacterOfPosition(middlewareArg.getStart()).line + 1,
+        endLine: sourceFile.getLineAndCharacterOfPosition(middlewareArg.getEnd()).line + 1,
+        snippet: middlewareArg.getText(sourceFile),
+        highlights: analysis.highlights
+      }
+    };
+  }
+  /**
+   * Analyze middleware function to extract response types and headers
+   */
+  analyzeMiddleware(middleware, sourceFile) {
+    const responseTypes = {};
+    const headers = [];
+    const highlights = [];
+    const variableValues = /* @__PURE__ */ new Map();
+    const visit = (node) => {
+      if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name)) {
+        const varName = node.name.getText(sourceFile);
+        if (node.initializer) {
+          if (ts.isNumericLiteral(node.initializer)) {
+            const value = parseInt(node.initializer.text);
+            if (!isNaN(value)) {
+              variableValues.set(varName, value);
+            }
+          } else if (ts.isBinaryExpression(node.initializer) && node.initializer.operatorToken.kind === ts.SyntaxKind.BarBarToken) {
+            if (ts.isNumericLiteral(node.initializer.right)) {
+              const value = parseInt(node.initializer.right.text);
+              if (!isNaN(value)) {
+                variableValues.set(varName, value);
+              }
+            }
+          }
+        }
+      }
+      if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression)) {
+        const obj = node.expression.expression.getText(sourceFile);
+        const prop = node.expression.name.getText(sourceFile);
+        if (obj === "ctx" && ["json", "text", "html", "jsx"].includes(prop)) {
+          if (node.arguments.length >= 2) {
+            const statusArg = node.arguments[1];
+            let statusCode;
+            if (ts.isNumericLiteral(statusArg)) {
+              statusCode = parseInt(statusArg.text);
+            } else if (ts.isIdentifier(statusArg)) {
+              const varName = statusArg.getText(sourceFile);
+              const value = variableValues.get(varName);
+              if (typeof value === "number") {
+                statusCode = value;
+              }
+            }
+            if (statusCode && statusCode >= 100 && statusCode < 600) {
+              const statusStr = String(statusCode);
+              if (!responseTypes[statusStr]) {
+                let description = `Error response (${statusCode})`;
+                if (statusCode === 401) description = "Unauthorized";
+                else if (statusCode === 403) description = "Forbidden";
+                else if (statusCode === 429) description = "Too Many Requests";
+                else if (statusCode === 500) description = "Internal Server Error";
+                const content = {};
+                if (prop === "json") {
+                  content["application/json"] = { schema: { type: "object" } };
+                } else if (prop === "text") {
+                  content["text/plain"] = { schema: { type: "string" } };
+                } else if (prop === "html" || prop === "jsx") {
+                  content["text/html"] = { schema: { type: "string" } };
+                }
+                responseTypes[statusStr] = {
+                  description,
+                  ...Object.keys(content).length > 0 ? { content } : {}
+                };
+              }
+            }
+          }
+        }
+        if (["set", "header"].includes(prop)) {
+          if (node.arguments.length >= 1 && ts.isStringLiteral(node.arguments[0])) {
+            const headerName = node.arguments[0].text;
+            if (headerName && !headers.includes(headerName)) {
+              headers.push(headerName);
+            }
+          }
+        }
+      }
+      ts.forEachChild(node, visit);
+    };
+    visit(middleware);
+    const middlewareSource = middleware.getText(sourceFile);
+    if (middlewareSource.includes("X-RateLimit")) {
+      const rateLimitHeaders = ["X-RateLimit-Limit", "X-RateLimit-Remaining", "X-RateLimit-Reset", "Retry-After"];
+      for (const header of rateLimitHeaders) {
+        if (middlewareSource.includes(header) && !headers.includes(header)) {
+          headers.push(header);
+        }
+      }
+    }
+    return {
+      responseTypes: Object.keys(responseTypes).length > 0 ? responseTypes : void 0,
+      headers: headers.length > 0 ? headers : void 0,
+      highlights: highlights.length > 0 ? highlights : void 0
+    };
+  }
+  /**
+   * Resolve an imported middleware identifier and analyze its definition
+   */
+  resolveImportedMiddlewareDefinition(middlewareName, sourceFile) {
+    const fileImports = this.imports.get(sourceFile.fileName);
+    if (!fileImports || !fileImports.has(middlewareName)) {
+      return {};
+    }
+    const importInfo = fileImports.get(middlewareName);
+    const modulePath = importInfo.modulePath;
+    if (!modulePath.startsWith(".")) {
+      return {};
+    }
+    const dir = path.dirname(sourceFile.fileName);
+    let absolutePath = path.resolve(dir, modulePath);
+    const extensions = [".ts", ".js", ".tsx", ".jsx", "/index.ts", "/index.js"];
+    let resolvedPath;
+    for (const ext of extensions) {
+      const testPath = absolutePath + ext;
+      if (fs.existsSync(testPath)) {
+        resolvedPath = testPath;
+        break;
+      }
+    }
+    if (!resolvedPath && fs.existsSync(absolutePath)) {
+      resolvedPath = absolutePath;
+    }
+    if (!resolvedPath) {
+      return {};
+    }
+    const importedSourceFile = this.program?.getSourceFile(resolvedPath);
+    if (!importedSourceFile) {
+      return {};
+    }
+    let middlewareNode;
+    const exportName = importInfo.exportName || middlewareName;
+    ts.forEachChild(importedSourceFile, (node) => {
+      if (ts.isFunctionDeclaration(node) && node.name?.getText(importedSourceFile) === exportName) {
+        const modifiers = node.modifiers;
+        if (modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword)) {
+          middlewareNode = node;
+        }
+      }
+      if (ts.isVariableStatement(node)) {
+        const modifiers = node.modifiers;
+        if (modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword)) {
+          for (const declaration of node.declarationList.declarations) {
+            if (ts.isIdentifier(declaration.name) && declaration.name.getText(importedSourceFile) === exportName) {
+              middlewareNode = declaration.initializer;
+            }
+          }
+        }
+      }
+    });
+    if (!middlewareNode) {
+      return {};
+    }
+    return this.analyzeMiddleware(middlewareNode, importedSourceFile);
+  }
   /**
    * Check if a reference is to an external dependency
    */
@@ -1005,4 +1551,4 @@ class OpenAPIAnalyzer {
   }
 }
 exports.OpenAPIAnalyzer = OpenAPIAnalyzer;
-//# sourceMappingURL=analyzer.impl-D9Yi1Hax.cjs.map
+//# sourceMappingURL=analyzer.impl-CfpMu4-g.cjs.map