@credibledata/cred-cli 0.1.3 → 0.1.5

package/src/commands/version/listversions.spec.ts

@@ -0,0 +1,138 @@
+import { expect } from "chai";
+import sinon from "sinon";
+import { VersionsApi } from "../../client/api";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import { prettifyJson } from "../../utils";
+import { listVersions } from "./listversions";
+
+describe("list-versions", () => {
+   let sandbox: sinon.SinonSandbox;
+   let listVersionsStub: sinon.SinonStub;
+   let loggerStub: sinon.SinonStubbedInstance<typeof logger>;
+   let consoleLogStub: sinon.SinonStub;
+
+   beforeEach(() => {
+      sandbox = sinon.createSandbox();
+      listVersionsStub = sandbox.stub();
+      loggerStub = sandbox.stub(logger);
+      consoleLogStub = sandbox.stub(console, "log");
+
+      sandbox
+         .stub(ClientConfiguration.prototype, "getOrganization")
+         .returns("test-org");
+      sandbox
+         .stub(ClientConfiguration.prototype, "getProject")
+         .returns("test-project");
+      sandbox
+         .stub(ClientConfiguration.prototype, "doesConfigExists")
+         .returns(true);
+      sandbox
+         .stub(ClientConfiguration.prototype, "getHeaders")
+         .returns({ Authorization: "Bearer test-token" });
+
+      sandbox
+         .stub(VersionsApi.prototype, "listVersions")
+         .callsFake(listVersionsStub);
+   });
+
+   afterEach(() => {
+      sandbox.restore();
+   });
+
+   it("should list versions successfully", async () => {
+      const mockVersions = [
+         { id: "1.0.0", archiveStatus: "active" },
+         { id: "2.0.0", archiveStatus: "active" },
+      ];
+      const mockResponse = {
+         data: mockVersions,
+      };
+      listVersionsStub.resolves(mockResponse);
+
+      await listVersions("http://test-server", "/test-package", false);
+
+      expect(listVersionsStub.calledOnce).to.be.true;
+      expect(listVersionsStub.firstCall.args[0]).to.equal("test-org");
+      expect(listVersionsStub.firstCall.args[1]).to.equal("test-project");
+      expect(listVersionsStub.firstCall.args[2]).to.equal("test-package");
+      expect(listVersionsStub.firstCall.args[3]).to.deep.include({
+         baseURL: "http://test-server",
+         headers: { Authorization: "Bearer test-token" },
+      });
+      expect(consoleLogStub.calledWith(prettifyJson(mockVersions))).to.be.true;
+   });
+
+   it("should handle package path without leading slash", async () => {
+      const mockVersions = [{ id: "1.0.0" }];
+      const mockResponse = {
+         data: mockVersions,
+      };
+      listVersionsStub.resolves(mockResponse);
+
+      await listVersions("http://test-server", "test-package", false);
+
+      expect(listVersionsStub.firstCall.args[2]).to.equal("test-package");
+   });
+
+   it("should handle missing config", async () => {
+      sandbox.restore();
+      sandbox = sinon.createSandbox();
+      listVersionsStub = sandbox.stub();
+      loggerStub = sandbox.stub(logger);
+      consoleLogStub = sandbox.stub(console, "log");
+
+      sandbox
+         .stub(ClientConfiguration.prototype, "doesConfigExists")
+         .returns(false);
+      sandbox
+         .stub(VersionsApi.prototype, "listVersions")
+         .callsFake(listVersionsStub);
+
+      await listVersions("http://test-server", "/test-package", false);
+
+      expect(listVersionsStub.called).to.be.false;
+      expect(
+         loggerStub.error.calledWith(
+            sinon.match("Please, make sure that you are logged in"),
+         ),
+      ).to.be.true;
+   });
+
+   it("should handle missing project", async () => {
+      sandbox.restore();
+      sandbox = sinon.createSandbox();
+      listVersionsStub = sandbox.stub();
+      loggerStub = sandbox.stub(logger);
+      consoleLogStub = sandbox.stub(console, "log");
+
+      sandbox
+         .stub(ClientConfiguration.prototype, "doesConfigExists")
+         .returns(true);
+      sandbox.stub(ClientConfiguration.prototype, "getProject").returns("");
+      sandbox
+         .stub(VersionsApi.prototype, "listVersions")
+         .callsFake(listVersionsStub);
+
+      await listVersions("http://test-server", "/test-package", false);
+
+      expect(listVersionsStub.called).to.be.false;
+      expect(
+         loggerStub.error.calledWith(
+            sinon.match("Please, make sure to set a project"),
+         ),
+      ).to.be.true;
+   });
+
+   it("should handle API errors", async () => {
+      const mockError = new Error("API Error");
+      listVersionsStub.rejects(mockError);
+
+      await listVersions("http://test-server", "/test-package", true);
+
+      expect(listVersionsStub.calledOnce).to.be.true;
+      expect(
+         loggerStub.error.calledWith(sinon.match("Failed to list versions")),
+      ).to.be.true;
+   });
+});

