oas-toolkit 0.6.0 → 0.6.2

package/cli/commands/check-conflicts.js

@@ -19,6 +19,7 @@ module.exports = async function ({ argv }) {
     merger.ensureNoPathColissions(oas, argv);
     merger.ensureNoTagColissions(oas, argv);
     merger.ensureNoSecurityColissions(oas, argv);
+    merger.ensureNoComplexObjectCollisions(oas, argv);
   } catch (e) {
     console.error(`ERROR: ${e.message}`);
     process.exit(1);

package/merger.js

@@ -36,19 +36,6 @@ function merge(objects, options) {
     }
   });
 
-  // Validate that $ref is the only thing at a specific level
-  combinedSpec = traverse(combinedSpec).map(function () {
-    if (["oneOf", "allOf", "anyOf", "$ref"].includes(this.key)) {
-      if (Object.keys(this.parent.node).length > 1) {
-        throw new Error(
-          `Cannot have ${
-            this.key
-          } and other properties at the same level: ${this.path.join(".")}`
-        );
-      }
-    }
-  });
-
   return combinedSpec;
 }
 
@@ -208,9 +195,62 @@ function ensureNoSecurityColissions(objects) {
   }
 }
 
+function ensureNoComplexObjectCollisions(objects) {
+  const allPaths = {};
+  for (let object of objects) {
+    traverse(object).forEach(function () {
+      if (
+        ["oneOf", "allOf", "anyOf", "$ref", "properties"].includes(this.key)
+      ) {
+        const k = this.path.slice(0, -1).join(".");
+        allPaths[k] = allPaths[k] || [];
+        allPaths[k].push({
+          key: this.key,
+          file: object.info.title,
+          value: this.node,
+        });
+      }
+    });
+  }
+
+  for (let path in allPaths) {
+    if (allPaths[path].length > 1) {
+      const v = allPaths[path];
+
+      // If all entries for this path use the same special key
+      if (
+        uniqWith(
+          v.map((f) => f.key),
+          isEqual
+        ).length == 1
+      ) {
+        // Check if all the values are the same
+        const values = v.map((f) => {
+          // If it's a oneOf, order doesn't matter so sort for comparison
+          if (f.key == "oneOf") {
+            f.value.sort();
+          }
+          return f.value;
+        });
+
+        if (isEqual(...values)) {
+          continue;
+        }
+      }
+
+      throw new Error(
+        `Conflicting complex object detected: ${path} (${v
+          .map((f) => `${f.file}[${f.key}]`)
+          .join(", ")})`
+      );
+    }
+  }
+}
+
 module.exports = Object.assign(merge, {
   ensureNoComponentColissions,
   ensureNoPathColissions,
   ensureNoTagColissions,
   ensureNoSecurityColissions,
+  ensureNoComplexObjectCollisions,
 });

package/merger.test.js

@@ -3,6 +3,7 @@ const {
   ensureNoPathColissions,
   ensureNoTagColissions,
   ensureNoSecurityColissions,
+  ensureNoComplexObjectCollisions,
 } = require("./merger");
 const merger = require("./merger");
 
@@ -152,6 +153,161 @@ describe("#ensureNoComponentColissions", () => {
   });
 });
 
