@credibledata/cred-cli 0.1.0

package/src/clientconfiguration.ts

@@ -0,0 +1,204 @@
+import fs from "fs";
+import kleur from "kleur";
+import os from "os";
+import { ASCII_TITLE, Environment } from "./constants";
+import { logger } from "./logger";
+
+interface ConfigFile {
+   configPerEnvironment: Partial<
+      Record<
+         Environment,
+         {
+            organization?: string;
+            project?: string;
+            auth?: { username: string; password: string };
+            vsCodeUser?: {
+               username: string;
+               email: string;
+            };
+            accessToken?: string;
+            jwtAccessToken?: string;
+            refreshToken?: string;
+            isServiceAccountToken?: boolean;
+         }
+      >
+   >;
+   activeEnvironment: Environment;
+}
+
+export class ClientConfiguration {
+   private configPath = `${os.homedir()}/.cred`;
+   private config: ConfigFile;
+
+   constructor(customConfigPath?: string) {
+      if (customConfigPath) {
+         this.configPath = customConfigPath;
+      }
+   }
+
+   public loadConfig(): ConfigFile {
+      try {
+         const fileContents = fs.readFileSync(this.configPath);
+         this.config = JSON.parse(fileContents.toString());
+         if (
+            !this.config.activeEnvironment ||
+            !this.config.configPerEnvironment
+         ) {
+            throw new Error(
+               "Corrupted config file found, restoring to default settings.",
+            );
+         }
+      } catch (error) {
+         logger.warn(error);
+         this.config = {
+            configPerEnvironment: {
+               production: {},
+               staging: {},
+               localhost: {},
+            },
+            activeEnvironment: "production",
+         };
+         // Ensure the config file exists with default settings
+         fs.writeFileSync(this.configPath, JSON.stringify(this.config));
+      }
+
+      return this.config;
+   }
+
+   public setOrganization(organizationName: string) {
+      this.loadConfig();
+      // TODO: Validate organization exists and user has access.
+      const environment = this.getEnvironment();
+      this.config.configPerEnvironment[environment].organization =
+         organizationName;
+      fs.writeFileSync(this.configPath, JSON.stringify(this.config));
+   }
+
+   public setProject(projectName: string) {
+      this.loadConfig();
+      // TODO: Validate project exists and user has access.
+      const environment = this.getEnvironment();
+      this.config.configPerEnvironment[environment].project = projectName;
+      fs.writeFileSync(this.configPath, JSON.stringify(this.config));
+   }
+
+   public getOrganization() {
+      this.loadConfig();
+      const environment = this.getEnvironment();
+      return this.config.configPerEnvironment[environment].organization;
+   }
+
+   public getProject() {
+      this.loadConfig();
+      const environment = this.getEnvironment();
+      return this.config.configPerEnvironment[environment].project;
+   }
+
+   public setAccessToken(userToken: boolean, accessToken: string) {
+      this.loadConfig();
+      const environment = this.getEnvironment();
+      this.config.configPerEnvironment[environment].isServiceAccountToken = !userToken;
+      this.config.configPerEnvironment[environment].accessToken = accessToken;
+      fs.writeFileSync(this.configPath, JSON.stringify(this.config));
+   }
+
+   public getAuthenticationHeader() {
+      const environment = this.getEnvironment();
+      const jwt = this.config.configPerEnvironment[environment].accessToken;
+      const isServiceAccountToken = this.config.configPerEnvironment[environment].isServiceAccountToken;
+      const authType = isServiceAccountToken ? "ApiKey" : "Bearer";
+      return `${authType} ${jwt}`;
+   }
+
+   getAccessToken() {
+      this.loadConfig();
+      const environment = this.getEnvironment();
+      return this.config.configPerEnvironment[environment].accessToken;
+   }
+
+   public setJwtAccessToken(jwtAccessToken: string) {
+      this.loadConfig();
+      const environment = this.getEnvironment();
+      this.config.configPerEnvironment[environment].jwtAccessToken =
+         jwtAccessToken;
+      fs.writeFileSync(this.configPath, JSON.stringify(this.config));
+   }
+
+   public getJwtAccessToken(): string | undefined {
+      this.loadConfig();
+      const environment = this.getEnvironment();
+      return this.config.configPerEnvironment[environment].jwtAccessToken;
+   }
+
+   public setVSCodeUser(username: string, email: string) {
+      this.loadConfig();
+      const environment = this.getEnvironment();
+      if (!this.config.configPerEnvironment[environment]) {
+         this.config.configPerEnvironment[environment] = {};
+      }
+      this.config.configPerEnvironment[environment].vsCodeUser = {
+         username,
+         email,
+      };
+      fs.writeFileSync(this.configPath, JSON.stringify(this.config));
+   }
+
+   public getVSCodeUser(): { username: string; email: string } | undefined {
+      this.loadConfig();
+      const environment = this.getEnvironment();
+      return this.config.configPerEnvironment[environment].vsCodeUser;
+   }
+
+   public setRefreshToken(refreshToken: string) {
+      this.loadConfig();
+      const environment = this.getEnvironment();
+      this.config.configPerEnvironment[environment].refreshToken = refreshToken;
+      fs.writeFileSync(this.configPath, JSON.stringify(this.config));
+   }
+
+   public getRefreshToken(): string | undefined {
+      this.loadConfig();
+      const environment = this.getEnvironment();
+      return this.config.configPerEnvironment[environment].refreshToken;
+   }
+
+   public doesConfigExists() {
+      this.loadConfig();
+      const environment = this.getEnvironment();
+      return Boolean(this.config.configPerEnvironment[environment]);
+   }
+
+   public getHeaders() {
+      return {
+         Authorization: `Bearer ${this.getAccessToken()}`,
+      };
+   }
+
+   public destroyConfig() {
+      this.loadConfig();
+      const environment = this.getEnvironment();
+      this.config.configPerEnvironment[environment] = {};
+      fs.writeFileSync(this.configPath, JSON.stringify(this.config));
+   }
+
+   public setEnvironment(environment: Environment) {
+      this.loadConfig();
+      this.config.activeEnvironment = environment;
+      fs.writeFileSync(this.configPath, JSON.stringify(this.config));
+   }
+
+   public getEnvironment() {
+      this.loadConfig();
+      return this.config.activeEnvironment || "production";
+   }
+
+   public printStatus() {
+      this.loadConfig();
+      const organization = this.getOrganization();
+      const project = this.getProject();
+      // eslint-disable-next-line no-console
+      console.log(kleur.green(ASCII_TITLE));
+      logger.info(`Organization: ${kleur.green(organization || "Not set")}`);
+      logger.info(`Project: ${kleur.green(project || "Not set")}`);
+   }
+}

