Laying the groundwork for the git refactor

jest.config.js

@@ -15,8 +15,12 @@ const config = {
     },
     {
       displayName: "Unit-Tests",
-      testMatch: ["<rootDir>/src/tests/*.test.js"],
+      testMatch: ["<rootDir>/src/tests/vcs.test.js"],
     },
+    {
+      displayName: "VCS-Tests",
+      testMatch: ["<rootDir>/src/vcs_providers_tests/**/*.test.js"],
+    }
   ],
 };
 

package.json

@@ -12,6 +12,7 @@
     "test:integration": "cross-env NODE_ENV=test PULSAR_STATUS=dev jest --selectProjects Integration-Tests",
     "start:dev": "cross-env PULSAR_STATUS=dev node ./src/dev_server.js",
     "test": "cross-env NODE_ENV=test PULSAR_STATUS=dev jest",
+    "test:vcs": "cross-env NODE_ENV=test PULSAR_STATUS=dev jest --selectProjects VCS-Tests",
     "api-docs": "quick-webserver-docs -i ./src/main.js -o ./docs/reference/API_Definition.md",
     "lint": "prettier --check -u -w .",
     "complex": "cr --newmi --config .complexrc .",

src/tests/vcs.test.js

@@ -0,0 +1,62 @@
+const vcs = require("../vcs.js");
+
+describe("determineProvider Returns as expected", () => {
+  test("Returns null when no input is passed", () => {
+    const res = vcs.determineProvider();
+    expect(res.type).toBe("na");
+    expect(res.url).toBe("");
+  });
+  test("Returns null when null input is passed", () => {
+    const res = vcs.determineProvider(null);
+    expect(res.type).toBe("na");
+    expect(res.url).toBe("");
+  });
+  test("Returns proper object, when object is passed", () => {
+    const tmp = { type: "git", url: "https://github.com/confused-Techie/atom-backend" };
+    const res = vcs.determineProvider(tmp);
+    expect(res.type).toBe(tmp.type);
+    expect(res.url).toBe(tmp.url);
+  });
+  test("Returns unknown VCS Object, when unkown is passed", () => {
+    const tmp = "https://new-vcs.com/pulsar-edit/pulsar";
+    const res = vcs.determineProvider(tmp);
+    expect(res.type).toBe("unkown");
+    expect(res.url).toBe(tmp);
+  });
+  test("Returns unkown string when passed invalid data", () => {
+    const tmp = 123;
+    const res = vcs.determineProvider(tmp);
+    expect(res.type).toBe("unkown");
+    expect(res.url).toBe(tmp);
+  });
+  test("Returns proper GitHub Object, passed GitHub string", () => {
+    const tmp = "https://github.com/confused-Techie/atom-backend";
+    const res = vcs.determineProvider(tmp);
+    expect(res.type).toBe("git");
+    expect(res.url).toBe(tmp);
+  });
+  test("Returns proper GitLab Object, passed GitLab string", () => {
+    const tmp = "https://gitlab.com/clj-editors/atom-chlorine";
+    const res = vcs.determineProvider(tmp);
+    expect(res.type).toBe("lab");
+    expect(res.url).toBe(tmp);
+  });
+  test("Returns proper Sourceforge Object, when passed Sourceforge string", () => {
+    const tmp = "https://sourceforge.net/projects/jellyfin.mirror/";
+    const res = vcs.determineProvider(tmp);
+    expect(res.type).toBe("sfr");
+    expect(res.url).toBe(tmp);
+  });
+  test("Returns proper Bitbucket Object, when passed Bitbucket string", () => {
+    const tmp = "https://bitbucket.org/docker_alpine/alpine-jellyfin/src/master/";
+    const res = vcs.determineProvider(tmp);
+    expect(res.type).toBe("bit");
+    expect(res.url).toBe(tmp);
+  });
+  test("Returns proper Codeberg Object, when passed Codeberg string", () => {
+    const tmp = "https://codeberg.org/itbastian/makemkv-move-extras";
+    const res = vcs.determineProvider(tmp);
+    expect(res.type).toBe("berg");
+    expect(res.url).toBe(tmp);
+  });
+});

src/vcs.js

