@credibledata/cred-cli 0.0.6

package/src/commands/project/listprojects.spec.ts

@@ -0,0 +1,121 @@
+import { expect } from "chai";
+import sinon from "sinon";
+import { ProjectsApi } from "../../client/api";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import { prettifyJson } from "../../utils";
+import { listProjects, printOutProjects } from "./listprojects";
+
+describe("list-projects", () => {
+   let sandbox: sinon.SinonSandbox;
+   let listProjectsStub: sinon.SinonStub;
+   let loggerStub: sinon.SinonStubbedInstance<typeof logger>;
+   let consoleLogStub: sinon.SinonStub;
+
+   beforeEach(() => {
+      sandbox = sinon.createSandbox();
+      listProjectsStub = sandbox.stub();
+      loggerStub = sandbox.stub(logger);
+      consoleLogStub = sandbox.stub(console, "log");
+
+      sandbox
+         .stub(ClientConfiguration.prototype, "getOrganization")
+         .returns("test-org");
+      sandbox
+         .stub(ClientConfiguration.prototype, "doesConfigExists")
+         .returns(true);
+      sandbox
+         .stub(ClientConfiguration.prototype, "getHeaders")
+         .returns({ Authorization: "Bearer test-token" });
+
+      sandbox
+         .stub(ProjectsApi.prototype, "listProjects")
+         .callsFake(listProjectsStub);
+   });
+
+   afterEach(() => {
+      sandbox.restore();
+   });
+
+   it("should list projects successfully", async () => {
+      const mockProjects = [
+         { name: "project1", replicationCount: 2 },
+         { name: "project2", replicationCount: 3 },
+      ];
+      const mockResponse = {
+         data: mockProjects,
+         headers: {},
+      };
+      listProjectsStub.resolves(mockResponse);
+
+      const result = await listProjects("http://test-server", false);
+
+      expect(listProjectsStub.calledOnce).to.be.true;
+      expect(listProjectsStub.firstCall.args[0]).to.equal("test-org");
+      expect(listProjectsStub.firstCall.args[1]).to.equal(-1); // limit
+      expect(listProjectsStub.firstCall.args[2]).to.equal(0); // offset
+      expect(listProjectsStub.firstCall.args[3]).to.deep.include({
+         baseURL: "http://test-server",
+         headers: { Authorization: "Bearer test-token" },
+      });
+      expect(result).to.deep.equal({
+         projects: mockProjects,
+         totalCount: undefined,
+      });
+   });
+
+   it("should return empty array when config doesn't exist", async () => {
+      sandbox.restore();
+      sandbox = sinon.createSandbox();
+      listProjectsStub = sandbox.stub();
+      loggerStub = sandbox.stub(logger);
+      consoleLogStub = sandbox.stub(console, "log");
+
+      sandbox
+         .stub(ClientConfiguration.prototype, "doesConfigExists")
+         .returns(false);
+      sandbox
+         .stub(ProjectsApi.prototype, "listProjects")
+         .callsFake(listProjectsStub);
+
+      const result = await listProjects("http://test-server", false);
+
+      expect(listProjectsStub.called).to.be.false;
+      expect(result).to.be.undefined;
+      expect(
+         loggerStub.error.calledWith(
+            sinon.match("Please, make sure that you are logged in"),
+         ),
+      ).to.be.true;
+   });
+
+   it("should return empty array on API error", async () => {
+      const mockError = new Error("API Error");
+      listProjectsStub.rejects(mockError);
+
+      const result = await listProjects("http://test-server", true);
+
+      expect(listProjectsStub.calledOnce).to.be.true;
+      expect(result).to.be.undefined;
+      expect(
+         loggerStub.error.calledWith(sinon.match("Failed to list projects")),
+      ).to.be.true;
+   });
+
+   it("should print projects when using printOutProjects", async () => {
+      const mockProjects = [{ name: "project1" }];
+      const mockResponse = {
+         data: mockProjects,
+         headers: {},
+      };
+      listProjectsStub.resolves(mockResponse);
+
+      await printOutProjects("http://test-server", false);
+
+      expect(consoleLogStub.calledOnce).to.be.true;
+      const loggedValue = consoleLogStub.firstCall.args[0];
+      const parsed = JSON.parse(loggedValue);
+      expect(parsed).to.have.property("projects");
+      expect(parsed.projects).to.deep.equal(mockProjects);
+   });
+});

