adorn-api 1.0.7 → 1.0.9

package/dist/cli.js

@@ -197,7 +197,8 @@ function classifyParameters(parameters, httpMethod, pathParamIndices, checker) {
   for (let i = 0; i < parameters.length; i++) {
     const param = parameters[i];
     if (usedIndices.has(i)) continue;
-    const typeStr = param.type.getSymbol()?.getName() ?? "";
+    const nonNullableType = checker.getNonNullableType(param.type);
+    const typeStr = getTypeName(param.type) || getTypeName(nonNullableType);
     if (typeStr === "Body") {
       bodyParamIndex = i;
       usedIndices.add(i);
@@ -223,7 +224,7 @@ function classifyParameters(parameters, httpMethod, pathParamIndices, checker) {
       usedIndices.add(i);
       continue;
     }
-    const isObj = isObjectType(param.type, checker);
+    const isObj = isObjectType(nonNullableType, checker);
     if (isObj && queryObjectParamIndex === null && !isBodyMethod) {
       queryObjectParamIndex = i;
       usedIndices.add(i);
@@ -252,6 +253,12 @@ function isObjectType(type, checker) {
   if (callSignatures && callSignatures.length > 0) return false;
   return true;
 }
+function getTypeName(type) {
+  const aliasSymbol = type.aliasSymbol ?? type.aliasSymbol;
+  if (aliasSymbol) return aliasSymbol.getName();
+  const symbol = type.getSymbol();
+  return symbol?.getName() ?? "";
+}
 function findDecorator(node, name) {
   const decorators = ts2.getDecorators(node);
   if (!decorators) return null;
@@ -286,7 +293,7 @@ function unwrapPromise(type, checker) {
 }
 
 // src/compiler/schema/openapi.ts
-import ts5 from "typescript";
+import ts6 from "typescript";
 
 // src/compiler/schema/typeToJsonSchema.ts
 import ts3 from "typescript";
@@ -760,6 +767,56 @@ 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();
@@ -851,12 +908,12 @@ function mergeBodySchemaAnnotations(bodyParam, ctx, schema) {
   const declarations = typeSymbol.getDeclarations();
   if (!declarations || declarations.length === 0) return schema;
   const classDecl = declarations[0];
-  if (!ts5.isClassDeclaration(classDecl)) return schema;
+  if (!ts6.isClassDeclaration(classDecl)) return schema;
   const result = { ...schema };
   const props = { ...result.properties };
   for (const member of classDecl.members) {
-    if (!ts5.isPropertyDeclaration(member) || !member.name) continue;
-    const propName = ts5.isIdentifier(member.name) ? member.name.text : null;
+    if (!ts6.isPropertyDeclaration(member) || !member.name) continue;
+    const propName = ts6.isIdentifier(member.name) ? member.name.text : null;
     if (!propName) continue;
     if (!props[propName]) continue;
     const frags = extractPropertySchemaFragments(ctx.checker, member);
@@ -891,19 +948,36 @@ 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 (!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);
-      parameters.push({
-        name: propName,
+    if (queryStyle?.style === "deepObject") {
+      const explode = queryStyle.explode ?? true;
+      const deepParam = {
+        name: queryParam.name,
         in: "query",
-        required: isRequired,
-        schema: propSchema,
-        ...Object.keys(serialization).length > 0 ? serialization : {}
-      });
+        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);
+        parameters.push({
+          name: propName,
+          in: "query",
+          required: isRequired,
+          schema: propSchema,
+          ...Object.keys(serialization).length > 0 ? serialization : {}
+        });
+      }
     }
   }
   for (const paramIndex of operation.queryParamIndices) {
@@ -973,7 +1047,7 @@ function buildCookieParameters(operation, ctx, parameters) {
 }
 
 // src/compiler/manifest/emit.ts
-import ts6 from "typescript";
+import ts7 from "typescript";
 function generateManifest(controllers, checker, version, validationMode = "ajv-runtime") {
   const components = /* @__PURE__ */ new Map();
   const ctx = {
@@ -994,7 +1068,7 @@ function generateManifest(controllers, checker, version, validationMode = "ajv-r
     generator: {
       name: "adorn-api",
       version,
-      typescript: ts6.version
+      typescript: ts7.version
     },
     schemas: {
       kind: "openapi-3.1",
@@ -1079,21 +1153,38 @@ 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 (!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";
-        }
+      if (queryStyle?.style === "deepObject") {
+        const schemaRef = querySchema.$ref ?? "#/components/schemas/InlineQueryParam";
         args.query.push({
-          name: propName,
+          name: queryParam.name,
           index: queryParam.index,
-          required: !isRequired,
+          required: !queryParam.isOptional,
           schemaRef,
-          schemaType: propSchema.type
+          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
+          });
+        }
       }
     }
   }
@@ -1402,7 +1493,7 @@ async function isStale(params) {
 // src/compiler/cache/writeCache.ts
 import fs3 from "fs";
 import path3 from "path";
-import ts8 from "typescript";
+import ts9 from "typescript";
 function statMtimeMs2(p) {
   return fs3.statSync(p).mtimeMs;
 }
@@ -1435,7 +1526,7 @@ function writeCache(params) {
     generator: {
       name: "adorn-api",
       version: params.adornVersion,
-      typescript: ts8.version
+      typescript: ts9.version
     },
     project: {
       tsconfigPath: params.tsconfigAbs,
@@ -1448,7 +1539,7 @@ function writeCache(params) {
 }
 
 // src/cli.ts
-import ts9 from "typescript";
+import ts10 from "typescript";
 import process from "process";
 var ADORN_VERSION = "0.1.0";
 function log(msg) {
@@ -1476,7 +1567,7 @@ async function buildCommand(args) {
       outDir: outputDir,
       project: projectPath,
       adornVersion: ADORN_VERSION,
-      typescriptVersion: ts9.version
+      typescriptVersion: ts10.version
     });
     if (!stale.stale) {
       log("adorn-api: artifacts up-to-date");