adorn-api 1.0.11 → 1.0.12

package/dist/cli.js

@@ -154,7 +154,7 @@ function analyzeMethod(node, className, checker) {
   }
   const pathParamNames = extractPathParams(path4);
   const pathParamIndices = matchPathParamsToIndices(pathParamNames, parameters);
-  const { bodyParamIndex, queryParamIndices, queryObjectParamIndex, headerObjectParamIndex, cookieObjectParamIndex, paginationParamIndex, bodyContentType } = classifyParameters(parameters, httpMethod, pathParamIndices, checker);
+  const { bodyParamIndex, queryParamIndices, queryObjectParamIndex, headerObjectParamIndex, cookieObjectParamIndex, bodyContentType } = classifyParameters(parameters, httpMethod, pathParamIndices, checker);
   return {
     methodName,
     httpMethod,
@@ -170,7 +170,6 @@ function analyzeMethod(node, className, checker) {
     queryObjectParamIndex,
     headerObjectParamIndex,
     cookieObjectParamIndex,
-    paginationParamIndex,
     bodyContentType
   };
 }
@@ -196,7 +195,6 @@ function classifyParameters(parameters, httpMethod, pathParamIndices, checker) {
   let queryObjectParamIndex = null;
   let headerObjectParamIndex = null;
   let cookieObjectParamIndex = null;
-  let paginationParamIndex = null;
   const isBodyMethod = ["POST", "PUT", "PATCH"].includes(httpMethod);
   for (let i = 0; i < parameters.length; i++) {
     const param = parameters[i];
@@ -223,11 +221,6 @@ function classifyParameters(parameters, httpMethod, pathParamIndices, checker) {
       usedIndices.add(i);
       continue;
     }
-    if (typeStr === "PaginationParams") {
-      paginationParamIndex = i;
-      usedIndices.add(i);
-      continue;
-    }
     if (isBodyMethod && bodyParamIndex === null) {
       bodyParamIndex = i;
       usedIndices.add(i);
@@ -248,19 +241,19 @@ function classifyParameters(parameters, httpMethod, pathParamIndices, checker) {
     queryObjectParamIndex,
     headerObjectParamIndex,
     cookieObjectParamIndex,
-    paginationParamIndex,
     bodyContentType: void 0
   };
 }
 function isObjectType(type, checker) {
   const objectFlags = (type.flags & ts2.TypeFlags.Object) !== 0;
-  if (!objectFlags) return false;
+  const intersectionFlags = (type.flags & ts2.TypeFlags.Intersection) !== 0;
+  if (!objectFlags && !intersectionFlags) return false;
   const symbol = type.getSymbol();
   if (symbol?.getName() === "__object") return true;
   const properties = checker.getPropertiesOfType(type);
   if (properties.length > 0) return true;
-  const callSignatures = type.getCallSignatures();
-  if (callSignatures && callSignatures.length > 0) return false;
+  const callSigs = type.getCallSignatures?.();
+  if (callSigs && callSigs.length > 0) return false;
   return true;
 }
 function getTypeName(type) {
@@ -312,7 +305,7 @@ function unwrapPromiseTypeNode(typeNode) {
 }
 
 // src/compiler/schema/openapi.ts
-import ts6 from "typescript";
+import ts5 from "typescript";
 
 // src/compiler/schema/typeToJsonSchema.ts
 import ts3 from "typescript";
@@ -331,7 +324,7 @@ function typeToJsonSchema(type, ctx, typeNode) {
     return { type: "string" };
   }
   if (type.flags & ts3.TypeFlags.Number) {
-    return { type: "number" };
+    return normalizeNumericType(type, checker, typeNode);
   }
   if (type.flags & ts3.TypeFlags.Boolean) {
     return { type: "boolean" };
@@ -593,9 +586,12 @@ function getBranchSchemaName(type, ctx) {
   return `Anonymous_${ctx.typeNameStack.length}`;
 }
 function handleObjectType(type, ctx, typeNode) {
-  const { checker, components, typeStack } = ctx;
+  const { checker, components, typeStack, mode } = ctx;
   const symbol = type.getSymbol();
   const typeName = symbol?.getName?.() ?? getTypeNameFromNode(typeNode, ctx);
+  if (isMetalOrmWrapperType(type, checker)) {
+    return handleMetalOrmWrapper(type, ctx);
+  }
   if (typeName && typeName !== "__type") {
     if (components.has(typeName)) {
       return { $ref: `#/components/schemas/${typeName}` };
@@ -608,7 +604,8 @@ function handleObjectType(type, ctx, typeNode) {
   const schema = buildObjectSchema(type, ctx, typeNode);
   if (typeName && typeName !== "__type") {
     typeStack.delete(type);
-    if (!components.has(typeName)) {
+    const existing = components.get(typeName);
+    if (!existing) {
       components.set(typeName, schema);
     }
     return { $ref: `#/components/schemas/${typeName}` };
@@ -630,22 +627,44 @@ function getExplicitTypeNameFromNode(typeNode) {
   }
   return null;
 }
+function shouldBeIntegerType(typeName) {
+  if (!typeName) return false;
+  const lower = typeName.toLowerCase();
+  return lower === "id" || lower.endsWith("id") || lower === "primarykey" || lower === "pk";
+}
+function normalizeNumericType(type, checker, typeNode) {
+  const typeName = getExplicitTypeNameFromNode(typeNode) ?? null;
+  const symbol = getEffectiveSymbol(type, checker);
+  const symbolName = symbol?.getName() ?? null;
+  if (shouldBeIntegerType(typeName) || shouldBeIntegerType(symbolName)) {
+    return { type: "integer" };
+  }
+  return { type: "number" };
+}
 function getTypeNameFromNode(typeNode, ctx) {
   const explicitName = getExplicitTypeNameFromNode(typeNode);
   if (explicitName) return explicitName;
   return `Anonymous_${ctx.typeNameStack.length}`;
 }
 function buildObjectSchema(type, ctx, typeNode) {
-  const { checker } = ctx;
+  const { checker, mode } = ctx;
   const properties = {};
   const required = [];
   const props = checker.getPropertiesOfType(type);
   for (const prop of props) {
     const propName = prop.getName();
+    if (isIteratorOrSymbolProperty(propName)) {
+      continue;
+    }
     const propType = checker.getTypeOfSymbol(prop);
+    if (isMethodLike(propType)) {
+      continue;
+    }
     const isOptional = !!(prop.flags & ts3.SymbolFlags.Optional);
+    const isRelation = isMetalOrmWrapperType(propType, checker);
     properties[propName] = typeToJsonSchema(propType, ctx);
-    if (!isOptional) {
+    const shouldRequire = mode === "response" ? !isRelation && !isOptional : !isOptional;
+    if (shouldRequire) {
       required.push(propName);
     }
   }
@@ -684,6 +703,56 @@ function getRecordValueType(type, checker) {
   }
   return null;
 }
+var METAL_ORM_WRAPPER_NAMES = ["HasManyCollection", "ManyToManyCollection", "BelongsToReference", "HasOneReference"];
+function isMetalOrmWrapperType(type, checker) {
+  const aliasSymbol = type.aliasSymbol || type.symbol;
+  if (!aliasSymbol) return false;
+  return METAL_ORM_WRAPPER_NAMES.includes(aliasSymbol.getName());
+}
+function getWrapperTypeName(type, checker) {
+  const symbol = getEffectiveSymbol(type, checker);
+  if (!symbol) return null;
+  const name = symbol.getName();
+  return METAL_ORM_WRAPPER_NAMES.includes(name) ? name : null;
+}
+function getEffectiveSymbol(type, checker) {
+  const aliasSymbol = type.aliasSymbol ?? type.aliasSymbol;
+  if (aliasSymbol && aliasSymbol.flags & ts3.SymbolFlags.Alias) {
+    return checker.getAliasedSymbol(aliasSymbol);
+  }
+  return type.getSymbol() ?? null;
+}
+function isMethodLike(type) {
+  const callSigs = type.getCallSignatures?.();
+  return !!(callSigs && callSigs.length > 0);
+}
+function isIteratorOrSymbolProperty(propName) {
+  return propName.startsWith("__@") || propName.startsWith("[") || propName === Symbol.iterator.toString();
+}
+function handleMetalOrmWrapper(type, ctx) {
+  const typeRef = type;
+  const typeArgs = typeRef.typeArguments;
+  const targetType = typeArgs?.[0] ?? null;
+  const wrapperName = getWrapperTypeName(type, ctx.checker);
+  if (!wrapperName) return {};
+  const wrapperRel = { wrapper: wrapperName };
+  if (wrapperName === "HasManyCollection" || wrapperName === "ManyToManyCollection") {
+    const items = targetType ? typeToJsonSchema(targetType, ctx) : {};
+    if (wrapperName === "ManyToManyCollection" && typeArgs?.[1]) {
+      wrapperRel.pivot = typeArgs[1];
+    }
+    return {
+      type: "array",
+      items,
+      "x-metal-orm-rel": wrapperRel
+    };
+  }
+  const targetSchema = targetType ? typeToJsonSchema(targetType, ctx) : {};
+  return {
+    ...targetSchema,
+    "x-metal-orm-rel": wrapperRel
+  };
+}
 
 // src/compiler/schema/extractAnnotations.ts
 import ts4 from "typescript";
@@ -831,56 +900,6 @@ function mergeFragments(base, ...frags) {
   return result;
 }
 
-// src/compiler/analyze/extractQueryStyle.ts
-import ts5 from "typescript";
-function extractQueryStyleOptions(checker, method) {
-  if (!ts5.canHaveDecorators(method)) return null;
-  const decorators = ts5.getDecorators(method);
-  if (!decorators || decorators.length === 0) return null;
-  for (const decorator of decorators) {
-    const expr = decorator.expression;
-    const isCall = ts5.isCallExpression(expr);
-    const callee = isCall ? expr.expression : expr;
-    const args = isCall ? expr.arguments : ts5.factory.createNodeArray([]);
-    const sym = checker.getSymbolAtLocation(callee);
-    if (!sym) continue;
-    const resolved = sym.flags & ts5.SymbolFlags.Alias ? checker.getAliasedSymbol(sym) : sym;
-    const name = resolved.getName();
-    if (name !== "QueryStyle") continue;
-    const optsNode = args[0];
-    if (!optsNode || !ts5.isObjectLiteralExpression(optsNode)) {
-      return {};
-    }
-    return parseQueryStyleOptions(optsNode);
-  }
-  return null;
-}
-function parseQueryStyleOptions(node) {
-  const opts = {};
-  for (const prop of node.properties) {
-    if (!ts5.isPropertyAssignment(prop)) continue;
-    const name = getPropName(prop.name);
-    if (!name) continue;
-    if (name === "style" && ts5.isStringLiteral(prop.initializer)) {
-      const style = prop.initializer.text;
-      opts.style = style;
-    } else if (name === "explode" && isBooleanLiteral(prop.initializer)) {
-      opts.explode = prop.initializer.kind === ts5.SyntaxKind.TrueKeyword;
-    } else if (name === "allowReserved" && isBooleanLiteral(prop.initializer)) {
-      opts.allowReserved = prop.initializer.kind === ts5.SyntaxKind.TrueKeyword;
-    }
-  }
-  return opts;
-}
-function getPropName(name) {
-  if (ts5.isIdentifier(name)) return name.text;
-  if (ts5.isStringLiteral(name)) return name.text;
-  return null;
-}
-function isBooleanLiteral(node) {
-  return node.kind === ts5.SyntaxKind.TrueKeyword || node.kind === ts5.SyntaxKind.FalseKeyword;
-}
-
 // src/compiler/schema/openapi.ts
 function generateOpenAPI(controllers, checker, options = {}) {
   const components = /* @__PURE__ */ new Map();
@@ -888,7 +907,8 @@ function generateOpenAPI(controllers, checker, options = {}) {
     checker,
     components,
     typeStack: /* @__PURE__ */ new Set(),
-    typeNameStack: []
+    typeNameStack: [],
+    mode: "response"
   };
   const paths = {};
   for (const controller of controllers) {
@@ -916,7 +936,11 @@ function generateOpenAPI(controllers, checker, options = {}) {
 function convertToOpenApiPath(basePath, path4) {
   const base = basePath.endsWith("/") ? basePath.slice(0, -1) : basePath;
   const converted = path4.replace(/:([^/]+)/g, "{$1}");
-  return base + converted || "/";
+  let fullPath = base + converted || "/";
+  if (fullPath.endsWith("/") && fullPath !== "/") {
+    fullPath = fullPath.slice(0, -1);
+  }
+  return fullPath;
 }
 function buildOperation(operation, ctx, controllerConsumes) {
   const op = {
@@ -931,7 +955,8 @@ function buildOperation(operation, ctx, controllerConsumes) {
   if (parameters.length > 0) {
     op.parameters = parameters;
   }
-  const responseSchema = typeToJsonSchema(operation.returnType, ctx, operation.returnTypeNode);
+  const responseCtx = { ...ctx, mode: "response" };
+  const responseSchema = typeToJsonSchema(operation.returnType, responseCtx, operation.returnTypeNode);
   const status = operation.httpMethod === "POST" ? 201 : 200;
   op.responses[status] = {
     description: status === 201 ? "Created" : "OK",
@@ -944,8 +969,9 @@ function buildOperation(operation, ctx, controllerConsumes) {
   if (["POST", "PUT", "PATCH"].includes(operation.httpMethod) && operation.bodyParamIndex !== null) {
     const bodyParam = operation.parameters[operation.bodyParamIndex];
     if (bodyParam) {
-      let bodySchema = typeToJsonSchema(bodyParam.type, ctx);
-      bodySchema = mergeBodySchemaAnnotations(bodyParam, ctx, bodySchema);
+      const requestCtx = { ...ctx, mode: "request" };
+      let bodySchema = typeToJsonSchema(bodyParam.type, requestCtx);
+      bodySchema = mergeBodySchemaAnnotations(bodyParam, requestCtx, bodySchema);
       const contentType = operation.bodyContentType ?? controllerConsumes?.[0] ?? "application/json";
       const requestBody = {
         required: !bodyParam.isOptional,
@@ -972,12 +998,12 @@ function mergeBodySchemaAnnotations(bodyParam, ctx, schema) {
   const declarations = typeSymbol.getDeclarations();
   if (!declarations || declarations.length === 0) return schema;
   const classDecl = declarations[0];
-  if (!ts6.isClassDeclaration(classDecl)) return schema;
+  if (!ts5.isClassDeclaration(classDecl)) return schema;
   const result = { ...schema };
   const props = { ...result.properties };
   for (const member of classDecl.members) {
-    if (!ts6.isPropertyDeclaration(member) || !member.name) continue;
-    const propName = ts6.isIdentifier(member.name) ? member.name.text : null;
+    if (!ts5.isPropertyDeclaration(member) || !member.name) continue;
+    const propName = ts5.isIdentifier(member.name) ? member.name.text : null;
     if (!propName) continue;
     if (!props[propName]) continue;
     const frags = extractPropertySchemaFragments(ctx.checker, member);
@@ -999,48 +1025,124 @@ function buildPathParameters(operation, ctx, parameters) {
           paramSchema = mergeFragments(paramSchema, ...frags);
         }
       }
+      const schema = paramSchema.$ref ? { $ref: paramSchema.$ref } : paramSchema;
       parameters.push({
         name: param.name,
         in: "path",
         required: !param.isOptional,
-        schema: paramSchema.$ref ? { type: "string", $ref: paramSchema.$ref } : paramSchema
+        schema
       });
     }
   }
 }
+function isObjectLikeSchema(schema, ctx) {
+  const resolved = resolveSchemaRef(schema, ctx.components);
+  if (resolved.type === "object" || resolved.properties || resolved.additionalProperties) {
+    return true;
+  }
+  if (resolved.allOf) {
+    for (const branch of resolved.allOf) {
+      if (isObjectLikeSchema(branch, ctx)) {
+        return true;
+      }
+    }
+  }
+  if (resolved.type === "array" && resolved.items) {
+    const itemsSchema = resolveSchemaRef(resolved.items, ctx.components);
+    return isObjectLikeSchema(itemsSchema, ctx);
+  }
+  return false;
+}
+function resolveSchemaRef(schema, components) {
+  const ref = schema.$ref;
+  if (typeof ref !== "string" || !ref.startsWith("#/components/schemas/")) {
+    return schema;
+  }
+  const name = ref.replace("#/components/schemas/", "");
+  const next = components.get(name);
+  if (!next) return schema;
+  return resolveSchemaRef(next, components);
+}
+function resolveAndCollectObjectProps(schema, components) {
+  const resolved = resolveSchemaRef(schema, components);
+  const properties = {};
+  const required = [];
+  const processSchema = (s) => {
+    const current = resolveSchemaRef(s, components);
+    if (current.properties) {
+      for (const [key, val] of Object.entries(current.properties)) {
+        if (!properties[key]) {
+          properties[key] = val;
+        }
+      }
+    }
+    if (current.required) {
+      for (const req of current.required) {
+        if (!required.includes(req)) {
+          required.push(req);
+        }
+      }
+    }
+    if (current.allOf) {
+      for (const branch of current.allOf) {
+        processSchema(branch);
+      }
+    }
+  };
+  processSchema(resolved);
+  return { properties, required };
+}
 function buildQueryParameters(operation, ctx, parameters) {
   if (operation.queryObjectParamIndex !== null) {
     const queryParam = operation.parameters[operation.queryObjectParamIndex];
     if (!queryParam) return;
-    const queryStyle = extractQueryStyleOptions(ctx.checker, operation.methodDeclaration);
     const querySchema = typeToJsonSchema(queryParam.type, ctx);
-    if (queryStyle?.style === "deepObject") {
-      const explode = queryStyle.explode ?? true;
-      const deepParam = {
-        name: queryParam.name,
-        in: "query",
-        required: !queryParam.isOptional,
-        schema: querySchema.$ref ? { $ref: querySchema.$ref } : querySchema,
-        style: "deepObject",
-        explode
-      };
-      if (queryStyle.allowReserved !== void 0) {
-        deepParam.allowReserved = queryStyle.allowReserved;
-      }
-      parameters.push(deepParam);
-    } else {
-      if (!querySchema.properties) return;
-      const queryObjProps = querySchema.properties;
-      for (const [propName, propSchema] of Object.entries(queryObjProps)) {
-        const isRequired = querySchema.required?.includes(propName) ?? false;
-        const serialization = determineQuerySerialization(propSchema.type);
+    const { properties: queryObjProps, required: queryRequired } = resolveAndCollectObjectProps(querySchema, ctx.components);
+    for (const [propName, propSchema] of Object.entries(queryObjProps)) {
+      const isRequired = queryRequired.includes(propName) ?? false;
+      const isObjectLike = isObjectLikeSchema(propSchema, ctx);
+      const serialization = determineQuerySerialization(propSchema.type);
+      if (isObjectLike) {
         parameters.push({
           name: propName,
           in: "query",
           required: isRequired,
-          schema: propSchema,
-          ...Object.keys(serialization).length > 0 ? serialization : {}
+          content: {
+            "application/json": {
+              schema: propSchema.$ref ? { $ref: propSchema.$ref } : propSchema
+            }
+          },
+          description: `URL-encoded JSON. Example: ${propName}=${encodeURIComponent(JSON.stringify({ example: "value" }))}`
         });
+      } else {
+        const paramDef = {
+          name: propName,
+          in: "query",
+          required: isRequired,
+          schema: propSchema.$ref ? { $ref: propSchema.$ref } : propSchema
+        };
+        if (propName === "page") {
+          paramDef.schema = { type: "integer", default: 1, minimum: 1 };
+        } else if (propName === "pageSize") {
+          paramDef.schema = { type: "integer", default: 10, minimum: 1 };
+        } else if (propName === "totalItems") {
+          paramDef.schema = { type: "integer", minimum: 0 };
+        } else if (propName === "sort") {
+          paramDef.schema = {
+            oneOf: [
+              { type: "string" },
+              { type: "array", items: { type: "string" } }
+            ]
+          };
+        } else if (propName === "q") {
+          paramDef.schema = { type: "string" };
+        } else if (propName === "hasComments") {
+          paramDef.schema = { type: "boolean" };
+        }
+        if (Object.keys(serialization).length > 0) {
+          Object.assign(paramDef, serialization);
+        }
+        parameters.push(paramDef);
       }
     }
   }
@@ -1054,14 +1156,28 @@ function buildQueryParameters(operation, ctx, parameters) {
           paramSchema = mergeFragments(paramSchema, ...frags);
         }
       }
-      const serialization = determineQuerySerialization(paramSchema.type);
-      parameters.push({
-        name: param.name,
-        in: "query",
-        required: !param.isOptional,
-        schema: paramSchema.$ref ? { type: "string", $ref: paramSchema.$ref } : paramSchema,
-        ...Object.keys(serialization).length > 0 ? serialization : {}
-      });
+      const isObjectLike = isObjectLikeSchema(paramSchema, ctx);
+      if (isObjectLike) {
+        parameters.push({
+          name: param.name,
+          in: "query",
+          required: !param.isOptional,
+          content: {
+            "application/json": {
+              schema: paramSchema.$ref ? { $ref: paramSchema.$ref } : paramSchema
+            }
+          }
+        });
+      } else {
+        const serialization = determineQuerySerialization(paramSchema.type);
+        parameters.push({
+          name: param.name,
+          in: "query",
+          required: !param.isOptional,
+          schema: paramSchema.$ref ? { $ref: paramSchema.$ref } : paramSchema,
+          ...Object.keys(serialization).length > 0 ? serialization : {}
+        });
+      }
     }
   }
 }
@@ -1111,14 +1227,15 @@ function buildCookieParameters(operation, ctx, parameters) {
 }
 
 // src/compiler/manifest/emit.ts
-import ts7 from "typescript";
+import ts6 from "typescript";
 function generateManifest(controllers, checker, version, validationMode = "ajv-runtime") {
   const components = /* @__PURE__ */ new Map();
   const ctx = {
     checker,
     components,
     typeStack: /* @__PURE__ */ new Set(),
-    typeNameStack: []
+    typeNameStack: [],
+    mode: "request"
   };
   const controllerEntries = controllers.map((ctrl) => ({
     controllerId: ctrl.className,
@@ -1132,7 +1249,7 @@ function generateManifest(controllers, checker, version, validationMode = "ajv-r
     generator: {
       name: "adorn-api",
       version,
-      typescript: ts7.version
+      typescript: ts6.version
     },
     schemas: {
       kind: "openapi-3.1",
@@ -1143,14 +1260,70 @@ function generateManifest(controllers, checker, version, validationMode = "ajv-r
     controllers: controllerEntries
   };
 }
+function resolveSchemaRef2(schema, components) {
+  const ref = schema.$ref;
+  if (typeof ref !== "string" || !ref.startsWith("#/components/schemas/")) {
+    return schema;
+  }
+  const name = ref.replace("#/components/schemas/", "");
+  const next = components.get(name);
+  if (!next) return schema;
+  return resolveSchemaRef2(next, components);
+}
+function resolveAndCollectObjectProps2(schema, components) {
+  const resolved = resolveSchemaRef2(schema, components);
+  const properties = {};
+  const required = [];
+  const processSchema = (s) => {
+    const current = resolveSchemaRef2(s, components);
+    if (current.properties) {
+      for (const [key, val] of Object.entries(current.properties)) {
+        if (!properties[key]) {
+          properties[key] = val;
+        }
+      }
+    }
+    if (current.required) {
+      for (const req of current.required) {
+        if (!required.includes(req)) {
+          required.push(req);
+        }
+      }
+    }
+    if (current.allOf) {
+      for (const branch of current.allOf) {
+        processSchema(branch);
+      }
+    }
+  };
+  processSchema(resolved);
+  return { properties, required };
+}
+function isObjectLikeSchema2(schema, components) {
+  const resolved = resolveSchemaRef2(schema, components);
+  if (resolved.type === "object" || resolved.properties || resolved.additionalProperties) {
+    return true;
+  }
+  if (resolved.allOf) {
+    for (const branch of resolved.allOf) {
+      if (isObjectLikeSchema2(branch, components)) {
+        return true;
+      }
+    }
+  }
+  if (resolved.type === "array" && resolved.items) {
+    const itemsSchema = resolveSchemaRef2(resolved.items, components);
+    return isObjectLikeSchema2(itemsSchema, components);
+  }
+  return false;
+}
 function buildOperationEntry(op, ctx) {
   const args = {
     body: null,
     path: [],
     query: [],
     headers: [],
-    cookies: [],
-    paginationParamIndex: op.paginationParamIndex
+    cookies: []
   };
   buildPathArgs(op, ctx, args);
   buildQueryArgs(op, ctx, args);
@@ -1217,53 +1390,39 @@ function buildPathArgs(op, ctx, args) {
 function buildQueryArgs(op, ctx, args) {
   if (op.queryObjectParamIndex !== null) {
     const queryParam = op.parameters[op.queryObjectParamIndex];
-    if (queryParam) {
-      const queryStyle = extractQueryStyleOptions(ctx.checker, op.methodDeclaration);
-      const querySchema = typeToJsonSchema(queryParam.type, ctx);
-      if (queryStyle?.style === "deepObject") {
-        const schemaRef = querySchema.$ref ?? "#/components/schemas/InlineQueryParam";
-        args.query.push({
-          name: queryParam.name,
-          index: queryParam.index,
-          required: !queryParam.isOptional,
-          schemaRef,
-          schemaType: querySchema.type,
-          serialization: {
-            style: "deepObject",
-            explode: queryStyle.explode ?? true,
-            allowReserved: queryStyle.allowReserved
-          }
-        });
-      } else {
-        if (!querySchema.properties) return;
-        for (const [propName, propSchema] of Object.entries(querySchema.properties)) {
-          const isRequired = querySchema.required?.includes(propName) ?? false;
-          let schemaRef = propSchema.$ref;
-          if (!schemaRef) {
-            schemaRef = "#/components/schemas/InlineQueryParam";
-          }
-          args.query.push({
-            name: propName,
-            index: queryParam.index,
-            required: !isRequired,
-            schemaRef,
-            schemaType: propSchema.type
-          });
-        }
+    if (!queryParam) return;
+    const querySchema = typeToJsonSchema(queryParam.type, ctx);
+    const { properties: queryObjProps, required: queryRequired } = resolveAndCollectObjectProps2(querySchema, ctx.components);
+    for (const [propName, propSchema] of Object.entries(queryObjProps)) {
+      const isRequired = queryRequired.includes(propName) ?? false;
+      const isObjectLike = isObjectLikeSchema2(propSchema, ctx.components);
+      let schemaRef = propSchema.$ref;
+      if (!schemaRef) {
+        schemaRef = "#/components/schemas/InlineQueryParam";
       }
+      args.query.push({
+        name: propName,
+        index: queryParam.index,
+        required: !isRequired,
+        schemaRef,
+        schemaType: propSchema.type,
+        content: isObjectLike ? "application/json" : void 0
+      });
     }
   }
   for (const paramIndex of op.queryParamIndices) {
     const param = op.parameters[paramIndex];
     if (param) {
       const paramSchema = typeToJsonSchema(param.type, ctx);
+      const isObjectLike = isObjectLikeSchema2(paramSchema, ctx.components);
       const schemaRef = paramSchema.$ref ?? "#/components/schemas/InlineQueryParam";
       args.query.push({
         name: param.name,
         index: param.index,
         required: !param.isOptional,
         schemaRef,
-        schemaType: paramSchema.type
+        schemaType: paramSchema.type,
+        content: isObjectLike ? "application/json" : void 0
       });
     }
   }
@@ -1558,7 +1717,7 @@ async function isStale(params) {
 // src/compiler/cache/writeCache.ts
 import fs3 from "fs";
 import path3 from "path";
-import ts9 from "typescript";
+import ts8 from "typescript";
 function statMtimeMs2(p) {
   return fs3.statSync(p).mtimeMs;
 }
@@ -1591,7 +1750,7 @@ function writeCache(params) {
     generator: {
       name: "adorn-api",
       version: params.adornVersion,
-      typescript: ts9.version
+      typescript: ts8.version
     },
     project: {
       tsconfigPath: params.tsconfigAbs,
@@ -1604,7 +1763,7 @@ function writeCache(params) {
 }
 
 // src/cli.ts
-import ts10 from "typescript";
+import ts9 from "typescript";
 import process from "process";
 var ADORN_VERSION = "0.1.0";
 function log(msg) {
@@ -1615,6 +1774,26 @@ function debug(...args) {
     console.error("[adorn-api]", ...args);
   }
 }
+function sanitizeForJson(obj) {
+  if (obj === null || obj === void 0) return obj;
+  if (typeof obj !== "object") return obj;
+  if (Array.isArray(obj)) {
+    return obj.map((item) => sanitizeForJson(item));
+  }
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (key.startsWith("__@") || key.startsWith("[")) continue;
+    if (typeof value === "function") continue;
+    if (value !== null && typeof value === "object") {
+      const typeName = value.constructor?.name;
+      if (typeName && !["Object", "Array", "String", "Number", "Boolean", "Date", "RegExp"].includes(typeName)) {
+        continue;
+      }
+    }
+    result[key] = sanitizeForJson(value);
+  }
+  return result;
+}
 async function buildCommand(args) {
   const projectIndex = args.indexOf("-p");
   const projectPath = projectIndex !== -1 ? args[projectIndex + 1] : "./tsconfig.json";
@@ -1632,7 +1811,7 @@ async function buildCommand(args) {
       outDir: outputDir,
       project: projectPath,
       adornVersion: ADORN_VERSION,
-      typescriptVersion: ts10.version
+      typescriptVersion: ts9.version
     });
     if (!stale.stale) {
       log("adorn-api: artifacts up-to-date");
@@ -1653,7 +1832,7 @@ async function buildCommand(args) {
   const openapi = generateOpenAPI(controllers, checker, { title: "API", version: "1.0.0" });
   const manifest = generateManifest(controllers, checker, ADORN_VERSION, validationMode);
   mkdirSync(outputPath, { recursive: true });
-  writeFileSync(resolve2(outputPath, "openapi.json"), JSON.stringify(openapi, null, 2));
+  writeFileSync(resolve2(outputPath, "openapi.json"), JSON.stringify(sanitizeForJson(openapi), null, 2));
   writeFileSync(resolve2(outputPath, "manifest.json"), JSON.stringify(manifest, null, 2));
   if (validationMode === "precompiled") {
     log("Generating precompiled validators...");