oas-toolkit 0.7.4 → 0.7.6

package/components.js

@@ -2,6 +2,7 @@ const traverse = require("traverse");
 const isEqual = require("lodash.isequal");
 const difference = require("lodash.difference");
 const intersection = require("lodash.intersection");
+const uniqWith = require("lodash.uniqwith");
 
 function removeUnusedComponents(oas) {
   const used = getReferencedComponents(oas);
@@ -90,20 +91,79 @@ function getDefinedComponents(oas) {
   }, []);
 }
 
+// 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);
+      // Add all the references for each reference to build a complete list
+      referencesTo[ref] = referencesTo[ref].concat(
+        referencesTo[ref].flatMap((r) => {
+          if (!referencesTo[r]) {
+            return [];
+          }
+          return referencesTo[r];
+        })
+      );
+      referencesTo[ref] = uniqWith(referencesTo[ref], isEqual);
+    }
+
+    let shouldRemove = true;
+    for (let ref of references) {
+      if (!isEqual(referencesTo[component], referencesTo[ref])) {
+        shouldRemove = false;
+      }
+    }
+    if (shouldRemove) {
+      unused.push(component);
+    }
   }
   return unused;
 }
 
+const recursiveCache = {};
+function getRecursiveReferencesToComponent(oas, component, originalComponents) {
+  if (recursiveCache[component]) {
+    return recursiveCache[component];
+  }
+
+  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();
+
+  recursiveCache[component] = refs;
+  return refs;
+}
+
 module.exports = {
   getReferencedComponents,
   getDefinedComponents,

package/components.test.js

@@ -253,7 +253,7 @@ describe("#components", () => {
     });
   });
 
-  it("Removes schemas that are circular", () => {
+  it("Removes schemas that are circular (self reference)", () => {
     expect(
       c.removeUnusedComponents({
         info: { title: "One" },
@@ -276,6 +276,42 @@ describe("#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({

package/merger.test.js

@@ -491,7 +491,7 @@ describe("returns unique items for:", () => {
     });
   });
 
-  fit("handles keys that don't exist in both specs", () => {
+  it("handles keys that don't exist in both specs", () => {
     expect(
       merger([
         {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oas-toolkit",
-  "version": "0.7.4",
+  "version": "0.7.6",
   "description": "",
   "main": "index.js",
   "bin": {