adorn-api 1.0.19 → 1.0.21

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,376 @@ 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 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 = {}) {
@@ -1716,6 +2135,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 +2231,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 +2284,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 +2302,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 +2324,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 +2809,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 +2842,7 @@ function writeCache(params) {
     generator: {
       name: "adorn-api",
       version: params.adornVersion,
-      typescript: ts11.version
+      typescript: ts13.version
     },
     project: {
       tsconfigPath: params.tsconfigAbs,
@@ -2850,7 +3362,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") {
@@ -3083,7 +3595,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 +3847,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 +3925,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}`;
@@ -3504,7 +4016,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");
@@ -3524,7 +4036,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");
@@ -3582,7 +4094,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);
@@ -3622,9 +4134,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) {
@@ -3745,12 +4257,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
@@ -3761,7 +4273,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