@credibledata/cred-cli 0.0.6

package/src/commands/update.ts

@@ -0,0 +1,64 @@
+import { Command } from "commander";
+import { controlPlanesByEnv, Environment } from "../constants";
+import { updatePackage } from "./package/updatepackage";
+import { updateProject } from "./project/updateproject";
+
+export const registerUpdateCommands = (
+   cli: Command,
+   environment: Environment,
+) => {
+   const update = cli
+      .command("update")
+      .description("Update a resource")
+      .argument("<resource>", "The resource to update");
+
+   update
+      .command("project")
+      .description("Update a project.")
+      .argument("<projectName>", "The name of the project to update.")
+      .option(
+         "--replication <replicationCount>",
+         "The new replication count (must be at least 1).",
+         parseInt,
+      )
+      .option("--debug")
+      .option("-y, --yes", "Skip confirmation.")
+      .action((projectName, options) => {
+         updateProject(
+            controlPlanesByEnv[environment],
+            projectName,
+            {
+               replicationCount: options.replication,
+            },
+            options.debug,
+            options.yes,
+         );
+      });
+
+   update
+      .command("package")
+      .description("Update a package.")
+      .argument("<packageName>", "The name of the package to update.")
+      .option(
+         "--replication <replicationCount>",
+         "The new replication count (must be at least 1).",
+         parseInt,
+      )
+      .option("--version <latestVersion>", "The new latest version.")
+      .option("--desc, --description <description>", "The new description.")
+      .option("--debug")
+      .option("-y, --yes", "Skip confirmation.")
+      .action((packageName, options) => {
+         updatePackage(
+            controlPlanesByEnv[environment],
+            packageName,
+            {
+               replicationCount: options.replication,
+               latestVersion: options.version,
+               description: options.description,
+            },
+            options.debug,
+            options.yes,
+         );
+      });
+};

package/src/commands/version/archive-unarchive-version.spec.ts

