adorn-api 1.0.21 → 1.0.23

package/dist/cli.js

@@ -306,7 +306,7 @@ function unwrapPromiseTypeNode(typeNode) {
 }
 
 // src/compiler/schema/openapi.ts
-import ts11 from "typescript";
+import ts12 from "typescript";
 
 // src/compiler/schema/typeToJsonSchema.ts
 import ts7 from "typescript";
@@ -1612,7 +1612,221 @@ function resolveAndCollectObjectProps(schema, components) {
 }
 
 // src/compiler/schema/queryBuilderAnalyzer.ts
+import ts10 from "typescript";
+
+// src/compiler/schema/serviceCallAnalyzer.ts
 import ts9 from "typescript";
+var ServiceCallAnalyzer = class {
+  checker;
+  program;
+  cache = /* @__PURE__ */ new Map();
+  analyzedMethods = /* @__PURE__ */ new Set();
+  constructor(checker, program) {
+    this.checker = checker;
+    this.program = program;
+  }
+  /**
+   * Analyzes a controller method for query builder patterns, following service calls
+   */
+  analyzeControllerMethod(methodDeclaration, options = {}) {
+    const cacheKey = this.getMethodCacheKey(methodDeclaration);
+    if (this.cache.has(cacheKey)) {
+      return this.cache.get(cacheKey) ?? null;
+    }
+    const maxDepth = options.maxDepth ?? 3;
+    const schema = this.analyzeMethodWithServiceCalls(methodDeclaration, 0, maxDepth, options);
+    this.cache.set(cacheKey, schema);
+    return schema;
+  }
+  /**
+   * Recursively analyzes method with service call traversal
+   */
+  analyzeMethodWithServiceCalls(methodDeclaration, currentDepth, maxDepth, options) {
+    if (currentDepth >= maxDepth) {
+      return null;
+    }
+    const methodKey = this.getMethodCacheKey(methodDeclaration);
+    if (this.analyzedMethods.has(methodKey)) {
+      return null;
+    }
+    this.analyzedMethods.add(methodKey);
+    const directSchema = analyzeQueryBuilderForSchema(methodDeclaration, this.checker);
+    if (directSchema) {
+      return directSchema;
+    }
+    const serviceCalls = this.findServiceCalls(methodDeclaration);
+    for (const serviceCall of serviceCalls) {
+      const serviceSchema = this.analyzeServiceMethod(serviceCall, currentDepth, maxDepth, options);
+      if (serviceSchema) {
+        return serviceSchema;
+      }
+    }
+    return null;
+  }
+  /**
+   * Analyzes a service method for query builder patterns
+   */
+  analyzeServiceMethod(serviceCall, currentDepth, maxDepth, options) {
+    const directSchema = analyzeQueryBuilderForSchema(serviceCall.methodDeclaration, this.checker);
+    if (directSchema) {
+      return directSchema;
+    }
+    if (options.analyzeHelpers) {
+      return this.analyzeMethodWithServiceCalls(
+        serviceCall.methodDeclaration,
+        currentDepth + 1,
+        maxDepth,
+        options
+      );
+    }
+    return null;
+  }
+  /**
+   * Finds service calls in a method body
+   */
+  findServiceCalls(methodDeclaration) {
+    const serviceCalls = [];
+    const body = methodDeclaration.body;
+    if (!body) {
+      return serviceCalls;
+    }
+    const visitor = (node) => {
+      if (ts9.isCallExpression(node)) {
+        const serviceCall = this.resolveServiceCall(node);
+        if (serviceCall) {
+          serviceCalls.push(serviceCall);
+        }
+      }
+      ts9.forEachChild(node, visitor);
+    };
+    ts9.forEachChild(body, visitor);
+    return serviceCalls;
+  }
+  /**
+   * Resolves a call expression to a service method
+   */
+  resolveServiceCall(callExpression) {
+    if (ts9.isPropertyAccessExpression(callExpression.expression)) {
+      const propAccess = callExpression.expression;
+      const methodName = propAccess.name.text;
+      const objectType = this.checker.getTypeAtLocation(propAccess.expression);
+      const objectSymbol = objectType.getSymbol();
+      if (objectSymbol) {
+        const classDeclaration = this.findClassDeclaration(objectSymbol);
+        if (classDeclaration) {
+          const methodDeclaration = this.findMethodDeclaration(classDeclaration, methodName);
+          if (methodDeclaration) {
+            return {
+              serviceName: classDeclaration.name?.text || "Unknown",
+              methodName,
+              filePath: classDeclaration.getSourceFile().fileName,
+              classDeclaration,
+              methodDeclaration
+            };
+          }
+        }
+      }
+    }
+    if (ts9.isPropertyAccessExpression(callExpression.expression)) {
+      const propAccess = callExpression.expression;
+      const methodName = propAccess.name.text;
+      if (ts9.isIdentifier(propAccess.expression)) {
+        const className = propAccess.expression.text;
+        const classSymbol = this.checker.getSymbolAtLocation(propAccess.expression);
+        if (classSymbol) {
+          const classDeclaration = this.findClassDeclaration(classSymbol);
+          if (classDeclaration && classDeclaration.name?.text === className) {
+            const methodDeclaration = this.findMethodDeclaration(classDeclaration, methodName);
+            if (methodDeclaration) {
+              return {
+                serviceName: className,
+                methodName,
+                filePath: classDeclaration.getSourceFile().fileName,
+                classDeclaration,
+                methodDeclaration
+              };
+            }
+          }
+        }
+      }
+    }
+    return null;
+  }
+  /**
+   * Finds class declaration from a symbol
+   */
+  findClassDeclaration(symbol) {
+    const declarations = symbol.getDeclarations();
+    if (!declarations) return null;
+    for (const declaration of declarations) {
+      if (ts9.isClassDeclaration(declaration)) {
+        return declaration;
+      }
+    }
+    return null;
+  }
+  /**
+   * Finds method declaration in a class
+   */
+  findMethodDeclaration(classDeclaration, methodName) {
+    for (const member of classDeclaration.members) {
+      if (ts9.isMethodDeclaration(member) && member.name) {
+        if (ts9.isIdentifier(member.name) && member.name.text === methodName) {
+          return member;
+        }
+      }
+    }
+    return null;
+  }
+  /**
+   * Generates cache key for a method
+   */
+  getMethodCacheKey(methodDeclaration) {
+    const sourceFile = methodDeclaration.getSourceFile();
+    const className = this.getClassName(methodDeclaration);
+    const methodName = methodDeclaration.name?.getText() || "unknown";
+    const line = sourceFile.getLineAndCharacterOfPosition(methodDeclaration.getStart()).line;
+    return `${sourceFile.fileName}:${className}:${methodName}:${line}`;
+  }
+  /**
+   * Gets class name from method declaration
+   */
+  getClassName(methodDeclaration) {
+    let node = methodDeclaration;
+    while (node) {
+      if (ts9.isClassDeclaration(node)) {
+        return node.name?.text || "Unknown";
+      }
+      node = node.parent;
+    }
+    return "Unknown";
+  }
+  /**
+   * Clears the analysis cache
+   */
+  clearCache() {
+    this.cache.clear();
+    this.analyzedMethods.clear();
+  }
+  /**
+   * Gets cache statistics
+   */
+  getCacheStats() {
+    return {
+      cached: this.cache.size,
+      analyzed: this.analyzedMethods.size
+    };
+  }
+};
+function analyzeControllerWithServiceCalls(methodDeclaration, checker, program, options = {}) {
+  if (!program) {
+    return null;
+  }
+  const analyzer = new ServiceCallAnalyzer(checker, program);
+  return analyzer.analyzeControllerMethod(methodDeclaration, options);
+}
+
+// src/compiler/schema/queryBuilderAnalyzer.ts
 function analyzeQueryBuilderForSchema(methodDeclaration, checker, options = {}) {
   const body = methodDeclaration.body;
   if (!body) {
@@ -1632,6 +1846,24 @@ function analyzeQueryBuilderForSchema(methodDeclaration, checker, options = {})
   }
   return parseQueryBuilderChain(callChain, checker, options);
 }