package/src/common/UserGroupId.spec.ts

@@ -0,0 +1,117 @@
+import { expect } from "chai";
+import { ResourceType, UserGroupId } from "./UserGroupId";
+
+describe("UserGroupId", () => {
+   describe("constructor", () => {
+      it("should parse a valid user id", () => {
+         const id = new UserGroupId("user:john");
+         expect(id.getResourceType()).to.equal(ResourceType.USER);
+         expect(id.getResourceName()).to.equal("john");
+         expect(id.getValue()).to.equal("user:john");
+      });
+
+      it("should parse a valid group id", () => {
+         const id = new UserGroupId("group:admins");
+         expect(id.getResourceType()).to.equal(ResourceType.GROUP);
+         expect(id.getResourceName()).to.equal("admins");
+         expect(id.getValue()).to.equal("group:admins");
+      });
+
+      it("should trim whitespace from input", () => {
+         const id = new UserGroupId("  user:john  ");
+         expect(id.getValue()).to.equal("user:john");
+         expect(id.getResourceName()).to.equal("john");
+      });
+
+      it("should throw for null or empty input", () => {
+         expect(() => new UserGroupId("")).to.throw("cannot be null or empty");
+         expect(() => new UserGroupId("   ")).to.throw(
+            "cannot be null or empty",
+         );
+      });
+
+      it("should throw for invalid format", () => {
+         expect(() => new UserGroupId("invalid")).to.throw(
+            "Invalid UserGroupId format",
+         );
+         expect(() => new UserGroupId("user:")).to.throw(
+            "Invalid UserGroupId format",
+         );
+         expect(() => new UserGroupId("foo:bar")).to.throw(
+            "Invalid UserGroupId format",
+         );
+         expect(() => new UserGroupId("user:a:b")).to.throw(
+            "Invalid UserGroupId format",
+         );
+      });
+   });
+
+   describe("static factory methods", () => {
+      it("forPublicAccess should create user:* id", () => {
+         const id = UserGroupId.forPublicAccess();
+         expect(id.getResourceType()).to.equal(ResourceType.USER);
+         expect(id.getResourceName()).to.equal("*");
+         expect(id.getValue()).to.equal("user:*");
+      });
+
+      it("forUser should create a user id", () => {
+         const id = UserGroupId.forUser("alice");
+         expect(id.getResourceType()).to.equal(ResourceType.USER);
+         expect(id.getResourceName()).to.equal("alice");
+      });
+
+      it("forUser should throw for undefined user name", () => {
+         expect(() => UserGroupId.forUser(undefined)).to.throw(
+            "cannot be undefined",
+         );
+      });
+
+      it("forGroup should create a group id", () => {
+         const id = UserGroupId.forGroup("developers");
+         expect(id.getResourceType()).to.equal(ResourceType.GROUP);
+         expect(id.getResourceName()).to.equal("developers");
+      });
+
+      it("create should build from ResourceType and name", () => {
+         const userId = UserGroupId.create(ResourceType.USER, "bob");
+         expect(userId.getResourceType()).to.equal(ResourceType.USER);
+         expect(userId.getResourceName()).to.equal("bob");
+
+         const groupId = UserGroupId.create(ResourceType.GROUP, "team");
+         expect(groupId.getResourceType()).to.equal(ResourceType.GROUP);
+         expect(groupId.getResourceName()).to.equal("team");
+      });
+   });
+
+   describe("serialization", () => {
+      it("toString should return original value", () => {
+         const id = new UserGroupId("user:john");
+         expect(id.toString()).to.equal("user:john");
+      });
+
+      it("toJSON should return original value for JSON serialization", () => {
+         const id = new UserGroupId("group:admins");
+         expect(id.toJSON()).to.equal("group:admins");
+         expect(JSON.stringify(id)).to.equal('"group:admins"');
+      });
+   });
+
+   describe("isPublicAccess", () => {
+      it("should return false for regular user ids", () => {
+         const id = new UserGroupId("user:john");
+         expect(id.isPublicAccess()).to.be.false;
+      });
+
+      it("should return false for group ids", () => {
+         const id = new UserGroupId("group:admins");
+         expect(id.isPublicAccess()).to.be.false;
+      });
+
+      it("should return false for user:* (checks originalValue not resourceName)", () => {
+         // isPublicAccess checks this.originalValue === "*" which is never true
+         // since originalValue is the full string "user:*"
+         const id = UserGroupId.forPublicAccess();
+         expect(id.isPublicAccess()).to.be.false;
+      });
+   });
+});

