oas-toolkit 0.2.0 → 0.4.0

package/cli/bin.js

@@ -9,4 +9,9 @@ yargs(hideBin(process.argv))
     "merge the provided OpenAPI files",
     require("./commands/merge")
   )
+  .command(
+    "check-conflicts <openapi.yaml> <...more.yaml>",
+    "check for conflicting components, paths, tags, and security schemes",
+    require("./commands/check-conflicts")
+  )
   .parse();

package/cli/commands/check-conflicts.js

@@ -0,0 +1,26 @@
+const fs = require("fs");
+const yaml = require("js-yaml");
+
+module.exports = async function ({ argv }) {
+  try {
+    const oasFiles = argv._.slice(1);
+    if (oasFiles.length < 2) {
+      return;
+    }
+
+    const merger = require("../../merger");
+
+    const oas = [];
+    for (let f of oasFiles) {
+      oas.push(yaml.load(fs.readFileSync(f)));
+    }
+
+    merger.ensureNoComponentColissions(oas, argv);
+    merger.ensureNoPathColissions(oas, argv);
+    merger.ensureNoTagColissions(oas, argv);
+    merger.ensureNoSecurityColissions(oas, argv);
+  } catch (e) {
+    console.error(`ERROR: ${e.message}`);
+    process.exit(1);
+  }
+};

package/merger.js

@@ -1,9 +1,8 @@
 const mergician = require("mergician");
+const isEqual = require("lodash.isequal");
+const uniqWith = require("lodash.uniqwith");
 
 function merge(objects, options) {
-  ensureNoComponentColissions(objects, options);
-  ensureNoPathColissions(objects, options);
-
   // Do the merge
   let combinedSpec = {};
 
@@ -21,6 +20,14 @@ function merge(objects, options) {
     combinedSpec = mergeSection(combinedSpec, appendMerge, objects, section);
   }
 
+  // Values that should be unique
+  const uniqueSections = ["security", "tags"];
+  for (let section of uniqueSections) {
+    if (combinedSpec[section]) {
+      combinedSpec[section] = uniqWith(combinedSpec[section], isEqual);
+    }
+  }
+
   return combinedSpec;
 }
 
@@ -106,7 +113,83 @@ function ensureNoPathColissions(objects) {
   }
 }
 
+function ensureListUniqueness(list, key, objects) {
+  let all = [];
+  for (let object of objects) {
+    all = all.concat(object[list] || []);
+  }
+
+  for (let c of all) {
+    const d = all.filter((t) => {
+      return t[key] == c[key] && !isEqual(c, t);
+    });
+
+    if (d.length > 0) {
+      // Which files does this exist in?
+      const sources = [];
+      for (let object of objects) {
+        if (!object[list]) {
+          continue;
+        }
+
+        const match = object[list].filter((t) => t[key] == c[key]);
+        if (match.length) {
+          sources.push(object.info.title);
+        }
+      }
+
+      throw new Error(
+        `Conflicting ${list} detected: ${c[key]} (${sources.join(", ")})`
+      );
+    }
+  }
+}
+
+function ensureNoTagColissions(objects) {
+  ensureListUniqueness("tags", "name", objects);
+}
+
+function ensureNoSecurityColissions(objects) {
+  let all = [];
+  for (let object of objects) {
+    all = all.concat(object.security || []);
+  }
+
+  all = all.map((s) => Object.entries(s)[0]);
+
+  for (let c of all) {
+    const d = all.filter((t) => {
+      return t[0] == c[0] && !isEqual(c, t);
+    });
+
+    if (d.length > 0) {
+      // Which files does this exist in?
+      const sources = [];
+      for (let object of objects) {
+        if (!object.security) {
+          continue;
+        }
+
+        const match = object.security.filter((t) => {
+          const k = Object.keys(t)[0];
+          return k == c[0];
+        });
+
+        if (match.length) {
+          sources.push(object.info.title);
+        }
+      }
+
+      throw new Error(
+        `Conflicting security detected: ${c[0]} (${sources.join(", ")})`
+      );
+    }
+  }
+}
+
 module.exports = Object.assign(merge, {
   ensureNoComponentColissions,
   ensureNoPathColissions,
+  ensureNoTagColissions,
+  ensureNoSecurityColissions,
 });

