@credibledata/cred-cli 0.0.6

package/src/commands/misc/set-access-token.spec.ts

@@ -0,0 +1,95 @@
+import { expect } from "chai";
+import sinon from "sinon";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import { setAccessToken } from "./set-access-token";
+
+describe("set-access-token", () => {
+   let sandbox: sinon.SinonSandbox;
+   let setAccessTokenStub: sinon.SinonStub;
+   let setJwtAccessTokenStub: sinon.SinonStub;
+   let setOrganizationStub: sinon.SinonStub;
+   let loggerStub: sinon.SinonStubbedInstance<typeof logger>;
+
+   beforeEach(() => {
+      sandbox = sinon.createSandbox();
+      loggerStub = sandbox.stub(logger);
+      setAccessTokenStub = sandbox.stub(
+         ClientConfiguration.prototype,
+         "setAccessToken",
+      );
+      setJwtAccessTokenStub = sandbox.stub(
+         ClientConfiguration.prototype,
+         "setJwtAccessToken",
+      );
+      setOrganizationStub = sandbox.stub(
+         ClientConfiguration.prototype,
+         "setOrganization",
+      );
+   });
+
+   afterEach(() => {
+      sandbox.restore();
+   });
+
+   it("should set access token successfully", () => {
+      const jwtToken = "test-jwt-token";
+
+      setAccessToken(jwtToken);
+
+      expect(setAccessTokenStub.calledOnce).to.be.true;
+      expect(setAccessTokenStub.firstCall.args).to.deep.equal([
+         false,
+         jwtToken,
+      ]);
+      expect(setJwtAccessTokenStub.calledOnce).to.be.true;
+      expect(setJwtAccessTokenStub.firstCall.args[0]).to.equal(jwtToken);
+      expect(
+         loggerStub.info.calledWith(
+            sinon.match("Access token set successfully"),
+         ),
+      ).to.be.true;
+   });
+
+   it("should set access token and organization when provided", () => {
+      const jwtToken = "test-jwt-token";
+      const organizationName = "test-org";
+
+      setAccessToken(jwtToken, organizationName);
+
+      expect(setAccessTokenStub.calledOnce).to.be.true;
+      expect(setJwtAccessTokenStub.calledOnce).to.be.true;
+      expect(setOrganizationStub.calledOnce).to.be.true;
+      expect(setOrganizationStub.firstCall.args[0]).to.equal(organizationName);
+      expect(
+         loggerStub.info.calledWith(
+            sinon.match("Access token set successfully"),
+         ),
+      ).to.be.true;
+      expect(
+         loggerStub.info.calledWith(
+            sinon.match(`Organization set to: ${organizationName}`),
+         ),
+      ).to.be.true;
+   });
+
+   it("should not set organization when not provided", () => {
+      const jwtToken = "test-jwt-token";
+
+      setAccessToken(jwtToken);
+
+      expect(setOrganizationStub.called).to.be.false;
+      expect(loggerStub.info.calledWith(sinon.match(/Organization set to:/))).to
+         .be.false;
+   });
+
+   it("should handle custom config path", () => {
+      const jwtToken = "test-jwt-token";
+      const configPath = "/custom/path/config.json";
+
+      setAccessToken(jwtToken, undefined, configPath);
+
+      expect(setAccessTokenStub.calledOnce).to.be.true;
+      expect(setJwtAccessTokenStub.calledOnce).to.be.true;
+   });
+});

package/src/commands/misc/set-access-token.ts

@@ -0,0 +1,32 @@
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+
+/**
+ * Sets a service account JWT token for CLI authentication.
+ *
+ * @param jwtToken The JWT token to use for authentication
+ * @param organizationName Optional organization name to set
+ * @param configPath Optional custom config path
+ */
+export function setAccessToken(
+   jwtToken: string,
+   organizationName?: string,
+   configPath?: string,
+) {
+   const config = new ClientConfiguration(configPath);
+
+   // Set the JWT token as both access token and JWT access token
+   config.setAccessToken(false, jwtToken);
+   config.setJwtAccessToken(jwtToken);
+
+   // Set organization if provided
+   if (organizationName) {
+      config.setOrganization(organizationName);
+   }
+
+   logger.info("Access token set successfully");
+
+   if (organizationName) {
+      logger.info(`Organization set to: ${organizationName}`);
+   }
+}

