@credibledata/cred-cli 0.1.0

package/src/commands/package/updatepackage.ts

@@ -0,0 +1,95 @@
+import { Package, 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());
+
+type NewParams = {
+   latestVersion?: string;
+   replicationCount?: number;
+   description?: string;
+};
+export async function updatePackage(
+   packageServer: string,
+   packageName: string,
+   newParams: NewParams,
+   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;
+   }
+
+   logger.info(
+      `Setting replication count for package ${packageName} to ${newParams.replicationCount}`,
+   );
+
+   try {
+      if (!autoConfirm) {
+         const confirmation = await getConfirmation(
+            `Are you sure you that want to update the replication count for package ${packageName} to ${newParams.replicationCount}?`,
+         );
+         if (!confirmation) {
+            logger.info("Operation cancelled.");
+            return;
+         }
+      }
+      const packageUpdate: Package = {
+         replicationCount: newParams.replicationCount || undefined,
+         latestVersion: newParams.latestVersion || undefined,
+         description: newParams.description || undefined,
+      };
+      const pathParts = packageName
+         .split("/")
+         .filter((part) => part.length > 0);
+      if (pathParts.length !== 1) {
+         logger.error("Invalid package path. Expected format: /<packageName>");
+         return;
+      }
+
+      packageName = pathParts[0];
+
+      const response = await packagesApi.updatePackage(
+         organizationName,
+         projectName,
+         packageName,
+         packageUpdate,
+         {
+            baseURL: packageServer,
+            headers: clientConfig.getHeaders(),
+         },
+      );
+
+      if (response.status === 200) {
+         logger.info(
+            `Successfully set replication count for package ${packageName} to ${newParams.replicationCount}`,
+         );
+      } else {
+         logger.error(
+            `Failed to set replication count. Status: ${response.status}`,
+         );
+      }
+   } catch (e) {
+      logger.error(
+         `Failed to set replication count for package ${packageName}`,
+      );
+      printOutError(e, debug);
+   }
+}

package/src/commands/project/createproject.ts

@@ -0,0 +1,59 @@
+import fs from "fs";
+import { Project, ProjectsApi } from "../../client/api";
+import { Configuration } from "../../client/configuration";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import { getConfirmation, printOutError } from "../../utils";
+
+const projectsApi = new ProjectsApi(new Configuration());
+
+export async function createProject(
+   controlPlane: string,
+   projectName: string,
+   readmeFile: string,
+   debug: boolean,
+   autoConfirm: boolean,
+) {
+   const clientConfig = new ClientConfiguration();
+
+   if (!clientConfig.doesConfigExists()) {
+      logger.error("Please, make sure that you are logged in");
+      return;
+   }
+   if (!autoConfirm) {
+      const confirmation = await getConfirmation(
+         `Are you sure you that want to create a project named ${projectName}?`,
+      );
+      if (!confirmation) {
+         logger.info("Operation cancelled.");
+         return;
+      }
+   }
+   logger.info("Creating project " + projectName);
+
+   let readmeContents = "";
+   if (readmeFile) {
+      readmeContents = fs.readFileSync(readmeFile).toString();
+   }
+
+   try {
+      const project: Project = { name: projectName, readme: readmeContents };
+      await projectsApi
+         .createProject(clientConfig.getOrganization(), project, {
+            baseURL: controlPlane,
+            headers: {
+               Authorization: clientConfig.getAuthenticationHeader(),
+            },
+         })
+         .then((response) => {
+            const jsonString = JSON.stringify(response.data, null, 2);
+            console.log(jsonString);
+            // Make the new project the default project.
+            clientConfig.setProject(projectName);
+         });
+      logger.info("Project created successfully");
+   } catch (e) {
+      logger.error("Failed to create project");
+      printOutError(e, debug);
+   }
+}

package/src/commands/project/deleteproject.ts