package/src/commands/add.ts

@@ -0,0 +1,106 @@
+import { Command } from "commander";
+import { controlPlanesByEnv, Environment } from "../constants";
+import { createConnections } from "./connection/createconnections";
+import { addMember } from "./group/addmember";
+import { createGroup } from "./group/creategroup";
+import { createGroupAccessToken } from "./groupaccesstoken/createToken";
+import { createProject } from "./project/createproject";
+
+export const registerAddCommands = (cli: Command, environment: Environment) => {
+   const add = cli
+      .command("add")
+      .description("Add a resource")
+      .argument("<resource>", "The resource to add");
+
+   add.command("project")
+      .description("Add a project.")
+      .argument("<projectName>", "The name of the project to create.")
+      .option("--debug")
+      .option("-y, --yes", "Skip confirmation.")
+      .option(
+         "--readmeFile <readmeFile>",
+         "The path to the readme file for the project.",
+      )
+      .action((projectName, options) => {
+         createProject(
+            controlPlanesByEnv[environment],
+            projectName,
+            options.readmeFile,
+            options.debug,
+            options.yes,
+         );
+      });
+
+   add.command("connection")
+      .argument(
+         "<connectionFileName>",
+         "The path to the file containing the connections to create.",
+      )
+      .option("--debug")
+      .option("-y, --yes", "Skip confirmation.")
+      .action((connectionFileName, options) => {
+         createConnections(
+            controlPlanesByEnv[environment],
+            connectionFileName,
+            options.debug,
+            options.yes,
+         );
+      });
+
+   add.command("group")
+      .description("Add a group.")
+      .argument("<groupName>", "The name of the group to create")
+      .option("-d, --description <description>", "Description for the group")
+      .option("--debug")
+      .option("-y, --yes", "Skip confirmation.")
+      .action((groupName, options) => {
+         createGroup(
+            controlPlanesByEnv[environment],
+            groupName,
+            options.debug || false,
+            options.description,
+         );
+      });
+
+   add.command("member")
+      .description("Add a member to 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")
+      .argument("<role>", "The role for the member (admin or member)")
+      .option("--debug")
+      .action((groupName, memberType, memberName, role, options) => {
+         addMember(
+            controlPlanesByEnv[environment],
+            groupName,
+            memberType,
+            memberName,
+            role,
+            options.debug || false,
+         );
+      });
+
+
+   add.command("group-access-token")
+      .description("Create an access token for a group.")
+      .argument(
+         "<groupName>",
+         "The name of the group",
+      )
+      .argument("<tokenName>", "The name of the token to create")
+      .option(
+         "-e, --expires-at <expiresAt>",
+         "Token expiration date in ISO 8601 format (e.g., 2025-12-31T23:59:59Z). If not provided, token will expire in 99 years.",
+      )
+      .option("--debug")
+      .action((groupName, tokenName, options) => {
+         createGroupAccessToken(
+            controlPlanesByEnv[environment],
+            groupName,
+            tokenName,
+            options.expiresAt,
+            options.debug || false,
+         );
+      });
+
+};

