@credibledata/cred-cli 0.1.0

package/src/commands/misc/login.ts

@@ -0,0 +1,142 @@
+import axios, { isAxiosError } from "axios";
+import { jwtDecode } from "jwt-decode";
+import { ClientConfiguration } from "../../clientconfiguration";
+import {
+   auth0ConfigsByEnv,
+   Environment,
+   LOGIN_TIMEOUT_MS,
+} from "../../constants";
+import { logger } from "../../logger";
+import { prettifyJson, printOutError, sleep } from "../../utils";
+
+export async function login(organizationName: string, configPath?: string) {
+   const config = new ClientConfiguration(configPath);
+   const environment = config.getEnvironment();
+
+   if (environment === "e2e-test") {
+      return loginM2M(organizationName, config);
+   } else {
+      return loginWithDeviceCode(environment, organizationName, config);
+   }
+}
+
+async function loginWithDeviceCode(
+   environment: Environment,
+   organizationName: string,
+   config: ClientConfiguration,
+) {
+   const auth0Domain = auth0ConfigsByEnv[environment].domain;
+   const auth0ClientId = auth0ConfigsByEnv[environment].clientId;
+   let deviceCodeData = null;
+
+   try {
+      const deviceCode = await axios.request({
+         method: "POST",
+         url: `${auth0Domain}/oauth/device/code`,
+         headers: { "content-type": "application/x-www-form-urlencoded" },
+         data: {
+            client_id: auth0ClientId,
+            audience: auth0ConfigsByEnv[environment].audience,
+            scope: "openid profile email offline_access",
+         },
+      });
+      deviceCodeData = deviceCode.data;
+
+      logger.info(
+         `Please visit the following URL to login ${deviceCode.data.verification_uri_complete} and verify user code ${deviceCode.data.user_code}.`,
+      );
+      logger.info("Waiting for login...");
+   } catch (e) {
+      printOutError(e, false);
+      process.exit(1);
+   }
+
+   const startTime = Date.now();
+
+   while (true) {
+      try {
+         const accessToken = await axios.request({
+            method: "POST",
+            url: `${auth0Domain}/oauth/token`,
+            headers: { "content-type": "application/x-www-form-urlencoded" },
+            data: new URLSearchParams({
+               grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+               device_code: deviceCodeData.device_code,
+               client_id: auth0ClientId,
+            }),
+         });
+         const decoded = jwtDecode(accessToken.data.id_token);
+         if (
+            typeof decoded === "object" &&
+            decoded !== null &&
+            "email" in decoded &&
+            "name" in decoded
+         ) {
+            const user = decoded as { email?: string; name?: string };
+            config.setVSCodeUser(user.name, user.email);
+         }
+
+         config.setAccessToken(true, accessToken.data.access_token);
+         config.setJwtAccessToken(accessToken.data.access_token);
+         config.setRefreshToken(accessToken.data.refresh_token);
+         if (organizationName !== config.getOrganization()) {
+            config.setOrganization(organizationName);
+            config.setProject(undefined);
+         }
+
+         logger.info("Login successful");
+         break;
+      } catch (error) {
+         if (
+            isAxiosError(error) &&
+            error.response?.data?.error !== "authorization_pending"
+         ) {
+            logger.error(prettifyJson(error.response?.data));
+         }
+         if (Date.now() - startTime > LOGIN_TIMEOUT_MS) {
+            logger.info("Login timed out after 5 minutes");
+            process.exit(1);
+         }
+
+         await sleep(deviceCodeData.interval * 1000);
+      }
+   }
+}
+
+async function loginM2M(
+   organizationName: string,
+   config: ClientConfiguration,
+): Promise<void> {
+   const auth0Config = auth0ConfigsByEnv["e2e-test"];
+
+   if (!auth0Config) {
+      throw new Error("No environment variables present for e2e");
+   }
+
+   try {
+      const response = await axios.request({
+         method: "POST",
+         url: `${auth0Config.domain}/oauth/token`,
+         headers: { "content-type": "application/x-www-form-urlencoded" },
+         data: {
+            grant_type: "client_credentials",
+            client_id: auth0Config.clientId,
+            client_secret: auth0Config.clientSecret,
+            audience: auth0Config.audience,
+         },
+      });
+
+      const token = response.data.access_token;
+
+      if (!token) {
+         throw new Error("No access token received");
+      }
+
+      config.destroyConfig();
+      config.setAccessToken(true, token);
+      config.setOrganization(organizationName);
+   } catch (e) {
+      printOutError(e, false);
+      process.exit(1);
+   }
+}

