fumadocs-openapi 3.2.0 → 3.3.0

package/dist/index.js

@@ -281,39 +281,43 @@ function isObject(schema) {
   return schema.type === "object" || schema.properties !== void 0;
 }
 function schemaElement(name, schema, ctx) {
+  return render(name, schema, {
+    ...ctx,
+    stack: []
+  });
+}
+function render(name, schema, ctx) {
   if (schema.readOnly && !ctx.readOnly) return "";
   if (schema.writeOnly && !ctx.writeOnly) return "";
   const { renderer } = ctx.render;
   const child = [];
   function field(key, value) {
-    child.push(span(`${key}:  \`${value}\``));
+    child.push(span(`${key}: \`${value}\``));
   }
   if (isObject(schema) && ctx.parseObject) {
     const { additionalProperties, properties } = schema;
-    if (additionalProperties) {
-      if (additionalProperties === true) {
-        child.push(
-          renderer.Property(
-            {
-              name: "[key: string]",
-              type: "any"
-            },
-            []
-          )
-        );
-      } else {
-        child.push(
-          schemaElement("[key: string]", noRef(additionalProperties), {
-            ...ctx,
-            required: false,
-            parseObject: false
-          })
-        );
-      }
+    if (additionalProperties === true) {
+      child.push(
+        renderer.Property(
+          {
+            name: "[key: string]",
+            type: "any"
+          },
+          []
+        )
+      );
+    } else if (additionalProperties) {
+      child.push(
+        render("[key: string]", noRef(additionalProperties), {
+          ...ctx,
+          required: false,
+          parseObject: false
+        })
+      );
     }
     Object.entries(properties ?? {}).forEach(([key, value]) => {
       child.push(
-        schemaElement(key, noRef(value), {
+        render(key, noRef(value), {
           ...ctx,
           required: schema.required?.includes(key) ?? false,
           parseObject: false
@@ -334,17 +338,38 @@ function schemaElement(name, schema, ctx) {
       schema.enum.map((value) => JSON.stringify(value)).join(" | ")
     );
   }
-  const resolved = resolveObjectType(schema);
-  if (resolved && !ctx.parseObject) {
+  if (isObject(schema) && !ctx.parseObject) {
     child.push(
       renderer.ObjectCollapsible({ name }, [
-        schemaElement(name, resolved, {
+        render(name, schema, {
           ...ctx,
           parseObject: true,
           required: false
         })
       ])
     );
+  } else {
+    const mentionedObjectTypes = [
+      ...schema.anyOf ?? schema.oneOf ?? schema.allOf ?? [],
+      ...schema.not ? [schema.not] : [],
+      ...schema.type === "array" ? [schema.items] : []
+    ].map(noRef).filter((s) => isComplexType(s) && !ctx.stack.includes(s));
+    ctx.stack.push(schema);
+    child.push(
+      ...mentionedObjectTypes.map(
+        (s, idx) => renderer.ObjectCollapsible(
+          { name: s.title ?? `Object ${(idx + 1).toString()}` },
+          [
+            render("element", noRef(s), {
+              ...ctx,
+              parseObject: true,
+              required: false
+            })
+          ]
+        )
+      )
+    );
+    ctx.stack.pop();
   }
   return renderer.Property(
     {
@@ -356,28 +381,29 @@ function schemaElement(name, schema, ctx) {
     child
   );
 }
-function resolveObjectType(schema) {
-  if (isObject(schema)) return schema;
-  if (schema.type === "array") {
-    return resolveObjectType(noRef(schema.items));
-  }
+function isComplexType(schema) {
+  if (schema.anyOf ?? schema.oneOf ?? schema.allOf) return true;
+  return isObject(schema) || schema.type === "array";
 }
 function getSchemaType(schema) {
   if (schema.nullable) {
-    if (!schema.type) return "null";
-    return `${getSchemaType({ ...schema, nullable: false })} | null`;
+    const type = getSchemaType({ ...schema, nullable: false });
+    return type === "unknown" ? "null" : `${type} | null`;
   }
+  if (schema.title) return schema.title;
   if (schema.type === "array")
-    return `array of ${getSchemaType(noRef(schema.items))}`;
+    return `array<${getSchemaType(noRef(schema.items))}>`;
   if (schema.oneOf)
     return schema.oneOf.map((one) => getSchemaType(noRef(one))).join(" | ");
   if (schema.allOf)
     return schema.allOf.map((one) => getSchemaType(noRef(one))).join(" & ");
-  if (schema.anyOf)
+  if (schema.not) return `not ${getSchemaType(noRef(schema.not))}`;
+  if (schema.anyOf) {
     return `Any properties in ${schema.anyOf.map((one) => getSchemaType(noRef(one))).join(", ")}`;
+  }
   if (schema.type) return schema.type;
   if (isObject(schema)) return "object";
-  throw new Error(`Cannot detect object type: ${JSON.stringify(schema)}`);
+  return "unknown";
 }
 
 // src/render/operation.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fumadocs-openapi",
-  "version": "3.2.0",
+  "version": "3.3.0",
   "description": "Generate MDX docs for your OpenAPI spec",
   "keywords": [
     "NextJs",
@@ -20,12 +20,12 @@
     "@apidevtools/json-schema-ref-parser": "^11.6.4",
     "fast-glob": "^3.3.1",
     "js-yaml": "^4.1.0",
-    "json-schema-to-typescript": "^14.0.5",
+    "json-schema-to-typescript": "^14.1.0",
     "openapi-sampler": "^1.5.1"
   },
   "devDependencies": {
     "@types/js-yaml": "^4.0.9",
-    "@types/node": "18.17.5",
+    "@types/node": "20.14.9",
     "@types/openapi-sampler": "^1.0.3",
     "openapi-types": "^12.1.3",
     "eslint-config-custom": "0.0.0",