oas-toolkit 0.2.0 → 0.3.0

package/merger.js

@@ -1,8 +1,12 @@
 const mergician = require("mergician");
+const isEqual = require("lodash.isequal");
+const uniqWith = require("lodash.uniqwith");
 
 function merge(objects, options) {
   ensureNoComponentColissions(objects, options);
   ensureNoPathColissions(objects, options);
+  ensureNoTagColissions(objects, options);
+  ensureNoSecurityColissions(objects, options);
 
   // Do the merge
   let combinedSpec = {};
@@ -21,6 +25,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 +118,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.3.0",
   "description": "",
   "main": "index.js",
   "bin": {
@@ -20,6 +20,8 @@
     "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"
   }