package/src/constants.ts

@@ -3,16 +3,23 @@ export type Environment =
    | "staging"
    | "dev"
    | "localhost"
-   | "e2e-test";
+   | "e2e-test"
+   | "videoamp";
 
 export const controlPlanesByEnv: Record<Environment, string> = {
-   production: "https://admin.ms2.co/api/v0",
-   dev: "https://dev-admin.ms2.co/api/v0",
-   staging: "https://staging-admin.ms2.co/api/v0",
+   production: "https://admin.credibledata.com/api/v0",
+   dev: "https://dev-admin.credibledata.com/api/v0",
+   staging: "https://staging-admin.credibledata.com/api/v0",
    localhost: "http://admin.ms2.localhost/api/v0",
    "e2e-test": "http://admin.ms2.localhost/api/v0",
+   videoamp: "https://admin.videoamp-aws-us-east-1.credibledata.com/api/v0",
 };
 
+/** Environments that must have an object in `~/.cred` `configPerEnvironment` (avoids undefined on write). */
+export const ALL_ENVIRONMENTS = Object.keys(
+   controlPlanesByEnv,
+) as Environment[];
+
 export const auth0ConfigsByEnv: Record<
    Environment,
    {
@@ -23,34 +30,73 @@ export const auth0ConfigsByEnv: Record<
    }
 > = {
    production: {
-      domain: "https://ms2data.us.auth0.com",
+      domain: "https://auth.credibledata.com",
       clientId: "ge8JL5TJNwqy7bygAaJkD92KdluqEZgO",
       audience: "https://ms2data.us.auth0.com/api/v2/",
    },
    dev: {
-      domain: "https://dev-ohaafogw5p8uyx1m.us.auth0.com",
+      domain: "https://dev-auth.credibledata.com",
       clientId: "rr6mzJNj9b104MjCc9xWKPPehq1MJx0L",
       audience: "https://dev-ohaafogw5p8uyx1m.us.auth0.com/api/v2/",
    },
    staging: {
-      domain: "https://dev-ohaafogw5p8uyx1m.us.auth0.com",
+      domain: "https://dev-auth.credibledata.com",
       clientId: "rr6mzJNj9b104MjCc9xWKPPehq1MJx0L",
       audience: "https://dev-ohaafogw5p8uyx1m.us.auth0.com/api/v2/",
    },
    localhost: {
-      domain: "https://dev-ohaafogw5p8uyx1m.us.auth0.com",
+      domain: "https://dev-auth.credibledata.com",
       clientId: "rr6mzJNj9b104MjCc9xWKPPehq1MJx0L",
       audience: "https://dev-ohaafogw5p8uyx1m.us.auth0.com/api/v2/",
    },
    "e2e-test": {
-      domain: "https://dev-ohaafogw5p8uyx1m.us.auth0.com",
+      domain: "https://dev-auth.credibledata.com",
       clientId: "atd8n8dEiGUiNRM7Geuvg41fi5s8ZKqY",
       clientSecret:
          "ZrEvs86WLqKO9EPp4y_cOvUn3NQT1qc3XC8111f6DBt9oyaclV5sWHz6Nkyo_bEF",
       audience: "https://dev-ohaafogw5p8uyx1m.us.auth0.com/api/v2/",
    },
+   videoamp: {
+      domain: "https://auth.credibledata.com",
+      clientId: "ge8JL5TJNwqy7bygAaJkD92KdluqEZgO",
+      audience: "https://ms2data.us.auth0.com/api/v2/",
+   },
 };
 
