@credibledata/cred-cli 0.0.6

package/src/index.ts

@@ -0,0 +1,209 @@
+#!/usr/bin/env node
+import axios from "axios";
+import { program } from "commander";
+import kleur from "kleur";
+import omelette from "omelette";
+import cliPackage from "../package.json";
+import { ClientConfiguration } from "./clientconfiguration";
+import { registerAddCommands } from "./commands/add";
+import { registerGetCommands } from "./commands/get";
+import { registerListCommands } from "./commands/list";
+import { login } from "./commands/misc/login";
+import { logout } from "./commands/misc/logout";
+import { setAccessToken } from "./commands/misc/set-access-token";
+import { listPackages } from "./commands/package/listpackages";
+import { publish } from "./commands/package/publish";
+import { listProjects } from "./commands/project/listprojects";
+import { registerRmCommands } from "./commands/rm";
+import { registerSetCommands } from "./commands/set";
+import { registerUpdateCommands } from "./commands/update";
+import {
+   archiveVersion,
+   unarchiveVersion,
+} from "./commands/version/archive-unarchive-version";
+import { ASCII_TITLE, controlPlanesByEnv } from "./constants";
+
+const clientConfig = new ClientConfiguration();
+
+const getActiveEnvironment = () => {
+   return clientConfig.getEnvironment();
+};
+axios.defaults.baseURL = controlPlanesByEnv[getActiveEnvironment()];
+
+const cli = program
+   .version(
+      cliPackage.version,
+      "-V, --cli-version",
+      "Output the CLI version number",
+   )
+   .description(kleur.green(ASCII_TITLE));
+
+// Nested CRUD commands for resource management
+registerGetCommands(cli, getActiveEnvironment());
+registerListCommands(cli, getActiveEnvironment());
+registerUpdateCommands(cli, getActiveEnvironment());
+registerRmCommands(cli, getActiveEnvironment());
+registerAddCommands(cli, getActiveEnvironment());
+registerSetCommands(cli);
+
+// Root commands
+cli.command("publish")
+   .description("Publish a new version of the package.")
+   .option("--debug")
+   .option("-y, --yes", "Skip confirmation.")
+   .option(
+      "--replication <replication_count>",
+      "The number of replicas to create.",
+      (v) => (v === undefined ? undefined : parseInt(v)),
+      undefined,
+   )
+   .option(
+      "--set-latest",
+      "Set this version as the latest version of the package.",
+      false,
+   )
+   .action((options) => {
+      publish(
+         controlPlanesByEnv[getActiveEnvironment()],
+         options.replicationCount,
+         options.debug,
+         options.yes,
+         options.setLatest,
+      );
+   });
+
+cli.command("archive")
+   .description("Archive a version of a package.")
+   .argument(
+      "<packageName>",
+      "The name of the package to archive the version of.",
+   )
+   .argument("<versionId>", "The id of the version to archive.")
+   .option("--debug")
+   .option("-y, --yes", "Skip confirmation.")
+   .action((packageName, versionId, options) => {
+      archiveVersion(
+         controlPlanesByEnv[getActiveEnvironment()],
+         packageName,
+         versionId,
+         options.debug,
+         options.yes,
+      );
+   });
+
+cli.command("unarchive")
+   .description("Unarchive a version of a package.")
+   .argument(
+      "<packageName>",
+      "The name of the package to unarchive the version of.",
+   )
+   .argument("<versionId>", "The id of the version to unarchive.")
+   .option("--debug")
+   .option("-y, --yes", "Skip confirmation.")
+   .action((packageName, versionId, options) => {
+      unarchiveVersion(
+         controlPlanesByEnv[getActiveEnvironment()],
+         packageName,
+         versionId,
+         options.debug,
+         options.yes,
+      );
+   });
+
+cli.command("login")
+   .description("Login into Credible service.")
+   .argument("<organizationName>", "The organization to login to.")
+   .action((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")
+   .description("Resets Credible service credentials")
+   .action(logout);
+
+cli.command("set-access-token")
+   .description("Set a service account JWT token for CLI authentication")
+   .argument("<jwtToken>", "The JWT token to use for authentication")
+   .option("-o, --organization <organizationName>", "Organization name to set")
+   .action((jwtToken, options) => {
+      setAccessToken(jwtToken, options.organization);
+   });
+
+cli.command("status")
+   .description("Shows the currently active organization and project.")
+   .action(() => {
+      const config = new ClientConfiguration();
+      config.printStatus();
+   });
+
+const complete = omelette("credible").tree({
+   // CRUD commands
+   get: ["project", "group"],
+   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"],
+   login: [],
+   logout: [],
+   "set-access-token": [],
+   status: [],
+   publish: [],
+   archive: [],
+   unarchive: [],
+});
+
+complete.onAsync("$3", async ({ reply, line }) => {
+   const projectRelatedCommands = ["set project", "get project", "rm project"];
+   if (projectRelatedCommands.some((cmd) => line.includes(cmd))) {
+      reply(
+         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[getActiveEnvironment()], false).then(
+            (result) => result.packages.map((_package) => _package.name),
+         ),
+      );
+   }
+});
+
+complete.next(() => {
+   program.parse(process.argv);
+});
+
+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/logger.ts

@@ -0,0 +1,86 @@
+import { AxiosError } from "axios";
+import kleur from "kleur";
+import winston from "winston";
+
+const logColors = {
+   error: kleur.red,
+   warn: kleur.yellow,
+   info: kleur.cyan,
+   http: kleur.magenta,
+   debug: kleur.gray,
+};
+
+// Custom console log format
+const consoleFormat = winston.format.printf(({ level, message, timestamp }) => {
+   const colorFn = logColors[level] || ((text: string) => text);
+   return `[${kleur.gray(timestamp as string)}] ${colorFn(level.toUpperCase())}: ${message}`;
+});
+
+// Create Winston logger
+export const logger = winston.createLogger({
+   level: "debug",
+   format: winston.format.combine(
+      winston.format.timestamp({ format: "YYYY-MM-DD HH:mm:ss" }),
+      winston.format.errors({ stack: true }),
+      winston.format.splat(),
+   ),
+   transports: [
+      // Console transport with colored logs
+      new winston.transports.Console({
+         format: consoleFormat,
+      }),
+
+      // NOTE disabled app.log logging
+      // File transport (logs without colors)
+      // new winston.transports.File({
+      //    filename: "app.log",
+      //    level: "info",
+      //    format: winston.format.json(),
+      // }),
+   ],
+});
+
+export const logAxiosError = (error: AxiosError, debug: boolean) => {
+   if (error.response) {
+      // The request was made and the server responded with a status code
+      // that falls out of the range of 2xx
+      if (debug) {
+         logger.error(
+            `Error ${error.response.status} at ${error.request.path}`,
+         );
+      }
+      switch (error.response.status) {
+         case 401:
+            logger.error(
+               "Unauthorized: Please double check that you are logged in",
+            );
+            break;
+         case 403:
+            logger.error(
+               "Forbidden: You're not allowed to perform this operation",
+            );
+            break;
+         case 500:
+            logger.error("Internal Server Error");
+            break;
+         default:
+            break;
+      }
+      if (error.response.data) {
+         logger.error(error.response.data);
+      }
+   } else if (error.request) {
+      // The request was made but no response was received
+      // `error.request` is an instance of XMLHttpRequest in the browser and an instance of
+      // http.ClientRequest in node.js
+      const requestOptions = error.request._options;
+      logger.error(
+         `Failed to ${requestOptions.method} resource ${requestOptions.path} on ${requestOptions.hostname}:${requestOptions.port}`,
+      );
+
+      logger.error(error.code, error.message);
+   } else {
+      // Something happened in setting up the request that triggered an Error
+      logger.error("Error", error.message);
+   }
+};

package/src/polyfills/file.polyfill.ts

@@ -0,0 +1,6 @@
+/* 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.
+//globalThis.File = File as unknown as typeof globalThis.File;
+//globalThis.Blob = Blob as unknown as typeof globalThis.Blob;

package/src/utils.spec.ts

@@ -0,0 +1,135 @@
+import axios from "axios";
+import { expect } from "chai";
+import inquirer from "inquirer";
+import sinon from "sinon";
+import * as loggerModule from "./logger";
+import { getConfirmation, prettifyJson, printOutError, sleep } from "./utils";
+
+describe("utils", () => {
+   let sandbox: sinon.SinonSandbox;
+   let loggerStub: sinon.SinonStubbedInstance<typeof loggerModule.logger>;
+   let logAxiosErrorStub: sinon.SinonStub;
+
+   beforeEach(() => {
+      sandbox = sinon.createSandbox();
+      loggerStub = sandbox.stub(loggerModule.logger);
+      logAxiosErrorStub = sandbox.stub(loggerModule, "logAxiosError");
+   });
+
+   afterEach(() => {
+      sandbox.restore();
+   });
+
+   describe("sleep", () => {
+      it("should wait for the specified time", async function () {
+         this.timeout(100);
+         const start = Date.now();
+         await sleep(50);
+         const elapsed = Date.now() - start;
+         expect(elapsed).to.be.at.least(45);
+      });
+   });
+
+   describe("prettifyJson", () => {
+      it("should format JSON with 2-space indentation", () => {
+         const obj = { name: "test", value: 123 };
+         const result = prettifyJson(obj);
+         expect(result).to.equal('{\n  "name": "test",\n  "value": 123\n}');
+      });
+
+      it("should handle empty objects", () => {
+         const result = prettifyJson({});
+         expect(result).to.equal("{}");
+      });
+
+      it("should handle nested objects", () => {
+         const obj = { nested: { key: "value" } };
+         const result = prettifyJson(obj);
+         expect(result).to.include("nested");
+         expect(result).to.include("key");
+         expect(result).to.include("value");
+      });
+   });
+
+   describe("printOutError", () => {
+      it("should handle axios errors", () => {
+         const axiosError = {
+            isAxiosError: true,
+            response: {
+               status: 404,
+               data: { message: "Not found" },
+            },
+            config: {},
+            name: "AxiosError",
+            message: "Request failed",
+         };
+         sandbox.stub(axios, "isAxiosError").returns(true);
+
+         printOutError(axiosError as any, false);
+
+         expect(logAxiosErrorStub.calledOnce).to.be.true;
+         expect(logAxiosErrorStub.firstCall.args[0]).to.equal(axiosError);
+         expect(logAxiosErrorStub.firstCall.args[1]).to.equal(false);
+      });
+
+      it("should handle non-axios errors", () => {
+         const error = new Error("Generic error");
+         sandbox.stub(axios, "isAxiosError").returns(false);
+
+         printOutError(error, false);
+
+         expect(loggerStub.error.calledOnce).to.be.true;
+         expect(loggerStub.error.calledWith(sinon.match("Unexpected error"))).to
+            .be.true;
+         // Check that error was passed as second argument (Winston accepts Error objects)
+         const errorCall = loggerStub.error.getCall(0);
+         expect(errorCall.args.length).to.be.at.least(2);
+         expect((errorCall.args as any)[1]).to.equal(error);
+      });
+
+      it("should log debug info when debug is true", () => {
+         const error = new Error("Test error");
+         sandbox.stub(axios, "isAxiosError").returns(false);
+
+         printOutError(error, true);
+
+         expect(loggerStub.debug.calledWith(error)).to.be.true;
+      });
+
+      it("should not log debug info when debug is false", () => {
+         const error = new Error("Test error");
+         sandbox.stub(axios, "isAxiosError").returns(false);
+
+         printOutError(error, false);
+
+         expect(loggerStub.debug.called).to.be.false;
+      });
+   });
+
+   describe("getConfirmation", () => {
+      it("should return true when user confirms", async () => {
+         const promptStub = sandbox
+            .stub(inquirer, "prompt")
+            .resolves({ confirm: true });
+
+         const result = await getConfirmation("Are you sure?");
+
+         expect(result).to.be.true;
+         expect(promptStub.calledOnce).to.be.true;
+         expect(promptStub.firstCall.args[0][0].message).to.equal(
+            "Are you sure?",
+         );
+      });
+
+      it("should return false when user denies", async () => {
+         const promptStub = sandbox
+            .stub(inquirer, "prompt")
+            .resolves({ confirm: false });
+
+         const result = await getConfirmation("Are you sure?");
+
+         expect(result).to.be.false;
+         expect(promptStub.calledOnce).to.be.true;
+      });
+   });
+});