@credibledata/cred-cli 0.0.6

package/src/commands/group/listgroups.ts

@@ -0,0 +1,45 @@
+import { GroupsApi } from "../../client/api";
+import { Configuration } from "../../client/configuration";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import { printOutError } from "../../utils";
+
+const groupsApi = new GroupsApi(new Configuration());
+
+export async function listGroups(controlPlane: 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(`Listing groups in organization ${organizationName}`);
+
+   try {
+      const response = await groupsApi.listGroups(organizationName, {
+         baseURL: controlPlane,
+         headers: {
+            Authorization: clientConfig.getAuthenticationHeader(),
+         },
+      });
+
+      const jsonString = JSON.stringify(response.data, null, 2);
+      console.log(jsonString);
+      logger.info("Groups listed successfully");
+   } catch (error) {
+      logger.error("Failed to list groups");
+      printOutError(error, debug);
+      process.exit(1);
+   }
+}
+
+export async function printOutGroups(controlPlane: string, debug: boolean) {
+   return listGroups(controlPlane, debug);
+}

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

@@ -0,0 +1,224 @@
+import { expect } from "chai";
+import sinon from "sinon";
+import { GroupsApi } from "../../client/api";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import { removeMember } from "./removemember";
+
+describe("remove-member", () => {
+   let sandbox: sinon.SinonSandbox;
+   let removeGroupMembersStub: sinon.SinonStub;
+   let loggerStub: sinon.SinonStubbedInstance<typeof logger>;
+   let processExitStub: sinon.SinonStub;
+
+   beforeEach(() => {
+      sandbox = sinon.createSandbox();
+      removeGroupMembersStub = 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, "removeGroupMembers")
+         .callsFake(removeGroupMembersStub);
+   });
+
+   afterEach(() => {
+      sandbox.restore();
+   });
+
+   it("should remove user member successfully", async () => {
+      const mockResponse = {
+         data: {},
+      };
+      removeGroupMembersStub.resolves(mockResponse);
+
+      await removeMember(
+         "http://test-server",
+         "test-group",
+         "user",
+         "test-user",
+         false,
+      );
+
+      expect(removeGroupMembersStub.calledOnce).to.be.true;
+      expect(removeGroupMembersStub.firstCall.args[0]).to.equal("test-org");
+      expect(removeGroupMembersStub.firstCall.args[1]).to.equal("test-group");
+      expect(removeGroupMembersStub.firstCall.args[2]).to.deep.include({
+         members: [
+            {
+               userGroupId: "user:test-user",
+            },
+         ],
+      });
+      expect(
+         loggerStub.info.calledWith(
+            sinon.match(
+               "Successfully removed user test-user from group test-group",
+            ),
+         ),
+      ).to.be.true;
+   });
+
+   it("should remove group member successfully", async () => {
+      const mockResponse = {
+         data: {},
+      };
+      removeGroupMembersStub.resolves(mockResponse);
+
+      await removeMember(
+         "http://test-server",
+         "test-group",
+         "group",
+         "test-subgroup",
+         false,
+      );
+
+      expect(removeGroupMembersStub.firstCall.args[2]).to.deep.include({
+         members: [
+            {
+               userGroupId: "group:test-subgroup",
+            },
+         ],
+      });
+      expect(
+         loggerStub.info.calledWith(
+            sinon.match(
+               "Successfully removed group test-subgroup from group test-group",
+            ),
+         ),
+      ).to.be.true;
+   });
+
+   it("should handle case-insensitive member type", async () => {
+      const mockResponse = {
+         data: {},
+      };
+      removeGroupMembersStub.resolves(mockResponse);
+
+      await removeMember(
+         "http://test-server",
+         "test-group",
+         "USER",
+         "test-user",
+         false,
+      );
+
+      expect(
+         removeGroupMembersStub.firstCall.args[2].members[0].userGroupId,
+      ).to.equal("user:test-user");
+   });
+
+   it("should handle missing config", async () => {
+      sandbox.restore();
+      sandbox = sinon.createSandbox();
+      removeGroupMembersStub = sandbox.stub();
+      loggerStub = sandbox.stub(logger);
+      processExitStub = sandbox.stub(process, "exit");
+
+      sandbox
+         .stub(ClientConfiguration.prototype, "doesConfigExists")
+         .returns(false);
+      sandbox
+         .stub(GroupsApi.prototype, "removeGroupMembers")
+         .callsFake(removeGroupMembersStub);
+
+      await removeMember(
+         "http://test-server",
+         "test-group",
+         "user",
+         "test-user",
+         false,
+      );
+
+      expect(removeGroupMembersStub.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();
+      removeGroupMembersStub = 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, "removeGroupMembers")
+         .callsFake(removeGroupMembersStub);
+
+      await removeMember(
+         "http://test-server",
+         "test-group",
+         "user",
+         "test-user",
+         false,
+      );
+
+      expect(removeGroupMembersStub.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 removeMember(
+         "http://test-server",
+         "test-group",
+         "invalid",
+         "test-user",
+         false,
+      );
+
+      expect(removeGroupMembersStub.called).to.be.false;
+      expect(
+         loggerStub.error.calledWith(
+            sinon.match("Error: memberType must be either 'user' or 'group'"),
+         ),
+      ).to.be.true;
+      expect(processExitStub.calledWith(1)).to.be.true;
+   });
+
+   it("should handle API errors", async () => {
+      const mockError = new Error("API Error");
+      removeGroupMembersStub.rejects(mockError);
+
+      await removeMember(
+         "http://test-server",
+         "test-group",
+         "user",
+         "test-user",
+         true,
+      );
+
+      expect(removeGroupMembersStub.calledOnce).to.be.true;
+      expect(
+         loggerStub.error.calledWith(
+            sinon.match("Failed to remove member from group"),
+         ),
+      ).to.be.true;
+      expect(processExitStub.calledWith(1)).to.be.true;
+   });
+});