+describe("#ensureNoComplexObjectCollisions", () => {
+  it("throws when $ref is detected alongside other values", () => {
+    expect(() => {
+      ensureNoComplexObjectCollisions([
+        {
+          info: { title: "One" },
+          components: {
+            schemas: {
+              DemoError: {
+                type: "object",
+                properties: {
+                  code: {
+                    type: "string",
+                    example: "ERROR_ABC",
+                  },
+                },
+              },
+            },
+          },
+        },
+        {
+          info: { title: "Two" },
+          components: {
+            schemas: {
+              DemoError: {
+                $ref: "#/components/schemas/AnotherError",
+              },
+            },
+          },
+        },
+      ]);
+    }).toThrow(
+      "Conflicting complex object detected: components.schemas.DemoError (One[properties], Two[$ref])"
+    );
+  });
+
+  it("does not throw when refs point to the same component", () => {
+    expect(() => {
+      ensureNoComplexObjectCollisions([
+        {
+          info: { title: "One" },
+          components: {
+            schemas: {
+              DemoError: {
+                $ref: "#/components/schemas/AnotherError",
+              },
+            },
+          },
+        },
+        {
+          info: { title: "Two" },
+          components: {
+            schemas: {
+              DemoError: {
+                $ref: "#/components/schemas/AnotherError",
+              },
+            },
+          },
+        },
+      ]);
+    }).not.toThrow();
+  });
+
+  it("does not throw when oneOf point to the same component (order independent)", () => {
+    expect(() => {
+      ensureNoComplexObjectCollisions([
+        {
+          info: { title: "One" },
+          components: {
+            schemas: {
+              DemoError: {
+                oneOf: ["#/components/schemas/One", "#/components/schemas/Two"],
+              },
+            },
+          },
+        },
+        {
+          info: { title: "Two" },
+          components: {
+            schemas: {
+              DemoError: {
+                oneOf: ["#/components/schemas/Two", "#/components/schemas/One"],
+              },
+            },
+          },
+        },
+      ]);
+    }).not.toThrow();
+  });
+
+  it("throws when allOf values are provided in different orders", () => {
+    expect(() => {
+      ensureNoComplexObjectCollisions([
+        {
+          info: { title: "One" },
+          components: {
+            schemas: {
+              DemoError: {
+                allOf: ["#/components/schemas/One", "#/components/schemas/Two"],
+              },
+            },
+          },
+        },
+        {
+          info: { title: "Two" },
+          components: {
+            schemas: {
+              DemoError: {
+                allOf: ["#/components/schemas/Two", "#/components/schemas/One"],
+              },
+            },
+          },
+        },
+      ]);
+    }).toThrow(
+      "Conflicting complex object detected: components.schemas.DemoError (One[allOf], Two[allOf])"
+    );
+  });
+
+  it("throws when oneOf is detected alongside other values", () => {
+    expect(() => {
+      ensureNoComplexObjectCollisions([
+        {
+          info: { title: "One" },
+          components: {
+            schemas: {
+              DemoError: {
+                type: "object",
+                properties: {
+                  code: {
+                    type: "string",
+                    example: "ERROR_ABC",
+                  },
+                },
+              },
+            },
+          },
+        },
+        {
+          info: { title: "Two" },
+          components: {
+            schemas: {
+              DemoError: {
+                oneOf: ["#/components/schemas/AnotherError"],
+              },
+            },
+          },
+        },
+      ]);
+    }).toThrow(
+      "Conflicting complex object detected: components.schemas.DemoError (One[properties], Two[oneOf])"
+    );
+  });
+});
+
 describe("path collisions", () => {
   it("does not throw with overlapping paths and different verbs", () => {
     expect(
@@ -453,71 +609,3 @@ describe("returns unique items for:", () => {
     });
   });
 });
-
-describe("validates the final output", () => {
-  it("throws when $ref is detected alongside other values", () => {
-    expect(() => {
-      merger([
-        {
-          components: {
-            schemas: {
-              DemoError: {
-                type: "object",
-                properties: {
-                  code: {
-                    type: "string",
-                    example: "ERROR_ABC",
-                  },
-                },
-              },
-            },
-          },
-        },
-        {
-          components: {
-            schemas: {
-              DemoError: {
-                $ref: "#/components/schemas/AnotherError",
-              },
-            },
-          },
-        },
-      ]);
-    }).toThrow(
-      "Cannot have $ref and other properties at the same level: components.schemas.DemoError.$ref"
-    );
-  });
-
-  it("throws when $ref is detected alongside other values", () => {
-    expect(() => {
-      merger([
-        {
-          components: {
-            schemas: {
-              DemoError: {
-                type: "object",
-                properties: {
-                  code: {
-                    type: "string",
-                    example: "ERROR_ABC",
-                  },
-                },
-              },
-            },
-          },
-        },
-        {
-          components: {
-            schemas: {
-              DemoError: {
-                oneOf: ["#/components/schemas/AnotherError"],
-              },
-            },
-          },
-        },
-      ]);
-    }).toThrow(
-      "Cannot have oneOf and other properties at the same level: components.schemas.DemoError.oneOf"
-    );
-  });
-});

package/package.json

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