@credibledata/cred-cli 0.1.3 → 0.1.5

package/src/clientconfiguration.spec.ts

@@ -4,6 +4,19 @@ import os from "os";
 import { join } from "path";
 import sinon from "sinon";
 import { ClientConfiguration } from "./clientconfiguration";
+import { ALL_ENVIRONMENTS, type Environment } from "./constants";
+import { logger } from "./logger";
+
+/** Expected `configPerEnvironment` shape after `loadConfig()` (every env has an object). */
+function fullPerEnv(
+   filled: Partial<Record<Environment, Record<string, unknown>>> = {},
+): Record<string, Record<string, unknown>> {
+   const out: Record<string, Record<string, unknown>> = {};
+   for (const env of ALL_ENVIRONMENTS) {
+      out[env] = filled[env] != null ? { ...filled[env]! } : {};
+   }
+   return out;
+}
 
 describe("ClientConfiguration", () => {
    let clientConfig: ClientConfiguration;
@@ -33,11 +46,7 @@ describe("ClientConfiguration", () => {
       readFileSyncStub.throws(new Error("File not found"));
       clientConfig.loadConfig();
       expect(clientConfig["config"]).to.deep.equal({
-         configPerEnvironment: {
-            production: {},
-            staging: {},
-            localhost: {},
-         },
+         configPerEnvironment: fullPerEnv(),
          activeEnvironment: "production",
       });
    });
@@ -53,7 +62,33 @@ describe("ClientConfiguration", () => {
       };
       readFileSyncStub.returns(JSON.stringify(mockConfig));
       clientConfig.loadConfig();
-      expect(clientConfig["config"]).to.deep.equal(mockConfig);
+      expect(clientConfig["config"]).to.deep.equal({
+         configPerEnvironment: fullPerEnv({
+            production: { project: "test-project" },
+         }),
+         activeEnvironment: "production",
+      });
+   });
+
+   it("should allow setAccessToken when activeEnvironment had no bucket on disk (e.g. videoamp)", () => {
+      const mockConfig = {
+         configPerEnvironment: {
+            production: {},
+            staging: {},
+            dev: {},
+            localhost: {},
+            "e2e-test": {},
+         },
+         activeEnvironment: "videoamp",
+      };
+      readFileSyncStub.returns(JSON.stringify(mockConfig));
+      clientConfig.setAccessToken(true, "user-jwt");
+      const written = JSON.parse(writeFileSyncStub.lastCall.args[1] as string);
+      expect(written.configPerEnvironment.videoamp.accessToken).to.equal(
+         "user-jwt",
+      );
+      expect(written.configPerEnvironment.videoamp.isServiceAccountToken).to.be
+         .false;
    });
 
    it("should set and get the project correctly", () => {
@@ -64,11 +99,9 @@ describe("ClientConfiguration", () => {
          writeFileSyncStub.calledWith(
             customConfigPath,
             JSON.stringify({
-               configPerEnvironment: {
+               configPerEnvironment: fullPerEnv({
                   production: { project: "new-project" },
-                  staging: {},
-                  localhost: {},
-               },
+               }),
                activeEnvironment: "production",
             }),
          ),
@@ -83,11 +116,12 @@ describe("ClientConfiguration", () => {
          writeFileSyncStub.calledWith(
             customConfigPath,
             JSON.stringify({
-               configPerEnvironment: {
-                  production: { isServiceAccountToken: true, accessToken: "token-123" },
-                  staging: {},
-                  localhost: {},
-               },
+               configPerEnvironment: fullPerEnv({
+                  production: {
+                     isServiceAccountToken: true,
+                     accessToken: "token-123",
+                  },
+               }),
                activeEnvironment: "production",
             }),
          ),
@@ -103,14 +137,354 @@ describe("ClientConfiguration", () => {
          writeFileSyncStub.calledWith(
             customConfigPath,
             JSON.stringify({
-               configPerEnvironment: {
-                  production: { isServiceAccountToken: false, accessToken: "new-token" },
-                  staging: {},
-                  localhost: {},
-               },
+               configPerEnvironment: fullPerEnv({
+                  production: {
+                     isServiceAccountToken: false,
+                     accessToken: "new-token",
+                  },
+               }),
+               activeEnvironment: "production",
+            }),
+         ),
+      ).to.be.true;
+   });
+
+   it("should set and get organization", () => {
+      readFileSyncStub.throws(new Error("File not found"));
+      clientConfig.setOrganization("my-org");
+
+      expect(
+         writeFileSyncStub.calledWith(
+            customConfigPath,
+            JSON.stringify({
+               configPerEnvironment: fullPerEnv({
+                  production: { organization: "my-org" },
+               }),
+               activeEnvironment: "production",
+            }),
+         ),
+      ).to.be.true;
+   });
+
+   it("should set and get refresh token", () => {
+      readFileSyncStub.throws(new Error("File not found"));
+      clientConfig.setRefreshToken("refresh-token-123");
+
+      expect(
+         writeFileSyncStub.calledWith(
+            customConfigPath,
+            JSON.stringify({
+               configPerEnvironment: fullPerEnv({
+                  production: { refreshToken: "refresh-token-123" },
+               }),
+               activeEnvironment: "production",
+            }),
+         ),
+      ).to.be.true;
+   });
+
+   it("should set and get VSCode user", () => {
+      readFileSyncStub.throws(new Error("File not found"));
+      clientConfig.setVSCodeUser("testuser", "test@example.com");
+
+      expect(
+         writeFileSyncStub.calledWith(
+            customConfigPath,
+            JSON.stringify({
+               configPerEnvironment: fullPerEnv({
+                  production: {
+                     vsCodeUser: {
+                        username: "testuser",
+                        email: "test@example.com",
+                     },
+                  },
+               }),
                activeEnvironment: "production",
             }),
          ),
       ).to.be.true;
    });
+
+   it("should set and get JWT access token", () => {
+      readFileSyncStub.throws(new Error("File not found"));
+      clientConfig.setJwtAccessToken("jwt-token-abc");
+
+      expect(
+         writeFileSyncStub.calledWith(
+            customConfigPath,
+            JSON.stringify({
+               configPerEnvironment: fullPerEnv({
+                  production: { jwtAccessToken: "jwt-token-abc" },
+               }),
+               activeEnvironment: "production",
+            }),
+         ),
+      ).to.be.true;
+   });
+
+   it("should return true for doesConfigExists when environment config exists", () => {
+      const mockConfig = {
+         configPerEnvironment: {
+            production: { project: "test" },
+            staging: {},
+            localhost: {},
+         },
+         activeEnvironment: "production",
+      };
+      readFileSyncStub.returns(JSON.stringify(mockConfig));
+
+      expect(clientConfig.doesConfigExists()).to.be.true;
+   });
+
+   it("should destroy config by resetting environment config to empty", () => {
+      const mockConfig = {
+         configPerEnvironment: {
+            production: { organization: "my-org", project: "my-proj" },
+            staging: {},
+            localhost: {},
+         },
+         activeEnvironment: "production",
+      };
+      readFileSyncStub.returns(JSON.stringify(mockConfig));
+      clientConfig.destroyConfig();
+
+      const lastWrite = writeFileSyncStub.lastCall.args[1] as string;
+      expect(JSON.parse(lastWrite)).to.deep.equal({
+         configPerEnvironment: fullPerEnv(),
+         activeEnvironment: "production",
+      });
+   });
+
+   it("should set and get environment", () => {
+      readFileSyncStub.throws(new Error("File not found"));
+      clientConfig.setEnvironment("staging");
+
+      expect(
+         writeFileSyncStub.calledWith(
+            customConfigPath,
+            JSON.stringify({
+               configPerEnvironment: fullPerEnv(),
+               activeEnvironment: "staging",
+            }),
+         ),
+      ).to.be.true;
+   });
+
+   it("should return headers with Bearer token for user tokens", () => {
+      const mockConfig = {
+         configPerEnvironment: {
+            production: {
+               accessToken: "user-token",
+               isServiceAccountToken: false,
+            },
+            staging: {},
+            localhost: {},
+         },
+         activeEnvironment: "production",
+      };
+      readFileSyncStub.returns(JSON.stringify(mockConfig));
+      clientConfig.loadConfig();
+
+      const headers = clientConfig.getHeaders();
+      expect(headers.Authorization).to.equal("Bearer user-token");
+   });
+
+   it("should return headers with ApiKey for service account tokens", () => {
+      const mockConfig = {
+         configPerEnvironment: {
+            production: {
+               accessToken: "service-token",
+               isServiceAccountToken: true,
+            },
+            staging: {},
+            localhost: {},
+         },
+         activeEnvironment: "production",
+      };
+      readFileSyncStub.returns(JSON.stringify(mockConfig));
+      clientConfig.loadConfig();
+
+      const headers = clientConfig.getHeaders();
+      expect(headers.Authorization).to.equal("ApiKey service-token");
+   });
+
+   it("should reset to defaults when config file is corrupted (missing activeEnvironment)", () => {
+      readFileSyncStub.returns(JSON.stringify({ configPerEnvironment: {} }));
+      clientConfig.loadConfig();
+
+      expect(clientConfig["config"].activeEnvironment).to.equal("production");
+   });
+
+   describe("isTokenValid", () => {
+      it("should return invalid when no token exists", () => {
+         const mockConfig = {
+            configPerEnvironment: {
+               production: {},
+               staging: {},
+               localhost: {},
+            },
+            activeEnvironment: "production",
+         };
+         readFileSyncStub.returns(JSON.stringify(mockConfig));
+
+         const result = clientConfig.isTokenValid();
+         expect(result.valid).to.be.false;
+         expect(result.reason).to.equal("No token found. Please login.");
+      });
+
+      it("should return valid for service account tokens", () => {
+         const mockConfig = {
+            configPerEnvironment: {
+               production: {
+                  accessToken: "some-api-key",
+                  isServiceAccountToken: true,
+               },
+               staging: {},
+               localhost: {},
+            },
+            activeEnvironment: "production",
+         };
+         readFileSyncStub.returns(JSON.stringify(mockConfig));
+
+         const result = clientConfig.isTokenValid();
+         expect(result.valid).to.be.true;
+      });
+
+      it("should return invalid for expired JWT", () => {
+         // Create a JWT with an expired exp claim
+         const payload = { exp: Math.floor(Date.now() / 1000) - 3600 };
+         const fakeJwt =
+            Buffer.from(JSON.stringify({ alg: "HS256" })).toString(
+               "base64url",
+            ) +
+            "." +
+            Buffer.from(JSON.stringify(payload)).toString("base64url") +
+            ".signature";
+
+         const mockConfig = {
+            configPerEnvironment: {
+               production: {
+                  accessToken: fakeJwt,
+                  isServiceAccountToken: false,
+               },
+               staging: {},
+               localhost: {},
+            },
+            activeEnvironment: "production",
+         };
+         readFileSyncStub.returns(JSON.stringify(mockConfig));
+
+         const result = clientConfig.isTokenValid();
+         expect(result.valid).to.be.false;
+         expect(result.reason).to.equal("Token expired. Please login again.");
+      });
+
+      it("should return valid for non-expired JWT", () => {
+         const payload = { exp: Math.floor(Date.now() / 1000) + 3600 };
+         const fakeJwt =
+            Buffer.from(JSON.stringify({ alg: "HS256" })).toString(
+               "base64url",
+            ) +
+            "." +
+            Buffer.from(JSON.stringify(payload)).toString("base64url") +
+            ".signature";
+
+         const mockConfig = {
+            configPerEnvironment: {
+               production: {
+                  accessToken: fakeJwt,
+                  isServiceAccountToken: false,
+               },
+               staging: {},
+               localhost: {},
+            },
+            activeEnvironment: "production",
+         };
+         readFileSyncStub.returns(JSON.stringify(mockConfig));
+
+         const result = clientConfig.isTokenValid();
+         expect(result.valid).to.be.true;
+      });
+
+      it("should return invalid for malformed token", () => {
+         const mockConfig = {
+            configPerEnvironment: {
+               production: {
+                  accessToken: "not-a-valid-jwt",
+                  isServiceAccountToken: false,
+               },
+               staging: {},
+               localhost: {},
+            },
+            activeEnvironment: "production",
+         };
+         readFileSyncStub.returns(JSON.stringify(mockConfig));
+
+         const result = clientConfig.isTokenValid();
+         expect(result.valid).to.be.false;
+         expect(result.reason).to.equal(
+            "Invalid token format. Please login again.",
+         );
+      });
+   });
+
+   describe("printStatus", () => {
+      let loggerStub: sinon.SinonStubbedInstance<typeof logger>;
+      let consoleLogStub: sinon.SinonStub;
+
+      beforeEach(() => {
+         loggerStub = sinon.stub(logger);
+         consoleLogStub = sinon.stub(console, "log");
+      });
+
+      it("should print org and project when token is valid", () => {
+         const payload = { exp: Math.floor(Date.now() / 1000) + 3600 };
+         const fakeJwt =
+            Buffer.from(JSON.stringify({ alg: "HS256" })).toString(
+               "base64url",
+            ) +
+            "." +
+            Buffer.from(JSON.stringify(payload)).toString("base64url") +
+            ".signature";
+
+         const mockConfig = {
+            configPerEnvironment: {
+               production: {
+                  accessToken: fakeJwt,
+                  isServiceAccountToken: false,
+                  organization: "my-org",
+                  project: "my-project",
+               },
+               staging: {},
+               localhost: {},
+            },
+            activeEnvironment: "production",
+         };
+         readFileSyncStub.returns(JSON.stringify(mockConfig));
+
+         clientConfig.printStatus();
+
+         expect(loggerStub.info.calledWith(sinon.match("Organization:"))).to.be
+            .true;
+         expect(loggerStub.info.calledWith(sinon.match("Project:"))).to.be.true;
+      });
+
+      it("should print error when token is invalid", () => {
+         const mockConfig = {
+            configPerEnvironment: {
+               production: {},
+               staging: {},
+               localhost: {},
+            },
+            activeEnvironment: "production",
+         };
+         readFileSyncStub.returns(JSON.stringify(mockConfig));
+
+         clientConfig.printStatus();
+
+         expect(
+            loggerStub.error.calledWith(sinon.match("Failed to get status")),
+         ).to.be.true;
+      });
+   });
 });

package/src/clientconfiguration.ts

@@ -1,7 +1,8 @@
 import fs from "fs";
+import { jwtDecode } from "jwt-decode";
 import kleur from "kleur";
 import os from "os";
-import { ASCII_TITLE, Environment } from "./constants";
+import { ALL_ENVIRONMENTS, ASCII_TITLE, Environment } from "./constants";
 import { logger } from "./logger";
 
 interface ConfigFile {
@@ -26,6 +27,12 @@ interface ConfigFile {
    activeEnvironment: Environment;
 }
 
+interface JwtPayload {
+   exp: number;
+   iat?: number;
+   sub?: string;
+}
+
 export class ClientConfiguration {
    private configPath = `${os.homedir()}/.cred`;
    private config: ConfigFile;
@@ -50,18 +57,23 @@ export class ClientConfiguration {
          }
       } catch (error) {
          logger.warn(error);
+         const configPerEnvironment: ConfigFile["configPerEnvironment"] = {};
+         for (const env of ALL_ENVIRONMENTS) {
+            configPerEnvironment[env] = {};
+         }
          this.config = {
-            configPerEnvironment: {
-               production: {},
-               staging: {},
-               localhost: {},
-            },
+            configPerEnvironment,
             activeEnvironment: "production",
          };
-         // Ensure the config file exists with default settings
          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;
    }
 
@@ -97,7 +109,8 @@ export class ClientConfiguration {
    public setAccessToken(userToken: boolean, accessToken: string) {
       this.loadConfig();
       const environment = this.getEnvironment();
-      this.config.configPerEnvironment[environment].isServiceAccountToken = !userToken;
+      this.config.configPerEnvironment[environment].isServiceAccountToken =
+         !userToken;
       this.config.configPerEnvironment[environment].accessToken = accessToken;
       fs.writeFileSync(this.configPath, JSON.stringify(this.config));
    }
@@ -105,7 +118,8 @@ export class ClientConfiguration {
    public getAuthenticationHeader() {
       const environment = this.getEnvironment();
       const jwt = this.config.configPerEnvironment[environment].accessToken;
-      const isServiceAccountToken = this.config.configPerEnvironment[environment].isServiceAccountToken;
+      const isServiceAccountToken =
+         this.config.configPerEnvironment[environment].isServiceAccountToken;
       const authType = isServiceAccountToken ? "ApiKey" : "Bearer";
       return `${authType} ${jwt}`;
    }
@@ -192,13 +206,58 @@ export class ClientConfiguration {
       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 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")}`);
+      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

@@ -21,11 +21,17 @@ export const registerAddCommands = (cli: Command, environment: Environment) => {
          "--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,
          );
@@ -44,6 +50,11 @@ export const registerAddCommands = (cli: Command, environment: Environment) => {
          "--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) => {
@@ -52,6 +63,7 @@ export const registerAddCommands = (cli: Command, environment: Environment) => {
             connectionFileName,
             options.includeTables,
             options.excludeTables,
+            options.skipIndexing,
             options.debug,
             options.yes,
          );
@@ -90,27 +102,24 @@ export const registerAddCommands = (cli: Command, environment: Environment) => {
          );
       });
 
-
    add.command("group-access-token")
       .description("Create an access token for a group.")
-      .argument(
-         "<groupName>",
-         "The name of the 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,
          );
       });
-
 };