@@ -0,0 +1,133 @@
+/**
+ * @module vcs
+ * @desc This Module is intended to be the platform agnostic tool to interaction
+ * with Version Control Systems of different types in the cloud.
+ * To collect data from them, format it accordingly ang return it to the requesting
+ * function.
+ */
+
+/**
+ * @async
+ * @function ownership
+ * @desc Allows the ability to check if a user has permissions to write to a repo.
+ * <b>MUST</b> be provided the full `user` and `package` objects here to account
+ * for possible situations. This allows any new handling that's needed to be defined
+ * here rather than in multiple locations throughout the codebase.
+ * Returns `ok: true` where content is the repo data from the service provider on
+ * success, returns `ok: false` if they do not have access to said repo, with
+ * specificity available within the `short` key.
+ * @param {object} userObj - The Full User Object, as returned by the backend,
+ * and appended to with authorization data.
+ * @param {object} packObj - The full Package objects data from the backend.
+ * @param {object} [opts] - An optional configuration object, that allows the
+ * definition of non-standard options to change the fucntionality of this function.
+ * `opts` can accept the following parameters:
+ *  - dev_override: {boolean} - Wether to enable or disable the dev_override. Disabled
+ *    by default, this dangerous boolean is inteded to be used during tests that
+ *    overrides the default safe static returns, and lets the function run as intended
+ *    in development mode.
+ * @returns {object} - A Server Status object containing either minor repo data on
+ * success or a failure.
+ */
+async function ownership(userObj, packObj, opts = { dev_override: false }) {
+  if (
+    process.env.PULSAR_STATUS === "dev" &&
+    !dev_override &&
+    process.env.MOCK_GH !== "false"
+  ) {
+    console.log(`git.js.ownership() Is returning Dev Only Permissions for ${user.username}`);
+
+
+  }
+  // None dev return.
+
+
+}
+
+/**
+ * @function determineProvider
+ * @desc Determines the repostiry object by the given argument.
+ * Takes the `repository` key of a `package.json` and with very little if not no
+ * desctructing will attempt to locate the provider service and return an object
+ * with it.
+ * @param {string|object} repo - The `repository` of the retrieved package.
+ * @returns {object} The object related to the package repository type.
+ */
+function determineProvider(repo) {
+  try {
+    // First party packages do already have the regular package object.
+    // So we will need to check if it's an object or string.
+    if (repo === null || repo === undefined) {
+      return {
+        type: "na",
+        url: ""
+      };
+    }
+
+    // If not null, it's likely a first party package
+    // With an already valid package object that can just be returned.
+    if (typeof repo === "object") {
+      return repo;
+    }
+
+    if (typeof repo !== "string") {
+      return {
+        type: "unkown",
+        url: repo
+      };
+    }
+
+    // The repo is a string, and we need to determine who the provider is.
+    const lcRepo = repo.toLowerCase();
+
+    switch(true) {
+      case lcRepo.includes("github"):
+        return {
+          type: "git",
+          url: repo,
+        };
+
+      case lcRepo.includes("bitbucket"):
+        return {
+          type: "bit",
+          url: repo,
+        };
+
+      case lcRepo.includes("sourceforge"):
+        return {
+          type: "sfr",
+          url: repo,
+        };
+
+      case lcRepo.includes("gitlab"):
+        return {
+          type: "lab",
+          url: repo,
+        };
+
+      case lcRepo.includes("codeberg"):
+        return {
+          type: "berg",
+          url: repo
+        };
+
+      default:
+        // If no other recognized matches exist, return repo with na service provider.
+        return {
+          type: "unkown",
+          url: repo,
+        };
+    }
+
+  } catch(err) {
+    return {
+      type: "na",
+      url: ""
+    };
+  }
+}
+
+module.exports = {
+  determineProvider,
+  ownership,
+};

src/vcs_providers/git.js

