adorn-api 1.0.13 → 1.0.14

package/dist/cli.cjs

@@ -731,9 +731,6 @@ function handleObjectType(type, ctx, typeNode) {
     if (isMetalOrmGeneric) {
       return {};
     }
-    if (components.has(typeName)) {
-      return { $ref: `#/components/schemas/${typeName}` };
-    }
     if (typeStack.has(type)) {
       return { $ref: `#/components/schemas/${typeName}` };
     }
@@ -745,6 +742,11 @@ function handleObjectType(type, ctx, typeNode) {
     const existing = components.get(typeName);
     if (!existing) {
       components.set(typeName, schema);
+    } else {
+      const merged = mergeSchemasIfNeeded(existing, schema);
+      if (merged !== existing) {
+        components.set(typeName, merged);
+      }
     }
     return { $ref: `#/components/schemas/${typeName}` };
   }
@@ -838,6 +840,96 @@ function getExplicitTypeNameFromNode4(typeNode) {
   }
   return null;
 }
+function mergeSchemasIfNeeded(existing, newSchema) {
+  if (existing.type === "array" && newSchema.type === "array") {
+    return mergeArraySchemas(existing, newSchema);
+  }
+  const result = { ...existing };
+  for (const [key, newValue] of Object.entries(newSchema)) {
+    if (key === "properties" && newValue) {
+      result.properties = mergePropertiesIfNeeded(existing.properties || {}, newValue);
+    } else if (key === "required" && newValue) {
+      result.required = mergeRequiredFields(existing.required || [], newValue);
+    } else if (!deepEqual(existing[key], newValue)) {
+      result[key] = newValue;
+    }
+  }
+  return result;
+}
+function mergePropertiesIfNeeded(existing, newProps) {
+  const result = { ...existing };
+  for (const [propName, newPropSchema] of Object.entries(newProps)) {
+    const existingProp = existing[propName];
+    if (!existingProp) {
+      result[propName] = newPropSchema;
+    } else if (deepEqual(existingProp, newPropSchema)) {
+      continue;
+    } else {
+      result[propName] = mergePropertySchemas(existingProp, newPropSchema);
+    }
+  }
+  return result;
+}
+function mergePropertySchemas(schema1, schema2) {
+  if (deepEqual(schema1, schema2)) {
+    return schema1;
+  }
+  if (schema1.type === "array" && schema2.type === "array") {
+    return mergeArraySchemas(schema1, schema2);
+  }
+  const existingOneOf = schema1.oneOf || schema1.anyOf;
+  const newOneOf = schema2.oneOf || schema2.anyOf;
+  if (existingOneOf) {
+    const mergedOneOf = [...existingOneOf];
+    if (newOneOf) {
+      for (const newItem of newOneOf) {
+        if (!mergedOneOf.some((item) => deepEqual(item, newItem))) {
+          mergedOneOf.push(newItem);
+        }
+      }
+    } else if (!mergedOneOf.some((item) => deepEqual(item, schema2))) {
+      mergedOneOf.push(schema2);
+    }
+    return { ...schema1, oneOf: mergedOneOf };
+  }
+  return {
+    oneOf: [schema1, schema2]
+  };
+}
+function mergeArraySchemas(schema1, schema2) {
+  const result = { type: "array" };
+  if (schema1.uniqueItems || schema2.uniqueItems) {
+    result.uniqueItems = true;
+  }
+  if (schema1.items && schema2.items) {
+    result.items = mergePropertySchemas(schema1.items, schema2.items);
+  } else if (schema1.items) {
+    result.items = schema1.items;
+  } else if (schema2.items) {
+    result.items = schema2.items;
+  }
+  return result;
+}
+function mergeRequiredFields(existing, newFields) {
+  const merged = /* @__PURE__ */ new Set([...existing, ...newFields]);
+  return Array.from(merged);
+}
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (a == null || b == null) return false;
+  if (typeof a !== typeof b) return false;
+  if (typeof a === "object") {
+    const aKeys = Object.keys(a);
+    const bKeys = Object.keys(b);
+    if (aKeys.length !== bKeys.length) return false;
+    for (const key of aKeys) {
+      if (!bKeys.includes(key)) return false;
+      if (!deepEqual(a[key], b[key])) return false;
+    }
+    return true;
+  }
+  return false;
+}
 var METAL_ORM_WRAPPER_NAMES = ["HasManyCollection", "ManyToManyCollection", "BelongsToReference", "HasOneReference"];
 function findMetalOrmWrapper(type, checker) {
   if (type.isIntersection()) {
@@ -889,7 +981,27 @@ function handleMetalOrmWrapper(type, ctx) {
   const wrapperName = getWrapperTypeName(type, ctx.checker);
   if (!wrapperName) return {};
   const wrapperRel = { wrapper: wrapperName };
+  if (!targetType) {
+    return { "x-metal-orm-rel": wrapperRel };
+  }
   if (wrapperName === "HasManyCollection" || wrapperName === "ManyToManyCollection") {
+    if (ctx.typeStack.has(targetType)) {
+      const items2 = {
+        type: "object",
+        properties: {
+          id: { type: "integer" }
+        },
+        required: ["id"]
+      };
+      if (wrapperName === "ManyToManyCollection" && typeArgs?.[1]) {
+        wrapperRel.pivot = typeArgs[1];
+      }
+      return {
+        type: "array",
+        items: items2,
+        "x-metal-orm-rel": wrapperRel
+      };
+    }
     const items = targetType ? typeToJsonSchema(targetType, ctx) : {};
     if (wrapperName === "ManyToManyCollection" && typeArgs?.[1]) {
       wrapperRel.pivot = typeArgs[1];
@@ -900,9 +1012,6 @@ function handleMetalOrmWrapper(type, ctx) {
       "x-metal-orm-rel": wrapperRel
     };
   }
-  if (!targetType) {
-    return { "x-metal-orm-rel": wrapperRel };
-  }
   if (wrapperName === "BelongsToReference" || wrapperName === "HasOneReference") {
     return handleBelongsToReference(targetType, ctx, wrapperRel);
   }
@@ -913,7 +1022,7 @@ function handleMetalOrmWrapper(type, ctx) {
   };
 }
 function handleBelongsToReference(targetType, ctx, wrapperRel) {
-  const { components } = ctx;
+  const { components, typeStack } = ctx;
   const targetSymbol = targetType.getSymbol();
   const typeName = targetSymbol?.getName();
   if (!typeName) {
@@ -930,6 +1039,20 @@ function handleBelongsToReference(targetType, ctx, wrapperRel) {
       "x-metal-orm-rel": wrapperRel
     };
   }
+  if (typeStack.has(targetType)) {
+    const circularRefSchema = {
+      type: "object",
+      properties: {
+        id: { type: "integer" }
+      },
+      required: ["id"]
+    };
+    components.set(refSchemaName, circularRefSchema);
+    return {
+      $ref: `#/components/schemas/${refSchemaName}`,
+      "x-metal-orm-rel": wrapperRel
+    };
+  }
   const refSchema = buildRefSchema(targetType, ctx);
   components.set(refSchemaName, refSchema);
   return {
@@ -1199,10 +1322,20 @@ function buildQueryParameters(operation, ctx, parameters) {
     const { properties: queryObjProps, required: queryRequired } = resolveAndCollectObjectProps(querySchema, ctx.components);
     for (const [propName, propSchema] of Object.entries(queryObjProps)) {
       const isRequired = queryRequired.includes(propName);
+      const isDeepObject = isDeepObjectSchema(propSchema, ctx);
       const isObjectLike = isObjectLikeSchema(propSchema, ctx);
       const serialization = determineQuerySerialization(propSchema.type);
       const exampleValue = generateExampleValue(propSchema, propName);
-      if (isObjectLike) {
+      if (isDeepObject) {
+        parameters.push({
+          name: propName,
+          in: "query",
+          required: isRequired,
+          style: "deepObject",
+          explode: true,
+          schema: propSchema.$ref ? { $ref: propSchema.$ref } : propSchema
+        });
+      } else if (isObjectLike) {
         const schemaRef = propSchema.$ref || "#/components/schemas/InlineQueryParam";
         parameters.push({
           name: propName,
@@ -1257,8 +1390,18 @@ function buildQueryParameters(operation, ctx, parameters) {
           paramSchema = mergeFragments(paramSchema, ...frags);
         }
       }
+      const isDeepObject = isDeepObjectSchema(paramSchema, ctx);
       const isObjectLike = isObjectLikeSchema(paramSchema, ctx);
-      if (isObjectLike) {
+      if (isDeepObject) {
+        parameters.push({
+          name: param.name,
+          in: "query",
+          required: !param.isOptional,
+          style: "deepObject",
+          explode: true,
+          schema: paramSchema.$ref ? { $ref: paramSchema.$ref } : paramSchema
+        });
+      } else if (isObjectLike) {
         const schemaRef = paramSchema.$ref || "#/components/schemas/InlineQueryParam";
         const exampleValue = generateExampleValue(paramSchema, param.name);
         parameters.push({
@@ -1360,6 +1503,23 @@ function parseExampleValue(description) {
   }
   return JSON.stringify({ key: "value" });
 }
+function isDeepObjectSchema(schema, ctx) {
+  const resolved = resolveSchemaRef(schema, ctx.components);
+  if (resolved.type === "array") {
+    return false;
+  }
+  if (resolved.type === "object" || resolved.properties || resolved.additionalProperties) {
+    return true;
+  }
+  if (resolved.allOf) {
+    for (const branch of resolved.allOf) {
+      if (isDeepObjectSchema(branch, ctx)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
 function isObjectLikeSchema(schema, ctx) {
   const resolved = resolveSchemaRef(schema, ctx.components);
   if (resolved.type === "object" || resolved.properties || resolved.additionalProperties) {
@@ -1710,6 +1870,23 @@ function resolveAndCollectObjectProps2(schema, components) {
   processSchema(resolved);
   return { properties, required };
 }
+function isDeepObjectSchema2(schema, components) {
+  const resolved = resolveSchemaRef2(schema, components);
+  if (resolved.type === "array") {
+    return false;
+  }
+  if (resolved.type === "object" || resolved.properties || resolved.additionalProperties) {
+    return true;
+  }
+  if (resolved.allOf) {
+    for (const branch of resolved.allOf) {
+      if (isDeepObjectSchema2(branch, components)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
 function isObjectLikeSchema2(schema, components) {
   const resolved = resolveSchemaRef2(schema, components);
   if (resolved.type === "object" || resolved.properties || resolved.additionalProperties) {
@@ -1806,6 +1983,7 @@ function buildQueryArgs(op, ctx, args) {
     const { properties: queryObjProps, required: queryRequired } = resolveAndCollectObjectProps2(querySchema, ctx.components);
     for (const [propName, propSchema] of Object.entries(queryObjProps)) {
       const isRequired = queryRequired.includes(propName) ?? false;
+      const isDeepObject = isDeepObjectSchema2(propSchema, ctx.components);
       const isObjectLike = isObjectLikeSchema2(propSchema, ctx.components);
       let schemaRef = propSchema.$ref;
       if (!schemaRef) {
@@ -1817,7 +1995,8 @@ function buildQueryArgs(op, ctx, args) {
         required: isRequired,
         schemaRef,
         schemaType: propSchema.type,
-        content: isObjectLike ? "application/json" : void 0
+        serialization: isDeepObject ? { style: "deepObject", explode: true } : void 0,
+        content: !isDeepObject && isObjectLike ? "application/json" : void 0
       });
     }
   }
@@ -1825,6 +2004,7 @@ function buildQueryArgs(op, ctx, args) {
     const param = op.parameters[paramIndex];
     if (param) {
       const paramSchema = typeToJsonSchema(param.type, ctx);
+      const isDeepObject = isDeepObjectSchema2(paramSchema, ctx.components);
       const isObjectLike = isObjectLikeSchema2(paramSchema, ctx.components);
       const schemaRef = paramSchema.$ref ?? "#/components/schemas/InlineQueryParam";
       args.query.push({
@@ -1833,7 +2013,8 @@ function buildQueryArgs(op, ctx, args) {
         required: !param.isOptional,
         schemaRef,
         schemaType: paramSchema.type,
-        content: isObjectLike ? "application/json" : void 0
+        serialization: isDeepObject ? { style: "deepObject", explode: true } : void 0,
+        content: !isDeepObject && isObjectLike ? "application/json" : void 0
       });
     }
   }