@@ -0,0 +1,456 @@
+import axios from "axios";
+import { expect } from "chai";
+import sinon from "sinon";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import { archiveVersion, unarchiveVersion } from "./archive-unarchive-version";
+
+describe("archive-unarchive-version", () => {
+   let sandbox: sinon.SinonSandbox;
+   let axiosStub: sinon.SinonStub;
+   let loggerStub: sinon.SinonStubbedInstance<typeof logger>;
+
+   beforeEach(() => {
+      sandbox = sinon.createSandbox();
+      axiosStub = sandbox.stub(axios, "patch");
+      sandbox.createStubInstance(ClientConfiguration);
+      loggerStub = sandbox.stub(logger);
+
+      // Mock ClientConfiguration constructor
+      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" });
+   });
+
+   afterEach(() => {
+      sandbox.restore();
+   });
+
+   describe("archiveVersion", () => {
+      it("should archive a version successfully", async () => {
+         const mockResponse = { status: 200 };
+         axiosStub.resolves(mockResponse);
+
+         await archiveVersion(
+            "http://test-server",
+            "test-package",
+            "1.0.0",
+            false,
+            true,
+         );
+
+         expect(axiosStub.calledOnce).to.be.true;
+         expect(axiosStub.firstCall.args[0]).to.equal(
+            "http://test-server/organizations/test-org/projects/test-project/packages/test-package/versions/1.0.0",
+         );
+         expect(axiosStub.firstCall.args[1]).to.deep.equal({
+            archiveStatus: "archive",
+         });
+         expect(axiosStub.firstCall.args[2]).to.deep.equal({
+            headers: { Authorization: "Bearer test-token" },
+         });
+      });
+
+      it("should handle API errors", async () => {
+         const mockError = new Error("API Error");
+         axiosStub.rejects(mockError);
+
+         await archiveVersion(
+            "http://test-server",
+            "test-package",
+            "1.0.0",
+            true,
+            true,
+         );
+
+         expect(axiosStub.calledOnce).to.be.true;
+         expect(
+            loggerStub.error.calledWith(
+               sinon.match("Failed to archive version"),
+            ),
+         ).to.be.true;
+      });
+   });
+
+   describe("unarchiveVersion", () => {
+      it("should unarchive a version successfully", async () => {
+         const mockResponse = { status: 200 };
+         axiosStub.resolves(mockResponse);
+
+         await unarchiveVersion(
+            "http://test-server",
+            "test-package",
+            "1.0.0",
+            false,
+            true,
+         );
+
+         expect(axiosStub.calledOnce).to.be.true;
+         expect(axiosStub.firstCall.args[0]).to.equal(
+            "http://test-server/organizations/test-org/projects/test-project/packages/test-package/versions/1.0.0",
+         );
+         expect(axiosStub.firstCall.args[1]).to.deep.equal({
+            archiveStatus: "unarchive",
+         });
+         expect(axiosStub.firstCall.args[2]).to.deep.equal({
+            headers: { Authorization: "Bearer test-token" },
+         });
+      });
+
+      it("should handle API errors", async () => {
+         const mockError = new Error("API Error");
+         axiosStub.rejects(mockError);
+
+         await unarchiveVersion(
+            "http://test-server",
+            "test-package",
+            "1.0.0",
+            true,
+            true,
+         );
+
+         expect(axiosStub.calledOnce).to.be.true;
+         expect(
+            loggerStub.error.calledWith(
+               sinon.match("Failed to unarchive version"),
+            ),
+         ).to.be.true;
+      });
+   });
+
+   describe("path parsing", () => {
+      it("should handle paths with leading slash", async () => {
+         const mockResponse = { status: 200 };
+         axiosStub.resolves(mockResponse);
+
+         await archiveVersion(
+            "http://test-server",
+            "package-name",
+            "2.1.0",
+            false,
+            true,
+         );
+
+         expect(axiosStub.firstCall.args[0]).to.include(
+            "/packages/package-name/versions/2.1.0",
+         );
+      });
+
+      it("should handle paths without leading slash", async () => {
+         const mockResponse = { status: 200 };
+         axiosStub.resolves(mockResponse);
+
+         await archiveVersion(
+            "http://test-server",
+            "package-name",
+            "2.1.0",
+            false,
+            true,
+         );
+
+         expect(axiosStub.firstCall.args[0]).to.include(
+            "/packages/package-name/versions/2.1.0",
+         );
+      });
+   });
+
+   describe("validators", () => {
+      describe("authentication validation", () => {
+         it("should fail when user is not logged in", async () => {
+            sandbox.restore();
+            sandbox = sinon.createSandbox();
+            axiosStub = sandbox.stub(axios, "patch");
+            loggerStub = sandbox.stub(logger);
+
+            sandbox
+               .stub(ClientConfiguration.prototype, "doesConfigExists")
+               .returns(false);
+
+            await archiveVersion(
+               "http://test-server",
+               "/test-package/1.0.0",
+               "1.0.0",
+               false,
+               true,
+            );
+
+            expect(axiosStub.called).to.be.false;
+            expect(
+               loggerStub.error.calledWith(
+                  sinon.match("Please, make sure that you are logged in"),
+               ),
+            ).to.be.true;
+         });
+
+         it("should fail when no project is set", async () => {
+            sandbox.restore();
+            sandbox = sinon.createSandbox();
+            axiosStub = sandbox.stub(axios, "patch");
+            loggerStub = sandbox.stub(logger);
+
+            sandbox
+               .stub(ClientConfiguration.prototype, "doesConfigExists")
+               .returns(true);
+            sandbox
+               .stub(ClientConfiguration.prototype, "getProject")
+               .returns("");
+
+            await archiveVersion(
+               "http://test-server",
+               "/test-package/1.0.0",
+               "1.0.0",
+               false,
+               true,
+            );
+
+            expect(axiosStub.called).to.be.false;
+            expect(
+               loggerStub.error.calledWith(
+                  sinon.match("Please, make sure to set a project"),
+               ),
+            ).to.be.true;
+         });
+      });
+
+      describe("path format validation", () => {
+         it("should accept valid semantic version formats", async () => {
+            const mockResponse = { status: 200 };
+            axiosStub.resolves(mockResponse);
+
+            const validVersions = [
+               "/package/1.0.0",
+               "/package/2.1.3",
+               "/package/10.20.30",
+               "/package/1.0.0-alpha",
+               "/package/1.0.0-beta.1",
+               "/package/1.0.0+20130313144700",
+            ];
+
+            for (const version of validVersions) {
+               await archiveVersion(
+                  "http://test-server",
+                  version,
+                  "1.0.0",
+                  false,
+                  true,
+               );
+               expect(axiosStub.called).to.be.true;
+               axiosStub.reset();
+            }
+         });
+
+         it("should reject empty package names", async () => {
+            await archiveVersion(
+               "http://test-server",
+               "",
+               "1.0.0",
+               false,
+               true,
+            );
+
+            expect(axiosStub.called).to.be.false;
+            expect(
+               loggerStub.error.calledWith(
+                  sinon.match("Please provide a package name"),
+               ),
+            ).to.be.true;
+         });
+
+         it("should reject empty version IDs", async () => {
+            await archiveVersion(
+               "http://test-server",
+               "package",
+               "",
+               false,
+               true,
+            );
+
+            expect(axiosStub.called).to.be.false;
+            expect(
+               loggerStub.error.calledWith(
+                  sinon.match("Please provide a version ID"),
+               ),
+            ).to.be.true;
+         });
+
+         it("should reject empty package names", async () => {
+            await archiveVersion(
+               "http://test-server",
+               "",
+               "1.0.0",
+               false,
+               true,
+            );
+
+            expect(axiosStub.called).to.be.false;
+            expect(
+               loggerStub.error.calledWith(
+                  sinon.match("Please provide a package name"),
+               ),
+            ).to.be.true;
+         });
+
+         it("should reject paths with special characters in package name", async () => {
+            const invalidPaths = [
+               "/package-name/1.0.0",
+               "/package_name/1.0.0",
+               "/package.name/1.0.0",
+               "/package@name/1.0.0",
+               "/package#name/1.0.0",
+            ];
+
+            for (const path of invalidPaths) {
+               await archiveVersion(
+                  "http://test-server",
+                  path,
+                  "1.0.0",
+                  false,
+                  true,
+               );
+               // These should actually work as they are valid package names
+               // The test is to ensure they don't cause parsing errors
+               expect(axiosStub.called).to.be.true;
+               axiosStub.reset();
+            }
+         });
+      });
+
+      describe("API response validation", () => {
+         it("should handle successful responses", async () => {
+            const mockResponse = { status: 200 };
+            axiosStub.resolves(mockResponse);
+
+            await archiveVersion(
+               "http://test-server",
+               "/test-package/1.0.0",
+               "1.0.0",
+               false,
+               true,
+            );
+
+            expect(axiosStub.calledOnce).to.be.true;
+            expect(
+               loggerStub.info.calledWith(
+                  sinon.match("Version archived successfully"),
+               ),
+            ).to.be.true;
+         });
+
+         it("should handle non-200 responses", async () => {
+            const mockResponse = { status: 400 };
+            axiosStub.resolves(mockResponse);
+
+            await archiveVersion(
+               "http://test-server",
+               "/test-package/1.0.0",
+               "1.0.0",
+               false,
+               true,
+            );
+
+            expect(axiosStub.calledOnce).to.be.true;
+            expect(
+               loggerStub.error.calledWith(
+                  sinon.match("Failed to archive version. Status: 400"),
+               ),
+            ).to.be.true;
+         });
+
+         it("should handle network errors", async () => {
+            const mockError = new Error("Network Error");
+            axiosStub.rejects(mockError);
+
+            await archiveVersion(
+               "http://test-server",
+               "/test-package/1.0.0",
+               "1.0.0",
+               true,
+               true,
+            );
+
+            expect(axiosStub.calledOnce).to.be.true;
+            expect(
+               loggerStub.error.calledWith(
+                  sinon.match("Failed to archive version"),
+               ),
+            ).to.be.true;
+         });
+
+         it("should handle HTTP errors with response data", async () => {
+            const mockError = {
+               response: {
+                  status: 404,
+                  data: { message: "Version not found" },
+               },
+            };
+            axiosStub.rejects(mockError);
+
+            await archiveVersion(
+               "http://test-server",
+               "/test-package/1.0.0",
+               "1.0.0",
+               true,
+               true,
+            );
+
+            expect(axiosStub.calledOnce).to.be.true;
+            expect(
+               loggerStub.error.calledWith(
+                  sinon.match("Failed to archive version"),
+               ),
+            ).to.be.true;
+         });
+      });
+
+      describe("URL construction validation", () => {
+         it("should construct correct API URLs", async () => {
+            const mockResponse = { status: 200 };
+            axiosStub.resolves(mockResponse);
+
+            await archiveVersion(
+               "https://api.example.com",
+               "my-package",
+               "2.0.0",
+               false,
+               true,
+            );
+
+            expect(axiosStub.firstCall.args[0]).to.equal(
+               "https://api.example.com/organizations/test-org/projects/test-project/packages/my-package/versions/2.0.0",
+            );
+         });
+
+         it("should handle different server URLs", async () => {
+            const mockResponse = { status: 200 };
+            axiosStub.resolves(mockResponse);
+
+            const servers = [
+               "http://localhost:8080",
+               "https://staging-api.example.com",
+               "https://api.production.com",
+            ];
+
+            for (const server of servers) {
+               await archiveVersion(
+                  server,
+                  "test-package",
+                  "1.0.0",
+                  false,
+                  true,
+               );
+               expect(axiosStub.firstCall.args[0]).to.include(server);
+               axiosStub.reset();
+            }
+         });
+      });
+   });
+});

