adorn-api 1.0.20 → 1.0.22

package/dist/cli.js

@@ -306,7 +306,7 @@ function unwrapPromiseTypeNode(typeNode) {
 }
 
 // src/compiler/schema/openapi.ts
-import ts9 from "typescript";
+import ts11 from "typescript";
 
 // src/compiler/schema/typeToJsonSchema.ts
 import ts7 from "typescript";
@@ -701,6 +701,48 @@ function getExplicitTypeNameFromNode3(typeNode) {
 
 // src/compiler/schema/objectHandler.ts
 import ts6 from "typescript";
+function getTypeParameterName(type) {
+  if (type.flags & ts6.TypeFlags.TypeParameter) {
+    const typeParam = type;
+    return typeParam.symbol?.getName() ?? null;
+  }
+  return null;
+}
+function getTypeArguments(type) {
+  const typeRef = type;
+  const args = typeRef.typeArguments;
+  if (!args) return void 0;
+  return Array.from(args);
+}
+function createTypeParameterSubstitutions(type, typeNode, checker) {
+  const typeArgs = getTypeArguments(type);
+  if (!typeArgs || typeArgs.length === 0) {
+    return void 0;
+  }
+  if (!typeNode || !ts6.isTypeReferenceNode(typeNode)) {
+    return void 0;
+  }
+  const typeParams = typeNode.typeArguments;
+  if (!typeParams || typeParams.length !== typeArgs.length) {
+    return void 0;
+  }
+  const substitutions = /* @__PURE__ */ new Map();
+  for (let i = 0; i < typeParams.length; i++) {
+    const typeParamNode = typeParams[i];
+    const typeArg = typeArgs[i];
+    if (ts6.isIdentifier(typeParamNode)) {
+      substitutions.set(typeParamNode.text, typeArg);
+    }
+  }
+  return substitutions.size > 0 ? substitutions : void 0;
+}
+function resolveTypeParameter(type, substitutions, _checker) {
+  if (!substitutions) return null;
+  const paramName = getTypeParameterName(type);
+  if (!paramName) return null;
+  const resolved = substitutions.get(paramName);
+  return resolved ?? null;
+}
 function handleObjectType(type, ctx, typeNode) {
   const { checker, components, typeStack } = ctx;
   const symbol = type.getSymbol();
@@ -720,7 +762,9 @@ function handleObjectType(type, ctx, typeNode) {
     }
     typeStack.add(type);
   }
-  const schema = buildObjectSchema(type, ctx, typeNode);
+  const typeParamSubstitutions = createTypeParameterSubstitutions(type, typeNode, checker);
+  const buildCtx = typeParamSubstitutions ? { ...ctx, typeParameterSubstitutions: typeParamSubstitutions } : ctx;
+  const schema = buildObjectSchema(type, buildCtx, typeNode);
   if (typeName && typeName !== "__type") {
     typeStack.delete(type);
     const existing = components.get(typeName);
@@ -738,7 +782,7 @@ function handleObjectType(type, ctx, typeNode) {
   return schema;
 }
 function buildObjectSchema(type, ctx, _typeNode) {
-  const { checker, mode } = ctx;
+  const { checker, mode, typeParameterSubstitutions } = ctx;
   const properties = {};
   const required = [];
   const props = checker.getPropertiesOfType(type);
@@ -747,10 +791,14 @@ function buildObjectSchema(type, ctx, _typeNode) {
     if (isIteratorOrSymbolProperty(propName)) {
       continue;
     }
-    const propType = checker.getTypeOfSymbol(prop);
+    let propType = checker.getTypeOfSymbol(prop);
     if (isMethodLike(propType)) {
       continue;
     }
+    const resolvedType = resolveTypeParameter(propType, typeParameterSubstitutions, checker);
+    if (resolvedType) {
+      propType = resolvedType;
+    }
     const isOptional = !!(prop.flags & ts6.SymbolFlags.Optional);
     const isRelation = isMetalOrmWrapperType(propType, checker);
     const propCtx = { ...ctx, propertyName: propName };
@@ -770,7 +818,8 @@ function buildObjectSchema(type, ctx, _typeNode) {
   if (isRecordType(type, checker)) {
     const valueType = getRecordValueType(type, checker);
     if (valueType) {
-      schema.additionalProperties = typeToJsonSchema(valueType, ctx);
+      const resolvedValueType = resolveTypeParameter(valueType, typeParameterSubstitutions, checker);
+      schema.additionalProperties = typeToJsonSchema(resolvedValueType ?? valueType, ctx);
     }
   }
   return schema;
@@ -1562,6 +1611,384 @@ function resolveAndCollectObjectProps(schema, components) {
   return { properties, required };
 }
 
+// src/compiler/schema/queryBuilderAnalyzer.ts
+import ts9 from "typescript";
+function analyzeQueryBuilderForSchema(methodDeclaration, checker, options = {}) {
+  const body = methodDeclaration.body;
+  if (!body) {
+    return null;
+  }
+  const trackedSchema = analyzeWithVariableTracking(body, checker, options);
+  if (trackedSchema) {
+    return trackedSchema;
+  }
+  const returnStatement = findReturnStatement(body);
+  if (!returnStatement) {
+    return null;
+  }
+  const callChain = analyzeReturnExpression(returnStatement.expression);
+  if (!callChain) {
+    return null;
+  }
+  return parseQueryBuilderChain(callChain, checker, options);
+}
+function analyzeQueryBuilderWithDetails(methodDeclaration, checker, options = {}, operationInfo) {
+  const schema = analyzeQueryBuilderForSchema(methodDeclaration, checker, options);
+  return {
+    detected: schema !== null,
+    schema,
+    ...operationInfo
+  };
+}
+function analyzeWithVariableTracking(body, checker, options) {
+  let queryBuilderVar = null;
+  let entityName = null;
+  const selectedFields = /* @__PURE__ */ new Set();
+  const includes = {};
+  let isPaged = false;
+  let hasReturn = false;
+  for (const statement of body.statements) {
+    if (ts9.isReturnStatement(statement)) {
+      hasReturn = true;
+      const returnExpr = statement.expression;
+      if (returnExpr && ts9.isCallExpression(returnExpr)) {
+        const callExpr = returnExpr;
+        if (ts9.isIdentifier(callExpr.expression) && queryBuilderVar) {
+          const varName = callExpr.expression.text;
+          if (varName === queryBuilderVar) {
+            const methodName = callExpr.expression.text;
+            if (methodName === "executePaged") {
+              isPaged = true;
+            }
+          }
+        }
+        if (ts9.isPropertyAccessExpression(callExpr.expression) && queryBuilderVar) {
+          const propAccess = callExpr.expression;
+          if (ts9.isIdentifier(propAccess.expression) && propAccess.expression.text === queryBuilderVar) {
+            const methodName = propAccess.name.text;
+            if (methodName === "executePaged") {
+              isPaged = true;
+            }
+          }
+        }
+      }
+      continue;
+    }
+    if (!ts9.isExpressionStatement(statement)) {
+      if (ts9.isVariableStatement(statement)) {
+        for (const declaration of statement.declarationList.declarations) {
+          if (!ts9.isIdentifier(declaration.name)) continue;
+          const varName = declaration.name.text;
+          const initializer = declaration.initializer;
+          if (!initializer || !ts9.isCallExpression(initializer)) continue;
+          const opInfo = extractChainedOperation(initializer);
+          if (opInfo && (opInfo.operation === "selectFromEntity" || opInfo.operation === "selectFrom")) {
+            queryBuilderVar = varName;
+            if (opInfo.entityName) {
+              entityName = opInfo.entityName;
+            }
+          }
+        }
+      }
+      continue;
+    }
+    const expr = statement.expression;
+    if (ts9.isBinaryExpression(expr) && expr.operatorToken.kind === ts9.SyntaxKind.EqualsToken) {
+      if (!ts9.isIdentifier(expr.left)) {
+        continue;
+      }
+      const varName = expr.left.text;
+      const rightSide = expr.right;
+      if (ts9.isCallExpression(rightSide)) {
+        const opInfo = extractChainedOperation(rightSide);
+        if (opInfo) {
+          if (opInfo.operation === "selectFromEntity" || opInfo.operation === "selectFrom") {
+            queryBuilderVar = varName;
+            if (opInfo.entityName) {
+              entityName = opInfo.entityName;
+            }
+          }
+          if ((opInfo.operation === "select" || opInfo.operation === "include") && queryBuilderVar === varName) {
+            if (opInfo.operation === "select") {
+              for (const field of opInfo.fields || []) {
+                selectedFields.add(field);
+              }
+            } else if (opInfo.operation === "include" && opInfo.includeArg) {
+              const parsedIncludes = parseIncludeObjectLiteral(opInfo.includeArg);
+              if (parsedIncludes) {
+                for (const [relName, relSchema] of Object.entries(parsedIncludes)) {
+                  includes[relName] = relSchema;
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  if (!hasReturn || !queryBuilderVar || !entityName) {
+    return null;
+  }
+  return {
+    entityName,
+    selectedFields: Array.from(selectedFields),
+    includes,
+    isPaged
+  };
+}
+function extractChainedOperation(callExpr) {
+  if (ts9.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)) {
+        entityName = entityArg.text;
+      } else if (ts9.isPropertyAccessExpression(entityArg)) {
+        entityName = entityArg.name.text;
+      }
+      return {
+        operation: methodName2 === "selectFromEntity" ? "selectFromEntity" : "selectFrom",
+        fields: null,
+        includeArg: null,
+        entityName
+      };
+    }
+  }
+  if (!ts9.isPropertyAccessExpression(callExpr.expression)) {
+    return null;
+  }
+  const propAccess = callExpr.expression;
+  const methodName = propAccess.name.text;
+  if (methodName === "select") {
+    const fields = [];
+    for (const arg of callExpr.arguments) {
+      if (ts9.isStringLiteral(arg)) {
+        fields.push(arg.text);
+      }
+    }
+    return {
+      operation: "select",
+      fields,
+      includeArg: null,
+      entityName: null
+    };
+  }
+  if (methodName === "include") {
+    return {
+      operation: "include",
+      fields: null,
+      includeArg: callExpr.arguments[0] || null,
+      entityName: null
+    };
+  }
+  return null;
+}
+function parseIncludeObjectLiteral(arg) {
+  if (!ts9.isObjectLiteralExpression(arg)) {
+    return null;
+  }
+  const includes = {};
+  for (const prop of arg.properties) {
+    if (!ts9.isPropertyAssignment(prop) || !ts9.isIdentifier(prop.name)) {
+      continue;
+    }
+    const relationName = prop.name.text;
+    const value = prop.initializer;
+    if (value.kind === ts9.SyntaxKind.TrueKeyword) {
+      includes[relationName] = true;
+    } else if (ts9.isObjectLiteralExpression(value)) {
+      const nestedSchema = parseNestedInclude(value, 0);
+      if (nestedSchema) {
+        includes[relationName] = nestedSchema;
+      }
+    }
+  }
+  return includes;
+}
+function parseNestedInclude(obj, depth) {
+  const selectedFields = [];
+  const includes = {};
+  for (const prop of obj.properties) {
+    if (!ts9.isPropertyAssignment(prop) || !ts9.isIdentifier(prop.name)) {
+      continue;
+    }
+    const propName = prop.name.text;
+    const value = prop.initializer;
+    if (propName === "select" && ts9.isArrayLiteralExpression(value)) {
+      for (const element of value.elements) {
+        if (ts9.isStringLiteral(element)) {
+          selectedFields.push(element.text);
+        }
+      }
+    } else if (propName === "include" && ts9.isObjectLiteralExpression(value)) {
+      const nestedIncludes = parseIncludeObjectLiteral(value);
+      if (nestedIncludes) {
+        for (const [relName, relSchema] of Object.entries(nestedIncludes)) {
+          includes[relName] = relSchema;
+        }
+      }
+    }
+  }
+  return {
+    entityName: "",
+    selectedFields,
+    includes,
+    isPaged: false
+  };
+}
+function getMethodName(expression) {
+  if (ts9.isIdentifier(expression)) {
+    return expression.text;
+  }
+  if (ts9.isPropertyAccessExpression(expression)) {
+    return expression.name.text;
+  }
+  return null;
+}
+function findReturnStatement(body) {
+  let returnStatement = null;
+  for (const statement of body.statements) {
+    if (ts9.isReturnStatement(statement)) {
+      if (returnStatement !== null) {
+        return null;
+      }
+      returnStatement = statement;
+    }
+  }
+  return returnStatement;
+}
+function analyzeReturnExpression(expression) {
+  if (!expression) {
+    return null;
+  }
+  if (ts9.isCallExpression(expression)) {
+    return buildCallChain(expression, null);
+  }
+  return null;
+}
+function buildCallChain(node, parent) {
+  if (ts9.isCallExpression(node)) {
+    const callNode = {
+      expression: node.expression,
+      methodName: getMethodName(node.expression),
+      arguments: node.arguments,
+      parent
+    };
+    if (ts9.isPropertyAccessExpression(node.expression)) {
+      return buildCallChain(node.expression.expression, callNode);
+    }
+    return callNode;
+  }
+  return parent;
+}
+function parseQueryBuilderChain(chain, checker, options) {
+  if (!chain) {
+    return null;
+  }
+  const rootNode = findSelectFromEntityCall(chain);
+  if (!rootNode) {
+    return null;
+  }
+  const entityName = extractEntityName(rootNode, checker);
+  if (!entityName) {
+    return null;
+  }
+  const selectedFields = /* @__PURE__ */ new Set();
+  const includes = {};
+  let isPaged = false;
+  let currentNode = chain;
+  while (currentNode) {
+    const methodName = currentNode.methodName;
+    if (methodName === "select") {
+      for (const arg of currentNode.arguments) {
+        if (ts9.isStringLiteral(arg)) {
+          selectedFields.add(arg.text);
+        }
+      }
+    } else if (methodName === "include") {
+      parseIncludeArgument(currentNode.arguments[0], includes, checker, options, 0);
+    } else if (methodName === "executePaged") {
+      isPaged = true;
+    }
+    currentNode = currentNode.parent;
+  }
+  return {
+    entityName,
+    selectedFields: Array.from(selectedFields),
+    includes,
+    isPaged
+  };
+}
+function findSelectFromEntityCall(chain) {
+  let currentNode = chain;
+  let lastNode = null;
+  while (currentNode) {
+    if (currentNode.methodName === "selectFromEntity" || currentNode.methodName === "selectFrom") {
+      return currentNode;
+    }
+    lastNode = currentNode;
+    currentNode = currentNode.parent;
+  }
+  return lastNode;
+}
+function extractEntityName(callNode, checker) {
+  if (callNode.arguments.length === 0) {
+    return null;
+  }
+  const entityArg = callNode.arguments[0];
+  if (ts9.isIdentifier(entityArg)) {
+    return entityArg.text;
+  }
+  if (ts9.isPropertyAccessExpression(entityArg)) {
+    return entityArg.name.text;
+  }
+  return null;
+}
+function parseIncludeArgument(arg, includes, checker, options, depth) {
+  if (!arg) {
+    return;
+  }
+  if (ts9.isObjectLiteralExpression(arg)) {
+    for (const prop of arg.properties) {
+      if (!ts9.isPropertyAssignment(prop) || !ts9.isIdentifier(prop.name)) {
+        continue;
+      }
+      const relationName = prop.name.text;
+      const value = prop.initializer;
+      if (value.kind === ts9.SyntaxKind.TrueKeyword) {
+        includes[relationName] = true;
+      } else if (ts9.isObjectLiteralExpression(value)) {
+        const maxDepth = options.maxDepth ?? 5;
+        if (depth < maxDepth) {
+          const nestedSchema = parseNestedInclude(value, depth + 1);
+          if (nestedSchema) {
+            includes[relationName] = nestedSchema;
+          }
+        }
+      }
+    }
+  }
+}
+
+// src/compiler/schema/queryBuilderSchemaBuilder.ts
+import "typescript";
+function wrapInPaginatedResult(schema) {
+  return {
+    type: "object",
+    properties: {
+      items: {
+        type: "array",
+        items: schema
+      },
+      page: { type: "integer" },
+      pageSize: { type: "integer" },
+      totalItems: { type: "integer" }
+    },
+    required: ["items", "page", "pageSize", "totalItems"]
+  };
+}
+
 // src/compiler/schema/openapi.ts
 var METAL_ORM_WRAPPER_NAMES2 = ["BelongsToReference", "HasOneReference", "HasManyCollection", "ManyToManyCollection"];
 function generateOpenAPI(controllers, checker, options = {}) {
@@ -1574,7 +2001,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) {
@@ -1586,6 +2018,32 @@ function generateOpenAPI(controllers, checker, options = {}) {
         paths[fullPath] = {};
       }
       const method = operation.httpMethod.toLowerCase();
+      const analysisResult = analyzeQueryBuilderWithDetails(
+        operation.methodDeclaration,
+        checker,
+        {},
+        {
+          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);
     }
   }
@@ -1716,6 +2174,88 @@ function convertToOpenApiPath(basePath, path4) {
   }
   return fullPath;
 }
+function tryInferQueryBuilderSchema(operation, checker) {
+  return analyzeQueryBuilderForSchema(operation.methodDeclaration, checker) ?? null;
+}
+function getEntityTypeFromReturnType(operation, checker) {
+  const returnType = operation.returnType;
+  const unwrapPromise2 = (type) => {
+    const symbol2 = type.getSymbol();
+    if (symbol2?.getName() === "Promise") {
+      const typeArgs = type.typeArguments;
+      if (typeArgs && typeArgs.length > 0) {
+        return typeArgs[0];
+      }
+    }
+    return type;
+  };
+  const innerType = unwrapPromise2(returnType);
+  const symbol = innerType.getSymbol();
+  if (symbol?.getName() === "PaginatedResult") {
+    const typeArgs = innerType.typeArguments;
+    if (typeArgs && typeArgs.length > 0) {
+      return typeArgs[0];
+    }
+  }
+  return null;
+}
+function filterSchemaByQueryBuilder(querySchema, operation, ctx) {
+  const entityType = getEntityTypeFromReturnType(operation, ctx.checker);
+  if (!entityType) {
+    return {};
+  }
+  const entitySchema = typeToJsonSchema(entityType, ctx);
+  let baseSchema = entitySchema;
+  if (entitySchema.$ref && entitySchema.$ref.startsWith("#/components/schemas/")) {
+    const schemaName = entitySchema.$ref.replace("#/components/schemas/", "");
+    const componentSchema = ctx.components.get(schemaName);
+    if (componentSchema) {
+      baseSchema = componentSchema;
+    }
+  }
+  if (!baseSchema.properties || Object.keys(baseSchema.properties).length === 0) {
+    return {};
+  }
+  const filteredSchema = buildFilteredSchema(querySchema, baseSchema);
+  if (querySchema.isPaged) {
+    return wrapInPaginatedResult(filteredSchema);
+  }
+  return filteredSchema;
+}
+function buildFilteredSchema(querySchema, entitySchema) {
+  const properties = {};
+  const required = [];
+  for (const field of querySchema.selectedFields) {
+    if (entitySchema.properties?.[field]) {
+      properties[field] = entitySchema.properties[field];
+      if (entitySchema.required && entitySchema.required.includes(field)) {
+        required.push(field);
+      }
+    }
+  }
+  for (const [relationName, includeSpec] of Object.entries(querySchema.includes)) {
+    if (entitySchema.properties?.[relationName]) {
+      properties[relationName] = {
+        type: "object",
+        properties: {
+          id: { type: "integer" }
+        },
+        required: ["id"]
+      };
+      if (entitySchema.required && entitySchema.required.includes(relationName)) {
+        required.push(relationName);
+      }
+    }
+  }
+  const schema = {
+    type: "object",
+    properties
+  };
+  if (required.length > 0) {
+    schema.required = required;
+  }
+  return schema;
+}
 function buildOperation(operation, ctx, controllerConsumes) {
   const op = {
     operationId: operation.operationId,
@@ -1730,7 +2270,18 @@ function buildOperation(operation, ctx, controllerConsumes) {
     op.parameters = parameters;
   }
   const responseCtx = { ...ctx, mode: "response" };
-  const responseSchema = typeToJsonSchema(operation.returnType, responseCtx, operation.returnTypeNode);
+  let responseSchema;
+  const querySchema = tryInferQueryBuilderSchema(operation, ctx.checker);
+  if (querySchema) {
+    const entityType = getEntityTypeFromReturnType(operation, ctx.checker);
+    if (entityType) {
+      responseSchema = filterSchemaByQueryBuilder(querySchema, operation, responseCtx);
+    } else {
+      responseSchema = typeToJsonSchema(operation.returnType, responseCtx, operation.returnTypeNode);
+    }
+  } else {
+    responseSchema = typeToJsonSchema(operation.returnType, responseCtx, operation.returnTypeNode);
+  }
   const status = operation.httpMethod === "POST" ? 201 : 200;
   op.responses[status] = {
     description: status === 201 ? "Created" : "OK",
@@ -1772,12 +2323,12 @@ function mergeBodySchemaAnnotations(bodyParam, ctx, schema) {
   const declarations = typeSymbol.getDeclarations();
   if (!declarations || declarations.length === 0) return schema;
   const classDecl = declarations[0];
-  if (!ts9.isClassDeclaration(classDecl)) return schema;
+  if (!ts11.isClassDeclaration(classDecl)) return schema;
   const result = { ...schema };
   const props = { ...result.properties };
   for (const member of classDecl.members) {
-    if (!ts9.isPropertyDeclaration(member) || !member.name) continue;
-    const propName = ts9.isIdentifier(member.name) ? member.name.text : null;
+    if (!ts11.isPropertyDeclaration(member) || !member.name) continue;
+    const propName = ts11.isIdentifier(member.name) ? member.name.text : null;
     if (!propName) continue;
     if (!props[propName]) continue;
     const frags = extractPropertySchemaFragments(ctx.checker, member);
@@ -1790,7 +2341,7 @@ function mergeBodySchemaAnnotations(bodyParam, ctx, schema) {
 }
 
 // src/compiler/manifest/emit.ts
-import ts10 from "typescript";
+import ts12 from "typescript";
 function generateManifest(controllers, checker, version, validationMode = "ajv-runtime") {
   const components = /* @__PURE__ */ new Map();
   const ctx = {
@@ -1812,7 +2363,7 @@ function generateManifest(controllers, checker, version, validationMode = "ajv-r
     generator: {
       name: "adorn-api",
       version,
-      typescript: ts10.version
+      typescript: ts12.version
     },
     schemas: {
       kind: "openapi-3.1",
@@ -2297,7 +2848,7 @@ async function isStale(params) {
 // src/compiler/cache/writeCache.ts
 import fs3 from "fs";
 import path3 from "path";
-import ts11 from "typescript";
+import ts13 from "typescript";
 function statMtimeMs2(p) {
   return fs3.statSync(p).mtimeMs;
 }
@@ -2330,7 +2881,7 @@ function writeCache(params) {
     generator: {
       name: "adorn-api",
       version: params.adornVersion,
-      typescript: ts11.version
+      typescript: ts13.version
     },
     project: {
       tsconfigPath: params.tsconfigAbs,
@@ -3083,7 +3634,7 @@ function getEdgesByRelation(graph, relation) {
 }
 
 // src/compiler/graph/builder.ts
-import ts12 from "typescript";
+import ts14 from "typescript";
 
 // src/compiler/graph/schemaGraph.ts
 var SchemaGraph = class {
@@ -3335,7 +3886,7 @@ var SchemaGraph = class {
 };
 
 // src/cli.ts
-import ts13 from "typescript";
+import ts15 from "typescript";
 import process2 from "process";
 var ADORN_VERSION = (() => {
   const tryReadPackageJson = (filePath) => {
@@ -3413,7 +3964,7 @@ function sanitizeForJson(obj) {
   return result;
 }
 function buildControllerGraph(controllers) {
-  const graph = createGraph(ts13.version);
+  const graph = createGraph(ts15.version);
   const nodeMap = /* @__PURE__ */ new Map();
   for (const ctrl of controllers) {
     const nodeId = `Controller:${ctrl.className}`;
@@ -3505,6 +4056,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");
@@ -3524,7 +4076,7 @@ async function buildCommand(args) {
       outDir: outputDir,
       project: projectPath,
       adornVersion: ADORN_VERSION,
-      typescriptVersion: ts13.version
+      typescriptVersion: ts15.version
     });
     if (!stale.stale) {
       progress.completePhase("staleness-check");
@@ -3565,6 +4117,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, {
@@ -3574,6 +4132,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) {
@@ -3632,6 +4215,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");
@@ -3713,7 +4307,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);
@@ -3741,30 +4340,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