@credibledata/cred-cli 0.0.6

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

@@ -0,0 +1,147 @@
+import { expect } from "chai";
+import sinon from "sinon";
+import { GroupsApi } from "../../client/api";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import { deleteGroupAccessToken } from "./deleteToken";
+
+describe("delete-group-access-token", () => {
+   let sandbox: sinon.SinonSandbox;
+   let deleteGroupAccessTokenStub: sinon.SinonStub;
+   let loggerStub: sinon.SinonStubbedInstance<typeof logger>;
+   let processExitStub: sinon.SinonStub;
+
+   beforeEach(() => {
+      sandbox = sinon.createSandbox();
+      deleteGroupAccessTokenStub = 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, "deleteGroupAccessToken")
+         .callsFake(deleteGroupAccessTokenStub);
+   });
+
+   afterEach(() => {
+      sandbox.restore();
+   });
+
+   it("should delete group access token successfully", async () => {
+      deleteGroupAccessTokenStub.resolves({ status: 200 });
+
+      await deleteGroupAccessToken(
+         "http://test-server",
+         "test-group",
+         "test-token",
+         false,
+      );
+
+      expect(deleteGroupAccessTokenStub.calledOnce).to.be.true;
+      expect(deleteGroupAccessTokenStub.firstCall.args[0]).to.equal("test-org");
+      expect(deleteGroupAccessTokenStub.firstCall.args[1]).to.equal(
+         "test-group",
+      );
+      expect(deleteGroupAccessTokenStub.firstCall.args[2]).to.equal(
+         "test-token",
+      );
+      expect(
+         loggerStub.info.calledWith(
+            sinon.match(
+               "Successfully deleted access token test-token. This token has been immediately revoked.",
+            ),
+         ),
+      ).to.be.true;
+   });
+
+   it("should handle missing config", async () => {
+      sandbox.restore();
+      sandbox = sinon.createSandbox();
+      deleteGroupAccessTokenStub = sandbox.stub();
+      loggerStub = sandbox.stub(logger);
+      processExitStub = sandbox.stub(process, "exit");
+
+      sandbox
+         .stub(ClientConfiguration.prototype, "doesConfigExists")
+         .returns(false);
+      sandbox
+         .stub(GroupsApi.prototype, "deleteGroupAccessToken")
+         .callsFake(deleteGroupAccessTokenStub);
+
+      const result = await deleteGroupAccessToken(
+         "http://test-server",
+         "test-group",
+         "test-token",
+         false,
+      );
+
+      expect(deleteGroupAccessTokenStub.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 missing organization", async () => {
+      sandbox.restore();
+      sandbox = sinon.createSandbox();
+      deleteGroupAccessTokenStub = 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, "deleteGroupAccessToken")
+         .callsFake(deleteGroupAccessTokenStub);
+
+      const result = await deleteGroupAccessToken(
+         "http://test-server",
+         "test-group",
+         "test-token",
+         false,
+      );
+
+      expect(deleteGroupAccessTokenStub.called).to.be.false;
+      expect(result).to.be.undefined;
+      expect(
+         loggerStub.error.calledWith(
+            sinon.match(
+               "No organization set. Please login or set an organization.",
+            ),
+         ),
+      ).to.be.true;
+   });
+
+   it("should handle API errors", async () => {
+      const mockError = new Error("API Error");
+      deleteGroupAccessTokenStub.rejects(mockError);
+
+      await deleteGroupAccessToken(
+         "http://test-server",
+         "test-group",
+         "test-token",
+         true,
+      );
+
+      expect(deleteGroupAccessTokenStub.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/deleteToken.ts

@@ -0,0 +1,29 @@
+import { logger } from "../../logger";
+import { withGroupContext } from "./groupContainer";
+
+export async function deleteGroupAccessToken(
+   controlPlane: string,
+   groupName: string,
+   tokenName: string,
+   debug: boolean,
+) {
+   return withGroupContext(
+      controlPlane,
+      async (context) => {
+         const { organizationName, groupsApi, options } = context;
+
+         logger.info(
+            `Deleting access token ${tokenName} from group ${groupName} in organization ${organizationName}`,
+         );
+
+         await groupsApi.deleteGroupAccessToken(
+            organizationName,
+            groupName,
+            tokenName,
+            options,
+         );
+      },
+      `Successfully deleted access token ${tokenName}. This token has been immediately revoked.`,
+      debug,
+   );
+}

package/src/commands/groupaccesstoken/groupContainer.ts

@@ -0,0 +1,83 @@
+import { GroupsApi } from "../../client/api";
+import { Configuration } from "../../client/configuration";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import { printOutError } from "../../utils";
+
+export interface ApiOptions {
+   baseURL: string;
+   headers: {
+      Authorization: string;
+   };
+   params?: Record<string, unknown>;
+}
+
+export interface GroupContext {
+   organizationName: string;
+   groupsApi: GroupsApi;
+   options: ApiOptions;
+}
+
+/**
+ * Container function that handles common ClientConfiguration checks, setup,
+ * error handling, and response printing for group access token operations.
+ *
+ * @param controlPlane The control plane URL
+ * @param handler The handler function to execute with the configured context
+ * @param successMessage Optional success message to display after the operation
+ * @param debug Whether to enable debug mode for error output
+ * @returns The result of the handler function, or void if validation fails
+ */
+export async function withGroupContext<T>(
+   controlPlane: string,
+   handler: (context: GroupContext) => Promise<T>,
+   successMessage?: string,
+   debug: boolean = false,
+): Promise<T | void> {
+   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;
+   }
+
+   const options: ApiOptions = {
+      baseURL: controlPlane,
+      headers: {
+         Authorization: clientConfig.getAuthenticationHeader(),
+      },
+   };
+
+   const context: GroupContext = {
+      organizationName,
+      groupsApi: new GroupsApi(new Configuration()),
+      options,
+   };
+
+   try {
+      const result = await handler(context);
+
+      // Print response if it exists
+      if (result !== undefined && result !== null) {
+         const jsonString = JSON.stringify(result, null, 2);
+         console.log(jsonString);
+      }
+
+      // Print success message if provided
+      if (successMessage) {
+         logger.info(successMessage);
+      }
+
+      return result;
+   } catch (error) {
+      logger.error("Operation failed");
+      printOutError(error, debug);
+      process.exit(1);
+   }
+}

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

@@ -0,0 +1,147 @@
+import { expect } from "chai";
+import sinon from "sinon";
+import { GroupsApi } from "../../client/api";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import { listGroupAccessTokens } from "./listTokens";
+
+describe("list-group-access-tokens", () => {
+   let sandbox: sinon.SinonSandbox;
+   let listGroupAccessTokensStub: sinon.SinonStub;
+   let loggerStub: sinon.SinonStubbedInstance<typeof logger>;
+   let consoleLogStub: sinon.SinonStub;
+   let processExitStub: sinon.SinonStub;
+
+   beforeEach(() => {
+      sandbox = sinon.createSandbox();
+      listGroupAccessTokensStub = 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, "listGroupAccessTokens")
+         .callsFake(listGroupAccessTokensStub);
+   });
+
+   afterEach(() => {
+      sandbox.restore();
+   });
+
+   it("should list group access tokens successfully", async () => {
+      const mockTokens = [
+         { tokenName: "token1", createdAt: "2024-01-01" },
+         { tokenName: "token2", createdAt: "2024-01-02" },
+      ];
+      const mockResponse = {
+         data: mockTokens,
+      };
+      listGroupAccessTokensStub.resolves(mockResponse);
+
+      const result = await listGroupAccessTokens(
+         "http://test-server",
+         "test-group",
+         false,
+      );
+
+      expect(listGroupAccessTokensStub.calledOnce).to.be.true;
+      expect(listGroupAccessTokensStub.firstCall.args[0]).to.equal("test-org");
+      expect(listGroupAccessTokensStub.firstCall.args[1]).to.equal(
+         "test-group",
+      );
+      expect(consoleLogStub.called).to.be.true;
+      expect(
+         loggerStub.info.calledWith(
+            sinon.match("Group access tokens listed successfully"),
+         ),
+      ).to.be.true;
+      expect(result).to.deep.equal(mockTokens);
+   });
+
+   it("should handle missing config", async () => {
+      sandbox.restore();
+      sandbox = sinon.createSandbox();
+      listGroupAccessTokensStub = 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, "listGroupAccessTokens")
+         .callsFake(listGroupAccessTokensStub);
+
+      const result = await listGroupAccessTokens(
+         "http://test-server",
+         "test-group",
+         false,
+      );
+
+      expect(listGroupAccessTokensStub.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 missing organization", async () => {
+      sandbox.restore();
+      sandbox = sinon.createSandbox();
+      listGroupAccessTokensStub = sandbox.stub();
+      loggerStub = sandbox.stub(logger);
+      consoleLogStub = sandbox.stub(console, "log");
+      processExitStub = sandbox.stub(process, "exit");
+
+      sandbox
+         .stub(ClientConfiguration.prototype, "doesConfigExists")
+         .returns(true);
+      sandbox
+         .stub(ClientConfiguration.prototype, "getOrganization")
+         .returns(undefined);
+      sandbox
+         .stub(GroupsApi.prototype, "listGroupAccessTokens")
+         .callsFake(listGroupAccessTokensStub);
+
+      const result = await listGroupAccessTokens(
+         "http://test-server",
+         "test-group",
+         false,
+      );
+
+      expect(listGroupAccessTokensStub.called).to.be.false;
+      expect(result).to.be.undefined;
+      expect(
+         loggerStub.error.calledWith(
+            sinon.match(
+               "No organization set. Please login or set an organization.",
+            ),
+         ),
+      ).to.be.true;
+   });
+
+   it("should handle API errors", async () => {
+      const mockError = new Error("API Error");
+      listGroupAccessTokensStub.rejects(mockError);
+
+      await listGroupAccessTokens("http://test-server", "test-group", true);
+
+      expect(listGroupAccessTokensStub.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/listTokens.ts

@@ -0,0 +1,29 @@
+import { logger } from "../../logger";
+import { withGroupContext } from "./groupContainer";
+
+export async function listGroupAccessTokens(
+   controlPlane: string,
+   groupName: string,
+   debug: boolean,
+) {
+   return withGroupContext(
+      controlPlane,
+      async (context) => {
+         const { organizationName, groupsApi, options } = context;
+
+         logger.info(
+            `Listing access tokens for group ${groupName} in organization ${organizationName}`,
+         );
+
+         const response = await groupsApi.listGroupAccessTokens(
+            organizationName,
+            groupName,
+            options,
+         );
+
+         return response.data;
+      },
+      "Group access tokens listed successfully",
+      debug,
+   );
+}

package/src/commands/list.ts

@@ -0,0 +1,131 @@
+import { Command } from "commander";
+import { controlPlanesByEnv, Environment } from "../constants";
+import { DEFAULT_PAGE_SIZE, DEFAULT_PAGE } from "../utils";
+import { listConnections } from "./connection/listconnections";
+import { printOutGroups } from "./group/listgroups";
+import { listGroupAccessTokens } from "./groupaccesstoken/listTokens";
+import { printOutPackages } from "./package/listpackages";
+import { printOutProjects } from "./project/listprojects";
+import { listVersions } from "./version/listversions";
+
+export const registerListCommands = (
+   cli: Command,
+   environment: Environment,
+) => {
+   const list = cli
+      .command("ls")
+      .description("List resources of a given type")
+      .argument("<resource>", "The resource to list");
+
+   list
+      .command("project")
+      .alias("projects")
+      .description("List all projects.")
+      .option("--debug")
+      .option(
+         "--page <number>",
+         `Page number (starts at  ${DEFAULT_PAGE})`,
+         String(DEFAULT_PAGE),
+      )
+      .option(
+         "--page-size <number>",
+         `Items per page (default: all records, max: 500)`,
+         String(DEFAULT_PAGE_SIZE),
+      )
+      .action((options) => {
+         printOutProjects(
+            controlPlanesByEnv[environment],
+            options.debug,
+            options.page,
+            options.pageSize,
+         );
+      });
+
+   list
+      .command("connection")
+      .alias("connections")
+      .description("List all connections.")
+      .option("--debug")
+      .option(
+         "--page <number>",
+         `Page number (starts at  ${DEFAULT_PAGE})`,
+         String(DEFAULT_PAGE),
+      )
+      .option(
+         "--page-size <number>",
+         `Items per page (default: all records, max: 500)`,
+         String(DEFAULT_PAGE_SIZE),
+      )
+      .action((options) => {
+         listConnections(
+            controlPlanesByEnv[environment],
+            options.debug,
+            options.page,
+            options.pageSize,
+         );
+      });
+
+   list
+      .command("package")
+      .alias("packages")
+      .description("List the packages in the active project.")
+      .option("--debug")
+      .option(
+         "--page <number>",
+         `Page number (starts at  ${DEFAULT_PAGE})`,
+         String(DEFAULT_PAGE),
+      )
+      .option(
+         "--page-size <number>",
+         `Items per page (default: all records, max: 500)`,
+         String(DEFAULT_PAGE_SIZE),
+      )
+      .action((options) => {
+         printOutPackages(
+            controlPlanesByEnv[environment],
+            options.debug,
+            options.page,
+            options.pageSize,
+         );
+      });
+
+   list
+      .command("version")
+      .alias("versions")
+      .description("List the versions of a package.")
+      .argument(
+         "<packageName>",
+         "The name of the package to list the versions of.",
+      )
+      .option("--debug")
+      .action((packageName, options) => {
+         listVersions(
+            controlPlanesByEnv[environment],
+            packageName,
+            options.debug,
+         );
+      });
+
+   list
+      .command("group")
+      .alias("groups")
+      .description("List all groups in the organization.")
+      .option("--debug")
+      .action((options) => {
+         printOutGroups(controlPlanesByEnv[environment], options.debug);
+      });
+
+   list
+      .command("group-access-token")
+      .alias("group-access-tokens")
+      .description("List all access tokens for a group.")
+      .argument("<groupName>", "The name of the group")
+      .option("--debug")
+      .action((groupName, options) => {
+         listGroupAccessTokens(
+            controlPlanesByEnv[environment],
+            groupName,
+            options.debug,
+         );
+      });
+};