package/src/commands/connection/createconnections.ts

@@ -0,0 +1,67 @@
+import fs from "fs";
+import { Connection, ConnectionsApi } from "../../client/api";
+import { Configuration } from "../../client/configuration";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import { getConfirmation, printOutError } from "../../utils";
+
+const connectionsApi = new ConnectionsApi(new Configuration());
+
+export const createConnections = async (
+   controlPlane: string,
+   connectionFileName: string,
+   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;
+   }
+
+   const connections = JSON.parse(
+      fs.readFileSync(connectionFileName, "utf8"),
+   ) as Connection[];
+
+   for (const connection of connections) {
+
+      if (!/^[a-zA-Z_][a-zA-Z0-9_]+$/.test(connection.name)) {
+         logger.error(`Connection name can only contain letters, numbers, and underscores for connection and should start with a letter or underscore: ${connection.name}`);
+         continue;
+      }
+
+      if (!autoConfirm) {
+         const confirmation = await getConfirmation(
+            `Are you sure you that want to create a connection named ${connection.name}?`,
+         );
+         if (!confirmation) {
+            logger.info("Operation cancelled.");
+            return;
+         }
+      }
+      try {
+         await connectionsApi.createConnection(
+            organizationName,
+            projectName,
+            connection,
+            false,
+            {
+               baseURL: controlPlane,
+               headers: clientConfig.getHeaders(),
+            },
+         );
+         logger.info(`Connection ${connection.name} created successfully`);
+      } catch (error) {
+         logger.error(`Failed to create connection ${connection.name}`);
+         printOutError(error, debug);
+      }
+   }
+};

package/src/commands/connection/deleteconnection.ts

@@ -0,0 +1,57 @@
+import { ConnectionsApi } from "../../client/api";
+import { Configuration } from "../../client/configuration";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import { getConfirmation, printOutError } from "../../utils";
+
+const connectionsApi = new ConnectionsApi(new Configuration());
+
+export const deleteConnection = async (
+   controlPlane: string,
+   connectionName: string,
+   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 (!autoConfirm) {
+      const confirmation = await getConfirmation(
+         `Are you sure you that want to delete the ${connectionName} connection? This action cannot be undone.`,
+      );
+      if (!confirmation) {
+         logger.info("Operation cancelled.");
+         return;
+      }
+   }
+
+   logger.info("Deleting connection " + connectionName);
+
+   try {
+      await connectionsApi.deleteConnection(
+         organizationName,
+         projectName,
+         connectionName,
+         {
+            baseURL: controlPlane,
+            headers: clientConfig.getHeaders(),
+         },
+      );
+
+      logger.info("Connection deleted successfully");
+   } catch (e) {
+      logger.error("Failed to delete connection");
+      printOutError(e, debug);
+   }
+};

package/src/commands/connection/listconnections.ts

@@ -0,0 +1,39 @@
+import { ConnectionsApi } from "../../client/api";
+import { Configuration } from "../../client/configuration";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import { prettifyJson, printOutError } from "../../utils";
+
+const connectionsApi = new ConnectionsApi(new Configuration());
+
+export const listConnections = async (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 connectionsApi.listConnections(
+         organizationName,
+         projectName,
+         {
+            baseURL: controlPlane,
+            headers: clientConfig.getHeaders(),
+         },
+      );
+
+      console.log(prettifyJson(response.data));
+   } catch (e) {
+      logger.error("Failed to list connections");
+      printOutError(e, debug);
+   }
+};

package/src/commands/get.ts

@@ -0,0 +1,31 @@
+import { Command } from "commander";
+import { controlPlanesByEnv, Environment } from "../constants";
+import { getGroup } from "./group/getgroup";
+import { getProject } from "./project/getproject";
+
+export const registerGetCommands = (cli: Command, environment: Environment) => {
+   const get = cli
+      .command("get")
+      .description("Get a resource")
+      .argument("<resource>", "The resource to get (project | group)");
+
+   get.command("project")
+      .description("Get a project by name.")
+      .argument("<projectName>", "The name of the project to get.")
+      .option("--debug")
+      .action((projectName, options) => {
+         getProject(
+            controlPlanesByEnv[environment],
+            projectName,
+            options.debug,
+         );
+      });
+
+   get.command("group")
+      .description("Get a group by name.")
+      .argument("<groupName>", "The name of the group to get.")
+      .option("--debug")
+      .action((groupName, options) => {
+         getGroup(controlPlanesByEnv[environment], groupName, options.debug);
+      });
+};