package/src/commands/package/deletepackage.spec.ts

@@ -0,0 +1,164 @@
+import { expect } from "chai";
+import sinon from "sinon";
+import { PackagesApi } from "../../client/api";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import { getConfirmation } from "../../utils";
+import { deletePackage } from "./deletepackage";
+
+describe("delete-package", () => {
+   let sandbox: sinon.SinonSandbox;
+   let deletePackageStub: sinon.SinonStub;
+   let loggerStub: sinon.SinonStubbedInstance<typeof logger>;
+   let getConfirmationStub: sinon.SinonStub;
+
+   beforeEach(() => {
+      sandbox = sinon.createSandbox();
+      deletePackageStub = sandbox.stub();
+      loggerStub = sandbox.stub(logger);
+      getConfirmationStub = sandbox.stub();
+
+      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(PackagesApi.prototype, "deletePackage")
+         .callsFake(deletePackageStub);
+      sandbox
+         .stub(require("../../utils"), "getConfirmation")
+         .callsFake(getConfirmationStub);
+   });
+
+   afterEach(() => {
+      sandbox.restore();
+   });
+
+   it("should delete package successfully", async () => {
+      deletePackageStub.resolves({ status: 200 });
+      getConfirmationStub.resolves(true);
+
+      await deletePackage("http://test-server", "/test-package", false, true);
+
+      expect(deletePackageStub.calledOnce).to.be.true;
+      expect(deletePackageStub.firstCall.args[0]).to.equal("test-org");
+      expect(deletePackageStub.firstCall.args[1]).to.equal("test-project");
+      expect(deletePackageStub.firstCall.args[2]).to.equal("test-package");
+      expect(deletePackageStub.firstCall.args[3]).to.deep.include({
+         baseURL: "http://test-server",
+         headers: { Authorization: "Bearer test-token" },
+      });
+      expect(
+         loggerStub.info.calledWith(
+            sinon.match("Package deleted successfully"),
+         ),
+      ).to.be.true;
+   });
+
+   it("should handle package path without leading slash", async () => {
+      deletePackageStub.resolves({ status: 200 });
+      getConfirmationStub.resolves(true);
+
+      await deletePackage("http://test-server", "test-package", false, true);
+
+      expect(deletePackageStub.firstCall.args[2]).to.equal("test-package");
+   });
+
+   it("should handle missing config", async () => {
+      sandbox.restore();
+      sandbox = sinon.createSandbox();
+      deletePackageStub = sandbox.stub();
+      loggerStub = sandbox.stub(logger);
+      getConfirmationStub = sandbox.stub();
+
+      sandbox
+         .stub(ClientConfiguration.prototype, "doesConfigExists")
+         .returns(false);
+      sandbox
+         .stub(PackagesApi.prototype, "deletePackage")
+         .callsFake(deletePackageStub);
+      sandbox
+         .stub(require("../../utils"), "getConfirmation")
+         .callsFake(getConfirmationStub);
+
+      await deletePackage("http://test-server", "/test-package", false, true);
+
+      expect(deletePackageStub.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();
+      deletePackageStub = sandbox.stub();
+      loggerStub = sandbox.stub(logger);
+      getConfirmationStub = sandbox.stub();
+
+      sandbox
+         .stub(ClientConfiguration.prototype, "doesConfigExists")
+         .returns(true);
+      sandbox.stub(ClientConfiguration.prototype, "getProject").returns("");
+      sandbox
+         .stub(PackagesApi.prototype, "deletePackage")
+         .callsFake(deletePackageStub);
+      sandbox
+         .stub(require("../../utils"), "getConfirmation")
+         .callsFake(getConfirmationStub);
+
+      await deletePackage("http://test-server", "/test-package", false, true);
+
+      expect(deletePackageStub.called).to.be.false;
+      expect(
+         loggerStub.error.calledWith(
+            sinon.match("Please, make sure to set a project"),
+         ),
+      ).to.be.true;
+   });
+
+   it("should request confirmation when autoConfirm is false", async () => {
+      deletePackageStub.resolves({ status: 200 });
+      getConfirmationStub.resolves(true);
+
+      await deletePackage("http://test-server", "/test-package", false, false);
+
+      expect(getConfirmationStub.calledOnce).to.be.true;
+      expect(deletePackageStub.calledOnce).to.be.true;
+   });
+
+   it("should cancel when confirmation is denied", async () => {
+      getConfirmationStub.resolves(false);
+
+      await deletePackage("http://test-server", "/test-package", false, false);
+
+      expect(getConfirmationStub.calledOnce).to.be.true;
+      expect(deletePackageStub.called).to.be.false;
+      expect(loggerStub.info.calledWith(sinon.match("Operation cancelled."))).to
+         .be.true;
+   });
+
+   it("should handle API errors", async () => {
+      const mockError = new Error("API Error");
+      deletePackageStub.rejects(mockError);
+      getConfirmationStub.resolves(true);
+
+      await deletePackage("http://test-server", "/test-package", true, true);
+
+      expect(deletePackageStub.calledOnce).to.be.true;
+      expect(
+         loggerStub.error.calledWith(sinon.match("Failed to delete package")),
+      ).to.be.true;
+   });
+});

package/src/commands/package/deletepackage.ts

@@ -0,0 +1,58 @@
+import { PackagesApi } from "../../client/api";
+import { Configuration } from "../../client/configuration";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import { getConfirmation, printOutError } from "../../utils";
+
+const packagesApi = new PackagesApi(new Configuration());
+
+export async function deletePackage(
+   packageServer: string,
+   packagePath: string,
+   debug: boolean,
+   autoConfirm: boolean,
+) {
+   const clientConfig = new ClientConfiguration();
+   const organizationName = clientConfig.getOrganization();
+   const projectName = clientConfig.getProject();
+   const packageName = packagePath.replace("/", "");
+
+   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 ${packagePath} package? This action cannot be undone.`,
+      );
+      if (!confirmation) {
+         logger.info("Operation cancelled.");
+         return;
+      }
+   }
+
+   logger.info("Deleting package " + packagePath);
+
+   try {
+      await packagesApi.deletePackage(
+         organizationName,
+         projectName,
+         packageName,
+         {
+            baseURL: packageServer,
+            headers: clientConfig.getHeaders(),
+         },
+      );
+
+      logger.info("Package deleted successfully");
+   } catch (e) {
+      logger.error("Failed to delete package");
+      printOutError(e, debug);
+   }
+}

package/src/commands/package/listpackages.spec.ts

@@ -0,0 +1,147 @@
+import { expect } from "chai";
+import sinon from "sinon";
+import { PackagesApi } from "../../client/api";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import { prettifyJson } from "../../utils";
+import { listPackages, printOutPackages } from "./listpackages";
+
+describe("list-packages", () => {
+   let sandbox: sinon.SinonSandbox;
+   let listPackagesStub: sinon.SinonStub;
+   let loggerStub: sinon.SinonStubbedInstance<typeof logger>;
+   let consoleLogStub: sinon.SinonStub;
+
+   beforeEach(() => {
+      sandbox = sinon.createSandbox();
+      listPackagesStub = 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(PackagesApi.prototype, "listPackages")
+         .callsFake(listPackagesStub);
+   });
+
+   afterEach(() => {
+      sandbox.restore();
+   });
+
+   it("should list packages successfully", async () => {
+      const mockPackages = [
+         { name: "package1", latestVersion: "1.0.0" },
+         { name: "package2", latestVersion: "2.0.0" },
+      ];
+      const mockResponse = {
+         data: mockPackages,
+         headers: {},
+      };
+      listPackagesStub.resolves(mockResponse);
+
+      const result = await listPackages("http://test-server", false);
+
+      expect(listPackagesStub.calledOnce).to.be.true;
+      expect(listPackagesStub.firstCall.args[0]).to.equal("test-org");
+      expect(listPackagesStub.firstCall.args[1]).to.equal("test-project");
+      expect(listPackagesStub.firstCall.args[2]).to.equal(-1); // limit
+      expect(listPackagesStub.firstCall.args[3]).to.equal(0); // offset
+      expect(listPackagesStub.firstCall.args[4]).to.deep.include({
+         baseURL: "http://test-server",
+         headers: { Authorization: "Bearer test-token" },
+      });
+      expect(result).to.deep.equal({
+         packages: mockPackages,
+         totalCount: undefined,
+      });
+   });
+
+   it("should handle missing config", async () => {
+      sandbox.restore();
+      sandbox = sinon.createSandbox();
+      listPackagesStub = sandbox.stub();
+      loggerStub = sandbox.stub(logger);
+      consoleLogStub = sandbox.stub(console, "log");
+
+      sandbox
+         .stub(ClientConfiguration.prototype, "doesConfigExists")
+         .returns(false);
+      sandbox
+         .stub(PackagesApi.prototype, "listPackages")
+         .callsFake(listPackagesStub);
+
+      const result = await listPackages("http://test-server", false);
+
+      expect(listPackagesStub.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 project", async () => {
+      sandbox.restore();
+      sandbox = sinon.createSandbox();
+      listPackagesStub = 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(PackagesApi.prototype, "listPackages")
+         .callsFake(listPackagesStub);
+
+      const result = await listPackages("http://test-server", false);
+
+      expect(listPackagesStub.called).to.be.false;
+      expect(result).to.be.undefined;
+      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");
+      listPackagesStub.rejects(mockError);
+
+      const result = await listPackages("http://test-server", true);
+
+      expect(listPackagesStub.calledOnce).to.be.true;
+      expect(result).to.be.undefined;
+      expect(
+         loggerStub.error.calledWith(sinon.match("Failed to list packages")),
+      ).to.be.true;
+   });
+
+   it("should print packages when using printOutPackages", async () => {
+      const mockPackages = [{ name: "package1" }];
+      const mockResponse = {
+         data: mockPackages,
+         headers: {},
+      };
+      listPackagesStub.resolves(mockResponse);
+
+      await printOutPackages("http://test-server", false);
+
+      expect(consoleLogStub.called).to.be.true;
+   });
+});

package/src/commands/package/listpackages.ts

@@ -0,0 +1,67 @@
+import { PackagesApi } from "../../client/api";
+import { Configuration } from "../../client/configuration";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import {
+   prettifyJson,
+   printOutError,
+   parsePaginationParams,
+   extractTotalCount,
+} from "../../utils";
+
+const packagesApi = new PackagesApi(new Configuration());
+
+export async function listPackages(
+   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 packagesApi.listPackages(
+         organizationName,
+         projectName,
+         limit,
+         offset,
+         {
+            baseURL: controlPlane,
+            headers: clientConfig.getHeaders(),
+         },
+      );
+
+      const totalCount = extractTotalCount(response.headers);
+
+      return {
+         packages: response.data,
+         totalCount,
+      };
+   } catch (e) {
+      logger.error("Failed to list packages");
+      printOutError(e, debug);
+   }
+}
+
+export async function printOutPackages(
+   controlPlane: string,
+   debug: boolean,
+   page?: string | number,
+   pageSize?: string | number,
+) {
+   const packages = await listPackages(controlPlane, debug, page, pageSize);
+   console.log(prettifyJson(packages));
+}