@credibledata/cred-cli 0.0.6

package/src/clientconfiguration.ts

@@ -0,0 +1,263 @@
+import fs from "fs";
+import { jwtDecode } from "jwt-decode";
+import kleur from "kleur";
+import os from "os";
+import { ALL_ENVIRONMENTS, 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;
+}
+
+interface JwtPayload {
+   exp: number;
+   iat?: number;
+   sub?: string;
+}
+
+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);
+         const configPerEnvironment: ConfigFile["configPerEnvironment"] = {};
+         for (const env of ALL_ENVIRONMENTS) {
+            configPerEnvironment[env] = {};
+         }
+         this.config = {
+            configPerEnvironment,
+            activeEnvironment: "production",
+         };
+         fs.writeFileSync(this.configPath, JSON.stringify(this.config));
+      }
+
+      for (const env of ALL_ENVIRONMENTS) {
+         if (!this.config.configPerEnvironment[env]) {
+            this.config.configPerEnvironment[env] = {};
+         }
+      }
+
+      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: this.getAuthenticationHeader(),
+      };
+   }
+
+   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 isTokenValid(): { valid: boolean; reason?: string } {
+      this.loadConfig();
+      const environment = this.getEnvironment();
+      const accessToken =
+         this.config.configPerEnvironment[environment]?.accessToken;
+
+      if (!accessToken) {
+         return { valid: false, reason: "No token found. Please login." };
+      }
+
+      const isServiceAccountToken =
+         this.config.configPerEnvironment[environment]?.isServiceAccountToken;
+      if (isServiceAccountToken) {
+         return { valid: true };
+      }
+
+      try {
+         const decoded = jwtDecode<JwtPayload>(accessToken);
+         const currentTime = Math.floor(Date.now() / 1000);
+
+         if (decoded.exp && decoded.exp < currentTime) {
+            return {
+               valid: false,
+               reason: "Token expired. Please login again.",
+            };
+         }
+
+         return { valid: true };
+      } catch {
+         return {
+            valid: false,
+            reason: "Invalid token format. Please login again.",
+         };
+      }
+   }
+
+   public printStatus() {
+      this.loadConfig();
+      const tokenStatus = this.isTokenValid();
+
+      if (tokenStatus.valid) {
+         const organization = this.getOrganization();
+         const project = this.getProject();
+
+         console.log(kleur.green(ASCII_TITLE));
+         logger.info(`Organization: ${kleur.green(organization || "Not set")}`);
+         logger.info(`Project: ${kleur.green(project || "Not set")}`);
+      } else {
+         logger.error("Failed to get status");
+         logger.error(
+            tokenStatus.reason || "Please, make sure that you are logged in",
+         );
+      }
+   }
+}

package/src/commands/add.ts

@@ -0,0 +1,125 @@
+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.",
+      )
+      .option(
+         "--replication <replicationCount>",
+         "The replication count (must be at least 1).",
+         parseInt,
+      )
+      .action((projectName, options) => {
+         createProject(
+            controlPlanesByEnv[environment],
+            projectName,
+            options.readmeFile,
+            options.replication,
+            options.debug,
+            options.yes,
+         );
+      });
+
+   add.command("connection")
+      .argument(
+         "<connectionFileName>",
+         "The path to the file containing the connections to create.",
+      )
+      .option(
+         "--include-tables <includeTables>",
+         "The list of tables to include. Ex: {dataset/schema}.{table}",
+      )
+      .option(
+         "--exclude-tables <excludeTables>",
+         "The list of tables to exclude. Ex: {dataset/schema}.{table}",
+      )
+      .option(
+         "--skip-indexing",
+         "Disable automatic indexing for this connection.",
+         false,
+      )
+      .option("--debug")
+      .option("-y, --yes", "Skip confirmation.")
+      .action((connectionFileName, options) => {
+         createConnections(
+            controlPlanesByEnv[environment],
+            connectionFileName,
+            options.includeTables,
+            options.excludeTables,
+            options.skipIndexing,
+            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")
+      .option("-j, --json-output", "Output only JSON (for use in scripts)")
+      .action((groupName, tokenName, options) => {
+         createGroupAccessToken(
+            controlPlanesByEnv[environment],
+            groupName,
+            tokenName,
+            options.expiresAt,
+            options.jsonOutput === true,
+            options.debug || false,
+         );
+      });
+};