package/src/commands/misc/logout.ts

@@ -0,0 +1,9 @@
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+
+export function logout() {
+   const config = new ClientConfiguration();
+   config.destroyConfig();
+
+   logger.info("Credentials reset");
+}

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.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.ts

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

package/src/commands/package/publish.ts

@@ -0,0 +1,179 @@
+import "../../polyfills/file.polyfill"; // Native support for File is only available on Node 19.2 or above
+
+import archiver from "archiver";
+import crypto from "crypto";
+import fs from "fs";
+import path from "path";
+import { Package, PackagesApi } from "../../client/api";
+import { Configuration } from "../../client/configuration";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import { getConfirmation, prettifyJson, printOutError } from "../../utils";
+import { validateManifest } from "../../validator";
+const packagesApi = new PackagesApi(new Configuration());
+const PACKAGE_MANIFEST_NAME = "publisher.json";
+
+export async function publish(
+   controlPlane: string,
+   replicationCount: number,
+   debug: boolean,
+   autoConfirm: boolean,
+   setLatest: boolean,
+) {
+   const clientConfig = new ClientConfiguration();
+
+   if (!clientConfig.doesConfigExists()) {
+      logger.error("Please, make sure that you are logged in");
+      return;
+   }
+
+   if (!validateManifest()) {
+      return;
+   }
+
+   const projectName = clientConfig.getProject();
+   const organizationName = clientConfig.getOrganization();
+
+   if (!projectName) {
+      logger.error("Please, make sure to set a project");
+      return;
+   }
+
+   const packageManifestJson = fs.readFileSync(PACKAGE_MANIFEST_NAME);
+   const packageManifest = JSON.parse(packageManifestJson.toString());
+
+   const workingDirectory = process.cwd();
+   const packageName = workingDirectory.substring(
+      workingDirectory.lastIndexOf("/") + 1,
+   );
+   const tmpPackagePath = path.join("/tmp", packageName + ".zip");
+   if (!autoConfirm) {
+      const confirmation = await getConfirmation(
+         `Are you sure you that want to publish a package named ${packageName}?`,
+      );
+      if (!confirmation) {
+         logger.info("Operation cancelled.");
+         return;
+      }
+   }
+   await createTmpPackageArchive(tmpPackagePath);
+   await pushTmpPackageToRemoteServer(
+      clientConfig,
+      controlPlane,
+      replicationCount,
+      organizationName,
+      projectName,
+      tmpPackagePath,
+      packageManifest.name,
+      packageManifest.description,
+      packageManifest.version,
+      debug,
+      setLatest,
+   );
+   await removeTmpPackage(tmpPackagePath);
+}
+
+async function createTmpPackageArchive(
+   packagePath: string,
+): Promise<undefined> {
+   logger.info("Creating new package version in " + packagePath);
+   const output = fs.createWriteStream(packagePath);
+   const archive = archiver("zip", {
+      zlib: { level: 9 }, // Sets the compression level.
+   });
+
+   return new Promise((resolve, reject) => {
+      archive
+         .on("warning", function (err) {
+            reject(err);
+         })
+         .on("error", function (err) {
+            reject(err);
+         })
+         .directory(".", false)
+         .pipe(output);
+
+      output.on("close", function () {
+         logger.info(archive.pointer() + " total bytes");
+         resolve(undefined);
+      });
+      archive.finalize();
+   });
+}
+
+async function pushTmpPackageToRemoteServer(
+   clientConfig: ClientConfiguration,
+   controlPlane: string,
+   replicationCount: number,
+   organizationName: string,
+   projectName: string,
+   tmpPackagePath: string,
+   name: string,
+   description: string,
+   versionId: string,
+   debug: boolean,
+   setLatest: boolean,
+): Promise<undefined> {
+   logger.info("Pushing package " + name + " version " + versionId);
+
+   const packageContents = new File(
+      [fs.readFileSync(tmpPackagePath)],
+      tmpPackagePath,
+   );
+
+   // Build the post string from an object
+   const _package: Package = {
+      name: name,
+      description: description,
+      replicationCount: replicationCount,
+   };
+
+   // Set latest version based on the setLatest flag
+   if (setLatest) {
+      _package.latestVersion = versionId;
+   }
+
+   const version = {
+      id: versionId,
+   };
+   try {
+      const md5Hash = crypto
+         .createHash("md5")
+         .update(fs.readFileSync(tmpPackagePath))
+         .digest("hex");
+      const response = await packagesApi.createOrUpdatePackage(
+         organizationName,
+         projectName,
+         name,
+         _package,
+         version,
+         packageContents,
+         md5Hash,
+         {
+            baseURL: controlPlane,
+            headers: clientConfig.getHeaders(),
+         },
+      );
+
+      logger.info(prettifyJson(response.data));
+      const packageUrl = path.join(
+         organizationName,
+         projectName,
+         name,
+         versionId,
+      );
+      logger.info(`Package available at: ${packageUrl}`);
+   } catch (e) {
+      logger.error("Failed to publish package");
+      printOutError(e, debug);
+   }
+}
+
+async function removeTmpPackage(tmpPackagePath: string): Promise<undefined> {
+   return new Promise((resolve) => {
+      fs.unlink(tmpPackagePath, (err) => {
+         if (err) throw err;
+         resolve(undefined);
+      });
+   });
+}

