adorn-api 1.0.19 → 1.0.21

package/dist/cli.cjs

@@ -323,7 +323,7 @@ function unwrapPromiseTypeNode(typeNode) {
 }
 
 // src/compiler/schema/openapi.ts
-var import_typescript9 = __toESM(require("typescript"), 1);
+var import_typescript11 = __toESM(require("typescript"), 1);
 
 // src/compiler/schema/typeToJsonSchema.ts
 var import_typescript7 = __toESM(require("typescript"), 1);
@@ -718,6 +718,48 @@ function getExplicitTypeNameFromNode3(typeNode) {
 
 // src/compiler/schema/objectHandler.ts
 var import_typescript6 = __toESM(require("typescript"), 1);
+function getTypeParameterName(type) {
+  if (type.flags & import_typescript6.default.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 || !import_typescript6.default.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 (import_typescript6.default.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();
@@ -737,7 +779,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);
@@ -755,7 +799,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);
@@ -764,10 +808,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 & import_typescript6.default.SymbolFlags.Optional);
     const isRelation = isMetalOrmWrapperType(propType, checker);
     const propCtx = { ...ctx, propertyName: propName };
@@ -787,7 +835,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;
@@ -1579,6 +1628,376 @@ function resolveAndCollectObjectProps(schema, components) {
   return { properties, required };
 }
 
+// src/compiler/schema/queryBuilderAnalyzer.ts
+var import_typescript9 = __toESM(require("typescript"), 1);
+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 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 (import_typescript9.default.isReturnStatement(statement)) {
+      hasReturn = true;
+      const returnExpr = statement.expression;
+      if (returnExpr && import_typescript9.default.isCallExpression(returnExpr)) {
+        const callExpr = returnExpr;
+        if (import_typescript9.default.isIdentifier(callExpr.expression) && queryBuilderVar) {
+          const varName = callExpr.expression.text;
+          if (varName === queryBuilderVar) {
+            const methodName = callExpr.expression.text;
+            if (methodName === "executePaged") {
+              isPaged = true;
+            }
+          }
+        }
+        if (import_typescript9.default.isPropertyAccessExpression(callExpr.expression) && queryBuilderVar) {
+          const propAccess = callExpr.expression;
+          if (import_typescript9.default.isIdentifier(propAccess.expression) && propAccess.expression.text === queryBuilderVar) {
+            const methodName = propAccess.name.text;
+            if (methodName === "executePaged") {
+              isPaged = true;
+            }
+          }
+        }
+      }
+      continue;
+    }
+    if (!import_typescript9.default.isExpressionStatement(statement)) {
+      if (import_typescript9.default.isVariableStatement(statement)) {
+        for (const declaration of statement.declarationList.declarations) {
+          if (!import_typescript9.default.isIdentifier(declaration.name)) continue;
+          const varName = declaration.name.text;
+          const initializer = declaration.initializer;
+          if (!initializer || !import_typescript9.default.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 (import_typescript9.default.isBinaryExpression(expr) && expr.operatorToken.kind === import_typescript9.default.SyntaxKind.EqualsToken) {
+      if (!import_typescript9.default.isIdentifier(expr.left)) {
+        continue;
+      }
+      const varName = expr.left.text;
+      const rightSide = expr.right;
+      if (import_typescript9.default.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 (import_typescript9.default.isIdentifier(callExpr.expression)) {
+    const methodName2 = callExpr.expression.text;
+    if (methodName2 === "selectFromEntity" || methodName2 === "selectFrom") {
+      const entityArg = callExpr.arguments[0];
+      let entityName = null;
+      if (import_typescript9.default.isIdentifier(entityArg)) {
+        entityName = entityArg.text;
+      } else if (import_typescript9.default.isPropertyAccessExpression(entityArg)) {
+        entityName = entityArg.name.text;
+      }
+      return {
+        operation: methodName2 === "selectFromEntity" ? "selectFromEntity" : "selectFrom",
+        fields: null,
+        includeArg: null,
+        entityName
+      };
+    }
+  }
+  if (!import_typescript9.default.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 (import_typescript9.default.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 (!import_typescript9.default.isObjectLiteralExpression(arg)) {
+    return null;
+  }
+  const includes = {};
+  for (const prop of arg.properties) {
+    if (!import_typescript9.default.isPropertyAssignment(prop) || !import_typescript9.default.isIdentifier(prop.name)) {
+      continue;
+    }
+    const relationName = prop.name.text;
+    const value = prop.initializer;
+    if (value.kind === import_typescript9.default.SyntaxKind.TrueKeyword) {
+      includes[relationName] = true;
+    } else if (import_typescript9.default.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 (!import_typescript9.default.isPropertyAssignment(prop) || !import_typescript9.default.isIdentifier(prop.name)) {
+      continue;
+    }
+    const propName = prop.name.text;
+    const value = prop.initializer;
+    if (propName === "select" && import_typescript9.default.isArrayLiteralExpression(value)) {
+      for (const element of value.elements) {
+        if (import_typescript9.default.isStringLiteral(element)) {
+          selectedFields.push(element.text);
+        }
+      }
+    } else if (propName === "include" && import_typescript9.default.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 (import_typescript9.default.isIdentifier(expression)) {
+    return expression.text;
+  }
+  if (import_typescript9.default.isPropertyAccessExpression(expression)) {
+    return expression.name.text;
+  }
+  return null;
+}
+function findReturnStatement(body) {
+  let returnStatement = null;
+  for (const statement of body.statements) {
+    if (import_typescript9.default.isReturnStatement(statement)) {
+      if (returnStatement !== null) {
+        return null;
+      }
+      returnStatement = statement;
+    }
+  }
+  return returnStatement;
+}
+function analyzeReturnExpression(expression) {
+  if (!expression) {
+    return null;
+  }
+  if (import_typescript9.default.isCallExpression(expression)) {
+    return buildCallChain(expression, null);
+  }
+  return null;
+}
+function buildCallChain(node, parent) {
+  if (import_typescript9.default.isCallExpression(node)) {
+    const callNode = {
+      expression: node.expression,
+      methodName: getMethodName(node.expression),
+      arguments: node.arguments,
+      parent
+    };
+    if (import_typescript9.default.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 (import_typescript9.default.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 (import_typescript9.default.isIdentifier(entityArg)) {
+    return entityArg.text;
+  }
+  if (import_typescript9.default.isPropertyAccessExpression(entityArg)) {
+    return entityArg.name.text;
+  }
+  return null;
+}
+function parseIncludeArgument(arg, includes, checker, options, depth) {
+  if (!arg) {
+    return;
+  }
+  if (import_typescript9.default.isObjectLiteralExpression(arg)) {
+    for (const prop of arg.properties) {
+      if (!import_typescript9.default.isPropertyAssignment(prop) || !import_typescript9.default.isIdentifier(prop.name)) {
+        continue;
+      }
+      const relationName = prop.name.text;
+      const value = prop.initializer;
+      if (value.kind === import_typescript9.default.SyntaxKind.TrueKeyword) {
+        includes[relationName] = true;
+      } else if (import_typescript9.default.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
+var import_typescript10 = require("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 = {}) {
@@ -1733,6 +2152,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,
@@ -1747,7 +2248,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",
@@ -1789,12 +2301,12 @@ function mergeBodySchemaAnnotations(bodyParam, ctx, schema) {
   const declarations = typeSymbol.getDeclarations();
   if (!declarations || declarations.length === 0) return schema;
   const classDecl = declarations[0];
-  if (!import_typescript9.default.isClassDeclaration(classDecl)) return schema;
+  if (!import_typescript11.default.isClassDeclaration(classDecl)) return schema;
   const result = { ...schema };
   const props = { ...result.properties };
   for (const member of classDecl.members) {
-    if (!import_typescript9.default.isPropertyDeclaration(member) || !member.name) continue;
-    const propName = import_typescript9.default.isIdentifier(member.name) ? member.name.text : null;
+    if (!import_typescript11.default.isPropertyDeclaration(member) || !member.name) continue;
+    const propName = import_typescript11.default.isIdentifier(member.name) ? member.name.text : null;
     if (!propName) continue;
     if (!props[propName]) continue;
     const frags = extractPropertySchemaFragments(ctx.checker, member);
@@ -1807,7 +2319,7 @@ function mergeBodySchemaAnnotations(bodyParam, ctx, schema) {
 }
 
 // src/compiler/manifest/emit.ts
-var import_typescript10 = __toESM(require("typescript"), 1);
+var import_typescript12 = __toESM(require("typescript"), 1);
 function generateManifest(controllers, checker, version, validationMode = "ajv-runtime") {
   const components = /* @__PURE__ */ new Map();
   const ctx = {
@@ -1829,7 +2341,7 @@ function generateManifest(controllers, checker, version, validationMode = "ajv-r
     generator: {
       name: "adorn-api",
       version,
-      typescript: import_typescript10.default.version
+      typescript: import_typescript12.default.version
     },
     schemas: {
       kind: "openapi-3.1",
@@ -2315,7 +2827,7 @@ async function isStale(params) {
 // src/compiler/cache/writeCache.ts
 var import_node_fs4 = __toESM(require("fs"), 1);
 var import_node_path4 = __toESM(require("path"), 1);
-var import_typescript11 = __toESM(require("typescript"), 1);
+var import_typescript13 = __toESM(require("typescript"), 1);
 function statMtimeMs2(p) {
   return import_node_fs4.default.statSync(p).mtimeMs;
 }
@@ -2348,7 +2860,7 @@ function writeCache(params) {
     generator: {
       name: "adorn-api",
       version: params.adornVersion,
-      typescript: import_typescript11.default.version
+      typescript: import_typescript13.default.version
     },
     project: {
       tsconfigPath: params.tsconfigAbs,
@@ -2868,7 +3380,7 @@ function partitionSchemas(schemas, graph, schemaGraph, config = {}) {
       complexity: totalComplexity,
       dependencies: []
     }];
-    recommendation = recommendation || "Single file mode (--no-split)";
+    recommendation = recommendation || "Single file mode (--split not specified)";
   } else if (strategy === "controller") {
     groups = partitionByController(schemas, graph, finalConfig);
   } else if (strategy === "dependency") {
@@ -3101,7 +3613,7 @@ function getEdgesByRelation(graph, relation) {
 }
 
 // src/compiler/graph/builder.ts
-var import_typescript12 = __toESM(require("typescript"), 1);
+var import_typescript14 = __toESM(require("typescript"), 1);
 
 // src/compiler/graph/schemaGraph.ts
 var SchemaGraph = class {
@@ -3353,7 +3865,7 @@ var SchemaGraph = class {
 };
 
 // src/cli.ts
-var import_typescript13 = __toESM(require("typescript"), 1);
+var import_typescript15 = __toESM(require("typescript"), 1);
 var import_node_process2 = __toESM(require("process"), 1);
 var import_meta2 = {};
 var ADORN_VERSION = (() => {
@@ -3432,7 +3944,7 @@ function sanitizeForJson(obj) {
   return result;
 }
 function buildControllerGraph(controllers) {
-  const graph = createGraph(import_typescript13.default.version);
+  const graph = createGraph(import_typescript15.default.version);
   const nodeMap = /* @__PURE__ */ new Map();
   for (const ctrl of controllers) {
     const nodeId = `Controller:${ctrl.className}`;
@@ -3523,7 +4035,7 @@ async function buildCommand(args) {
   const validationMode = validationModeIndex !== -1 ? args[validationModeIndex + 1] : "ajv-runtime";
   const verbose = args.includes("--verbose");
   const quiet = args.includes("--quiet");
-  const noSplit = args.includes("--no-split");
+  const split = args.includes("--split");
   const splitStrategyIndex = args.indexOf("--split-strategy");
   const splitStrategy = splitStrategyIndex !== -1 ? args[splitStrategyIndex + 1] : void 0;
   const splitThresholdIndex = args.indexOf("--split-threshold");
@@ -3543,7 +4055,7 @@ async function buildCommand(args) {
       outDir: outputDir,
       project: projectPath,
       adornVersion: ADORN_VERSION,
-      typescriptVersion: import_typescript13.default.version
+      typescriptVersion: import_typescript15.default.version
     });
     if (!stale.stale) {
       progress.completePhase("staleness-check");
@@ -3601,7 +4113,7 @@ async function buildCommand(args) {
   if (!quiet) openapiSpinner.stop();
   const schemaCount = Object.keys(openapi.components?.schemas || {}).length;
   let splitEnabled = false;
-  if (!noSplit && schemaCount >= splitThreshold) {
+  if (split && schemaCount >= splitThreshold) {
     progress.verboseLog(`Schema count (${schemaCount}) >= threshold (${splitThreshold}), analyzing for auto-split...`);
     const graph = buildControllerGraph(controllers);
     const schemaGraph = new SchemaGraph(graph);
@@ -3641,9 +4153,9 @@ async function buildCommand(args) {
         log(`  Auto-split not needed: ${partitioning.recommendation}`);
       }
     }
-  } else if (noSplit) {
+  } else if (!split) {
     if (!quiet) {
-      log(`  Splitting disabled (--no-split)`);
+      log(`  Splitting disabled (--split not specified)`);
     }
   } else {
     if (!quiet) {
@@ -3764,12 +4276,12 @@ Commands:
   build     Generate OpenAPI and manifest from TypeScript source
   clean     Remove generated artifacts
 
-Options:
+ 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)
-  --no-split               Disable automatic schema splitting (default: auto-split enabled)
+  --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
@@ -3780,7 +4292,7 @@ Examples:
   adorn-api build --if-stale
   adorn-api build --validation-mode precompiled
   adorn-api build --verbose
-  adorn-api build --no-split              # Force single file mode
+  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