@credibledata/cred-cli 0.0.7 → 0.0.102

package/src/commands/{project/updateproject.spec.ts → environment/updateenvironment.spec.ts}

@@ -1,18 +1,18 @@
 import { expect } from "chai";
 import sinon from "sinon";
-import { ProjectsApi } from "../../client/api";
+import { EnvironmentsApi } from "../../client/api";
 import { ClientConfiguration } from "../../clientconfiguration";
 import { logger } from "../../logger";
-import { updateProject } from "./updateproject";
+import { updateEnvironment } from "./updateenvironment";
 
-describe("update-project", () => {
+describe("update-environment", () => {
    let sandbox: sinon.SinonSandbox;
-   let updateProjectStub: sinon.SinonStub;
+   let updateEnvironmentStub: sinon.SinonStub;
    let loggerStub: sinon.SinonStubbedInstance<typeof logger>;
 
    beforeEach(() => {
       sandbox = sinon.createSandbox();
-      updateProjectStub = sandbox.stub();
+      updateEnvironmentStub = sandbox.stub();
       loggerStub = sandbox.stub(logger);
 
       // Mock ClientConfiguration constructor
@@ -26,48 +26,50 @@ describe("update-project", () => {
          .stub(ClientConfiguration.prototype, "getHeaders")
          .returns({ Authorization: "Bearer test-token" });
 
-      // Mock ProjectsApi constructor and method
+      // Mock EnvironmentsApi constructor and method
       sandbox
-         .stub(ProjectsApi.prototype, "updateProject")
-         .callsFake(updateProjectStub);
+         .stub(EnvironmentsApi.prototype, "updateEnvironment")
+         .callsFake(updateEnvironmentStub);
    });
 
    afterEach(() => {
       sandbox.restore();
    });
 
-   describe("updateProject", () => {
-      it("should update project successfully", async () => {
+   describe("updateEnvironment", () => {
+      it("should update environment successfully", async () => {
          const mockResponse = { status: 200 };
-         updateProjectStub.resolves(mockResponse);
+         updateEnvironmentStub.resolves(mockResponse);
 
-         await updateProject(
+         await updateEnvironment(
             "http://test-server",
-            "test-project",
+            "test-environment",
             { replicationCount: 3 },
             false,
             true,
          );
 
-         expect(updateProjectStub.calledOnce).to.be.true;
-         expect(updateProjectStub.firstCall.args[0]).to.equal("test-org");
-         expect(updateProjectStub.firstCall.args[1]).to.equal("test-project");
-         expect(updateProjectStub.firstCall.args[2]).to.include({
+         expect(updateEnvironmentStub.calledOnce).to.be.true;
+         expect(updateEnvironmentStub.firstCall.args[0]).to.equal("test-org");
+         expect(updateEnvironmentStub.firstCall.args[1]).to.equal(
+            "test-environment",
+         );
+         expect(updateEnvironmentStub.firstCall.args[2]).to.include({
             replicationCount: 3,
          });
-         expect(updateProjectStub.firstCall.args[3]).to.deep.include({
+         expect(updateEnvironmentStub.firstCall.args[3]).to.deep.include({
             baseURL: "http://test-server",
             headers: { Authorization: "Bearer test-token" },
          });
          expect(
             loggerStub.info.calledWith(
-               sinon.match("Successfully updated project test-project"),
+               sinon.match("Successfully updated environment test-environment"),
             ),
          ).to.be.true;
       });
 
-      it("should handle missing project name", async () => {
-         await updateProject(
+      it("should handle missing environment name", async () => {
+         await updateEnvironment(
             "http://test-server",
             "",
             { replicationCount: 3 },
@@ -75,50 +77,50 @@ describe("update-project", () => {
             true,
          );
 
-         expect(updateProjectStub.called).to.be.false;
+         expect(updateEnvironmentStub.called).to.be.false;
          expect(
             loggerStub.error.calledWith(
-               sinon.match("Please provide a project name"),
+               sinon.match("Please provide an environment name"),
             ),
          ).to.be.true;
       });
 
       it("should handle API errors", async () => {
          const mockError = new Error("API Error");
-         updateProjectStub.rejects(mockError);
+         updateEnvironmentStub.rejects(mockError);
 
-         await updateProject(
+         await updateEnvironment(
             "http://test-server",
-            "test-project",
+            "test-environment",
             { replicationCount: 3 },
             true,
             true,
          );
 
-         expect(updateProjectStub.calledOnce).to.be.true;
+         expect(updateEnvironmentStub.calledOnce).to.be.true;
          expect(
             loggerStub.error.calledWith(
-               sinon.match("Failed to update project test-project"),
+               sinon.match("Failed to update environment test-environment"),
             ),
          ).to.be.true;
       });
 
       it("should handle non-200 response status", async () => {
          const mockResponse = { status: 400 };
-         updateProjectStub.resolves(mockResponse);
+         updateEnvironmentStub.resolves(mockResponse);
 
-         await updateProject(
+         await updateEnvironment(
             "http://test-server",
-            "test-project",
+            "test-environment",
             { replicationCount: 3 },
             false,
             true,
          );
 
-         expect(updateProjectStub.calledOnce).to.be.true;
+         expect(updateEnvironmentStub.calledOnce).to.be.true;
          expect(
             loggerStub.error.calledWith(
-               sinon.match("Failed to update project. Status: 400"),
+               sinon.match("Failed to update environment. Status: 400"),
             ),
          ).to.be.true;
       });
@@ -129,25 +131,25 @@ describe("update-project", () => {
          it("should fail when user is not logged in", async () => {
             sandbox.restore();
             sandbox = sinon.createSandbox();
-            updateProjectStub = sandbox.stub();
+            updateEnvironmentStub = sandbox.stub();
             loggerStub = sandbox.stub(logger);
 
             sandbox
                .stub(ClientConfiguration.prototype, "doesConfigExists")
                .returns(false);
             sandbox
-               .stub(ProjectsApi.prototype, "updateProject")
-               .callsFake(updateProjectStub);
+               .stub(EnvironmentsApi.prototype, "updateEnvironment")
+               .callsFake(updateEnvironmentStub);
 
-            await updateProject(
+            await updateEnvironment(
                "http://test-server",
-               "test-project",
+               "test-environment",
                { replicationCount: 3 },
                false,
                true,
             );
 
-            expect(updateProjectStub.called).to.be.false;
+            expect(updateEnvironmentStub.called).to.be.false;
             expect(
                loggerStub.error.calledWith(
                   sinon.match("Please, make sure that you are logged in"),
@@ -159,36 +161,36 @@ describe("update-project", () => {
       describe("replication count validation", () => {
          it("should accept valid replication counts", async () => {
             const mockResponse = { status: 200 };
-            updateProjectStub.resolves(mockResponse);
+            updateEnvironmentStub.resolves(mockResponse);
 
             const validCounts = [1, 2, 5, 10, 100];
 
             for (const count of validCounts) {
-               await updateProject(
+               await updateEnvironment(
                   "http://test-server",
-                  "test-project",
+                  "test-environment",
                   { replicationCount: count },
                   false,
                   true,
                );
-               expect(updateProjectStub.called).to.be.true;
-               expect(updateProjectStub.firstCall.args[2]).to.include({
+               expect(updateEnvironmentStub.called).to.be.true;
+               expect(updateEnvironmentStub.firstCall.args[2]).to.include({
                   replicationCount: count,
                });
-               updateProjectStub.reset();
+               updateEnvironmentStub.reset();
             }
          });
 
          it("should reject replication count less than 1", async () => {
-            await updateProject(
+            await updateEnvironment(
                "http://test-server",
-               "test-project",
+               "test-environment",
                { replicationCount: 0 },
                false,
                true,
             );
 
-            expect(updateProjectStub.called).to.be.false;
+            expect(updateEnvironmentStub.called).to.be.false;
             expect(
                loggerStub.error.calledWith(
                   sinon.match("Replication count must be at least 1"),
@@ -197,15 +199,15 @@ describe("update-project", () => {
          });
 
          it("should reject negative replication count", async () => {
-            await updateProject(
+            await updateEnvironment(
                "http://test-server",
-               "test-project",
+               "test-environment",
                { replicationCount: -1 },
                false,
                true,
             );
 
-            expect(updateProjectStub.called).to.be.false;
+            expect(updateEnvironmentStub.called).to.be.false;
             expect(
                loggerStub.error.calledWith(
                   sinon.match("Replication count must be at least 1"),

package/src/commands/{project/updateproject.ts → environment/updateenvironment.ts}

@@ -1,19 +1,19 @@
-import { Project, ProjectsApi } from "../../client/api";
+import { Environment, EnvironmentsApi } 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());
+const environmentsApi = new EnvironmentsApi(new Configuration());
 
-type UpdateProjectProperties = {
+type UpdateEnvironmentProperties = {
    replicationCount?: number;
 };
 
-export async function updateProject(
+export async function updateEnvironment(
    controlPlane: string,
-   projectName: string,
-   properties: UpdateProjectProperties,
+   environmentName: string,
+   properties: UpdateEnvironmentProperties,
    debug?: boolean,
    skipConfirmation?: boolean,
 ) {
@@ -23,8 +23,8 @@ export async function updateProject(
       return;
    }
 
-   if (!projectName) {
-      logger.error("Please provide a project name");
+   if (!environmentName) {
+      logger.error("Please provide an environment name");
       return;
    }
 
@@ -41,7 +41,7 @@ export async function updateProject(
    try {
       if (!skipConfirmation) {
          const confirmation = await getConfirmation(
-            `Are you sure you want to update project ${projectName}?`,
+            `Are you sure you want to update environment ${environmentName}?`,
          );
          if (!confirmation) {
             logger.info("Operation cancelled.");
@@ -49,16 +49,16 @@ export async function updateProject(
          }
       }
 
-      const projectUpdate: Project = {};
+      const environmentUpdate: Environment = {};
 
       if (properties.replicationCount !== undefined) {
-         projectUpdate.replicationCount = properties.replicationCount;
+         environmentUpdate.replicationCount = properties.replicationCount;
       }
 
-      const response = await projectsApi.updateProject(
+      const response = await environmentsApi.updateEnvironment(
          organizationName,
-         projectName,
-         projectUpdate,
+         environmentName,
+         environmentUpdate,
          {
             baseURL: controlPlane,
             headers: clientConfig.getHeaders(),
@@ -66,17 +66,19 @@ export async function updateProject(
       );
 
       if (response.status === 200) {
-         logger.info(`Successfully updated project ${projectName}`);
+         logger.info(`Successfully updated environment ${environmentName}`);
          if (properties.replicationCount !== undefined) {
             logger.info(
                `Replication count set to ${properties.replicationCount}`,
             );
          }
       } else {
-         logger.error(`Failed to update project. Status: ${response.status}`);
+         logger.error(
+            `Failed to update environment. Status: ${response.status}`,
+         );
       }
    } catch (e) {
-      logger.error(`Failed to update project ${projectName}`);
+      logger.error(`Failed to update environment ${environmentName}`);
       printOutError(e, debug);
    }
 }

package/src/commands/get.ts

@@ -1,24 +1,37 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import { Command } from "commander";
 import { controlPlanesByEnv, Environment } from "../constants";
 import { getGroup } from "./group/getgroup";
-import { getProject } from "./project/getproject";
+import { getEnvironment } from "./environment/getenvironment";
+import { warnProjectDeprecated } from "./legacy";
 
 export const registerGetCommands = (cli: Command, environment: Environment) => {
    const get = cli
       .command("get")
       .description("Get a resource")
-      .argument("<resource>", "The resource to get (project | group)");
+      .argument("<resource>", "The resource to get (environment | group)");
+
+   const getEnvironmentAction = (environmentName: string, options: any) => {
+      getEnvironment(
+         controlPlanesByEnv[environment],
+         environmentName,
+         options.debug,
+      );
+   };
+
+   get.command("environment")
+      .description("Get an environment by name.")
+      .argument("<environmentName>", "The name of the environment to get.")
+      .option("--debug")
+      .action(getEnvironmentAction);
 
    get.command("project")
-      .description("Get a project by name.")
-      .argument("<projectName>", "The name of the project to get.")
+      .description("[deprecated] Alias for 'get environment'.")
+      .argument("<projectName>", "The name of the environment to get.")
       .option("--debug")
       .action((projectName, options) => {
-         getProject(
-            controlPlanesByEnv[environment],
-            projectName,
-            options.debug,
-         );
+         warnProjectDeprecated("get environment");
+         getEnvironmentAction(projectName, options);
       });
 
    get.command("group")

package/src/commands/legacy.ts

@@ -0,0 +1,5 @@
+import { logger } from "../logger";
+
+export const warnProjectDeprecated = (newCommand: string) => {
+   logger.warn(`'project' is deprecated; use '${newCommand}' instead.`);
+};

package/src/commands/list.ts

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import { Command } from "commander";
 import { controlPlanesByEnv, Environment } from "../constants";
 import { DEFAULT_PAGE_SIZE, DEFAULT_PAGE } from "../utils";
@@ -5,8 +6,9 @@ import { listConnections } from "./connection/listconnections";
 import { printOutGroups } from "./group/listgroups";
 import { listGroupAccessTokens } from "./groupaccesstoken/listTokens";
 import { printOutPackages } from "./package/listpackages";
-import { printOutProjects } from "./project/listprojects";
+import { printOutEnvironments } from "./environment/listenvironments";
 import { listVersions } from "./version/listversions";
+import { warnProjectDeprecated } from "./legacy";
 
 export const registerListCommands = (
    cli: Command,
@@ -17,10 +19,36 @@ export const registerListCommands = (
       .description("List resources of a given type")
       .argument("<resource>", "The resource to list");
 
+   const listEnvironmentsAction = (options: any) => {
+      printOutEnvironments(
+         controlPlanesByEnv[environment],
+         options.debug,
+         options.page,
+         options.pageSize,
+      );
+   };
+
+   list
+      .command("environment")
+      .alias("environments")
+      .description("List all environments.")
+      .option("--debug")
+      .option(
+         "--page <number>",
+         `Page number (starts at  ${DEFAULT_PAGE})`,
+         String(DEFAULT_PAGE),
+      )
+      .option(
+         "--page-size <number>",
+         `Items per page (default: all records, max: 500)`,
+         String(DEFAULT_PAGE_SIZE),
+      )
+      .action(listEnvironmentsAction);
+
    list
       .command("project")
       .alias("projects")
-      .description("List all projects.")
+      .description("[deprecated] Alias for 'ls environment'.")
       .option("--debug")
       .option(
          "--page <number>",
@@ -33,12 +61,8 @@ export const registerListCommands = (
          String(DEFAULT_PAGE_SIZE),
       )
       .action((options) => {
-         printOutProjects(
-            controlPlanesByEnv[environment],
-            options.debug,
-            options.page,
-            options.pageSize,
-         );
+         warnProjectDeprecated("ls environment");
+         listEnvironmentsAction(options);
       });
 
    list
@@ -68,7 +92,7 @@ export const registerListCommands = (
    list
       .command("package")
       .alias("packages")
-      .description("List the packages in the active project.")
+      .description("List the packages in the active environment.")
       .option("--debug")
       .option(
          "--page <number>",

package/src/commands/misc/login.spec.ts

@@ -19,6 +19,7 @@ function createFakeIdToken(payload: Record<string, unknown>): string {
 }
 
 describe("login", () => {
+   let tmpConfigDir: string;
    let tmpConfigFilePath: string;
    let axiosStub: sinon.SinonStub;
    let orgPermissionsStub: sinon.SinonStub;
@@ -51,8 +52,26 @@ describe("login", () => {
    };
 
    beforeEach(() => {
-      tmpConfigFilePath = join(os.tmpdir(), "cred.json");
-      fs.writeFileSync(tmpConfigFilePath, "{}");
+      // mkdtempSync atomically creates a private (mode 0700) directory
+      // with an unguessable suffix, sidestepping the symlink / clobber
+      // class that CodeQL flags as js/insecure-temporary-file when a
+      // fixed name is reused inside the shared OS tmpdir.
+      tmpConfigDir = fs.mkdtempSync(join(os.tmpdir(), "cred-login-spec-"));
+      tmpConfigFilePath = join(tmpConfigDir, "cred.json");
+      // Seed with a valid ConfigFile. loadConfig now throws on malformed
+      // input rather than silently resetting, so an empty `{}` is no longer
+      // an acceptable starting state.
+      fs.writeFileSync(
+         tmpConfigFilePath,
+         JSON.stringify({
+            configPerEnvironment: {
+               production: {},
+               staging: {},
+               localhost: {},
+            },
+            activeEnvironment: "production",
+         }),
+      );
       axiosStub = sinon.stub(axios, "request");
       orgPermissionsStub = sinon
          .stub(OrganizationsApi.prototype, "getOrganization")
@@ -60,7 +79,7 @@ describe("login", () => {
    });
 
    afterEach(() => {
-      fs.rmSync(tmpConfigFilePath);
+      fs.rmSync(tmpConfigDir, { recursive: true, force: true });
       sinon.restore();
    });
 
@@ -159,7 +178,7 @@ describe("login", () => {
          "https://admin.videoamp-aws-us-east-1.credibledata.com/api/v0",
          tmpConfigFilePath,
       );
-      expect(orgIdStub.calledOnceWithExactly("videoamp")).to.be.true;
+      expect(orgIdStub.calledOnceWithExactly("videoamp", undefined)).to.be.true;
       expect(loopbackStub.calledOnce).to.be.true;
       const call = loopbackStub.getCall(0);
       expect(call.args[0].authorizeUrl).to.contain(
@@ -190,12 +209,35 @@ describe("login", () => {
          "https://admin.videoamp-aws-us-east-1.credibledata.com/api/v0",
          tmpConfigFilePath,
       );
-      expect(orgIdStub.calledOnceWithExactly("VideoAmp")).to.be.true;
+      expect(orgIdStub.calledOnceWithExactly("VideoAmp", undefined)).to.be.true;
       expect(loopbackStub.getCall(0).args[0].authorizeUrl).to.contain(
          "organization=org_nMRKafeSuxOiuJeG",
       );
    });
 
+   it("forwards the cluster arg to getAuth0OrganizationIdForCliLogin (so -c aws triggers PKCE)", async function () {
+      this.timeout(2000);
+      const orgIdStub = sinon
+         .stub(credConstants, "getAuth0OrganizationIdForCliLogin")
+         .returns("org_nMRKafeSuxOiuJeG");
+      sinon
+         .stub(loopbackOAuth, "authorizationCodeViaLoopback")
+         .callsFake(async (opts) => {
+            opts.onListening?.();
+            return { code: "test-pkce-auth-code" };
+         });
+      axiosStub.onFirstCall().resolves(mockedAccessTokenResponse);
+      const config = new ClientConfiguration(tmpConfigFilePath);
+      config.setEnvironment("videoamp");
+      await login(
+         "videoamp",
+         "https://admin.videoamp-aws-us-east-1.credibledata.com/api/v0",
+         tmpConfigFilePath,
+         "aws",
+      );
+      expect(orgIdStub.calledOnceWithExactly("videoamp", "aws")).to.be.true;
+   });
+
    it("should not pass Auth0 organization for unmapped org names", async function () {
       this.timeout(2000);
       axiosStub

package/src/commands/misc/login.ts

@@ -7,6 +7,7 @@ import { ClientConfiguration } from "../../clientconfiguration";
 import {
    auth0ConfigsByEnv,
    AUTH_CLI_LOOPBACK_REDIRECT_URI,
+   Cluster,
    Environment,
    getAuth0OrganizationIdForCliLogin,
    LOGIN_TIMEOUT_MS,
@@ -21,6 +22,7 @@ export async function login(
    organizationName: string,
    controlPlaneBaseURL?: string,
    configPath?: string,
+   cluster?: Cluster,
 ) {
    const config = new ClientConfiguration(configPath);
    const environment = config.getEnvironment();
@@ -29,8 +31,10 @@ export async function login(
       return loginM2M(organizationName, config);
    }
 
-   const auth0OrganizationId =
-      getAuth0OrganizationIdForCliLogin(organizationName);
+   const auth0OrganizationId = getAuth0OrganizationIdForCliLogin(
+      organizationName,
+      cluster,
+   );
    if (auth0OrganizationId) {
       return loginWithAuthCodePkceOrganization(
          environment,

package/src/commands/package/deletepackage.spec.ts

@@ -123,7 +123,7 @@ describe("delete-package", () => {
       expect(deletePackageStub.called).to.be.false;
       expect(
          loggerStub.error.calledWith(
-            sinon.match("Please, make sure to set a project"),
+            sinon.match("Please, make sure to set an environment"),
          ),
       ).to.be.true;
    });

package/src/commands/package/deletepackage.ts

@@ -14,7 +14,7 @@ export async function deletePackage(
 ) {
    const clientConfig = new ClientConfiguration();
    const organizationName = clientConfig.getOrganization();
-   const projectName = clientConfig.getProject();
+   const environmentName = clientConfig.getProject();
    const packageName = packagePath.replace("/", "");
 
    if (!clientConfig.doesConfigExists()) {
@@ -22,8 +22,8 @@ export async function deletePackage(
       return;
    }
 
-   if (!projectName) {
-      logger.error("Please, make sure to set a project");
+   if (!environmentName) {
+      logger.error("Please, make sure to set an environment");
       return;
    }
 
@@ -42,7 +42,7 @@ export async function deletePackage(
    try {
       await packagesApi.deletePackage(
          organizationName,
-         projectName,
+         environmentName,
          packageName,
          {
             baseURL: packageServer,

package/src/commands/package/listpackages.spec.ts

@@ -114,7 +114,7 @@ describe("list-packages", () => {
       expect(result).to.be.undefined;
       expect(
          loggerStub.error.calledWith(
-            sinon.match("Please, make sure to set a project"),
+            sinon.match("Please, make sure to set an environment"),
          ),
       ).to.be.true;
    });

package/src/commands/package/listpackages.ts

@@ -19,15 +19,15 @@ export async function listPackages(
 ) {
    const clientConfig = new ClientConfiguration();
    const organizationName = clientConfig.getOrganization();
-   const projectName = clientConfig.getProject();
+   const environmentName = 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");
+   if (!environmentName) {
+      logger.error("Please, make sure to set an environment");
       return;
    }
 
@@ -35,7 +35,7 @@ export async function listPackages(
       const { limit, offset } = parsePaginationParams(page, pageSize);
       const response = await packagesApi.listPackages(
          organizationName,
-         projectName,
+         environmentName,
          limit,
          offset,
          {