oas-toolkit 0.7.2 → 0.7.4

package/components.js

@@ -1,13 +1,36 @@
 const traverse = require("traverse");
-const get = require("lodash.get");
+const isEqual = require("lodash.isequal");
 const difference = require("lodash.difference");
+const intersection = require("lodash.intersection");
 
 function removeUnusedComponents(oas) {
   const used = getReferencedComponents(oas);
   const defined = getDefinedComponents(oas);
-  const unused = getUnusedComponents(defined, used);
+  const unused = getUnusedComponents(defined, used, oas);
 
-  return removeSpecifiedComponents(oas, unused);
+  const result = removeSpecifiedComponents(oas, unused);
+
+  // If nothing was removed, we've removed all unused components
+  // including those referenced by other components that were unused
+  if (isEqual(oas, result)) {
+    return result;
+  }
+
+  return removeUnusedComponents(result);
+}
+
+function getReferencesToComponent(oas, component) {
+  return traverse(oas).reduce(function (acc, x) {
+    if (
+      this.isLeaf &&
+      this.key == "$ref" &&
+      x == `#/${component.replace(/\./g, "/")}`
+    ) {
+      acc.push(this.path.slice(0, 3).join("."));
+    }
+
+    return acc;
+  }, []);
 }
 
 function removeSpecifiedComponents(oas, unused) {
@@ -67,8 +90,18 @@ function getDefinedComponents(oas) {
   }, []);
 }
 
-function getUnusedComponents(all, referenced) {
-  return difference(all, referenced);
+function getUnusedComponents(all, referenced, oas) {
+  const unused = difference(all, referenced);
+
+  // If we have a component that is only referenced by itself, it's unused
+  const used = intersection(all, referenced);
+  for (let component of used) {
+    const references = getReferencesToComponent(oas, component);
+    if (references.length == 1 && references[0] === component) {
+      unused.push(component);
+    }
+  }
+  return unused;
 }
 
 module.exports = {

package/components.test.js

@@ -227,6 +227,139 @@ describe("#components", () => {
     });
   });
 
+  it("Removes schemas that are only referenced by removed schemas", () => {
+    expect(
+      c.removeUnusedComponents({
+        info: { title: "One" },
+        components: {
+          schemas: {
+            SubSchema: {
+              type: "string",
+            },
+            MySchema: {
+              type: "object",
+              properties: {
+                subSchema: {
+                  $ref: "#/components/schemas/SubSchema",
+                },
+              },
+            },
+          },
+        },
+      })
+    ).toEqual({
+      info: { title: "One" },
+      components: {},
+    });
+  });
+
+  it("Removes schemas that are circular", () => {
+    expect(
+      c.removeUnusedComponents({
+        info: { title: "One" },
+        components: {
+          schemas: {
+            MySchema: {
+              type: "object",
+              properties: {
+                subSchema: {
+                  $ref: "#/components/schemas/MySchema",
+                },
+              },
+            },
+          },
+        },
+      })
+    ).toEqual({
+      info: { title: "One" },
+      components: {},
+    });
+  });
+
+  it("Does not remove circular schemas that are also referenced elsewhere", () => {
+    expect(
+      c.removeUnusedComponents({
+        info: { title: "One" },
+        paths: {
+          "/foo": {
+            get: {
+              responses: {
+                200: {
+                  content: {
+                    "application/json": {
+                      schema: {
+                        $ref: "#/components/schemas/AnotherSchema",
+                      },
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+        components: {
+          schemas: {
+            MySchema: {
+              type: "object",
+              properties: {
+                subSchema: {
+                  $ref: "#/components/schemas/MySchema",
+                },
+              },
+            },
+            AnotherSchema: {
+              type: "object",
+              properties: {
+                Foo: {
+                  $ref: "#/components/schemas/MySchema",
+                },
+              },
+            },
+          },
+        },
+      })
+    ).toEqual({
+      info: { title: "One" },
+      paths: {
+        "/foo": {
+          get: {
+            responses: {
+              200: {
+                content: {
+                  "application/json": {
+                    schema: {
+                      $ref: "#/components/schemas/AnotherSchema",
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+      },
+      components: {
+        schemas: {
+          MySchema: {
+            type: "object",
+            properties: {
+              subSchema: {
+                $ref: "#/components/schemas/MySchema",
+              },
+            },
+          },
+          AnotherSchema: {
+            type: "object",
+            properties: {
+              Foo: {
+                $ref: "#/components/schemas/MySchema",
+              },
+            },
+          },
+        },
+      },
+    });
+  });
+
   it("removes unused security schemes", () => {
     const securityOas = {
       info: { title: "One" },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oas-toolkit",
-  "version": "0.7.2",
+  "version": "0.7.4",
   "description": "",
   "main": "index.js",
   "bin": {
@@ -21,6 +21,7 @@
     "jsonpath-plus": "^7.2.0",
     "lodash.difference": "^4.5.0",
     "lodash.get": "^4.4.2",
+    "lodash.intersection": "^4.4.0",
     "lodash.isequal": "^4.5.0",
     "lodash.uniqwith": "^4.5.0",
     "mergician": "^1.1.0",