oas-toolkit 0.13.1 → 0.15.0

package/cli/bin.js

@@ -20,6 +20,24 @@ yargs(hideBin(process.argv))
     "check for conflicting components, paths, tags, and security schemes",
     require("./commands/check-conflicts")
   )
+  .command(
+    "filter-annotation <openapi>",
+    "keep/remove all paths with a specific annotation",
+    (yargs) => {
+      yargs.option("keep", {
+        demandOption: false,
+      });
+      yargs.option("remove", {
+        demandOption: false
+      });
+      yargs.positional("openapi", {
+        require: true,
+        describe: "the OpenAPI file to rewrite",
+        type: "string",
+      });
+    },
+    require("./commands/filter-annotation")
+  )
   .command(
     "remove-unused-components <openapi>",
     "remove unused components from the provided OpenAPI file",

package/cli/commands/filter-annotation.js

@@ -0,0 +1,14 @@
+const fs = require("fs");
+const yaml = require("js-yaml");
+
+module.exports = async function (argv) {
+  try {
+    const p = require("../../filter-annotation");
+    let oas = yaml.load(fs.readFileSync(argv.openapi));
+    oas = p.run(oas, { keep: argv.keep?.split(","), remove: argv.remove?.split(",") });
+    console.log(yaml.dump(oas));
+  } catch (e) {
+    console.error(`ERROR: ${e.message}`);
+    process.exit(1);
+  }
+};

package/filter-annotation.js

@@ -0,0 +1,38 @@
+const isEqual = require("lodash.isequal");
+const uniqWith = require("lodash.uniqwith");
+const url = require("url");
+function run(oas, opts = {}) {
+  oas = JSON.parse(JSON.stringify(oas)); // Prevent modification of original object
+
+  for (const p of Object.keys(oas.paths)) {
+    const path = oas.paths[p];
+    for (const verb in path) {
+      if (opts.keep?.length > 0) {
+        for (const keep of opts.keep) {
+          if (path[verb][keep] === undefined) {
+            delete path[verb];
+          }
+        }
+      }
+
+      if (opts.remove?.length > 0) {
+        for (const remove of opts.remove) {
+          if (path[verb][remove]) {
+            delete path[verb];
+          }
+        }
+      }
+    }
+
+    // Remove empty paths
+    if (Object.keys(path).length === 0) {
+      delete oas.paths[p];
+    }
+  }
+
+  return oas;
+}
+
+module.exports = {
+  run,
+};

package/filter-annotation.test.js

@@ -0,0 +1,48 @@
+const c = require("./filter-annotation");
+
+const oas = {
+  servers: [
+    {
+      url: "https://api.example.com/v1",
+    },
+  ],
+  paths: {
+    "/foo/hello": {
+      get: {
+        "x-internal": true,
+        description: "Hello world endpoint",
+      },
+      post: {
+        description: "Create a hello world",
+      },
+    },
+  },
+};
+
+
+describe("#run", () => {
+  it("with keep", () => {
+    expect(c.run(oas, { keep: ["x-internal"] }).paths).toEqual({
+      "/foo/hello": {
+        get: {
+          "x-internal": true,
+          description: "Hello world endpoint",
+        },
+      },
+    });
+  });
+
+  it("with remove", () => {
+    expect(c.run(oas, { remove: ["x-internal"] }).paths).toEqual({
+      "/foo/hello": {
+        post: {
+          description: "Create a hello world",
+        },
+      },
+    });
+  });
+
+  it("removes empty paths", () => {
+    expect(c.run(oas, { keep: ["x-missing"] }).paths).toEqual({});
+  });
+});

package/index.js

@@ -2,6 +2,7 @@ module.exports = {
   canonicalServer: require("./canonical-server"),
   components: require("./components"),
   expandAllOf: require("./expand-allof"),
+  filterAnnotation: require("./filter-annotation"),
   merger: require("./merger"),
   removeWithAnnotation: require("./remove-with-annotation"),
   rewritePath: require("./rewrite-path"),

package/merger.js

@@ -124,12 +124,26 @@ function ensureNoPathColissions(objects) {
   }
 }
 
-function ensureListUniqueness(list, key, objects) {
+function ensureListUniqueness(list, keys, objects) {
   let all = [];
+
   for (let object of objects) {
     all = all.concat(object[list] || []);
   }
 
+  // Update the key based on overrides
+  const key = keys[0];
+  keys = keys.slice(1);
+  all = all.map((s) => {
+    if (keys.length) {
+      const newKey = keys.find((k) => s[k]);
+      if (newKey) {
+        s[key] = s[newKey];
+      }
+    }
+    return s;
+  });
+
   for (let c of all) {
     const d = all.filter((t) => {
       return t[key] == c[key] && !isEqual(c, t);
@@ -157,7 +171,7 @@ function ensureListUniqueness(list, key, objects) {
 }
 
 function ensureNoTagColissions(objects) {
-  ensureListUniqueness("tags", "name", objects);
+  ensureListUniqueness("tags", ["name", "x-bundled-name", "x-name-override"], objects);
 }
 
 function ensureNoSecurityColissions(objects) {

package/merger.test.js

@@ -20,6 +20,42 @@ describe("#ensureNoTagColissions", () => {
     ).toBe(undefined);
   });
 
+  it("throws with different descriptions", () => {
+    expect(() => {
+      ensureNoTagColissions([
+        { info: { title: "One" }, tags: [{ name: "Demo", description: "Demo in One" }] },
+        { info: { title: "Two" }, tags: [{ name: "Demo", description: "Demo in Two" }] },
+      ])
+    }).toThrow(new Error("Conflicting tags detected: Demo (One, Two)"))
+  });
+
+  it("respects overrides (x-bundled-name)", () => {
+    expect(
+      ensureNoTagColissions([
+        { info: { title: "One" }, tags: [{ name: "Demo", description: "Demo in One", "x-bundled-name": "Demo One" }] },
+        { info: { title: "Two" }, tags: [{ name: "Demo", description: "Demo in Two", "x-bundled-name": "Demo Two" }] },
+      ])
+    ).toBe(undefined);
+  });
+
+  it("respects overrides (x-name-override)", () => {
+    expect(
+      ensureNoTagColissions([
+        { info: { title: "One" }, tags: [{ name: "Demo", description: "Demo in One", "x-name-override": "Demo One" }] },
+        { info: { title: "Two" }, tags: [{ name: "Demo", description: "Demo in Two", "x-name-override": "Demo Two" }] },
+      ])
+    ).toBe(undefined);
+  });
+
+  it("throws when the override is the same", () => {
+    expect(() => {
+      ensureNoTagColissions([
+        { info: { title: "One" }, tags: [{ name: "Demo One", description: "Demo in One", "x-bundled-name": "Demo" }] },
+        { info: { title: "Two" }, tags: [{ name: "Demo Two", description: "Demo in Two", "x-bundled-name": "Demo" }] },
+      ])
+    }).toThrow(new Error("Conflicting tags detected: Demo (One, Two)"))
+  });
+
   it("throws when there is a field in one tag but not in another", () => {
     expect(() => {
       ensureNoTagColissions([

package/package.json

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