+function analyzeQueryBuilderWithServiceCalls(methodDeclaration, checker, program, options = {}, operationInfo) {
+  let schema = analyzeQueryBuilderForSchema(methodDeclaration, checker, options);
+  if (!schema && program) {
+    try {
+      schema = analyzeControllerWithServiceCalls(methodDeclaration, checker, program, {
+        maxDepth: options.maxDepth,
+        analyzeHelpers: options.analyzeHelpers
+      });
+    } catch (error) {
+      console.warn("Service call analysis failed:", error);
+    }
+  }
+  return {
+    detected: schema !== null,
+    schema,
+    ...operationInfo
+  };
+}
 function analyzeWithVariableTracking(body, checker, options) {
   let queryBuilderVar = null;
   let entityName = null;
@@ -1640,12 +1872,12 @@ function analyzeWithVariableTracking(body, checker, options) {
   let isPaged = false;
   let hasReturn = false;
   for (const statement of body.statements) {
-    if (ts9.isReturnStatement(statement)) {
+    if (ts10.isReturnStatement(statement)) {
       hasReturn = true;
       const returnExpr = statement.expression;
-      if (returnExpr && ts9.isCallExpression(returnExpr)) {
+      if (returnExpr && ts10.isCallExpression(returnExpr)) {
         const callExpr = returnExpr;
-        if (ts9.isIdentifier(callExpr.expression) && queryBuilderVar) {
+        if (ts10.isIdentifier(callExpr.expression) && queryBuilderVar) {
           const varName = callExpr.expression.text;
           if (varName === queryBuilderVar) {
             const methodName = callExpr.expression.text;
@@ -1654,9 +1886,9 @@ function analyzeWithVariableTracking(body, checker, options) {
             }
           }
         }
-        if (ts9.isPropertyAccessExpression(callExpr.expression) && queryBuilderVar) {
+        if (ts10.isPropertyAccessExpression(callExpr.expression) && queryBuilderVar) {
           const propAccess = callExpr.expression;
-          if (ts9.isIdentifier(propAccess.expression) && propAccess.expression.text === queryBuilderVar) {
+          if (ts10.isIdentifier(propAccess.expression) && propAccess.expression.text === queryBuilderVar) {
             const methodName = propAccess.name.text;
             if (methodName === "executePaged") {
               isPaged = true;
@@ -1666,13 +1898,13 @@ function analyzeWithVariableTracking(body, checker, options) {
       }
       continue;
     }
-    if (!ts9.isExpressionStatement(statement)) {
-      if (ts9.isVariableStatement(statement)) {
+    if (!ts10.isExpressionStatement(statement)) {
+      if (ts10.isVariableStatement(statement)) {
         for (const declaration of statement.declarationList.declarations) {
-          if (!ts9.isIdentifier(declaration.name)) continue;
+          if (!ts10.isIdentifier(declaration.name)) continue;
           const varName = declaration.name.text;
           const initializer = declaration.initializer;
-          if (!initializer || !ts9.isCallExpression(initializer)) continue;
+          if (!initializer || !ts10.isCallExpression(initializer)) continue;
           const opInfo = extractChainedOperation(initializer);
           if (opInfo && (opInfo.operation === "selectFromEntity" || opInfo.operation === "selectFrom")) {
             queryBuilderVar = varName;
@@ -1685,13 +1917,13 @@ function analyzeWithVariableTracking(body, checker, options) {
       continue;
     }
     const expr = statement.expression;
-    if (ts9.isBinaryExpression(expr) && expr.operatorToken.kind === ts9.SyntaxKind.EqualsToken) {
-      if (!ts9.isIdentifier(expr.left)) {
+    if (ts10.isBinaryExpression(expr) && expr.operatorToken.kind === ts10.SyntaxKind.EqualsToken) {
+      if (!ts10.isIdentifier(expr.left)) {
         continue;
       }
       const varName = expr.left.text;
       const rightSide = expr.right;
-      if (ts9.isCallExpression(rightSide)) {
+      if (ts10.isCallExpression(rightSide)) {
         const opInfo = extractChainedOperation(rightSide);
         if (opInfo) {
           if (opInfo.operation === "selectFromEntity" || opInfo.operation === "selectFrom") {
@@ -1729,14 +1961,14 @@ function analyzeWithVariableTracking(body, checker, options) {
   };
 }
 function extractChainedOperation(callExpr) {
-  if (ts9.isIdentifier(callExpr.expression)) {
+  if (ts10.isIdentifier(callExpr.expression)) {
     const methodName2 = callExpr.expression.text;
     if (methodName2 === "selectFromEntity" || methodName2 === "selectFrom") {
       const entityArg = callExpr.arguments[0];
       let entityName = null;
-      if (ts9.isIdentifier(entityArg)) {
+      if (ts10.isIdentifier(entityArg)) {
         entityName = entityArg.text;
-      } else if (ts9.isPropertyAccessExpression(entityArg)) {
+      } else if (ts10.isPropertyAccessExpression(entityArg)) {
         entityName = entityArg.name.text;
       }
       return {
@@ -1747,7 +1979,7 @@ function extractChainedOperation(callExpr) {
       };
     }
   }
-  if (!ts9.isPropertyAccessExpression(callExpr.expression)) {
+  if (!ts10.isPropertyAccessExpression(callExpr.expression)) {
     return null;
   }
   const propAccess = callExpr.expression;
@@ -1755,7 +1987,7 @@ function extractChainedOperation(callExpr) {
   if (methodName === "select") {
     const fields = [];
     for (const arg of callExpr.arguments) {
-      if (ts9.isStringLiteral(arg)) {
+      if (ts10.isStringLiteral(arg)) {
         fields.push(arg.text);
       }
     }
@@ -1777,19 +2009,19 @@ function extractChainedOperation(callExpr) {
   return null;
 }
 function parseIncludeObjectLiteral(arg) {
-  if (!ts9.isObjectLiteralExpression(arg)) {
+  if (!ts10.isObjectLiteralExpression(arg)) {
     return null;
   }
   const includes = {};
   for (const prop of arg.properties) {
-    if (!ts9.isPropertyAssignment(prop) || !ts9.isIdentifier(prop.name)) {
+    if (!ts10.isPropertyAssignment(prop) || !ts10.isIdentifier(prop.name)) {
       continue;
     }
     const relationName = prop.name.text;
     const value = prop.initializer;
-    if (value.kind === ts9.SyntaxKind.TrueKeyword) {
+    if (value.kind === ts10.SyntaxKind.TrueKeyword) {
       includes[relationName] = true;
-    } else if (ts9.isObjectLiteralExpression(value)) {
+    } else if (ts10.isObjectLiteralExpression(value)) {
       const nestedSchema = parseNestedInclude(value, 0);
       if (nestedSchema) {
         includes[relationName] = nestedSchema;
@@ -1802,18 +2034,18 @@ function parseNestedInclude(obj, depth) {
   const selectedFields = [];
   const includes = {};
   for (const prop of obj.properties) {
-    if (!ts9.isPropertyAssignment(prop) || !ts9.isIdentifier(prop.name)) {
+    if (!ts10.isPropertyAssignment(prop) || !ts10.isIdentifier(prop.name)) {
       continue;
     }
     const propName = prop.name.text;
     const value = prop.initializer;
-    if (propName === "select" && ts9.isArrayLiteralExpression(value)) {
+    if (propName === "select" && ts10.isArrayLiteralExpression(value)) {
       for (const element of value.elements) {
-        if (ts9.isStringLiteral(element)) {
+        if (ts10.isStringLiteral(element)) {
           selectedFields.push(element.text);
         }
       }
-    } else if (propName === "include" && ts9.isObjectLiteralExpression(value)) {
+    } else if (propName === "include" && ts10.isObjectLiteralExpression(value)) {
       const nestedIncludes = parseIncludeObjectLiteral(value);
       if (nestedIncludes) {
         for (const [relName, relSchema] of Object.entries(nestedIncludes)) {
@@ -1830,10 +2062,10 @@ function parseNestedInclude(obj, depth) {
   };
 }
 function getMethodName(expression) {
-  if (ts9.isIdentifier(expression)) {
+  if (ts10.isIdentifier(expression)) {
     return expression.text;
   }
-  if (ts9.isPropertyAccessExpression(expression)) {
+  if (ts10.isPropertyAccessExpression(expression)) {
     return expression.name.text;
   }
   return null;
@@ -1841,7 +2073,7 @@ function getMethodName(expression) {
 function findReturnStatement(body) {
   let returnStatement = null;
   for (const statement of body.statements) {
-    if (ts9.isReturnStatement(statement)) {
+    if (ts10.isReturnStatement(statement)) {
       if (returnStatement !== null) {
         return null;
       }
@@ -1854,20 +2086,20 @@ function analyzeReturnExpression(expression) {
   if (!expression) {
     return null;
   }
-  if (ts9.isCallExpression(expression)) {
+  if (ts10.isCallExpression(expression)) {
     return buildCallChain(expression, null);
   }
   return null;
 }
 function buildCallChain(node, parent) {
-  if (ts9.isCallExpression(node)) {
+  if (ts10.isCallExpression(node)) {
     const callNode = {
       expression: node.expression,
       methodName: getMethodName(node.expression),
       arguments: node.arguments,
       parent
     };
-    if (ts9.isPropertyAccessExpression(node.expression)) {
+    if (ts10.isPropertyAccessExpression(node.expression)) {
       return buildCallChain(node.expression.expression, callNode);
     }
     return callNode;
@@ -1894,7 +2126,7 @@ function parseQueryBuilderChain(chain, checker, options) {
     const methodName = currentNode.methodName;
     if (methodName === "select") {
       for (const arg of currentNode.arguments) {
-        if (ts9.isStringLiteral(arg)) {
+        if (ts10.isStringLiteral(arg)) {
           selectedFields.add(arg.text);
         }
       }
@@ -1929,10 +2161,10 @@ function extractEntityName(callNode, checker) {
     return null;
   }
   const entityArg = callNode.arguments[0];
-  if (ts9.isIdentifier(entityArg)) {
+  if (ts10.isIdentifier(entityArg)) {
     return entityArg.text;
   }
-  if (ts9.isPropertyAccessExpression(entityArg)) {
+  if (ts10.isPropertyAccessExpression(entityArg)) {
     return entityArg.name.text;
   }
   return null;
@@ -1941,16 +2173,16 @@ function parseIncludeArgument(arg, includes, checker, options, depth) {
   if (!arg) {
     return;
   }
-  if (ts9.isObjectLiteralExpression(arg)) {
+  if (ts10.isObjectLiteralExpression(arg)) {
     for (const prop of arg.properties) {
-      if (!ts9.isPropertyAssignment(prop) || !ts9.isIdentifier(prop.name)) {
+      if (!ts10.isPropertyAssignment(prop) || !ts10.isIdentifier(prop.name)) {
         continue;
       }
       const relationName = prop.name.text;
       const value = prop.initializer;
-      if (value.kind === ts9.SyntaxKind.TrueKeyword) {
+      if (value.kind === ts10.SyntaxKind.TrueKeyword) {
         includes[relationName] = true;
-      } else if (ts9.isObjectLiteralExpression(value)) {
+      } else if (ts10.isObjectLiteralExpression(value)) {
         const maxDepth = options.maxDepth ?? 5;
         if (depth < maxDepth) {
           const nestedSchema = parseNestedInclude(value, depth + 1);
@@ -1993,7 +2225,12 @@ function generateOpenAPI(controllers, checker, options = {}) {
     mode: "response"
   };
   const paths = {};
-  const { onProgress } = options;
+  const { onProgress, onQueryBuilderProgress } = options;
+  let totalOperations = 0;
+  for (const controller of controllers) {
+    totalOperations += controller.operations.length;
+  }
+  let currentOperation = 0;
   for (let i = 0; i < controllers.length; i++) {
     const controller = controllers[i];
     if (onProgress) {
@@ -2005,6 +2242,34 @@ function generateOpenAPI(controllers, checker, options = {}) {
         paths[fullPath] = {};
       }
       const method = operation.httpMethod.toLowerCase();
+      const analysisResult = analyzeQueryBuilderWithServiceCalls(
+        operation.methodDeclaration,
+        checker,
+        null,
+        // TODO: Pass program when available
+        {},
+        {
+          methodName: operation.operationId,
+          httpMethod: operation.httpMethod,
+          path: operation.path,
+          operationId: operation.operationId
+        }
+      );
+      if (onQueryBuilderProgress) {
+        currentOperation++;
+        onQueryBuilderProgress({
+          controller: controller.className,
+          operation: operation.operationId,
+          method: operation.httpMethod,
+          path: operation.path,
+          queryBuilderDetected: analysisResult.detected,
+          entityName: analysisResult.schema?.entityName,
+          selectedFields: analysisResult.schema?.selectedFields,
+          isPaged: analysisResult.schema?.isPaged,
+          current: currentOperation,
+          total: totalOperations
+        });
+      }
       paths[fullPath][method] = buildOperation(operation, ctx, controller.consumes);
     }
   }
@@ -2284,12 +2549,12 @@ function mergeBodySchemaAnnotations(bodyParam, ctx, schema) {
   const declarations = typeSymbol.getDeclarations();
   if (!declarations || declarations.length === 0) return schema;
   const classDecl = declarations[0];
-  if (!ts11.isClassDeclaration(classDecl)) return schema;
+  if (!ts12.isClassDeclaration(classDecl)) return schema;
   const result = { ...schema };
   const props = { ...result.properties };
   for (const member of classDecl.members) {
-    if (!ts11.isPropertyDeclaration(member) || !member.name) continue;
-    const propName = ts11.isIdentifier(member.name) ? member.name.text : null;
+    if (!ts12.isPropertyDeclaration(member) || !member.name) continue;
+    const propName = ts12.isIdentifier(member.name) ? member.name.text : null;
     if (!propName) continue;
     if (!props[propName]) continue;
     const frags = extractPropertySchemaFragments(ctx.checker, member);
@@ -2302,7 +2567,7 @@ function mergeBodySchemaAnnotations(bodyParam, ctx, schema) {
 }
 
 // src/compiler/manifest/emit.ts
-import ts12 from "typescript";
+import ts13 from "typescript";
 function generateManifest(controllers, checker, version, validationMode = "ajv-runtime") {
   const components = /* @__PURE__ */ new Map();
   const ctx = {
@@ -2324,7 +2589,7 @@ function generateManifest(controllers, checker, version, validationMode = "ajv-r
     generator: {
       name: "adorn-api",
       version,
-      typescript: ts12.version
+      typescript: ts13.version
     },
     schemas: {
       kind: "openapi-3.1",
@@ -2809,7 +3074,7 @@ async function isStale(params) {
 // src/compiler/cache/writeCache.ts
 import fs3 from "fs";
 import path3 from "path";
-import ts13 from "typescript";
+import ts14 from "typescript";
 function statMtimeMs2(p) {
   return fs3.statSync(p).mtimeMs;
 }
@@ -2842,7 +3107,7 @@ function writeCache(params) {
     generator: {
       name: "adorn-api",
       version: params.adornVersion,
-      typescript: ts13.version
+      typescript: ts14.version
     },
     project: {
       tsconfigPath: params.tsconfigAbs,
@@ -3004,6 +3269,8 @@ var Spinner = class {
   current = 0;
   total = 0;
   customStatus;
+  frameIndex = 0;
+  lastLineLength = 0;
   constructor(message = "") {
     this.message = message;
   }
@@ -3011,9 +3278,8 @@ var Spinner = class {
    * Start the spinner.
    */
   start() {
-    let frameIndex = 0;
     this.interval = setInterval(() => {
-      const frame = this.frames[frameIndex];
+      const frame = this.frames[this.frameIndex];
       let output;
       if (this.customStatus) {
         output = `\r${frame} ${this.customStatus}`;
@@ -3022,11 +3288,12 @@ var Spinner = class {
       } else {
         output = `\r${frame} ${this.message}`;
       }
+      this.lastLineLength = output.length - 1;
       process.stdout.write(output);
       if (process.stdout.writable) {
         process.stdout.write("");
       }
-      frameIndex = (frameIndex + 1) % this.frames.length;
+      this.frameIndex = (this.frameIndex + 1) % this.frames.length;
     }, 80);
   }
   /**
@@ -3041,8 +3308,12 @@ var Spinner = class {
    */
   setStatus(status) {
     this.customStatus = status;
-    const frame = this.frames[this.current];
-    process.stdout.write(`\r${frame} ${status}`);
+    const frame = this.frames[this.frameIndex];
+    const output = `\r${frame} ${status}`;
+    const clearLength = Math.max(this.lastLineLength, output.length - 1);
+    process.stdout.write("\r" + " ".repeat(clearLength) + "\r");
+    this.lastLineLength = output.length - 1;
+    process.stdout.write(output);
     if (process.stdout.writable) {
       process.stdout.write("");
     }
@@ -3061,7 +3332,7 @@ var Spinner = class {
       clearInterval(this.interval);
       this.interval = void 0;
     }
-    process.stdout.write("\r" + " ".repeat(60) + "\r");
+    process.stdout.write("\r" + " ".repeat(this.lastLineLength) + "\r");
     if (completedMessage) {
       process.stdout.write(completedMessage + "\n");
     }
@@ -3595,7 +3866,7 @@ function getEdgesByRelation(graph, relation) {
 }
 
 // src/compiler/graph/builder.ts
-import ts14 from "typescript";
+import ts15 from "typescript";
 
 // src/compiler/graph/schemaGraph.ts
 var SchemaGraph = class {
@@ -3847,7 +4118,7 @@ var SchemaGraph = class {
 };
 
 // src/cli.ts
-import ts15 from "typescript";
+import ts16 from "typescript";
 import process2 from "process";
 var ADORN_VERSION = (() => {
   const tryReadPackageJson = (filePath) => {
@@ -3925,7 +4196,7 @@ function sanitizeForJson(obj) {
   return result;
 }
 function buildControllerGraph(controllers) {
-  const graph = createGraph(ts15.version);
+  const graph = createGraph(ts16.version);
   const nodeMap = /* @__PURE__ */ new Map();
   for (const ctrl of controllers) {
     const nodeId = `Controller:${ctrl.className}`;
@@ -4017,6 +4288,7 @@ async function buildCommand(args) {
   const verbose = args.includes("--verbose");
   const quiet = args.includes("--quiet");
   const split = args.includes("--split");
+  const showQueryBuilder = args.includes("--show-query-builder");
   const splitStrategyIndex = args.indexOf("--split-strategy");
   const splitStrategy = splitStrategyIndex !== -1 ? args[splitStrategyIndex + 1] : void 0;
   const splitThresholdIndex = args.indexOf("--split-threshold");
@@ -4036,7 +4308,7 @@ async function buildCommand(args) {
       outDir: outputDir,
       project: projectPath,
       adornVersion: ADORN_VERSION,
-      typescriptVersion: ts15.version
+      typescriptVersion: ts16.version
     });
     if (!stale.stale) {
       progress.completePhase("staleness-check");
@@ -4077,6 +4349,12 @@ async function buildCommand(args) {
     }
   }
   progress.startPhase("openapi", "Generating OpenAPI schema");
+  const queryBuilderStats = {
+    totalOperations,
+    detected: 0,
+    fallback: 0,
+    operations: []
+  };
   const openapiSpinner = new Spinner("Processing schemas");
   if (!quiet) openapiSpinner.start();
   const openapi = generateOpenAPI(controllers, checker, {
@@ -4086,6 +4364,31 @@ async function buildCommand(args) {
       if (!quiet) {
         openapiSpinner.setStatus(`${message} (${current}/${total})`);
       }
+    },
+    onQueryBuilderProgress: (info) => {
+      if (info.queryBuilderDetected) {
+        queryBuilderStats.detected++;
+      } else {
+        queryBuilderStats.fallback++;
+      }
+      queryBuilderStats.operations.push({
+        operationId: info.operation,
+        method: info.method,
+        path: info.path,
+        detected: info.queryBuilderDetected,
+        entityName: info.entityName,
+        selectedFields: info.selectedFields,
+        isPaged: info.isPaged
+      });
+      if (showQueryBuilder || verbose) {
+        if (info.queryBuilderDetected) {
+          const fieldsStr = info.selectedFields && info.selectedFields.length > 0 ? ` [select: ${info.selectedFields.join(",")}]` : "";
+          const pagedStr = info.isPaged ? " (paged)" : "";
+          progress.verboseLog(`  \u2713 Query builder: ${info.method} ${info.path} \u2192 ${info.entityName}${fieldsStr}${pagedStr}`);
+        } else {
+          progress.verboseLog(`  \u25CB No query builder: ${info.method} ${info.path} \u2192 using full entity schema`);
+        }
+      }
     }
   });
   if (!quiet) {
@@ -4144,6 +4447,17 @@ async function buildCommand(args) {
     }
   }
   progress.completePhase("openapi", `Generated ${schemaCount} schema(s)${splitEnabled ? " (split into groups)" : ""}`);
+  if (showQueryBuilder && totalOperations > 0) {
+    log("");
+    log("Query Builder Analysis:");
+    log(`  Operations analyzed:    ${totalOperations}`);
+    log(`  Patterns detected:      ${queryBuilderStats.detected} (${Math.round(queryBuilderStats.detected / totalOperations * 100)}%)`);
+    log(`  Full schemas used:      ${queryBuilderStats.fallback} (${Math.round(queryBuilderStats.fallback / totalOperations * 100)}%)`);
+    if (queryBuilderStats.detected > 0) {
+      const totalFields = queryBuilderStats.operations.filter((op) => op.detected && op.selectedFields).reduce((sum, op) => sum + (op.selectedFields?.length || 0), 0);
+      log(`  Fields selected:        ${totalFields} total (avg ${Math.round(totalFields / queryBuilderStats.detected)} per query)`);
+    }
+  }
   progress.startPhase("manifest", "Generating manifest");
   const manifest = generateManifest(controllers, checker, ADORN_VERSION, validationMode);
   progress.completePhase("manifest");
@@ -4225,7 +4539,12 @@ async function buildCommand(args) {
     schemas: schemaCount,
     sourceFiles: projectSourceFiles.length,
     artifactsWritten: artifacts.map((a) => a.name),
-    splitEnabled
+    splitEnabled,
+    queryBuilder: {
+      detected: queryBuilderStats.detected,
+      fallback: queryBuilderStats.fallback,
+      total: totalOperations
+    }
   };
   progress.printSummary(stats);
   progress.printArtifacts(artifacts);
@@ -4253,30 +4572,32 @@ if (command === "build") {
   console.log(`
 adorn-api CLI v${ADORN_VERSION}
 
-Commands:
-  build     Generate OpenAPI and manifest from TypeScript source
-  clean     Remove generated artifacts
+ Commands:
+   build     Generate OpenAPI and manifest from TypeScript source
+   clean     Remove generated artifacts
 
- Options:
-  -p <path>                Path to tsconfig.json (default: ./tsconfig.json)
-  --output <dir>           Output directory (default: .adorn)
-  --if-stale               Only rebuild if artifacts are stale
-  --validation-mode <mode> Validation mode: none, ajv-runtime, precompiled (default: ajv-runtime)
-  --split                  Enable automatic schema splitting (default: disabled)
-  --split-strategy <mode>  Override splitting strategy: controller, dependency, size, auto (default: auto)
-  --split-threshold <num>  Schema count threshold for auto-split (default: 50)
-  --verbose                Show detailed progress information
-  --quiet                  Suppress non-essential output
+  Options:
+   -p <path>                Path to tsconfig.json (default: ./tsconfig.json)
+   --output <dir>           Output directory (default: .adorn)
+   --if-stale               Only rebuild if artifacts are stale
+   --validation-mode <mode> Validation mode: none, ajv-runtime, precompiled (default: ajv-runtime)
+   --split                  Enable automatic schema splitting (default: disabled)
+   --split-strategy <mode>  Override splitting strategy: controller, dependency, size, auto (default: auto)
+   --split-threshold <num>  Schema count threshold for auto-split (default: 50)
+   --verbose                Show detailed progress information
+   --quiet                  Suppress non-essential output
+   --show-query-builder     Show query builder inspection details and statistics
 
-Examples:
-  adorn-api build -p ./tsconfig.json --output .adorn
-  adorn-api build --if-stale
-  adorn-api build --validation-mode precompiled
-  adorn-api build --verbose
-  adorn-api build --split                 # Enable split mode
-  adorn-api build --split-strategy controller  # Force controller-based splitting
-  adorn-api build --split-threshold 100   # Increase threshold to 100
-  adorn-api clean
-  `);
+ Examples:
+   adorn-api build -p ./tsconfig.json --output .adorn
+   adorn-api build --if-stale
+   adorn-api build --validation-mode precompiled
+   adorn-api build --verbose
+   adorn-api build --show-query-builder  # Show query builder analysis details
+   adorn-api build --split                 # Enable split mode
+   adorn-api build --split-strategy controller  # Force controller-based splitting
+   adorn-api build --split-threshold 100   # Increase threshold to 100
+   adorn-api clean
+   `);
 }
 //# sourceMappingURL=cli.js.map