package/src/commands/group/removemember.ts

@@ -0,0 +1,75 @@
+import {
+   GroupMember,
+   GroupsApi,
+   RemoveGroupMembersRequest,
+} 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 removeMember(
+   controlPlane: string,
+   groupName: string,
+   memberType: string,
+   memberName: 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(
+      `Removing ${memberType} ${memberName} from group ${groupName} in organization ${organizationName}`,
+   );
+
+   // 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 must be either 'user' or 'group'");
+      process.exit(1);
+      return;
+   }
+
+   const groupMember: GroupMember = {
+      userGroupId: userGroupId.getValue(),
+      // Note: status is not required for removal, only the member identifier
+   };
+
+   const request: RemoveGroupMembersRequest = {
+      members: [groupMember],
+   };
+
+   try {
+      await groupsApi.removeGroupMembers(organizationName, groupName, request, {
+         baseURL: controlPlane,
+         headers: {
+            Authorization: clientConfig.getAuthenticationHeader(),
+         },
+      });
+
+      logger.info(
+         `Successfully removed ${memberType} ${memberName} from group ${groupName}`,
+      );
+   } catch (error) {
+      logger.error("Failed to remove member from group");
+      printOutError(error, debug);
+      process.exit(1);
+   }
+}

package/src/commands/groupaccesstoken/createToken.spec.ts