package/src/commands/project/listprojects.ts

@@ -0,0 +1,62 @@
+import { ProjectsApi } from "../../client/api";
+import { Configuration } from "../../client/configuration";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import {
+   prettifyJson,
+   printOutError,
+   parsePaginationParams,
+   extractTotalCount,
+} from "../../utils";
+
+const projectsApi = new ProjectsApi(new Configuration());
+
+export async function listProjects(
+   controlPlane: string,
+   debug: boolean,
+   page?: string | number,
+   pageSize?: string | number,
+) {
+   const clientConfig = new ClientConfiguration();
+
+   if (!clientConfig.doesConfigExists()) {
+      logger.error("Please, make sure that you are logged in");
+      return;
+   }
+
+   try {
+      const { limit, offset } = parsePaginationParams(page, pageSize);
+
+      const response = await projectsApi.listProjects(
+         clientConfig.getOrganization(),
+         limit,
+         offset,
+         {
+            baseURL: controlPlane,
+            headers: clientConfig.getHeaders(),
+         },
+      );
+
+      const totalCount = extractTotalCount(response.headers);
+
+      return {
+         projects: response.data,
+         totalCount,
+      };
+   } catch (e) {
+      logger.error("Failed to list projects");
+      printOutError(e, debug);
+      return;
+   }
+}
+
+export async function printOutProjects(
+   controlPlane: string,
+   debug: boolean,
+   page?: string | number,
+   pageSize?: string | number,
+) {
+   const projects = await listProjects(controlPlane, debug, page, pageSize);
+
+   console.log(prettifyJson(projects));
+}

package/src/commands/project/setproject.spec.ts

@@ -0,0 +1,63 @@
+import { expect } from "chai";
+import sinon from "sinon";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import { setProject } from "./setproject";
+
+describe("set-project", () => {
+   let sandbox: sinon.SinonSandbox;
+   let setProjectStub: sinon.SinonStub;
+   let loggerStub: sinon.SinonStubbedInstance<typeof logger>;
+   let consoleLogStub: sinon.SinonStub;
+
+   beforeEach(() => {
+      sandbox = sinon.createSandbox();
+      loggerStub = sandbox.stub(logger);
+      consoleLogStub = sandbox.stub(console, "log");
+      setProjectStub = sandbox.stub(
+         ClientConfiguration.prototype,
+         "setProject",
+      );
+
+      sandbox
+         .stub(ClientConfiguration.prototype, "doesConfigExists")
+         .returns(true);
+   });
+
+   afterEach(() => {
+      sandbox.restore();
+   });
+
+   it("should set project successfully", async () => {
+      await setProject("test-project");
+
+      expect(setProjectStub.calledOnce).to.be.true;
+      expect(setProjectStub.firstCall.args[0]).to.equal("test-project");
+      expect(consoleLogStub.calledWith("Setting project test-project")).to.be
+         .true;
+   });
+
+   it("should handle missing config", async () => {
+      sandbox.restore();
+      sandbox = sinon.createSandbox();
+      loggerStub = sandbox.stub(logger);
+      consoleLogStub = sandbox.stub(console, "log");
+      setProjectStub = sandbox.stub(
+         ClientConfiguration.prototype,
+         "setProject",
+      );
+
+      sandbox
+         .stub(ClientConfiguration.prototype, "doesConfigExists")
+         .returns(false);
+
+      await setProject("test-project");
+
+      expect(setProjectStub.called).to.be.false;
+      expect(
+         loggerStub.error.calledWith(
+            sinon.match("Please, make sure that you are logged in"),
+         ),
+      ).to.be.true;
+   });
+});

package/src/commands/project/setproject.ts

@@ -0,0 +1,14 @@
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+
+export async function setProject(projectName: string) {
+   console.log("Setting project " + projectName);
+   const clientConfig = new ClientConfiguration();
+
+   if (!clientConfig.doesConfigExists()) {
+      logger.error("Please, make sure that you are logged in");
+      return;
+   }
+
+   clientConfig.setProject(projectName);
+}

