oas-toolkit 0.1.0 → 0.3.0

package/cli/commands/merge.js

@@ -15,7 +15,7 @@ module.exports = function ({ argv }) {
       oas.push(yaml.load(fs.readFileSync(f)));
     }
 
-    const combined = merger.apply(null, oas);
+    const combined = merger(oas, argv);
     console.log(yaml.dump(combined));
   } catch (e) {
     console.error(`ERROR: ${e.message}`);

package/merger.js

@@ -1,8 +1,12 @@
 const mergician = require("mergician");
+const isEqual = require("lodash.isequal");
+const uniqWith = require("lodash.uniqwith");
 
-function merge(...objects) {
-  ensureNoComponentColissions(objects);
-  ensureNoPathColissions(objects);
+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) {
     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;
 }
 
@@ -43,7 +55,8 @@ function mergeSection(spec, merger, objects, section) {
   );
 }
 
-function ensureNoComponentColissions(objects) {
+function ensureNoComponentColissions(objects, options) {
+  options = options || {};
   const componentList = {};
   // Fetch the first two levels of components
   for (const object of objects) {
@@ -59,8 +72,20 @@ function ensureNoComponentColissions(objects) {
   }
 
   for (let component in componentList) {
+    if (options.ignorePrefix) {
+      if (typeof options.ignorePrefix == "string") {
+        options.ignorePrefix = [options.ignorePrefix];
+      }
+      for (let prefix of options.ignorePrefix) {
+        if (component.startsWith(prefix)) {
+          delete componentList[component];
+        }
+      }
+    }
+
+    // Check if there are > 2
     const value = componentList[component];
-    if (value.length > 1) {
+    if (value && value.length > 1) {
       throw new Error(
         `Duplicate component detected: ${component} (${value.join(", ")})`
       );
@@ -93,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(
@@ -29,6 +110,18 @@ describe("#ensureNoComponentColissions", () => {
     ).toBe(undefined);
   });
 
+  it("does not throw when a conflicting schema is in the ignore list", () => {
+    expect(
+      ensureNoComponentColissions(
+        [
+          { info: { title: "One" }, components: { schemas: { FooSchema } } },
+          { info: { title: "Two" }, components: { schemas: { FooSchema } } },
+        ],
+        { ignorePrefix: ["components.schemas"] }
+      )
+    ).toBe(undefined);
+  });
+
   it("throws when two components have the same name", () => {
     expect(() => {
       ensureNoComponentColissions([
@@ -114,20 +207,20 @@ describe("path collisions", () => {
 
 describe("uses the last provided value for:", () => {
   it("openapi", () => {
-    expect(merger({ openapi: "3.0.3" }, { openapi: "3.1.0" })).toEqual({
+    expect(merger([{ openapi: "3.0.3" }, { openapi: "3.1.0" }])).toEqual({
       openapi: "3.1.0",
     });
   });
 
   it("info", () => {
     expect(
-      merger({ info: { title: "OAS One" } }, { info: { title: "OAS Two" } })
+      merger([{ info: { title: "OAS One" } }, { info: { title: "OAS Two" } }])
     ).toEqual({ info: { title: "OAS Two" } });
   });
 
   it("servers", () => {
     expect(
-      merger(
+      merger([
         {
           servers: [
             { url: "https://example.com", description: "My API Description" },
@@ -140,8 +233,8 @@ describe("uses the last provided value for:", () => {
               description: "Overwritten value",
             },
           ],
-        }
-      )
+        },
+      ])
     ).toEqual({
       servers: [
         { url: "https://api.example.com", description: "Overwritten value" },
@@ -153,10 +246,10 @@ describe("uses the last provided value for:", () => {
 describe("concatenates values for:", () => {
   it("tags", () => {
     expect(
-      merger(
+      merger([
         { tags: [{ name: "One", description: "Description one" }] },
-        { tags: [{ name: "Two", description: "Description two" }] }
-      )
+        { tags: [{ name: "Two", description: "Description two" }] },
+      ])
     ).toEqual({
       tags: [
         { name: "One", description: "Description one" },
@@ -167,7 +260,7 @@ describe("concatenates values for:", () => {
 
   it("paths", () => {
     expect(
-      merger(
+      merger([
         {
           info: { title: "One" },
           paths: { "/users": { get: { operationId: "list-users" } } },
@@ -175,8 +268,8 @@ describe("concatenates values for:", () => {
         {
           info: { title: "Two" },
           paths: { "/users": { post: { operationId: "create-user" } } },
-        }
-      )
+        },
+      ])
     ).toMatchObject({
       paths: {
         "/users": {
@@ -189,7 +282,7 @@ describe("concatenates values for:", () => {
 
   it("security", () => {
     expect(
-      merger(
+      merger([
         { security: [{ basicAuth: { type: "http", scheme: "basic" } }] },
         {
           security: [
@@ -201,8 +294,8 @@ describe("concatenates values for:", () => {
               },
             },
           ],
-        }
-      )
+        },
+      ])
     ).toEqual({
       security: [
         { basicAuth: { type: "http", scheme: "basic" } },
@@ -217,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.1.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"
   }