@@ -0,0 +1,211 @@
+import { expect } from "chai";
+import sinon from "sinon";
+import { GroupsApi } from "../../client/api";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import { createGroupAccessToken } from "./createToken";
+
+describe("create-group-access-token", () => {
+   let sandbox: sinon.SinonSandbox;
+   let createGroupAccessTokenStub: sinon.SinonStub;
+   let loggerStub: sinon.SinonStubbedInstance<typeof logger>;
+   let consoleLogStub: sinon.SinonStub;
+   let processExitStub: sinon.SinonStub;
+
+   beforeEach(() => {
+      sandbox = sinon.createSandbox();
+      createGroupAccessTokenStub = sandbox.stub();
+      loggerStub = sandbox.stub(logger);
+      consoleLogStub = sandbox.stub(console, "log");
+      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, "createGroupAccessToken")
+         .callsFake(createGroupAccessTokenStub);
+   });
+
+   afterEach(() => {
+      sandbox.restore();
+   });
+
+   it("should create group access token successfully", async () => {
+      const mockResponse = {
+         data: { tokenName: "test-token", secret: "secret-value" },
+      };
+      createGroupAccessTokenStub.resolves(mockResponse);
+
+      const result = await createGroupAccessToken(
+         "http://test-server",
+         "test-group",
+         "test-token",
+         undefined,
+         false,
+         false,
+      );
+
+      expect(createGroupAccessTokenStub.calledOnce).to.be.true;
+      expect(createGroupAccessTokenStub.firstCall.args[0]).to.equal("test-org");
+      expect(createGroupAccessTokenStub.firstCall.args[1]).to.equal(
+         "test-group",
+      );
+      expect(createGroupAccessTokenStub.firstCall.args[2]).to.equal(
+         "test-token",
+      );
+      expect(createGroupAccessTokenStub.firstCall.args[3]).to.be.undefined;
+      expect(consoleLogStub.called).to.be.true;
+      expect(
+         loggerStub.info.calledWith(
+            sinon.match("Group access token created successfully"),
+         ),
+      ).to.be.true;
+      expect(result).to.deep.equal(mockResponse.data);
+   });
+
+   it("should create token with expiration date", async () => {
+      const futureDate = new Date();
+      futureDate.setFullYear(futureDate.getFullYear() + 1);
+      const expiresAt = futureDate.toISOString();
+      const mockResponse = {
+         data: { tokenName: "test-token" },
+      };
+      createGroupAccessTokenStub.resolves(mockResponse);
+
+      await createGroupAccessToken(
+         "http://test-server",
+         "test-group",
+         "test-token",
+         expiresAt,
+         false,
+         false,
+      );
+
+      expect(createGroupAccessTokenStub.firstCall.args[3]).to.equal(expiresAt);
+   });
+
+   it("should reject invalid expiration date format", async () => {
+      await createGroupAccessToken(
+         "http://test-server",
+         "test-group",
+         "test-token",
+         "invalid-date",
+         false,
+         false,
+      );
+
+      expect(createGroupAccessTokenStub.called).to.be.false;
+      expect(
+         loggerStub.error.calledWith(
+            sinon.match(/Invalid expiration date format/),
+         ),
+      ).to.be.true;
+      expect(processExitStub.calledWith(1)).to.be.true;
+   });
+
+   it("should reject expiration date in the past", async () => {
+      const pastDate = new Date();
+      pastDate.setFullYear(pastDate.getFullYear() - 1);
+      const expiresAt = pastDate.toISOString();
+
+      await createGroupAccessToken(
+         "http://test-server",
+         "test-group",
+         "test-token",
+         expiresAt,
+         false,
+         false,
+      );
+
+      expect(createGroupAccessTokenStub.called).to.be.false;
+      expect(
+         loggerStub.error.calledWith(
+            sinon.match("Expiration date must be in the future"),
+         ),
+      ).to.be.true;
+      expect(processExitStub.calledWith(1)).to.be.true;
+   });
+
+   it("should return JSON output when jsonOutput is true", async () => {
+      const mockResponse = {
+         data: { tokenName: "test-token", secret: "secret-value" },
+      };
+      createGroupAccessTokenStub.resolves(mockResponse);
+
+      const result = await createGroupAccessToken(
+         "http://test-server",
+         "test-group",
+         "test-token",
+         undefined,
+         true,
+         false,
+      );
+
+      expect(result).to.deep.equal(mockResponse.data);
+      expect(
+         loggerStub.info.calledWith(
+            sinon.match("Group access token created successfully"),
+         ),
+      ).to.be.false;
+   });
+
+   it("should handle missing config", async () => {
+      sandbox.restore();
+      sandbox = sinon.createSandbox();
+      createGroupAccessTokenStub = sandbox.stub();
+      loggerStub = sandbox.stub(logger);
+      consoleLogStub = sandbox.stub(console, "log");
+      processExitStub = sandbox.stub(process, "exit");
+
+      sandbox
+         .stub(ClientConfiguration.prototype, "doesConfigExists")
+         .returns(false);
+      sandbox
+         .stub(GroupsApi.prototype, "createGroupAccessToken")
+         .callsFake(createGroupAccessTokenStub);
+
+      const result = await createGroupAccessToken(
+         "http://test-server",
+         "test-group",
+         "test-token",
+         undefined,
+         false,
+         false,
+      );
+
+      expect(createGroupAccessTokenStub.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 handle API errors", async () => {
+      const mockError = new Error("API Error");
+      createGroupAccessTokenStub.rejects(mockError);
+
+      await createGroupAccessToken(
+         "http://test-server",
+         "test-group",
+         "test-token",
+         undefined,
+         false,
+         true,
+      );
+
+      expect(createGroupAccessTokenStub.calledOnce).to.be.true;
+      expect(loggerStub.error.calledWith(sinon.match("Operation failed"))).to.be
+         .true;
+      expect(processExitStub.calledWith(1)).to.be.true;
+   });
+});

package/src/commands/groupaccesstoken/createToken.ts

@@ -0,0 +1,72 @@
+import kleur from "kleur";
+import { logger } from "../../logger";
+import { withGroupContext } from "./groupContainer";
+
+export async function createGroupAccessToken(
+   controlPlane: string,
+   groupName: string,
+   tokenName: string,
+   expiresAt: string | undefined,
+   jsonOutput: boolean,
+   debug: boolean,
+) {
+   // Validate expiresAt format if provided
+   if (expiresAt) {
+      const expiresAtDate = new Date(expiresAt);
+      if (isNaN(expiresAtDate.getTime())) {
+         logger.error(
+            `Invalid expiration date format: ${expiresAt}. Please use ISO 8601 format (e.g., 2025-12-31T23:59:59Z)`,
+         );
+         process.exit(1);
+         return;
+      }
+      if (expiresAtDate <= new Date()) {
+         logger.error("Expiration date must be in the future");
+         process.exit(1);
+         return;
+      }
+   }
+
+   const result = await withGroupContext(
+      controlPlane,
+      async (context) => {
+         const { organizationName, groupsApi, options } = context;
+
+         const response = await groupsApi.createGroupAccessToken(
+            organizationName,
+            groupName,
+            tokenName,
+            expiresAt,
+            options,
+         );
+
+         return response.data;
+      },
+      undefined,
+      debug,
+   );
+
+   if (jsonOutput) {
+      return result;
+   }
+
+   // Display security warning after the response is printed
+   console.log("\n" + kleur.yellow().bold("⚠️  IMPORTANT SECURITY NOTICE ⚠️"));
+   console.log(
+      kleur.yellow("The token secret shown above will NOT be displayed again."),
+   );
+   console.log(
+      kleur.yellow(
+         "Please store it securely in a password manager or secure vault.",
+      ),
+   );
+   console.log(
+      kleur.yellow(
+         "If you lose this token, you will need to create a new one.",
+      ),
+   );
+   console.log("");
+   logger.info("Group access token created successfully");
+
+   return result;
+}