oas-toolkit 0.6.3 → 0.7.0

package/cli/bin.js

@@ -19,4 +19,14 @@ yargs(hideBin(process.argv))
     "remove unused components from the provided OpenAPI file",
     require("./commands/remove-unused-components")
   )
+  .command(
+    "remove-unused-tags <openapi.yaml>",
+    "remove unused tags from the provided OpenAPI file",
+    require("./commands/remove-unused-tags")
+  )
+  .command(
+    "rewrite-path <openapi.yaml> --oldPrefix '^/v1' --newPrefix '/v2'",
+    "rewrite paths in the provided OpenAPI file",
+    require("./commands/rewrite-path")
+  )
   .parse();

package/cli/commands/remove-unused-tags.js

@@ -0,0 +1,19 @@
+const fs = require("fs");
+const yaml = require("js-yaml");
+
+module.exports = async function ({ argv }) {
+  try {
+    const oasFiles = argv._.slice(1);
+    if (oasFiles.length !== 1) {
+      return;
+    }
+
+    const tags = require("../../tags");
+    let oas = yaml.load(fs.readFileSync(oasFiles[0]));
+    oas = tags.removeUnusedTags(oas);
+    console.log(yaml.dump(oas));
+  } catch (e) {
+    console.error(`ERROR: ${e.message}`);
+    process.exit(1);
+  }
+};

package/cli/commands/rewrite-path.js

@@ -0,0 +1,24 @@
+const fs = require("fs");
+const yaml = require("js-yaml");
+
+module.exports = async function ({ argv }) {
+  try {
+    const oasFiles = argv._.slice(1);
+    if (oasFiles.length !== 1) {
+      return;
+    }
+
+    if (!argv.oldPrefix || !argv.newPrefix) {
+      console.error(`ERROR: --oldPrefix and --newPrefix are required`);
+      process.exit(1);
+    }
+
+    const p = require("../../rewrite-path");
+    let oas = yaml.load(fs.readFileSync(oasFiles[0]));
+    oas = p.regex(oas, argv.oldPrefix, argv.newPrefix);
+    console.log(yaml.dump(oas));
+  } catch (e) {
+    console.error(`ERROR: ${e.message}`);
+    process.exit(1);
+  }
+};

package/package.json

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

package/rewrite-path.js

@@ -0,0 +1,16 @@
+function regex(oas, oldPrefix, newPrefix) {
+  oldPrefix = new RegExp(oldPrefix);
+  oas = JSON.parse(JSON.stringify(oas)); // Prevent modification of original object
+  for (let path in oas.paths) {
+    if (path.match(oldPrefix)) {
+      const newPath = path.replace(oldPrefix, newPrefix);
+      oas.paths[newPath] = oas.paths[path];
+      delete oas.paths[path];
+    }
+  }
+  return oas;
+}
+
+module.exports = {
+  regex,
+};

package/rewrite-path.test.js

@@ -0,0 +1,61 @@
+const p = require("./rewrite-path");
+
+const hello = {
+  post: {
+    operationId: "create-hello",
+    requestBody: {
+      $ref: "#/components/requestBodies/CreateHello",
+    },
+    responses: {},
+  },
+  get: {
+    operationId: "get-hello",
+    responses: {},
+  },
+};
+
+const world = {
+  get: {
+    operationId: "create-world",
+    requestBody: {
+      $ref: "#/components/requestBodies/CreateWorld",
+    },
+    responses: {},
+  },
+};
+
+const oas = {
+  paths: {
+    "/v1/foo/hello": hello,
+    "/v1/foo/world": world,
+  },
+};
+
+describe("#rewrite-path", () => {
+  it("rewrites a prefix", () => {
+    expect(p.regex(oas, "^/v1", "/v2")).toEqual({
+      paths: {
+        "/v2/foo/hello": hello,
+        "/v2/foo/world": world,
+      },
+    });
+  });
+
+  it("rewrites anywhere in the string", () => {
+    expect(p.regex(oas, "/foo", "/bar")).toEqual({
+      paths: {
+        "/v1/bar/hello": hello,
+        "/v1/bar/world": world,
+      },
+    });
+  });
+
+  it("does not rewrite non-matching regex", () => {
+    expect(p.regex(oas, "^/foo", "/bar")).toEqual({
+      paths: {
+        "/v1/foo/hello": hello,
+        "/v1/foo/world": world,
+      },
+    });
+  });
+});

package/tags.js

@@ -0,0 +1,41 @@
+const traverse = require("traverse");
+const difference = require("lodash.difference");
+
+function removeUnusedTags(oas) {
+  const used = getReferencedTags(oas);
+  const defined = getDefinedTags(oas);
+  const unused = getUnusedTags(defined, used);
+
+  return removeSpecifiedTags(oas, unused);
+}
+
+function removeSpecifiedTags(oas, unused) {
+  oas = JSON.parse(JSON.stringify(oas)); // Prevent modification of original object
+  oas.tags = oas.tags.filter((t) => !unused.includes(t.name));
+  return oas;
+}
+
+function getReferencedTags(oas) {
+  return traverse(oas).reduce(function (acc, x) {
+    if (this.node && this.node["operationId"] && this.node["tags"]) {
+      acc = acc.concat(this.node["tags"]);
+    }
+    return acc;
+  }, []);
+}
+
+function getDefinedTags(oas) {
+  return oas.tags.map((t) => t.name);
+}
+
+function getUnusedTags(all, referenced) {
+  return difference(all, referenced);
+}
+
+module.exports = {
+  getReferencedTags,
+  getDefinedTags,
+  getUnusedTags,
+  removeSpecifiedTags,
+  removeUnusedTags,
+};

package/tags.test.js

@@ -0,0 +1,92 @@
+const t = require("./tags");
+
+const tags = [
+  {
+    name: "One",
+    description: "Tag Number One",
+  },
+  {
+    name: "Two",
+    description: "Tag Number One",
+  },
+  {
+    name: "Three",
+    description: "Tag Number One",
+  },
+];
+
+const oas = {
+  info: { title: "One" },
+  security: [{ personalAccessToken: {} }],
+  paths: {
+    "/foo": {
+      post: {
+        operationId: "create-foo",
+        tags: ["One"],
+        requestBody: {
+          $ref: "#/components/requestBodies/CreateFoo",
+        },
+        responses: {
+          201: {
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/Foo",
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+  tags,
+};
+
+describe("#tags", () => {
+  it("extracts referenced tags", () => {
+    expect(t.getReferencedTags(oas)).toEqual(["One"]);
+  });
+
+  it("returns unused tags (without unused)", () => {
+    expect(t.getUnusedTags(["One", "Two"], ["Two", "One"])).toEqual([]);
+  });
+
+  it("returns unused tags (with unused)", () => {
+    expect(t.getUnusedTags(["One", "Two"], ["Two"])).toEqual(["One"]);
+  });
+
+  it("returns all defined tags", () => {
+    expect(t.getDefinedTags(oas)).toEqual(["One", "Two", "Three"]);
+  });
+
+  it("removes unused tags", () => {
+    expect(t.removeUnusedTags(oas)).toEqual({
+      info: { title: "One" },
+      security: [{ personalAccessToken: {} }],
+      paths: {
+        "/foo": {
+          post: {
+            operationId: "create-foo",
+            tags: ["One"],
+            requestBody: {
+              $ref: "#/components/requestBodies/CreateFoo",
+            },
+            responses: {
+              201: {
+                content: {
+                  "application/json": {
+                    schema: {
+                      $ref: "#/components/schemas/Foo",
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+      },
+      tags: [{ name: "One", description: "Tag Number One" }],
+    });
+  });
+});