+/**
+ * `cred login <organizationName>` → Auth0 Organization ID for org-branded Universal Login.
+ *
+ * Auth0 documents the `organization` parameter on `/authorize` for Organizations
+ * (https://auth0.com/docs/manage-users/organizations/configure-organizations/use-org-name-authentication-api).
+ * The Device Authorization Flow documents only `client_id`, `scope`, and `audience` on
+ * `POST /oauth/device/code` — not `organization`
+ * (https://auth0.com/docs/get-started/authentication-and-authorization-flow/device-authorization-flow/call-your-api-using-the-device-authorization-flow#device-code-parameters),
+ * so mapped orgs use Authorization Code + PKCE with `organization` on `/authorize` and
+ * {@link AUTH_CLI_LOOPBACK_REDIRECT_URI}.
+ *
+ * Align with app `ORGANIZATION_HOST_ORG_ID_MAP` / `getAuth0OrganizationAuthorizationParams`.
+ *
+ * Entries are added when PKCE + Auth0 org id is ready for that CLI name; until then the map may
+ * stay empty and `login.spec` stubs {@link getAuth0OrganizationIdForCliLogin} for PKCE coverage.
+ */
+export const AUTH0_ORGANIZATION_IDS_BY_CLI_ORG_NAME: Record<string, string> = {
+   // videoamp: "org_nMRKafeSuxOiuJeG",
+};
+
+/**
+ * Allowlisted on the Auth0 Native application (CLI) as an Allowed Callback URL for PKCE logins
+ * that pass `organization` on `/authorize` (see Auth0 Organizations + Authentication API docs above).
+ */
+export const AUTH_CLI_LOOPBACK_REDIRECT_URI = "http://127.0.0.1:18240/callback";
+
+export function getAuth0OrganizationIdForCliLogin(
+   organizationName: string,
+): string | undefined {
+   return AUTH0_ORGANIZATION_IDS_BY_CLI_ORG_NAME[
+      organizationName.toLowerCase()
+   ];
+}
+
 // Time constants in ms
 export const SECOND = 1000;
 export const MINUTE = SECOND * 60;
@@ -61,10 +107,10 @@ export const DAY = HOUR * 24;
 export const LOGIN_TIMEOUT_MS = MINUTE * 5;
 
 export const ASCII_TITLE = `
-   _____              _ _ _     _         _____ _      _____ 
+   _____              _ _ _     _         _____ _      _____
   / ____|            | (_) |   | |       / ____| |    |_   _|
- | |     _ __ ___  __| |_| |__ | | ___  | |    | |      | |  
- | |    | '__/ _ \\/ _\` | | '_ \\| |/ _ \\ | |    | |      | |  
- | |____| | |  __/ (_| | | |_) | |  __/ | |____| |____ _| |_ 
+ | |     _ __ ___  __| |_| |__ | | ___  | |    | |      | |
+ | |    | '__/ _ \\/ _\` | | '_ \\| |/ _ \\ | |    | |      | |
+ | |____| | |  __/ (_| | | |_) | |  __/ | |____| |____ _| |_
   \\_____|_|  \\___|\\__,_|_|_.__/|_|\\___|  \\_____|______|_____|
 `;

package/src/index.ts

@@ -25,19 +25,25 @@ import { ASCII_TITLE, controlPlanesByEnv } from "./constants";
 
 const clientConfig = new ClientConfiguration();
 
-const activeEnvironment = clientConfig.getEnvironment();
-axios.defaults.baseURL = controlPlanesByEnv[activeEnvironment];
+const getActiveEnvironment = () => {
+   return clientConfig.getEnvironment();
+};
+axios.defaults.baseURL = controlPlanesByEnv[getActiveEnvironment()];
 
 const cli = program
-   .version(cliPackage.version)
+   .version(
+      cliPackage.version,
+      "-V, --cli-version",
+      "Output the CLI version number",
+   )
    .description(kleur.green(ASCII_TITLE));
 
 // Nested CRUD commands for resource management