@@ -0,0 +1,48 @@
+import { ProjectsApi } from "../../client/api";
+import { Configuration } from "../../client/configuration";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import { getConfirmation, printOutError } from "../../utils";
+
+const projectsApi = new ProjectsApi(new Configuration());
+
+export async function deleteProject(
+   controlPlane: string,
+   projectName: string,
+   debug: boolean,
+   autoConfirm: boolean,
+) {
+   const clientConfig = new ClientConfiguration();
+
+   if (!clientConfig.doesConfigExists()) {
+      logger.error("Please, make sure that you are logged in");
+      return;
+   }
+   if (!autoConfirm) {
+      const confirmation = await getConfirmation(
+         `Are you sure you that want to delete the ${projectName} project? This action cannot be undone.`,
+      );
+      if (!confirmation) {
+         logger.info("Operation cancelled.");
+         return;
+      }
+   }
+   logger.info("Deleting project " + projectName);
+
+   try {
+      await projectsApi.deleteProject(
+         clientConfig.getOrganization(),
+         projectName,
+         {
+            baseURL: controlPlane,
+            headers: {
+               Authorization: clientConfig.getAuthenticationHeader(),
+            },
+         },
+      );
+      logger.info("Project deleted successfully");
+   } catch (e) {
+      logger.error("Failed to delete project");
+      printOutError(e, debug);
+   }
+}

package/src/commands/project/getproject.ts

@@ -0,0 +1,43 @@
+import { ProjectsApi } from "../../client/api";
+import { Configuration } from "../../client/configuration";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import { prettifyJson, printOutError } from "../../utils";
+
+const projectsApi = new ProjectsApi(new Configuration());
+
+export async function getProject(
+   controlPlane: string,
+   projectName: string,
+   debug: boolean,
+) {
+   const clientConfig = new ClientConfiguration();
+   const organizationName = clientConfig.getOrganization();
+
+   if (!clientConfig.doesConfigExists()) {
+      logger.error("Please, make sure that you are logged in");
+      return;
+   }
+
+   if (!projectName) {
+      logger.error("Please, make sure to provide a project name");
+      return;
+   }
+
+   try {
+      const response = await projectsApi.getProject(
+         organizationName,
+         projectName,
+         false,
+         {
+            baseURL: controlPlane,
+            headers: clientConfig.getHeaders(),
+         },
+      );
+
+      console.log(prettifyJson(response.data));
+   } catch (e) {
+      logger.error("Failed to get project");
+      printOutError(e, debug);
+   }
+}

package/src/commands/project/listprojects.ts

@@ -0,0 +1,36 @@
+import { ProjectsApi } from "../../client/api";
+import { Configuration } from "../../client/configuration";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import { prettifyJson, printOutError } from "../../utils";
+
+const projectsApi = new ProjectsApi(new Configuration());
+
+export async function listProjects(controlPlane: string, debug: boolean) {
+   const clientConfig = new ClientConfiguration();
+
+   if (!clientConfig.doesConfigExists()) {
+      logger.error("Please, make sure that you are logged in");
+      return [];
+   }
+
+   try {
+      const response = await projectsApi.listProjects(
+         clientConfig.getOrganization(),
+         {
+            baseURL: controlPlane,
+            headers: clientConfig.getHeaders(),
+         },
+      );
+
+      return response.data;
+   } catch (e) {
+      logger.error("Failed to list projects");
+      printOutError(e, debug);
+      return [];
+   }
+}
+
+export async function printOutProjects(controlPlane: string, debug: boolean) {
+   console.log(prettifyJson(await listProjects(controlPlane, debug)));
+}

package/src/commands/project/setproject.ts

@@ -0,0 +1,14 @@
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+
+export async function setProject(projectName: string) {
+   console.log("Setting project " + projectName);
+   const clientConfig = new ClientConfiguration();
+
+   if (!clientConfig.doesConfigExists()) {
+      logger.error("Please, make sure that you are logged in");
+      return;
+   }
+
+   clientConfig.setProject(projectName);
+}

package/src/commands/rm.ts

