Support documentation categories by different root types

packages/core/src/group-info.js

@@ -27,8 +27,11 @@ function getGroups(rootTypes, groupByDirective) {
   Object.keys(rootTypes).forEach((typeName) => {
     let rootType = rootTypes[typeName];
     if (typeof rootType != "undefined" && rootType != null) {
+      if (typeof groups[typeName] == "undefined") {
+        groups[typeName] = {};
+      }
       Object.keys(rootType).forEach((type) => {
-        groups[type] = getGroupName(rootType[type], groupByDirective);
+        groups[typeName][type] = getGroupName(rootType[type], groupByDirective);
       });
     }
   });

packages/core/src/renderer.js

@@ -74,9 +74,15 @@ module.exports = class Renderer {
       );
     }
 
-    if (hasProperty(this.group, name)) {
-      dirPath = path.join(dirPath, toSlug(this.group[name]));
-      await this.generateCategoryMetafile(this.group[name], dirPath);
+    if (
+      hasProperty(this.group, rootTypeName) &&
+      hasProperty(this.group[rootTypeName], name)
+    ) {
+      dirPath = path.join(dirPath, toSlug(this.group[rootTypeName][name]));
+      await this.generateCategoryMetafile(
+        this.group[rootTypeName][name],
+        dirPath,
+      );
     }
 
     dirPath = path.join(dirPath, toSlug(rootTypeName));

packages/core/tests/__data__/schema_with_grouping.graphql

@@ -24,6 +24,7 @@ type Query {
   GPA(skip: Int = 0): Int  @doc(category: "Grade") 
   WeightedGPA(input: String, skip: Int!): Int  @doc(category: "Grade") 
   UnWeightedGPA(input: String, skip: Int!): Int  @doc(category: "Grade") 
+  Course(skip: Int = 0): Course @doc(category: "Course")
 }
 
 type Query {
@@ -52,3 +53,8 @@ type DepartmentInformation implements Record {
   departmentCloseTime: Time
   website: URL
 }
+
+type Course {
+  id: ID!
+  title: String!
+} 

packages/core/tests/integration/__snapshots__/generator.spec.js.snap

@@ -17,6 +17,7 @@ position: 1
 link: null
 ",
   "course/queries/all-courses.mdx": "all-courses",
+  "course/queries/course.mdx": "course",
   "course/queries/math-courses.mdx": "math-courses",
   "course/queries/science-courses.mdx": "science-courses",
   "generated.md": "Dummy homepage for tweet.graphql",
@@ -64,6 +65,7 @@ link: null
 position: 1
 link: null
 ",
+  "misc/objects/course.mdx": "course",
   "misc/objects/department-information.mdx": "department-information",
   "misc/objects/semester.mdx": "semester",
   "misc/queries/_category_.yml": "label: Queries

packages/core/tests/unit/group-info.test.js

@@ -32,6 +32,10 @@ describe("group-info", () => {
     type Elf @tag(category: "fantasy") {
       name: String!
     }
+
+    type Query {
+      birds: [Bird!]! @doc(category: "animal")
+    }
   `);
 
   const groupOptions = {
@@ -91,6 +95,7 @@ describe("group-info", () => {
   describe("getGroups()", () => {
     const schemaMap = {
       objects: schema.getTypeMap(),
+      queries: schema.getQueryType().getFields(),
     };
 
     test("returns undefined if groupByDirective not defined", () => {
@@ -103,11 +108,13 @@ describe("group-info", () => {
       expect.assertions(1);
 
       expect(getGroups(schemaMap, groupOptions)).toMatchInlineSnapshot(`
-          {
+        {
+          "objects": {
             "Bird": "animal",
             "Boolean": "common",
             "Elf": "common",
             "Fish": "common",
+            "Query": "common",
             "String": "common",
             "Unicorn": "common",
             "__Directive": "common",
@@ -118,18 +125,24 @@ describe("group-info", () => {
             "__Schema": "common",
             "__Type": "common",
             "__TypeKind": "common",
-          }
-        `);
+          },
+          "queries": {
+            "birds": "animal",
+          },
+        }
+      `);
     });
   });
 
   describe("getGroupName()", () => {
     test("returns group name if category directive", () => {
-      expect.assertions(1);
+      expect.assertions(2);
 
       const type = schema.getType("Bird");
+      const queryType = schema.getQueryType().getFields()["birds"];
 
       expect(getGroupName(type, groupOptions)).toBe("animal");
+      expect(getGroupName(queryType, groupOptions)).toBe("animal");
     });
 
     test.each([

packages/core/tests/unit/renderer.test.js

@@ -240,10 +240,12 @@ describe("renderer", () => {
         const [type, name, root, group] = [{}, "Foo", "Baz", "lorem"];
 
         const spy = jest.spyOn(rendererInstance, "generateCategoryMetafile");
-        jest.replaceProperty(rendererInstance, "group", { [name]: group });
+        jest.replaceProperty(rendererInstance, "group", {
+          [root]: { [name]: group },
+        });
         jest
           .spyOn(Utils.object, "hasProperty")
-          .mockImplementation((_, prop) => prop === name);
+          .mockImplementation((_, prop) => prop === root || prop === name);
 
         const dirPath = await rendererInstance.generateCategoryMetafileType(
           type,
@@ -312,7 +314,9 @@ describe("renderer", () => {
         jest.replaceProperty(rendererInstance, "options", {
           deprecated: "group",
         });
-        jest.replaceProperty(rendererInstance, "group", { [name]: group });
+        jest.replaceProperty(rendererInstance, "group", {
+          [root]: { [name]: group },
+        });
         jest.spyOn(Utils.object, "hasProperty").mockReturnValue(true);
         jest.spyOn(Utils.graphql, "isDeprecated").mockReturnValue(true);
 

packages/printer-legacy/src/group.js

@@ -4,13 +4,16 @@ const {
   graphql: { getNamedType },
 } = require("@graphql-markdown/utils");
 
-const getGroup = (type, groups) => {
+const getGroup = (type, groups, typeCategory) => {
   if (typeof groups !== "object" || groups === null) {
     return "";
   }
   const graphLQLNamedType = getNamedType(type);
   const typeName = graphLQLNamedType.name || graphLQLNamedType;
-  return hasProperty(groups, typeName) ? toSlug(groups[typeName]) : "";
+  return hasProperty(groups, typeCategory) &&
+    hasProperty(groups[typeCategory], typeName)
+    ? toSlug(groups[typeCategory][typeName])
+    : "";
 };
 
 module.exports = {

packages/printer-legacy/src/link.js

@@ -92,7 +92,7 @@ class Link {
         ? DEPRECATED
         : "";
     const group = hasProperty(options, "groups")
-      ? getGroup(type, options.groups)
+      ? getGroup(type, options.groups, category.plural)
       : "";
     const url = pathUrl.join(
       options.basePath,

packages/printer-legacy/tests/unit/group.test.js

@@ -21,26 +21,34 @@ describe("group", () => {
 
   describe("getGroup()", () => {
     test("returns empty string if groups not defined", () => {
-      const group = getGroup({ name: "FooBaz" }, undefined);
+      const group = getGroup({ name: "FooBaz" }, undefined, undefined);
       expect(group).toBe("");
     });
 
     test("returns empty string if groups is null", () => {
-      const group = getGroup({ name: "FooBaz" }, null);
+      const group = getGroup({ name: "FooBaz" }, null, undefined);
       expect(group).toBe("");
     });
 
     test("returns group name string if type has group", () => {
       jest.spyOn(Utils.graphql, "getNamedType").mockReturnValue("FooBaz");
       jest.spyOn(Utils.object, "hasProperty").mockReturnValue(true);
-      const group = getGroup({ name: "FooBaz" }, { FooBaz: "Group Test" });
+      const group = getGroup(
+        { name: "FooBaz" },
+        { objects: { FooBaz: "Group Test" } },
+        "objects",
+      );
       expect(group).toBe("Group Test");
     });
 
     test("returns empty string if type not in group", () => {
       jest.spyOn(Utils.graphql, "getNamedType").mockReturnValue("FooBaz");
       jest.spyOn(Utils.object, "hasProperty").mockReturnValue(false);
-      const group = getGroup({ name: "FooBar" }, { FooBaz: "Group Test" });
+      const group = getGroup(
+        { name: "FooBar" },
+        { objects: { FooBaz: "Group Test" } },
+        "objects",
+      );
       expect(group).toBe("");
     });
   });