oas-toolkit 0.7.3 → 0.7.5

package/components.js

@@ -1,11 +1,12 @@
 const traverse = require("traverse");
 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);
 
   const result = removeSpecifiedComponents(oas, unused);
 
@@ -18,6 +19,20 @@ function removeUnusedComponents(oas) {
   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) {
   oas = traverse(oas).clone();
   return traverse(oas).forEach(function (x) {
@@ -75,8 +90,61 @@ function getDefinedComponents(oas) {
   }, []);
 }
 
-function getUnusedComponents(all, referenced) {
-  return difference(all, referenced);
+// This is a horrible global hack, but it works
+const referencesTo = {};
+function getUnusedComponents(all, referenced, oas) {
+  const unused = difference(all, referenced);
+
+  if (!oas) {
+    return unused;
+  }
+
+  // If we have a component that is only referenced by itself, it's unused
+  const used = intersection(all, referenced);
+  for (let component of used) {
+    if (component.startsWith("components.securitySchemes")) {
+      continue;
+    }
+
+    const references = getReferencesToComponent(oas, component);
+    if (references.length == 1 && references[0] === component) {
+      unused.push(component);
+    }
+
+    // If there's a circular dependency and nothing else, it can be removed
+    for (let ref of references) {
+      referencesTo[ref] = getRecursiveReferencesToComponent(oas, ref);
+    }
+
+    let shouldRemove = true;
+    for (let ref of references) {
+      if (!isEqual(referencesTo[component], referencesTo[ref])) {
+        shouldRemove = false;
+      }
+    }
+    if (shouldRemove) {
+      unused.push(component);
+    }
+  }
+  return unused;
+}
+
+function getRecursiveReferencesToComponent(oas, component, originalComponents) {
+  if (!originalComponents) {
+    originalComponents = [];
+  }
+  originalComponents.push(component);
+  let refs = getReferencesToComponent(oas, component);
+  for (const ref of refs) {
+    if (!originalComponents.includes(ref)) {
+      refs = refs.concat(
+        getRecursiveReferencesToComponent(oas, ref, originalComponents)
+      );
+    }
+  }
+  refs.sort();
+
+  return refs;
 }
 
 module.exports = {

package/components.test.js

@@ -253,6 +253,149 @@ describe("#components", () => {
     });
   });
 
+  it("Removes schemas that are circular (self reference)", () => {
+    expect(
+      c.removeUnusedComponents({
+        info: { title: "One" },
+        components: {
+          schemas: {
+            MySchema: {
+              type: "object",
+              properties: {
+                subSchema: {
+                  $ref: "#/components/schemas/MySchema",
+                },
+              },
+            },
+          },
+        },
+      })
+    ).toEqual({
+      info: { title: "One" },
+      components: {},
+    });
+  });
+
+  it("Removes schemas that are circular (loop)", () => {
+    expect(
+      c.removeUnusedComponents({
+        info: { title: "One" },
+        components: {
+          schemas: {
+            SchemaA: {
+              properties: {
+                subSchema: {
+                  $ref: "#/components/schemas/SchemaC",
+                },
+              },
+            },
+            SchemaB: {
+              properties: {
+                subSchema: {
+                  $ref: "#/components/schemas/SchemaA",
+                },
+              },
+            },
+            SchemaC: {
+              properties: {
+                subSchema: {
+                  $ref: "#/components/schemas/SchemaB",
+                },
+              },
+            },
+          },
+        },
+      })
+    ).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.3",
+  "version": "0.7.5",
   "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",