package/src/commands/group/addmember.ts

@@ -0,0 +1,83 @@
+import {
+   AddGroupMembersRequest,
+   GroupMember,
+   GroupsApi,
+} from "../../client/api";
+import { Configuration } from "../../client/configuration";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { UserGroupId } from "../../common/UserGroupId";
+import { logger } from "../../logger";
+import { printOutError } from "../../utils";
+
+const groupsApi = new GroupsApi(new Configuration());
+
+export async function addMember(
+   controlPlane: string,
+   groupName: string,
+   memberType: string,
+   memberName: string,
+   role: string,
+   debug: boolean,
+) {
+   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;
+   }
+
+   logger.info(
+      `Adding ${memberType} ${memberName} to group ${groupName} in organization ${organizationName} with role ${role}`,
+   );
+
+   // Create UserGroupId based on member type
+   let userGroupId: UserGroupId;
+   if (memberType.toLowerCase() === "user") {
+      userGroupId = UserGroupId.forUser(memberName);
+   } else if (memberType.toLowerCase() === "group") {
+      userGroupId = UserGroupId.forGroup(memberName);
+   } else {
+      logger.error(
+         `Error: memberType ${memberType} must be either 'user' or 'group'`,
+      );
+      process.exit(1);
+   }
+
+   // Validate role
+   if (role !== "admin" && role !== "member") {
+      logger.error("Error: role must be either 'admin' or 'member'");
+      process.exit(1);
+   }
+
+   const groupMember: GroupMember = {
+      userGroupId: userGroupId.getValue(),
+      status: role as "admin" | "member",
+   };
+
+   const request: AddGroupMembersRequest = {
+      members: [groupMember],
+   };
+
+   try {
+      await groupsApi.addGroupMembers(organizationName, groupName, request, {
+         baseURL: controlPlane,
+         headers: {
+            Authorization: clientConfig.getAuthenticationHeader(),
+         },
+      });
+
+      logger.info(
+         `Successfully added ${memberType} ${memberName} to group ${groupName} with role ${role}`,
+      );
+   } catch (error) {
+      logger.error("Failed to add member to group");
+      printOutError(error, debug);
+      process.exit(1);
+   }
+}

package/src/commands/group/creategroup.ts

@@ -0,0 +1,54 @@
+import { Group, GroupsApi } from "../../client/api";
+import { Configuration } from "../../client/configuration";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import { printOutError } from "../../utils";
+
+const groupsApi = new GroupsApi(new Configuration());
+
+export async function createGroup(
+   controlPlane: string,
+   groupName: string,
+   debug: boolean,
+   description?: string,
+) {
+   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;
+   }
+
+   logger.info(
+      `Creating group ${groupName} in organization ${organizationName}`,
+   );
+
+   const group: Group = {
+      organizationName,
+      groupName,
+      description: description || `Group ${groupName}`,
+   };
+
+   try {
+      const response = await groupsApi.createGroup(organizationName, group, {
+         baseURL: controlPlane,
+         headers: {
+            Authorization: clientConfig.getAuthenticationHeader(),
+         },
+      });
+
+      const jsonString = JSON.stringify(response.data, null, 2);
+      console.log(jsonString);
+      logger.info("Group created successfully");
+   } catch (error) {
+      logger.error("Failed to create group");
+      printOutError(error, debug);
+      process.exit(1);
+   }
+}

package/src/commands/group/deletegroup.ts

@@ -0,0 +1,45 @@
+import { GroupsApi } from "../../client/api";
+import { Configuration } from "../../client/configuration";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import { printOutError } from "../../utils";
+
+const groupsApi = new GroupsApi(new Configuration());
+
+export async function deleteGroup(
+   controlPlane: string,
+   groupName: string,
+   debug: boolean,
+) {
+   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;
+   }
+
+   logger.info(
+      `Deleting group ${groupName} from organization ${organizationName}`,
+   );
+
+   try {
+      await groupsApi.deleteGroup(organizationName, groupName, {
+         baseURL: controlPlane,
+         headers: {
+            Authorization: clientConfig.getAuthenticationHeader(),
+         },
+      });
+
+      logger.info("Group deleted successfully");
+   } catch (error) {
+      logger.error("Failed to delete group");
+      printOutError(error, debug);
+      process.exit(1);
+   }
+}