package/merger.test.js

@@ -1,12 +1,93 @@
 const {
   ensureNoComponentColissions,
   ensureNoPathColissions,
+  ensureNoTagColissions,
+  ensureNoSecurityColissions,
 } = require("./merger");
 const merger = require("./merger");
 
 const FooSchema = { type: "string" };
 const BarSchema = { type: "boolean" };
 
+describe("#ensureNoTagColissions", () => {
+  it("does not throw when there are no colissions", () => {
+    expect(
+      ensureNoTagColissions([
+        { info: { title: "One" }, tags: [{ name: "Demo" }] },
+        { info: { title: "Two" }, tags: [{ name: "Demo" }] },
+      ])
+    ).toBe(undefined);
+  });
+
+  it("throws when there is a field in one tag but not in another", () => {
+    expect(() => {
+      ensureNoTagColissions([
+        { info: { title: "One" }, tags: [{ name: "Demo" }] },
+        {
+          info: { title: "Two" },
+          tags: [{ name: "Demo", description: "FOO" }],
+        },
+      ]);
+    }).toThrow(new Error("Conflicting tags detected: Demo (One, Two)"));
+  });
+
+  it("throws when there is a difference in deeply nested fields", () => {
+    expect(() => {
+      ensureNoTagColissions([
+        {
+          info: { title: "One" },
+          tags: [
+            {
+              name: "Demo",
+              externalDocs: {
+                description: "Hello",
+                url: "https://example.com",
+              },
+            },
+          ],
+        },
+        {
+          info: { title: "Two" },
+          tags: [
+            {
+              name: "Demo",
+              externalDocs: {
+                description: "Hello",
+                url: "https://another.example.com",
+              },
+            },
+          ],
+        },
+      ]);
+    }).toThrow(new Error("Conflicting tags detected: Demo (One, Two)"));
+  });
+});
+
+describe("#ensureNoSecurityColissions", () => {
+  it("does not throw when there are no colissions", () => {
+    expect(
+      ensureNoSecurityColissions([
+        { info: { title: "One" }, security: [{ appKey: [] }] },
+        { info: { title: "Two" }, security: [{ appKey: [] }] },
+      ])
+    ).toBe(undefined);
+  });
+
+  it("throws when there is a field in one security but not in another", () => {
+    expect(() => {
+      ensureNoSecurityColissions([
+        { info: { title: "One" }, security: [{ petstore_auth: [] }] },
+        {
+          info: { title: "Two" },
+          security: [{ petstore_auth: ["pets:write"] }],
+        },
+      ]);
+    }).toThrow(
+      new Error("Conflicting security detected: petstore_auth (One, Two)")
+    );
+  });
+});
+
 describe("#ensureNoComponentColissions", () => {
   it("does not throw when schemas have different prefixes", () => {
     expect(
@@ -229,3 +310,28 @@ describe("concatenates values for:", () => {
     });
   });
 });
+
+describe("returns unique items for:", () => {
+  it("tags", () => {
+    expect(
+      merger([
+        { tags: [{ name: "One", description: "Description one" }] },
+        { tags: [{ name: "Two", description: "Description two" }] },
+        { tags: [{ name: "One", description: "Description one" }] },
+      ])
+    ).toEqual({
+      tags: [
+        { name: "One", description: "Description one" },
+        { name: "Two", description: "Description two" },
+      ],
+    });
+  });
+
+  it("security", () => {
+    expect(
+      merger([{ security: [{ appKey: [] }] }, { security: [{ appKey: [] }] }])
+    ).toEqual({
+      security: [{ appKey: [] }],
+    });
+  });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oas-toolkit",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "",
   "main": "index.js",
   "bin": {
@@ -16,10 +16,11 @@
     "jest": "^29.5.0"
   },
   "dependencies": {
-    "@apidevtools/json-schema-ref-parser": "^10.1.0",
     "debug": "^4.3.4",
     "js-yaml": "^4.1.0",
     "jsonpath-plus": "^7.2.0",
+    "lodash.isequal": "^4.5.0",
+    "lodash.uniqwith": "^4.5.0",
     "mergician": "^1.1.0",
     "yargs": "^17.7.1"
   }