@credibledata/cred-cli 0.0.6

package/src/commands/connection/deleteconnection.ts

@@ -0,0 +1,57 @@
+import { ConnectionsApi } from "../../client/api";
+import { Configuration } from "../../client/configuration";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import { getConfirmation, printOutError } from "../../utils";
+
+const connectionsApi = new ConnectionsApi(new Configuration());
+
+export const deleteConnection = async (
+   controlPlane: string,
+   connectionName: string,
+   debug: boolean,
+   autoConfirm: boolean,
+) => {
+   const clientConfig = new ClientConfiguration();
+   const organizationName = clientConfig.getOrganization();
+   const projectName = clientConfig.getProject();
+
+   if (!clientConfig.doesConfigExists()) {
+      logger.error("Please, make sure that you are logged in");
+      return;
+   }
+
+   if (!projectName) {
+      logger.error("Please, make sure to set a project");
+      return;
+   }
+
+   if (!autoConfirm) {
+      const confirmation = await getConfirmation(
+         `Are you sure you that want to delete the ${connectionName} connection? This action cannot be undone.`,
+      );
+      if (!confirmation) {
+         logger.info("Operation cancelled.");
+         return;
+      }
+   }
+
+   logger.info("Deleting connection " + connectionName);
+
+   try {
+      await connectionsApi.deleteConnection(
+         organizationName,
+         projectName,
+         connectionName,
+         {
+            baseURL: controlPlane,
+            headers: clientConfig.getHeaders(),
+         },
+      );
+
+      logger.info("Connection deleted successfully");
+   } catch (e) {
+      logger.error("Failed to delete connection");
+      printOutError(e, debug);
+   }
+};

package/src/commands/connection/listconnections.spec.ts