package/src/commands/project/updateproject.spec.ts

@@ -0,0 +1,217 @@
+import { expect } from "chai";
+import sinon from "sinon";
+import { ProjectsApi } from "../../client/api";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import { updateProject } from "./updateproject";
+
+describe("update-project", () => {
+   let sandbox: sinon.SinonSandbox;
+   let updateProjectStub: sinon.SinonStub;
+   let loggerStub: sinon.SinonStubbedInstance<typeof logger>;
+
+   beforeEach(() => {
+      sandbox = sinon.createSandbox();
+      updateProjectStub = sandbox.stub();
+      loggerStub = sandbox.stub(logger);
+
+      // Mock ClientConfiguration constructor
+      sandbox
+         .stub(ClientConfiguration.prototype, "getOrganization")
+         .returns("test-org");
+      sandbox
+         .stub(ClientConfiguration.prototype, "doesConfigExists")
+         .returns(true);
+      sandbox
+         .stub(ClientConfiguration.prototype, "getHeaders")
+         .returns({ Authorization: "Bearer test-token" });
+
+      // Mock ProjectsApi constructor and method
+      sandbox
+         .stub(ProjectsApi.prototype, "updateProject")
+         .callsFake(updateProjectStub);
+   });
+
+   afterEach(() => {
+      sandbox.restore();
+   });
+
+   describe("updateProject", () => {
+      it("should update project successfully", async () => {
+         const mockResponse = { status: 200 };
+         updateProjectStub.resolves(mockResponse);
+
+         await updateProject(
+            "http://test-server",
+            "test-project",
+            { replicationCount: 3 },
+            false,
+            true,
+         );
+
+         expect(updateProjectStub.calledOnce).to.be.true;
+         expect(updateProjectStub.firstCall.args[0]).to.equal("test-org");
+         expect(updateProjectStub.firstCall.args[1]).to.equal("test-project");
+         expect(updateProjectStub.firstCall.args[2]).to.include({
+            replicationCount: 3,
+         });
+         expect(updateProjectStub.firstCall.args[3]).to.deep.include({
+            baseURL: "http://test-server",
+            headers: { Authorization: "Bearer test-token" },
+         });
+         expect(
+            loggerStub.info.calledWith(
+               sinon.match("Successfully updated project test-project"),
+            ),
+         ).to.be.true;
+      });
+
+      it("should handle missing project name", async () => {
+         await updateProject(
+            "http://test-server",
+            "",
+            { replicationCount: 3 },
+            false,
+            true,
+         );
+
+         expect(updateProjectStub.called).to.be.false;
+         expect(
+            loggerStub.error.calledWith(
+               sinon.match("Please provide a project name"),
+            ),
+         ).to.be.true;
+      });
+
+      it("should handle API errors", async () => {
+         const mockError = new Error("API Error");
+         updateProjectStub.rejects(mockError);
+
+         await updateProject(
+            "http://test-server",
+            "test-project",
+            { replicationCount: 3 },
+            true,
+            true,
+         );
+
+         expect(updateProjectStub.calledOnce).to.be.true;
+         expect(
+            loggerStub.error.calledWith(
+               sinon.match("Failed to update project test-project"),
+            ),
+         ).to.be.true;
+      });
+
+      it("should handle non-200 response status", async () => {
+         const mockResponse = { status: 400 };
+         updateProjectStub.resolves(mockResponse);
+
+         await updateProject(
+            "http://test-server",
+            "test-project",
+            { replicationCount: 3 },
+            false,
+            true,
+         );
+
+         expect(updateProjectStub.calledOnce).to.be.true;
+         expect(
+            loggerStub.error.calledWith(
+               sinon.match("Failed to update project. Status: 400"),
+            ),
+         ).to.be.true;
+      });
+   });
+
+   describe("validators", () => {
+      describe("authentication validation", () => {
+         it("should fail when user is not logged in", async () => {
+            sandbox.restore();
+            sandbox = sinon.createSandbox();
+            updateProjectStub = sandbox.stub();
+            loggerStub = sandbox.stub(logger);
+
+            sandbox
+               .stub(ClientConfiguration.prototype, "doesConfigExists")
+               .returns(false);
+            sandbox
+               .stub(ProjectsApi.prototype, "updateProject")
+               .callsFake(updateProjectStub);
+
+            await updateProject(
+               "http://test-server",
+               "test-project",
+               { replicationCount: 3 },
+               false,
+               true,
+            );
+
+            expect(updateProjectStub.called).to.be.false;
+            expect(
+               loggerStub.error.calledWith(
+                  sinon.match("Please, make sure that you are logged in"),
+               ),
+            ).to.be.true;
+         });
+      });
+
+      describe("replication count validation", () => {
+         it("should accept valid replication counts", async () => {
+            const mockResponse = { status: 200 };
+            updateProjectStub.resolves(mockResponse);
+
+            const validCounts = [1, 2, 5, 10, 100];
+
+            for (const count of validCounts) {
+               await updateProject(
+                  "http://test-server",
+                  "test-project",
+                  { replicationCount: count },
+                  false,
+                  true,
+               );
+               expect(updateProjectStub.called).to.be.true;
+               expect(updateProjectStub.firstCall.args[2]).to.include({
+                  replicationCount: count,
+               });
+               updateProjectStub.reset();
+            }
+         });
+
+         it("should reject replication count less than 1", async () => {
+            await updateProject(
+               "http://test-server",
+               "test-project",
+               { replicationCount: 0 },
+               false,
+               true,
+            );
+
+            expect(updateProjectStub.called).to.be.false;
+            expect(
+               loggerStub.error.calledWith(
+                  sinon.match("Replication count must be at least 1"),
+               ),
+            ).to.be.true;
+         });
+
+         it("should reject negative replication count", async () => {
+            await updateProject(
+               "http://test-server",
+               "test-project",
+               { replicationCount: -1 },
+               false,
+               true,
+            );
+
+            expect(updateProjectStub.called).to.be.false;
+            expect(
+               loggerStub.error.calledWith(
+                  sinon.match("Replication count must be at least 1"),
+               ),
+            ).to.be.true;
+         });
+      });
+   });
+});