@@ -0,0 +1,51 @@
+/**
+ * @module git
+ * @desc This Module ideally will support a base class that all VCS support systems can inherit.
+ * This Base model is needing to work against being properly useful, to helpfully cut down on
+ * the code needed to create future support for other services. So we will need to test.
+ */
+
+ const superagent = require("superagent");
+ const { GH_USERAGENT } = require("../config.js").getConfig();
+
+ class Git {
+   constructor(opts) {
+     this.api_url = opts.api_url;
+     this.acceptable_status_codes = opts.ok_status ?? [200];
+   }
+
+   async _webRequestAuth(url, token) {
+     try {
+
+       const res = await superagent
+        .get(`${this.api_url}${url}`)
+        .set({
+          Authorization: `Bearer ${token}`,
+        })
+        .set({ "User-Agent": GH_USERAGENT })
+        // This last line here, lets the class define what HTTP Status Codes
+        // It will not throw an error on.
+        // If a status code not present in this array is received, it will throw an error.
+        .ok((res) => this.acceptable_status_codes.includes(res.status));
+
+      if (res.status !== 200) {
+        // We have not received 200 code: return a failure
+        return { ok: false, short: "Failed Request", content: res };
+      }
+
+      // The Status code is a success, return the request.
+      return { ok: true, content: res };
+
+     } catch(err) {
+       return { ok: false, short: "Exception During Web Request", content: res };
+     }
+   }
+
+ }
+
+ // In order for extends classes to properly work with VCS, they will have to export certain functions:
+ // * ownership
+ // * readme
+ // *
+
+ module.exports = Git;

src/vcs_providers/github.js

@@ -0,0 +1,85 @@
+/**
+ * @module GitHub
+ * @desc A VCS Module to allow `vcs.js` to interact with GitHub as needed. Utilizing `git.js`
+ */
+
+const Git = require("./git.js");
+
+class GitHub extends Git {
+  constructor(opts) {
+
+    super({
+      api_url: opts.api_url ?? "https://api.github.com",
+      ok_status: [200, 401]
+    });
+  }
+
+  ownership(user, repo) {
+
+  }
+
+  async doesUserHaveRepo(token, ownerRepo, page = 1) {
+    try {
+      let check = await this._webRequestAuth(`/user/repos?page=${page}`, token);
+
+      if (!check.ok) {
+        if (check.short === "Failed Request") {
+          // This means the request failed with a non 200 HTTP Status Code.
+          // Looking into the error could tell us if the token is expired or etc.
+          switch(check.content.status) {
+            case 401:
+              return {
+                ok: false,
+                short: "Bad Auth"
+              };
+            default:
+              return {
+                ok: false,
+                short: "Server Error"
+              };
+          }
+        }
+        // Otherwise the short is something else. Likely a server error, and
+        // we will want to return a server error.
+        return {
+          ok: false,
+          short: "Server Error"
+        };
+      }
+
+      for (let i = 0; i < check.content.body.length; i++) {
+        if (check.content.body[i].full_name === ownerRepo) {
+          return {
+            ok: true,
+            content: check.content.body[i]
+          };
+        }
+      }
+
+      // After going through every repo returned, we haven't found a repo
+      // that the user owns. Lets check if there's multiple pages of returns.
+      const nextPage = page + 1;
+      if (res.headers.link.includes(`?page=${nextPage}`)) {
+        // We have another page available via the page headers
+        // Lets call this again with the next page
+        return await this.doesUserHaveRepo(token, ownerRepo, nextPage);
+      }
+
+      // There are no additional pages. Return that we don't have access
+      return {
+        ok: false,
+        short: "No Access"
+      };
+
+    } catch(err) {
+      // We encounted an exception that's not related to the webrequest.
+      return {
+        ok: false,
+        short: "Server Error",
+        content: err
+      };
+    }
+  }
+}
+
+module.exports = GitHub;

src/vcs_providers_tests/github/fixtures/doesUserHaveRepo_badAuth.js

@@ -0,0 +1,28 @@
+const express = require("express");
+const app = express();
+
+let port = "9999";
+
+app.get("/user/repos", async (req, res) => {
+  // We will return that these are invalid credentials no matter what
+  res
+    .status(401)
+    .set({
+      Authorization: req.get("Authorization"),
+      "User-Agent": req.get("User-Agent"),
+      Link: `<localhost:${port}/user/repos?page=1>; rel="first", <localhost:${port}/user/repos?page=1>; rel="last"`,
+    })
+    .json({
+      message: "Requires authentication",
+      documentation_url: "https://docs.github.com/rest/reference/repo#list-repositories-for-the-authenticated-user"
+    });
+});
+
+function setPort(val) {
+  port = val;
+}
+
+module.exports = {
+  app,
+  setPort,
+};