package/src/commands/version/archive-unarchive-version.ts

@@ -0,0 +1,111 @@
+import axios from "axios";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import { getConfirmation, printOutError } from "../../utils";
+
+export async function archiveVersion(
+   packageServer: string,
+   packageName: string,
+   versionId: string,
+   debug: boolean,
+   autoConfirm: boolean,
+) {
+   await updateVersionArchiveStatus(
+      packageServer,
+      packageName,
+      versionId,
+      "archive",
+      debug,
+      autoConfirm,
+   );
+}
+
+export async function unarchiveVersion(
+   packageServer: string,
+   packageName: string,
+   versionId: string,
+   debug: boolean,
+   autoConfirm: boolean,
+) {
+   await updateVersionArchiveStatus(
+      packageServer,
+      packageName,
+      versionId,
+      "unarchive",
+      debug,
+      autoConfirm,
+   );
+}
+
+async function updateVersionArchiveStatus(
+   packageServer: string,
+   packageName: string,
+   versionId: string,
+   action: "archive" | "unarchive",
+   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 (!packageName) {
+      logger.error("Please provide a package name");
+      return;
+   }
+
+   if (!versionId) {
+      logger.error("Please provide a version ID");
+      return;
+   }
+
+   if (!autoConfirm) {
+      const confirmation = await getConfirmation(
+         `Are you sure you want to ${action} version ${packageName}/${versionId}?`,
+      );
+      if (!confirmation) {
+         return;
+      }
+   }
+
+   logger.info(
+      `${action === "archive" ? "Archiving" : "Unarchiving"} version ${packageName}/${versionId}`,
+   );
+   console.log(
+      `${packageServer}/organizations/${organizationName}/projects/${projectName}/packages/${packageName}/versions/${versionId}`,
+   );
+   try {
+      const response = await axios.patch(
+         `${packageServer}/organizations/${organizationName}/projects/${projectName}/packages/${packageName}/versions/${versionId}`,
+         {
+            archiveStatus: action,
+         },
+         {
+            headers: clientConfig.getHeaders(),
+         },
+      );
+
+      if (response.status === 200) {
+         logger.info(
+            `Version ${action === "archive" ? "archived" : "unarchived"} successfully`,
+         );
+      } else {
+         logger.error(
+            `Failed to ${action} version. Status: ${response.status}`,
+         );
+      }
+   } catch (e) {
+      logger.error(`Failed to ${action} version`);
+      printOutError(e, debug);
+   }
+}