@@ -0,0 +1,132 @@
+import { expect } from "chai";
+import sinon from "sinon";
+import { ConnectionsApi } from "../../client/api";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import { prettifyJson } from "../../utils";
+import { listConnections } from "./listconnections";
+
+describe("list-connections", () => {
+   let sandbox: sinon.SinonSandbox;
+   let listConnectionsStub: sinon.SinonStub;
+   let loggerStub: sinon.SinonStubbedInstance<typeof logger>;
+   let consoleLogStub: sinon.SinonStub;
+
+   beforeEach(() => {
+      sandbox = sinon.createSandbox();
+      listConnectionsStub = 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(ConnectionsApi.prototype, "listConnections")
+         .callsFake(listConnectionsStub);
+   });
+
+   afterEach(() => {
+      sandbox.restore();
+   });
+
+   it("should list connections successfully", async () => {
+      const mockConnections = [
+         { name: "conn1", type: "postgres" },
+         { name: "conn2", type: "mysql" },
+      ];
+      const mockResponse = {
+         data: mockConnections,
+         headers: {},
+      };
+      listConnectionsStub.resolves(mockResponse);
+
+      await listConnections("http://test-server", false);
+
+      expect(listConnectionsStub.calledOnce).to.be.true;
+      expect(listConnectionsStub.firstCall.args[0]).to.equal("test-org");
+      expect(listConnectionsStub.firstCall.args[1]).to.equal("test-project");
+      expect(listConnectionsStub.firstCall.args[2]).to.equal(-1); // limit
+      expect(listConnectionsStub.firstCall.args[3]).to.equal(0); // offset
+      expect(listConnectionsStub.firstCall.args[4]).to.deep.include({
+         baseURL: "http://test-server",
+         headers: { Authorization: "Bearer test-token" },
+      });
+      expect(consoleLogStub.calledOnce).to.be.true;
+      const loggedValue = consoleLogStub.firstCall.args[0];
+      const parsed = JSON.parse(loggedValue);
+      expect(parsed).to.have.property("connections");
+      expect(parsed.connections).to.deep.equal(mockConnections);
+   });
+
+   it("should handle missing config", async () => {
+      sandbox.restore();
+      sandbox = sinon.createSandbox();
+      listConnectionsStub = sandbox.stub();
+      loggerStub = sandbox.stub(logger);
+      consoleLogStub = sandbox.stub(console, "log");
+
+      sandbox
+         .stub(ClientConfiguration.prototype, "doesConfigExists")
+         .returns(false);
+      sandbox
+         .stub(ConnectionsApi.prototype, "listConnections")
+         .callsFake(listConnectionsStub);
+
+      await listConnections("http://test-server", false);
+
+      expect(listConnectionsStub.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();
+      listConnectionsStub = 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(ConnectionsApi.prototype, "listConnections")
+         .callsFake(listConnectionsStub);
+
+      await listConnections("http://test-server", false);
+
+      expect(listConnectionsStub.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");
+      listConnectionsStub.rejects(mockError);
+
+      await listConnections("http://test-server", true);
+
+      expect(listConnectionsStub.calledOnce).to.be.true;
+      expect(
+         loggerStub.error.calledWith(sinon.match("Failed to list connections")),
+      ).to.be.true;
+   });
+});

package/src/commands/connection/listconnections.ts

@@ -0,0 +1,58 @@
+import { ConnectionsApi } from "../../client/api";
+import { Configuration } from "../../client/configuration";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import {
+   prettifyJson,
+   printOutError,
+   parsePaginationParams,
+   extractTotalCount,
+} from "../../utils";
+
+const connectionsApi = new ConnectionsApi(new Configuration());
+
+export const listConnections = async (
+   controlPlane: string,
+   debug: boolean,
+   page?: string | number,
+   pageSize?: string | number,
+) => {
+   const clientConfig = new ClientConfiguration();
+   const organizationName = clientConfig.getOrganization();
+   const projectName = clientConfig.getProject();
+
+   if (!clientConfig.doesConfigExists()) {
+      logger.error("Please, make sure that you are logged in");
+      return;
+   }
+
+   if (!projectName) {
+      logger.error("Please, make sure to set a project");
+      return;
+   }
+
+   try {
+      const { limit, offset } = parsePaginationParams(page, pageSize);
+      const response = await connectionsApi.listConnections(
+         organizationName,
+         projectName,
+         limit,
+         offset,
+         {
+            baseURL: controlPlane,
+            headers: clientConfig.getHeaders(),
+         },
+      );
+      const totalCount = extractTotalCount(response.headers);
+
+      const payload = {
+         connections: response.data,
+         totalCount,
+      };
+
+      console.log(prettifyJson(payload));
+   } catch (e) {
+      logger.error("Failed to list connections");
+      printOutError(e, debug);
+   }
+};

package/src/commands/get.ts

@@ -0,0 +1,31 @@
+import { Command } from "commander";
+import { controlPlanesByEnv, Environment } from "../constants";
+import { getGroup } from "./group/getgroup";
+import { getProject } from "./project/getproject";
+
+export const registerGetCommands = (cli: Command, environment: Environment) => {
+   const get = cli
+      .command("get")
+      .description("Get a resource")
+      .argument("<resource>", "The resource to get (project | group)");
+
+   get.command("project")
+      .description("Get a project by name.")
+      .argument("<projectName>", "The name of the project to get.")
+      .option("--debug")
+      .action((projectName, options) => {
+         getProject(
+            controlPlanesByEnv[environment],
+            projectName,
+            options.debug,
+         );
+      });
+
+   get.command("group")
+      .description("Get a group by name.")
+      .argument("<groupName>", "The name of the group to get.")
+      .option("--debug")
+      .action((groupName, options) => {
+         getGroup(controlPlanesByEnv[environment], groupName, options.debug);
+      });
+};

package/src/commands/group/addmember.spec.ts

@@ -0,0 +1,257 @@
+import { expect } from "chai";
+import sinon from "sinon";
+import { GroupsApi } from "../../client/api";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import { addMember } from "./addmember";
+
+describe("add-member", () => {
+   let sandbox: sinon.SinonSandbox;
+   let addGroupMembersStub: sinon.SinonStub;
+   let loggerStub: sinon.SinonStubbedInstance<typeof logger>;
+   let processExitStub: sinon.SinonStub;
+
+   beforeEach(() => {
+      sandbox = sinon.createSandbox();
+      addGroupMembersStub = sandbox.stub();
+      loggerStub = sandbox.stub(logger);
+      processExitStub = sandbox.stub(process, "exit");
+
+      sandbox
+         .stub(ClientConfiguration.prototype, "getOrganization")
+         .returns("test-org");
+      sandbox
+         .stub(ClientConfiguration.prototype, "doesConfigExists")
+         .returns(true);
+      sandbox
+         .stub(ClientConfiguration.prototype, "getAuthenticationHeader")
+         .returns("Bearer test-token");
+
+      sandbox
+         .stub(GroupsApi.prototype, "addGroupMembers")
+         .callsFake(addGroupMembersStub);
+   });
+
+   afterEach(() => {
+      sandbox.restore();
+   });
+
+   it("should add user member successfully", async () => {
+      const mockResponse = {
+         data: {},
+      };
+      addGroupMembersStub.resolves(mockResponse);
+
+      await addMember(
+         "http://test-server",
+         "test-group",
+         "user",
+         "test-user",
+         "admin",
+         false,
+      );
+
+      expect(addGroupMembersStub.calledOnce).to.be.true;
+      expect(addGroupMembersStub.firstCall.args[0]).to.equal("test-org");
+      expect(addGroupMembersStub.firstCall.args[1]).to.equal("test-group");
+      expect(addGroupMembersStub.firstCall.args[2]).to.deep.include({
+         members: [
+            {
+               userGroupId: "user:test-user",
+               status: "admin",
+            },
+         ],
+      });
+      expect(
+         loggerStub.info.calledWith(
+            sinon.match(
+               "Successfully added user test-user to group test-group with role admin",
+            ),
+         ),
+      ).to.be.true;
+   });
+
+   it("should add group member successfully", async () => {
+      const mockResponse = {
+         data: {},
+      };
+      addGroupMembersStub.resolves(mockResponse);
+
+      await addMember(
+         "http://test-server",
+         "test-group",
+         "group",
+         "test-subgroup",
+         "member",
+         false,
+      );
+
+      expect(addGroupMembersStub.firstCall.args[2]).to.deep.include({
+         members: [
+            {
+               userGroupId: "group:test-subgroup",
+               status: "member",
+            },
+         ],
+      });
+      expect(
+         loggerStub.info.calledWith(
+            sinon.match(
+               "Successfully added group test-subgroup to group test-group with role member",
+            ),
+         ),
+      ).to.be.true;
+   });
+
+   it("should handle case-insensitive member type", async () => {
+      const mockResponse = {
+         data: {},
+      };
+      addGroupMembersStub.resolves(mockResponse);
+
+      await addMember(
+         "http://test-server",
+         "test-group",
+         "USER",
+         "test-user",
+         "admin",
+         false,
+      );
+
+      expect(
+         addGroupMembersStub.firstCall.args[2].members[0].userGroupId,
+      ).to.equal("user:test-user");
+   });
+
+   it("should handle missing config", async () => {
+      sandbox.restore();
+      sandbox = sinon.createSandbox();
+      addGroupMembersStub = sandbox.stub();
+      loggerStub = sandbox.stub(logger);
+      processExitStub = sandbox.stub(process, "exit");
+
+      sandbox
+         .stub(ClientConfiguration.prototype, "doesConfigExists")
+         .returns(false);
+      sandbox
+         .stub(GroupsApi.prototype, "addGroupMembers")
+         .callsFake(addGroupMembersStub);
+
+      await addMember(
+         "http://test-server",
+         "test-group",
+         "user",
+         "test-user",
+         "admin",
+         false,
+      );
+
+      expect(addGroupMembersStub.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 organization", async () => {
+      sandbox.restore();
+      sandbox = sinon.createSandbox();
+      addGroupMembersStub = sandbox.stub();
+      loggerStub = sandbox.stub(logger);
+      processExitStub = sandbox.stub(process, "exit");
+
+      sandbox
+         .stub(ClientConfiguration.prototype, "doesConfigExists")
+         .returns(true);
+      sandbox
+         .stub(ClientConfiguration.prototype, "getOrganization")
+         .returns(undefined);
+      sandbox
+         .stub(GroupsApi.prototype, "addGroupMembers")
+         .callsFake(addGroupMembersStub);
+
+      await addMember(
+         "http://test-server",
+         "test-group",
+         "user",
+         "test-user",
+         "admin",
+         false,
+      );
+
+      expect(addGroupMembersStub.called).to.be.false;
+      expect(
+         loggerStub.error.calledWith(
+            sinon.match(
+               "No organization set. Please login or set an organization.",
+            ),
+         ),
+      ).to.be.true;
+   });
+
+   it("should reject invalid member type", async () => {
+      await addMember(
+         "http://test-server",
+         "test-group",
+         "invalid",
+         "test-user",
+         "admin",
+         false,
+      );
+
+      expect(addGroupMembersStub.called).to.be.false;
+      expect(
+         loggerStub.error.calledWith(
+            sinon.match(
+               (value: string) =>
+                  typeof value === "string" &&
+                  value.includes("memberType") &&
+                  value.includes("must be either 'user' or 'group'"),
+            ),
+         ),
+      ).to.be.true;
+      expect(processExitStub.calledWith(1)).to.be.true;
+   });
+
+   it("should reject invalid role", async () => {
+      await addMember(
+         "http://test-server",
+         "test-group",
+         "user",
+         "test-user",
+         "invalid-role",
+         false,
+      );
+
+      expect(addGroupMembersStub.called).to.be.false;
+      expect(
+         loggerStub.error.calledWith(
+            sinon.match(/role must be either 'admin' or 'member'/),
+         ),
+      ).to.be.true;
+      expect(processExitStub.calledWith(1)).to.be.true;
+   });
+
+   it("should handle API errors", async () => {
+      const mockError = new Error("API Error");
+      addGroupMembersStub.rejects(mockError);
+
+      await addMember(
+         "http://test-server",
+         "test-group",
+         "user",
+         "test-user",
+         "admin",
+         true,
+      );
+
+      expect(addGroupMembersStub.calledOnce).to.be.true;
+      expect(
+         loggerStub.error.calledWith(
+            sinon.match("Failed to add member to group"),
+         ),
+      ).to.be.true;
+      expect(processExitStub.calledWith(1)).to.be.true;
+   });
+});

package/src/commands/group/addmember.ts

@@ -0,0 +1,85 @@
+import {
+   AddGroupMembersRequest,
+   GroupMember,
+   GroupsApi,
+} from "../../client/api";
+import { Configuration } from "../../client/configuration";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { UserGroupId } from "../../common/UserGroupId";
+import { logger } from "../../logger";
+import { printOutError } from "../../utils";
+
+const groupsApi = new GroupsApi(new Configuration());
+
+export async function addMember(
+   controlPlane: string,
+   groupName: string,
+   memberType: string,
+   memberName: string,
+   role: string,
+   debug: boolean,
+) {
+   const clientConfig = new ClientConfiguration();
+
+   if (!clientConfig.doesConfigExists()) {
+      logger.error("Please, make sure that you are logged in");
+      return;
+   }
+
+   const organizationName = clientConfig.getOrganization();
+   if (!organizationName) {
+      logger.error("No organization set. Please login or set an organization.");
+      return;
+   }
+
+   logger.info(
+      `Adding ${memberType} ${memberName} to group ${groupName} in organization ${organizationName} with role ${role}`,
+   );
+
+   // Create UserGroupId based on member type
+   let userGroupId: UserGroupId;
+   if (memberType.toLowerCase() === "user") {
+      userGroupId = UserGroupId.forUser(memberName);
+   } else if (memberType.toLowerCase() === "group") {
+      userGroupId = UserGroupId.forGroup(memberName);
+   } else {
+      logger.error(
+         `Error: memberType ${memberType} must be either 'user' or 'group'`,
+      );
+      process.exit(1);
+      return;
+   }
+
+   // Validate role
+   if (role !== "admin" && role !== "member") {
+      logger.error("Error: role must be either 'admin' or 'member'");
+      process.exit(1);
+      return;
+   }
+
+   const groupMember: GroupMember = {
+      userGroupId: userGroupId.getValue(),
+      status: role as "admin" | "member",
+   };
+
+   const request: AddGroupMembersRequest = {
+      members: [groupMember],
+   };
+
+   try {
+      await groupsApi.addGroupMembers(organizationName, groupName, request, {
+         baseURL: controlPlane,
+         headers: {
+            Authorization: clientConfig.getAuthenticationHeader(),
+         },
+      });
+
+      logger.info(
+         `Successfully added ${memberType} ${memberName} to group ${groupName} with role ${role}`,
+      );
+   } catch (error) {
+      logger.error("Failed to add member to group");
+      printOutError(error, debug);
+      process.exit(1);
+   }
+}