@@ -0,0 +1,106 @@
+import { Command } from "commander";
+import { controlPlanesByEnv, Environment } from "../constants";
+import { deleteConnection } from "./connection/deleteconnection";
+import { deleteGroup } from "./group/deletegroup";
+import { removeMember } from "./group/removemember";
+import { deleteGroupAccessToken } from "./groupaccesstoken/deleteToken";
+import { deletePackage } from "./package/deletepackage";
+import { deleteProject } from "./project/deleteproject";
+
+export const registerRmCommands = (cli: Command, environment: Environment) => {
+   const rm = cli
+      .command("rm")
+      .description("Remove a resource")
+      .argument("<resource>", "The resource to remove");
+
+   rm.command("package")
+      .description("Delete a package.")
+      .argument("<packageName>", "The name of the package to delete.")
+      .option("--debug")
+      .option("-y, --yes", "Skip confirmation.")
+      .action((packageName, options) => {
+         deletePackage(
+            controlPlanesByEnv[environment],
+            packageName,
+            options.debug,
+            options.yes,
+         );
+      });
+
+   rm.command("project")
+      .description("Delete a project.")
+      .argument("<projectName>", "The name of the project to delete.")
+      .option("--debug")
+      .option("-y, --yes", "Skip confirmation.")
+      .action((projectName, options) => {
+         deleteProject(
+            controlPlanesByEnv[environment],
+            projectName,
+            options.debug,
+            options.yes,
+         );
+      });
+
+   rm.command("connection")
+      .description("Delete a connection.")
+      .argument("<connectionName>", "The name of the connection to delete.")
+      .option("--debug")
+      .option("-y, --yes", "Skip confirmation.")
+      .action((connectionName, options) => {
+         deleteConnection(
+            controlPlanesByEnv[environment],
+            connectionName,
+            options.debug,
+            options.yes,
+         );
+      });
+
+   rm.command("group")
+      .description("Delete a group.")
+      .argument("<groupName>", "The name of the group to delete")
+      .option("--debug")
+      .option("-y, --yes", "Skip confirmation.")
+      .action((groupName, options) => {
+         deleteGroup(
+            controlPlanesByEnv[environment],
+            groupName,
+            options.debug || false,
+         );
+      });
+
+   rm.command("member")
+      .description("Remove a member from a group.")
+      .argument("<groupName>", "The name of the group")
+      .argument("<memberType>", "The type of member (user or group)")
+      .argument("<memberName>", "The name of the member")
+      .option("--debug")
+      .action((groupName, memberType, memberName, options) => {
+         removeMember(
+            controlPlanesByEnv[environment],
+            groupName,
+            memberType,
+            memberName,
+            options.debug || false,
+         );
+      });
+
+
+   rm.command("group-access-token")
+      .description("Delete an access token from a group.")
+      .argument(
+         "<groupName>",
+         "The name of the group",
+      )
+      .argument("<tokenName>", "The name of the token to delete")
+      .option("--debug")
+      .option("-y, --yes", "Skip confirmation.")
+      .action((groupName, tokenName, options) => {
+         deleteGroupAccessToken(
+            controlPlanesByEnv[environment],
+            groupName,
+            tokenName,
+            options.debug || false,
+         );
+      });
+
+};

package/src/commands/set.ts

@@ -0,0 +1,16 @@
+import { Command } from "commander";
+import { setProject } from "./project/setproject";
+
+export const registerSetCommands = (cli: Command) => {
+   const set = cli
+      .command("set")
+      .description("Set a resource")
+      .argument("<resource>", "The resource to set");
+
+   set.command("project")
+      .description("Set the default project.")
+      .argument("<projectName>", "The name of the project to set.")
+      .action(setProject);
+
+   // TODO: It would be nice to `cred set org` and avoid logging again when switching orgs.
+};

package/src/commands/update.ts

@@ -0,0 +1,41 @@
+import { Command } from "commander";
+import { controlPlanesByEnv, Environment } from "../constants";
+import { updatePackage } from "./package/updatepackage";
+
+export const registerUpdateCommands = (
+   cli: Command,
+   environment: Environment,
+) => {
+   const update = cli
+      .command("update")
+      .description("Update a resource")
+      .argument("<resource>", "The resource to update");
+
+   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,
+         );
+      });
+
+};