package/src/commands/project/updateproject.ts

@@ -0,0 +1,82 @@
+import { Project, ProjectsApi } from "../../client/api";
+import { Configuration } from "../../client/configuration";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import { getConfirmation, printOutError } from "../../utils";
+
+const projectsApi = new ProjectsApi(new Configuration());
+
+type UpdateProjectProperties = {
+   replicationCount?: number;
+};
+
+export async function updateProject(
+   controlPlane: string,
+   projectName: string,
+   properties: UpdateProjectProperties,
+   debug?: boolean,
+   skipConfirmation?: boolean,
+) {
+   const clientConfig = new ClientConfiguration();
+   if (!clientConfig.doesConfigExists()) {
+      logger.error("Please, make sure that you are logged in");
+      return;
+   }
+
+   if (!projectName) {
+      logger.error("Please provide a project name");
+      return;
+   }
+
+   const organizationName = clientConfig.getOrganization();
+
+   if (
+      properties.replicationCount !== undefined &&
+      properties.replicationCount < 1
+   ) {
+      logger.error("Replication count must be at least 1");
+      return;
+   }
+
+   try {
+      if (!skipConfirmation) {
+         const confirmation = await getConfirmation(
+            `Are you sure you want to update project ${projectName}?`,
+         );
+         if (!confirmation) {
+            logger.info("Operation cancelled.");
+            return;
+         }
+      }
+
+      const projectUpdate: Project = {};
+
+      if (properties.replicationCount !== undefined) {
+         projectUpdate.replicationCount = properties.replicationCount;
+      }
+
+      const response = await projectsApi.updateProject(
+         organizationName,
+         projectName,
+         projectUpdate,
+         {
+            baseURL: controlPlane,
+            headers: clientConfig.getHeaders(),
+         },
+      );
+
+      if (response.status === 200) {
+         logger.info(`Successfully updated project ${projectName}`);
+         if (properties.replicationCount !== undefined) {
+            logger.info(
+               `Replication count set to ${properties.replicationCount}`,
+            );
+         }
+      } else {
+         logger.error(`Failed to update project. Status: ${response.status}`);
+      }
+   } catch (e) {
+      logger.error(`Failed to update project ${projectName}`);
+      printOutError(e, debug);
+   }
+}