-registerGetCommands(cli, activeEnvironment);
-registerListCommands(cli, activeEnvironment);
-registerUpdateCommands(cli, activeEnvironment);
-registerRmCommands(cli, activeEnvironment);
-registerAddCommands(cli, activeEnvironment);
+registerGetCommands(cli, getActiveEnvironment());
+registerListCommands(cli, getActiveEnvironment());
+registerUpdateCommands(cli, getActiveEnvironment());
+registerRmCommands(cli, getActiveEnvironment());
+registerAddCommands(cli, getActiveEnvironment());
 registerSetCommands(cli);
 
 // Root commands
@@ -58,7 +64,7 @@ cli.command("publish")
    )
    .action((options) => {
       publish(
-         controlPlanesByEnv[activeEnvironment],
+         controlPlanesByEnv[getActiveEnvironment()],
          options.replicationCount,
          options.debug,
          options.yes,
@@ -77,7 +83,7 @@ cli.command("archive")
    .option("-y, --yes", "Skip confirmation.")
    .action((packageName, versionId, options) => {
       archiveVersion(
-         controlPlanesByEnv[activeEnvironment],
+         controlPlanesByEnv[getActiveEnvironment()],
          packageName,
          versionId,
          options.debug,
@@ -96,7 +102,7 @@ cli.command("unarchive")
    .option("-y, --yes", "Skip confirmation.")
    .action((packageName, versionId, options) => {
       unarchiveVersion(
-         controlPlanesByEnv[activeEnvironment],
+         controlPlanesByEnv[getActiveEnvironment()],
          packageName,
          versionId,
          options.debug,
@@ -108,7 +114,11 @@ cli.command("login")
    .description("Login into Credible service.")
    .argument("<organizationName>", "The organization to login to.")
    .action((organizationName) => {
-      login(organizationName);
+      // TODO: Uncomment this when aws videoamp cluster is ready
+      // if (organizationName === "videoamp") {
+      //    clientConfig.setEnvironment("videoamp" as Environment);
+      // }
+      login(organizationName, controlPlanesByEnv[getActiveEnvironment()]);
    });
 
 cli.command("logout")
@@ -130,12 +140,26 @@ cli.command("status")
       config.printStatus();
    });
 
-const complete = omelette("cred").tree({
+const complete = omelette("credible").tree({
    // CRUD commands
    get: ["project", "group"],
-   ls: ["project", "connection", "package", "version", "group", "group-access-token"],
-   update: ["package"],
-   rm: ["project", "connection", "package", "group", "member", "group-access-token"],
+   ls: [
+      "project",
+      "connection",
+      "package",
+      "version",
+      "group",
+      "group-access-token",
+   ],
+   update: ["project", "package"],
+   rm: [
+      "project",
+      "connection",
+      "package",
+      "group",
+      "member",
+      "group-access-token",
+   ],
    add: ["project", "connection", "group", "member", "group-access-token"],
    // Misc commands
    set: ["project"],
@@ -152,16 +176,16 @@ complete.onAsync("$3", async ({ reply, line }) => {
    const projectRelatedCommands = ["set project", "get project", "rm project"];
    if (projectRelatedCommands.some((cmd) => line.includes(cmd))) {
       reply(
-         listProjects(controlPlanesByEnv[activeEnvironment], false).then(
-            (projects) => projects.map((project) => project.name),
+         listProjects(controlPlanesByEnv[getActiveEnvironment()], false).then(
+            (result) => result.projects.map((project) => project.name),
          ),
       );
    }
    const packageRelatedCommands = ["rm package", "ls version"];
    if (packageRelatedCommands.some((cmd) => line.includes(cmd))) {
       reply(
-         listPackages(controlPlanesByEnv[activeEnvironment], false).then(
-            (packages) => packages.map((_package) => _package.name),
+         listPackages(controlPlanesByEnv[getActiveEnvironment()], false).then(
+            (result) => result.packages.map((_package) => _package.name),
          ),
       );
    }
@@ -173,11 +197,13 @@ complete.next(() => {
 
 if (~process.argv.indexOf("--cleanup")) {
    complete.cleanupShellInitFile();
+   process.exit(0);
 }
 
 if (~process.argv.indexOf("--install")) {
    complete.setupShellInitFile();
    console.log("CLI installed successfully!");
+   process.exit(0);
 }
 
 complete.init();

package/src/logger.spec.ts

@@ -0,0 +1,158 @@
+import { expect } from "chai";
+import sinon from "sinon";
+import { AxiosError } from "axios";
+import { logger, logAxiosError } from "./logger";
+
+describe("logAxiosError", () => {
+   let loggerStub: sinon.SinonStubbedInstance<typeof logger>;
+   let sandbox: sinon.SinonSandbox;
+
+   beforeEach(() => {
+      sandbox = sinon.createSandbox();
+      loggerStub = sandbox.stub(logger);
+   });
+
+   afterEach(() => {
+      sandbox.restore();
+   });
+
+   it("should log 401 Unauthorized error", () => {
+      const error = {
+         response: {
+            status: 401,
+            data: null,
+         },
+         request: { path: "/api/test" },
+         isAxiosError: true,
+      } as unknown as AxiosError;
+
+      logAxiosError(error, false);
+
+      expect(loggerStub.error.calledWith(sinon.match("Unauthorized"))).to.be
+         .true;
+   });
+
+   it("should log 403 Forbidden error", () => {
+      const error = {
+         response: {
+            status: 403,
+            data: null,
+         },
+         request: { path: "/api/test" },
+         isAxiosError: true,
+      } as unknown as AxiosError;
+
+      logAxiosError(error, false);
+
+      expect(loggerStub.error.calledWith(sinon.match("Forbidden"))).to.be.true;
+   });
+
+   it("should log 500 Internal Server Error", () => {
+      const error = {
+         response: {
+            status: 500,
+            data: null,
+         },
+         request: { path: "/api/test" },
+         isAxiosError: true,
+      } as unknown as AxiosError;
+
+      logAxiosError(error, false);
+
+      expect(loggerStub.error.calledWith(sinon.match("Internal Server Error")))
+         .to.be.true;
+   });
+
+   it("should log response data when present", () => {
+      const error = {
+         response: {
+            status: 400,
+            data: "Bad request details",
+         },
+         request: { path: "/api/test" },
+         isAxiosError: true,
+      } as unknown as AxiosError;
+
+      logAxiosError(error, false);
+
+      expect(loggerStub.error.calledWith(sinon.match("Bad request details"))).to
+         .be.true;
+   });
+
+   it("should log debug info with status and path when debug is true", () => {
+      const error = {
+         response: {
+            status: 401,
+            data: null,
+         },
+         request: { path: "/api/test" },
+         isAxiosError: true,
+      } as unknown as AxiosError;
+
+      logAxiosError(error, true);
+
+      expect(loggerStub.error.calledWith(sinon.match("Error 401 at /api/test")))
+         .to.be.true;
+   });
+
+   it("should not log debug info when debug is false", () => {
+      const error = {
+         response: {
+            status: 401,
+            data: null,
+         },
+         request: { path: "/api/test" },
+         isAxiosError: true,
+      } as unknown as AxiosError;
+
+      logAxiosError(error, false);
+
+      expect(loggerStub.error.calledWith(sinon.match("Error 401 at"))).to.be
+         .false;
+   });
+
+   it("should handle request error with no response", () => {
+      const error = {
+         response: undefined,
+         request: {
+            _options: {
+               method: "GET",
+               path: "/api/resource",
+               hostname: "example.com",
+               port: 443,
+            },
+         },
+         code: "ECONNREFUSED",
+         message: "Connection refused",
+         isAxiosError: true,
+      } as unknown as AxiosError;
+
+      logAxiosError(error, false);
+
+      expect(
+         loggerStub.error.calledWith(
+            sinon.match(
+               "Failed to GET resource /api/resource on example.com:443",
+            ),
+         ),
+      ).to.be.true;
+   });
+
+   it("should handle setup error with no request or response", () => {
+      const error = {
+         response: undefined,
+         request: undefined,
+         message: "Invalid URL",
+         isAxiosError: true,
+      } as unknown as AxiosError;
+
+      logAxiosError(error, false);
+
+      expect(
+         (loggerStub.error as sinon.SinonStub).calledWith(
+            "Error",
+            "Invalid URL",
+         ),
+      ).to.be.true;
+   });
+});

package/src/polyfills/file.polyfill.ts

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/no-unused-vars -- reserved for future globalThis polyfill */
 import { File, Blob } from "formdata-node";
 
 // TODO: Polyfill leads to errors when pushing packages.