package/src/commands/package/updatepackage.spec.ts

@@ -0,0 +1,221 @@
+import { expect } from "chai";
+import sinon from "sinon";
+import { PackagesApi } from "../../client/api";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import { updatePackage } from "./updatepackage";
+
+describe("set-replication-count", () => {
+   let sandbox: sinon.SinonSandbox;
+   let updatePackageStub: sinon.SinonStub;
+   let loggerStub: sinon.SinonStubbedInstance<typeof logger>;
+
+   beforeEach(() => {
+      sandbox = sinon.createSandbox();
+      updatePackageStub = sandbox.stub();
+      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" });
+
+      // Mock PackagesApi constructor and method
+      sandbox
+         .stub(PackagesApi.prototype, "updatePackage")
+         .callsFake(updatePackageStub);
+   });
+
+   afterEach(() => {
+      sandbox.restore();
+   });
+
+   describe("setReplicationCount", () => {
+      it("should set replication count successfully", async () => {
+         const mockResponse = { status: 200 };
+         updatePackageStub.resolves(mockResponse);
+
+         await updatePackage(
+            "http://test-server",
+            "test-package",
+            { replicationCount: 3 },
+            false,
+            true,
+         );
+
+         expect(updatePackageStub.calledOnce).to.be.true;
+         expect(updatePackageStub.firstCall.args[0]).to.equal("test-org");
+         expect(updatePackageStub.firstCall.args[1]).to.equal("test-project");
+         expect(updatePackageStub.firstCall.args[2]).to.equal("test-package");
+         expect(updatePackageStub.firstCall.args[3]).to.include({
+            replicationCount: 3,
+         });
+         expect(updatePackageStub.firstCall.args[4]).to.deep.include({
+            baseURL: "http://test-server",
+            headers: { Authorization: "Bearer test-token" },
+         });
+         expect(
+            loggerStub.info.calledWith(
+               sinon.match(
+                  "Successfully set replication count for package test-package to 3",
+               ),
+            ),
+         ).to.be.true;
+      });
+
+      it("should handle missing package name", async () => {
+         await updatePackage(
+            "http://test-server",
+            "",
+            { replicationCount: 3 },
+            false,
+            true,
+         );
+
+         expect(updatePackageStub.called).to.be.false;
+         expect(
+            loggerStub.error.calledWith(
+               sinon.match("Please provide a package name"),
+            ),
+         ).to.be.true;
+      });
+
+      it("should handle API errors", async () => {
+         const mockError = new Error("API Error");
+         updatePackageStub.rejects(mockError);
+
+         await updatePackage(
+            "http://test-server",
+            "test-package",
+            { replicationCount: 3 },
+            true,
+            true,
+         );
+
+         expect(updatePackageStub.calledOnce).to.be.true;
+         expect(
+            loggerStub.error.calledWith(
+               sinon.match(
+                  "Failed to set replication count for package test-package",
+               ),
+            ),
+         ).to.be.true;
+      });
+
+      it("should handle non-200 response status", async () => {
+         const mockResponse = { status: 400 };
+         updatePackageStub.resolves(mockResponse);
+
+         await updatePackage(
+            "http://test-server",
+            "test-package",
+            { replicationCount: 3 },
+            false,
+            true,
+         );
+
+         expect(updatePackageStub.calledOnce).to.be.true;
+         expect(
+            loggerStub.error.calledWith(
+               sinon.match("Failed to set replication count. Status: 400"),
+            ),
+         ).to.be.true;
+      });
+   });
+
+   describe("validators", () => {
+      describe("authentication validation", () => {
+         it("should fail when user is not logged in", async () => {
+            sandbox.restore();
+            sandbox = sinon.createSandbox();
+            updatePackageStub = sandbox.stub();
+            loggerStub = sandbox.stub(logger);
+
+            sandbox
+               .stub(ClientConfiguration.prototype, "doesConfigExists")
+               .returns(false);
+            sandbox
+               .stub(PackagesApi.prototype, "updatePackage")
+               .callsFake(updatePackageStub);
+
+            await updatePackage(
+               "http://test-server",
+               "test-package",
+               { replicationCount: 3 },
+               false,
+               true,
+            );
+
+            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();
+            updatePackageStub = sandbox.stub();
+            loggerStub = sandbox.stub(logger);
+
+            sandbox
+               .stub(ClientConfiguration.prototype, "doesConfigExists")
+               .returns(true);
+            sandbox
+               .stub(ClientConfiguration.prototype, "getProject")
+               .returns("");
+            sandbox
+               .stub(PackagesApi.prototype, "updatePackage")
+               .callsFake(updatePackageStub);
+
+            await updatePackage(
+               "http://test-server",
+               "test-package",
+               { replicationCount: 3 },
+               false,
+               true,
+            );
+
+            expect(
+               loggerStub.error.calledWith(
+                  sinon.match("Please, make sure to set a project"),
+               ),
+            ).to.be.true;
+         });
+      });
+
+      describe("replication count validation", () => {
+         it("should accept valid replication counts", async () => {
+            const mockResponse = { status: 200 };
+            updatePackageStub.resolves(mockResponse);
+
+            const validCounts = [1, 2, 5, 10, 100];
+
+            for (const count of validCounts) {
+               await updatePackage(
+                  "http://test-server",
+                  "test-package",
+                  { replicationCount: count },
+                  false,
+                  true,
+               );
+               expect(updatePackageStub.called).to.be.true;
+               expect(updatePackageStub.firstCall.args[3]).to.include({
+                  replicationCount: count,
+               });
+               updatePackageStub.reset();
+            }
+         });
+      });
+   });
+});