oas-toolkit 0.5.2 → 0.6.0

package/components.js

@@ -28,14 +28,23 @@ function getReferencedComponents(oas) {
     if (this.isLeaf && this.key == "$ref") {
       acc.push(x.replace("#/", "").replace(/\//g, "."));
     }
+
+    // Per-operation security schemes
+    if (this.node && this.node["operationId"] && this.node["security"]) {
+      for (let item of this.node["security"]) {
+        for (let key of Object.keys(item)) {
+          acc.push(`components.securitySchemes.${key}`);
+        }
+      }
+    }
     return acc;
   }, []);
 
-  // Add security schemes
-  if (oas.security){
-    for (let item of oas.security){
-      for (let key of Object.keys(item)){
-        components.push(`components.securitySchemes.${key}`)
+  // Add global security schemes
+  if (oas.security) {
+    for (let item of oas.security) {
+      for (let key of Object.keys(item)) {
+        components.push(`components.securitySchemes.${key}`);
       }
     }
   }

package/components.test.js

@@ -258,4 +258,50 @@ describe("#components", () => {
       },
     });
   });
+
+  it("checks per-operation security schemas in addition to global", () => {
+    const securityOas = {
+      info: { title: "One" },
+      components: {
+        securitySchemes: {
+          personalAccessToken: {
+            type: "http",
+            scheme: "bearer",
+          },
+          systemAccessToken: {
+            type: "http",
+            scheme: "bearer",
+          },
+        },
+      },
+      paths: {
+        "/foo": {
+          post: {
+            operationId: "test-foo",
+            security: [{ systemAccessToken: {} }],
+          },
+        },
+      },
+    };
+
+    expect(c.removeUnusedComponents(securityOas)).toEqual({
+      info: { title: "One" },
+      paths: {
+        "/foo": {
+          post: {
+            operationId: "test-foo",
+            security: [{ systemAccessToken: {} }],
+          },
+        },
+      },
+      components: {
+        securitySchemes: {
+          systemAccessToken: {
+            type: "http",
+            scheme: "bearer",
+          },
+        },
+      },
+    });
+  });
 });

package/merger.js

@@ -1,4 +1,5 @@
 const mergician = require("mergician");
+const traverse = require("traverse");
 const isEqual = require("lodash.isequal");
 const uniqWith = require("lodash.uniqwith");
 
@@ -28,6 +29,26 @@ function merge(objects, options) {
     }
   }
 
+  // Unique values that are at a non-deterministic path
+  combinedSpec = traverse(combinedSpec).map(function () {
+    if (["oneOf", "allOf", "anyOf"].includes(this.key)) {
+      this.node = uniqWith(this.node, isEqual);
+    }
+  });
+
+  // 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;
 }
 

package/merger.test.js

@@ -334,4 +334,190 @@ describe("returns unique items for:", () => {
       security: [{ appKey: [] }],
     });
   });
+
+  it("oneOf", () => {
+    expect(
+      merger([
+        {
+          components: {
+            schemas: {
+              DemoError: {
+                oneOf: [
+                  { $ref: "#/components/schemas/One" },
+                  { $ref: "#/components/schemas/Two" },
+                  { $ref: "#/components/schemas/Three" },
+                ],
+              },
+            },
+          },
+        },
+        {
+          components: {
+            schemas: {
+              DemoError: {
+                oneOf: [
+                  { $ref: "#/components/schemas/One" },
+                  { $ref: "#/components/schemas/Two" },
+                  { $ref: "#/components/schemas/Four" },
+                ],
+              },
+              AnotherError: {
+                $ref: "#/components/schemas/One",
+              },
+            },
+          },
+        },
+      ])
+    ).toEqual({
+      components: {
+        schemas: {
+          DemoError: {
+            oneOf: [
+              { $ref: "#/components/schemas/One" },
+              { $ref: "#/components/schemas/Two" },
+              { $ref: "#/components/schemas/Three" },
+              { $ref: "#/components/schemas/Four" },
+            ],
+          },
+          AnotherError: {
+            $ref: "#/components/schemas/One",
+          },
+        },
+      },
+    });
+  });
+
+  it("allOf", () => {
+    expect(
+      merger([
+        {
+          components: {
+            schemas: {
+              DemoError: {
+                allOf: [{ $ref: "#/components/schemas/One" }],
+              },
+            },
+          },
+        },
+        {
+          components: {
+            schemas: {
+              DemoError: {
+                allOf: [{ $ref: "#/components/schemas/One" }],
+              },
+            },
+          },
+        },
+      ])
+    ).toEqual({
+      components: {
+        schemas: {
+          DemoError: {
+            allOf: [{ $ref: "#/components/schemas/One" }],
+          },
+        },
+      },
+    });
+  });
+
+  it("anyOf", () => {
+    expect(
+      merger([
+        {
+          components: {
+            schemas: {
+              DemoError: {
+                allOf: [{ $ref: "#/components/schemas/One" }],
+              },
+            },
+          },
+        },
+        {
+          components: {
+            schemas: {
+              DemoError: {
+                allOf: [{ $ref: "#/components/schemas/One" }],
+              },
+            },
+          },
+        },
+      ])
+    ).toEqual({
+      components: {
+        schemas: {
+          DemoError: {
+            allOf: [{ $ref: "#/components/schemas/One" }],
+          },
+        },
+      },
+    });
+  });
+});
+
+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.5.2",
+  "version": "0.6.0",
   "description": "",
   "main": "index.js",
   "bin": {