package/src/commands/rm.ts

@@ -0,0 +1,101 @@
+import { Command } from "commander";
+import { controlPlanesByEnv, Environment } from "../constants";
+import { deleteConnection } from "./connection/deleteconnection";
+import { deleteGroup } from "./group/deletegroup";
+import { removeMember } from "./group/removemember";
+import { deleteGroupAccessToken } from "./groupaccesstoken/deleteToken";
+import { deletePackage } from "./package/deletepackage";
+import { deleteProject } from "./project/deleteproject";
+
+export const registerRmCommands = (cli: Command, environment: Environment) => {
+   const rm = cli
+      .command("rm")
+      .description("Remove a resource")
+      .argument("<resource>", "The resource to remove");
+
+   rm.command("package")
+      .description("Delete a package.")
+      .argument("<packageName>", "The name of the package to delete.")
+      .option("--debug")
+      .option("-y, --yes", "Skip confirmation.")
+      .action((packageName, options) => {
+         deletePackage(
+            controlPlanesByEnv[environment],
+            packageName,
+            options.debug,
+            options.yes,
+         );
+      });
+
+   rm.command("project")
+      .description("Delete a project.")
+      .argument("<projectName>", "The name of the project to delete.")
+      .option("--debug")
+      .option("-y, --yes", "Skip confirmation.")
+      .action((projectName, options) => {
+         deleteProject(
+            controlPlanesByEnv[environment],
+            projectName,
+            options.debug,
+            options.yes,
+         );
+      });
+
+   rm.command("connection")
+      .description("Delete a connection.")
+      .argument("<connectionName>", "The name of the connection to delete.")
+      .option("--debug")
+      .option("-y, --yes", "Skip confirmation.")
+      .action((connectionName, options) => {
+         deleteConnection(
+            controlPlanesByEnv[environment],
+            connectionName,
+            options.debug,
+            options.yes,
+         );
+      });
+
+   rm.command("group")
+      .description("Delete a group.")
+      .argument("<groupName>", "The name of the group to delete")
+      .option("--debug")
+      .option("-y, --yes", "Skip confirmation.")
+      .action((groupName, options) => {
+         deleteGroup(
+            controlPlanesByEnv[environment],
+            groupName,
+            options.debug || false,
+         );
+      });
+
+   rm.command("member")
+      .description("Remove a member from a group.")
+      .argument("<groupName>", "The name of the group")
+      .argument("<memberType>", "The type of member (user or group)")
+      .argument("<memberName>", "The name of the member")
+      .option("--debug")
+      .action((groupName, memberType, memberName, options) => {
+         removeMember(
+            controlPlanesByEnv[environment],
+            groupName,
+            memberType,
+            memberName,
+            options.debug || false,
+         );
+      });
+
+   rm.command("group-access-token")
+      .description("Delete an access token from a group.")
+      .argument("<groupName>", "The name of the group")
+      .argument("<tokenName>", "The name of the token to delete")
+      .option("--debug")
+      .option("-y, --yes", "Skip confirmation.")
+      .action((groupName, tokenName, options) => {
+         deleteGroupAccessToken(
+            controlPlanesByEnv[environment],
+            groupName,
+            tokenName,
+            options.debug || false,
+         );
+      });
+};

package/src/commands/set.ts

@@ -0,0 +1,16 @@
+import { Command } from "commander";
+import { setProject } from "./project/setproject";
+
+export const registerSetCommands = (cli: Command) => {
+   const set = cli
+      .command("set")
+      .description("Set a resource")
+      .argument("<resource>", "The resource to set");
+
+   set.command("project")
+      .description("Set the default project.")
+      .argument("<projectName>", "The name of the project to set.")
+      .action(setProject);
+
+   // TODO: It would be nice to `cred set org` and avoid logging again when switching orgs.
+};