@credibledata/cred-cli 0.0.100 → 0.0.103

package/src/commands/{project/createproject.spec.ts → environment/createenvironment.spec.ts}

@@ -1,15 +1,15 @@
 import { expect } from "chai";
 import fs from "fs";
 import sinon from "sinon";
-import { ProjectsApi } from "../../client/api";
+import { EnvironmentsApi } from "../../client/api";
 import { ClientConfiguration } from "../../clientconfiguration";
 import { logger } from "../../logger";
 import { getConfirmation } from "../../utils";
-import { createProject } from "./createproject";
+import { createEnvironment } from "./createenvironment";
 
-describe("create-project", () => {
+describe("create-environment", () => {
    let sandbox: sinon.SinonSandbox;
-   let createProjectStub: sinon.SinonStub;
+   let createEnvironmentStub: sinon.SinonStub;
    let loggerStub: sinon.SinonStubbedInstance<typeof logger>;
    let consoleLogStub: sinon.SinonStub;
    let getConfirmationStub: sinon.SinonStub;
@@ -18,7 +18,7 @@ describe("create-project", () => {
 
    beforeEach(() => {
       sandbox = sinon.createSandbox();
-      createProjectStub = sandbox.stub();
+      createEnvironmentStub = sandbox.stub();
       loggerStub = sandbox.stub(logger);
       consoleLogStub = sandbox.stub(console, "log");
       getConfirmationStub = sandbox.stub();
@@ -39,8 +39,8 @@ describe("create-project", () => {
          .returns("Bearer test-token");
 
       sandbox
-         .stub(ProjectsApi.prototype, "createProject")
-         .callsFake(createProjectStub);
+         .stub(EnvironmentsApi.prototype, "createEnvironment")
+         .callsFake(createEnvironmentStub);
       sandbox
          .stub(require("../../utils"), "getConfirmation")
          .callsFake(getConfirmationStub);
@@ -50,47 +50,47 @@ describe("create-project", () => {
       sandbox.restore();
    });
 
-   it("should create project successfully", async () => {
+   it("should create environment successfully", async () => {
       const mockResponse = {
-         data: { name: "test-project", replicationCount: 2 },
+         data: { name: "test-environment", replicationCount: 2 },
       };
-      createProjectStub.resolves(mockResponse);
+      createEnvironmentStub.resolves(mockResponse);
       getConfirmationStub.resolves(true);
 
-      await createProject(
+      await createEnvironment(
          "http://test-server",
-         "test-project",
+         "test-environment",
          "",
          undefined,
          false,
          true,
       );
 
-      expect(createProjectStub.calledOnce).to.be.true;
-      expect(createProjectStub.firstCall.args[0]).to.equal("test-org");
-      expect(createProjectStub.firstCall.args[1]).to.deep.include({
-         name: "test-project",
+      expect(createEnvironmentStub.calledOnce).to.be.true;
+      expect(createEnvironmentStub.firstCall.args[0]).to.equal("test-org");
+      expect(createEnvironmentStub.firstCall.args[1]).to.deep.include({
+         name: "test-environment",
          readme: "",
       });
-      expect(setProjectStub.calledWith("test-project")).to.be.true;
+      expect(setProjectStub.calledWith("test-environment")).to.be.true;
       expect(
          loggerStub.info.calledWith(
-            sinon.match("Project created successfully"),
+            sinon.match("Environment created successfully"),
          ),
       ).to.be.true;
    });
 
-   it("should create project with readme file", async () => {
+   it("should create environment with readme file", async () => {
       const mockResponse = {
-         data: { name: "test-project" },
+         data: { name: "test-environment" },
       };
-      createProjectStub.resolves(mockResponse);
+      createEnvironmentStub.resolves(mockResponse);
       getConfirmationStub.resolves(true);
       readFileSyncStub.returns("README content");
 
-      await createProject(
+      await createEnvironment(
          "http://test-server",
-         "test-project",
+         "test-environment",
          "/path/to/readme.md",
          undefined,
          false,
@@ -98,30 +98,30 @@ describe("create-project", () => {
       );
 
       expect(readFileSyncStub.calledWith("/path/to/readme.md")).to.be.true;
-      expect(createProjectStub.firstCall.args[1]).to.deep.include({
-         name: "test-project",
+      expect(createEnvironmentStub.firstCall.args[1]).to.deep.include({
+         name: "test-environment",
          readme: "README content",
       });
    });
 
-   it("should create project with replication count", async () => {
+   it("should create environment with replication count", async () => {
       const mockResponse = {
-         data: { name: "test-project", replicationCount: 5 },
+         data: { name: "test-environment", replicationCount: 5 },
       };
-      createProjectStub.resolves(mockResponse);
+      createEnvironmentStub.resolves(mockResponse);
       getConfirmationStub.resolves(true);
 
-      await createProject(
+      await createEnvironment(
          "http://test-server",
-         "test-project",
+         "test-environment",
          "",
          5,
          false,
          true,
       );
 
-      expect(createProjectStub.firstCall.args[1]).to.deep.include({
-         name: "test-project",
+      expect(createEnvironmentStub.firstCall.args[1]).to.deep.include({
+         name: "test-environment",
          replicationCount: 5,
       });
       expect(
@@ -132,7 +132,7 @@ describe("create-project", () => {
    it("should handle missing config", async () => {
       sandbox.restore();
       sandbox = sinon.createSandbox();
-      createProjectStub = sandbox.stub();
+      createEnvironmentStub = sandbox.stub();
       loggerStub = sandbox.stub(logger);
       consoleLogStub = sandbox.stub(console, "log");
       getConfirmationStub = sandbox.stub();
@@ -146,22 +146,22 @@ describe("create-project", () => {
          .stub(ClientConfiguration.prototype, "doesConfigExists")
          .returns(false);
       sandbox
-         .stub(ProjectsApi.prototype, "createProject")
-         .callsFake(createProjectStub);
+         .stub(EnvironmentsApi.prototype, "createEnvironment")
+         .callsFake(createEnvironmentStub);
       sandbox
          .stub(require("../../utils"), "getConfirmation")
          .callsFake(getConfirmationStub);
 
-      await createProject(
+      await createEnvironment(
          "http://test-server",
-         "test-project",
+         "test-environment",
          "",
          undefined,
          false,
          true,
       );
 
-      expect(createProjectStub.called).to.be.false;
+      expect(createEnvironmentStub.called).to.be.false;
       expect(
          loggerStub.error.calledWith(
             sinon.match("Please, make sure that you are logged in"),
@@ -170,16 +170,16 @@ describe("create-project", () => {
    });
 
    it("should reject replication count less than 1", async () => {
-      await createProject(
+      await createEnvironment(
          "http://test-server",
-         "test-project",
+         "test-environment",
          "",
          0,
          false,
          true,
       );
 
-      expect(createProjectStub.called).to.be.false;
+      expect(createEnvironmentStub.called).to.be.false;
       expect(
          loggerStub.error.calledWith(
             sinon.match("Replication count must be at least 1"),
@@ -189,14 +189,14 @@ describe("create-project", () => {
 
    it("should request confirmation when autoConfirm is false", async () => {
       const mockResponse = {
-         data: { name: "test-project" },
+         data: { name: "test-environment" },
       };
-      createProjectStub.resolves(mockResponse);
+      createEnvironmentStub.resolves(mockResponse);
       getConfirmationStub.resolves(true);
 
-      await createProject(
+      await createEnvironment(
          "http://test-server",
-         "test-project",
+         "test-environment",
          "",
          undefined,
          false,
@@ -204,15 +204,15 @@ describe("create-project", () => {
       );
 
       expect(getConfirmationStub.calledOnce).to.be.true;
-      expect(createProjectStub.calledOnce).to.be.true;
+      expect(createEnvironmentStub.calledOnce).to.be.true;
    });
 
    it("should cancel when confirmation is denied", async () => {
       getConfirmationStub.resolves(false);
 
-      await createProject(
+      await createEnvironment(
          "http://test-server",
-         "test-project",
+         "test-environment",
          "",
          undefined,
          false,
@@ -220,28 +220,30 @@ describe("create-project", () => {
       );
 
       expect(getConfirmationStub.calledOnce).to.be.true;
-      expect(createProjectStub.called).to.be.false;
+      expect(createEnvironmentStub.called).to.be.false;
       expect(loggerStub.info.calledWith(sinon.match("Operation cancelled."))).to
          .be.true;
    });
 
    it("should handle API errors", async () => {
       const mockError = new Error("API Error");
-      createProjectStub.rejects(mockError);
+      createEnvironmentStub.rejects(mockError);
       getConfirmationStub.resolves(true);
 
-      await createProject(
+      await createEnvironment(
          "http://test-server",
-         "test-project",
+         "test-environment",
          "",
          undefined,
          true,
          true,
       );
 
-      expect(createProjectStub.calledOnce).to.be.true;
+      expect(createEnvironmentStub.calledOnce).to.be.true;
       expect(
-         loggerStub.error.calledWith(sinon.match("Failed to create project")),
+         loggerStub.error.calledWith(
+            sinon.match("Failed to create environment"),
+         ),
       ).to.be.true;
    });
 });

package/src/commands/{project/createproject.ts → environment/createenvironment.ts}

@@ -1,15 +1,15 @@
 import fs from "fs";
-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());
 
-export async function createProject(
+export async function createEnvironment(
    controlPlane: string,
-   projectName: string,
+   environmentName: string,
    readmeFile: string,
    replicationCount: number | undefined,
    debug: boolean,
@@ -27,14 +27,14 @@ export async function createProject(
    }
    if (!autoConfirm) {
       const confirmation = await getConfirmation(
-         `Are you sure you that want to create a project named ${projectName}?`,
+         `Are you sure you that want to create an environment named ${environmentName}?`,
       );
       if (!confirmation) {
          logger.info("Operation cancelled.");
          return;
       }
    }
-   logger.info("Creating project " + projectName);
+   logger.info("Creating environment " + environmentName);
 
    let readmeContents = "";
    if (readmeFile) {
@@ -42,12 +42,15 @@ export async function createProject(
    }
 
    try {
-      const project: Project = { name: projectName, readme: readmeContents };
+      const environment: Environment = {
+         name: environmentName,
+         readme: readmeContents,
+      };
       if (replicationCount !== undefined) {
-         project.replicationCount = replicationCount;
+         environment.replicationCount = replicationCount;
       }
-      await projectsApi
-         .createProject(clientConfig.getOrganization(), project, {
+      await environmentsApi
+         .createEnvironment(clientConfig.getOrganization(), environment, {
             baseURL: controlPlane,
             headers: {
                Authorization: clientConfig.getAuthenticationHeader(),
@@ -56,15 +59,15 @@ export async function createProject(
          .then((response) => {
             const jsonString = JSON.stringify(response.data, null, 2);
             console.log(jsonString);
-            // Make the new project the default project.
-            clientConfig.setProject(projectName);
+            // Make the new environment the default environment.
+            clientConfig.setProject(environmentName);
             if (replicationCount !== undefined) {
                logger.info(`Replication count set to ${replicationCount}`);
             }
          });
-      logger.info("Project created successfully");
+      logger.info("Environment created successfully");
    } catch (e) {
-      logger.error("Failed to create project");
+      logger.error("Failed to create environment");
       printOutError(e, debug);
    }
 }

package/src/commands/{project/deleteproject.spec.ts → environment/deleteenvironment.spec.ts}

@@ -1,20 +1,20 @@
 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 { getConfirmation } from "../../utils";
-import { deleteProject } from "./deleteproject";
+import { deleteEnvironment } from "./deleteenvironment";
 
-describe("delete-project", () => {
+describe("delete-environment", () => {
    let sandbox: sinon.SinonSandbox;
-   let deleteProjectStub: sinon.SinonStub;
+   let deleteEnvironmentStub: sinon.SinonStub;
    let loggerStub: sinon.SinonStubbedInstance<typeof logger>;
    let getConfirmationStub: sinon.SinonStub;
 
    beforeEach(() => {
       sandbox = sinon.createSandbox();
-      deleteProjectStub = sandbox.stub();
+      deleteEnvironmentStub = sandbox.stub();
       loggerStub = sandbox.stub(logger);
       getConfirmationStub = sandbox.stub();
 
@@ -29,8 +29,8 @@ describe("delete-project", () => {
          .returns("Bearer test-token");
 
       sandbox
-         .stub(ProjectsApi.prototype, "deleteProject")
-         .callsFake(deleteProjectStub);
+         .stub(EnvironmentsApi.prototype, "deleteEnvironment")
+         .callsFake(deleteEnvironmentStub);
       sandbox
          .stub(require("../../utils"), "getConfirmation")
          .callsFake(getConfirmationStub);
@@ -40,22 +40,29 @@ describe("delete-project", () => {
       sandbox.restore();
    });
 
-   it("should delete project successfully", async () => {
-      deleteProjectStub.resolves({ status: 200 });
+   it("should delete environment successfully", async () => {
+      deleteEnvironmentStub.resolves({ status: 200 });
       getConfirmationStub.resolves(true);
 
-      await deleteProject("http://test-server", "test-project", false, true);
-
-      expect(deleteProjectStub.calledOnce).to.be.true;
-      expect(deleteProjectStub.firstCall.args[0]).to.equal("test-org");
-      expect(deleteProjectStub.firstCall.args[1]).to.equal("test-project");
-      expect(deleteProjectStub.firstCall.args[2]).to.deep.include({
+      await deleteEnvironment(
+         "http://test-server",
+         "test-environment",
+         false,
+         true,
+      );
+
+      expect(deleteEnvironmentStub.calledOnce).to.be.true;
+      expect(deleteEnvironmentStub.firstCall.args[0]).to.equal("test-org");
+      expect(deleteEnvironmentStub.firstCall.args[1]).to.equal(
+         "test-environment",
+      );
+      expect(deleteEnvironmentStub.firstCall.args[2]).to.deep.include({
          baseURL: "http://test-server",
          headers: { Authorization: "Bearer test-token" },
       });
       expect(
          loggerStub.info.calledWith(
-            sinon.match("Project deleted successfully"),
+            sinon.match("Environment deleted successfully"),
          ),
       ).to.be.true;
    });
@@ -63,7 +70,7 @@ describe("delete-project", () => {
    it("should handle missing config", async () => {
       sandbox.restore();
       sandbox = sinon.createSandbox();
-      deleteProjectStub = sandbox.stub();
+      deleteEnvironmentStub = sandbox.stub();
       loggerStub = sandbox.stub(logger);
       getConfirmationStub = sandbox.stub();
 
@@ -71,15 +78,20 @@ describe("delete-project", () => {
          .stub(ClientConfiguration.prototype, "doesConfigExists")
          .returns(false);
       sandbox
-         .stub(ProjectsApi.prototype, "deleteProject")
-         .callsFake(deleteProjectStub);
+         .stub(EnvironmentsApi.prototype, "deleteEnvironment")
+         .callsFake(deleteEnvironmentStub);
       sandbox
          .stub(require("../../utils"), "getConfirmation")
          .callsFake(getConfirmationStub);
 
-      await deleteProject("http://test-server", "test-project", false, true);
+      await deleteEnvironment(
+         "http://test-server",
+         "test-environment",
+         false,
+         true,
+      );
 
-      expect(deleteProjectStub.called).to.be.false;
+      expect(deleteEnvironmentStub.called).to.be.false;
       expect(
          loggerStub.error.calledWith(
             sinon.match("Please, make sure that you are logged in"),
@@ -88,36 +100,53 @@ describe("delete-project", () => {
    });
 
    it("should request confirmation when autoConfirm is false", async () => {
-      deleteProjectStub.resolves({ status: 200 });
+      deleteEnvironmentStub.resolves({ status: 200 });
       getConfirmationStub.resolves(true);
 
-      await deleteProject("http://test-server", "test-project", false, false);
+      await deleteEnvironment(
+         "http://test-server",
+         "test-environment",
+         false,
+         false,
+      );
 
       expect(getConfirmationStub.calledOnce).to.be.true;
-      expect(deleteProjectStub.calledOnce).to.be.true;
+      expect(deleteEnvironmentStub.calledOnce).to.be.true;
    });
 
    it("should cancel when confirmation is denied", async () => {
       getConfirmationStub.resolves(false);
 
-      await deleteProject("http://test-server", "test-project", false, false);
+      await deleteEnvironment(
+         "http://test-server",
+         "test-environment",
+         false,
+         false,
+      );
 
       expect(getConfirmationStub.calledOnce).to.be.true;
-      expect(deleteProjectStub.called).to.be.false;
+      expect(deleteEnvironmentStub.called).to.be.false;
       expect(loggerStub.info.calledWith(sinon.match("Operation cancelled."))).to
          .be.true;
    });
 
    it("should handle API errors", async () => {
       const mockError = new Error("API Error");
-      deleteProjectStub.rejects(mockError);
+      deleteEnvironmentStub.rejects(mockError);
       getConfirmationStub.resolves(true);
 
-      await deleteProject("http://test-server", "test-project", true, true);
+      await deleteEnvironment(
+         "http://test-server",
+         "test-environment",
+         true,
+         true,
+      );
 
-      expect(deleteProjectStub.calledOnce).to.be.true;
+      expect(deleteEnvironmentStub.calledOnce).to.be.true;
       expect(
-         loggerStub.error.calledWith(sinon.match("Failed to delete project")),
+         loggerStub.error.calledWith(
+            sinon.match("Failed to delete environment"),
+         ),
       ).to.be.true;
    });
 });

package/src/commands/{project/deleteproject.ts → environment/deleteenvironment.ts}

@@ -1,14 +1,14 @@
-import { ProjectsApi } from "../../client/api";
+import { 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());
 
-export async function deleteProject(
+export async function deleteEnvironment(
    controlPlane: string,
-   projectName: string,
+   environmentName: string,
    debug: boolean,
    autoConfirm: boolean,
 ) {
@@ -20,19 +20,19 @@ export async function deleteProject(
    }
    if (!autoConfirm) {
       const confirmation = await getConfirmation(
-         `Are you sure you that want to delete the ${projectName} project? This action cannot be undone.`,
+         `Are you sure you that want to delete the ${environmentName} environment? This action cannot be undone.`,
       );
       if (!confirmation) {
          logger.info("Operation cancelled.");
          return;
       }
    }
-   logger.info("Deleting project " + projectName);
+   logger.info("Deleting environment " + environmentName);
 
    try {
-      await projectsApi.deleteProject(
+      await environmentsApi.deleteEnvironment(
          clientConfig.getOrganization(),
-         projectName,
+         environmentName,
          {
             baseURL: controlPlane,
             headers: {
@@ -40,9 +40,9 @@ export async function deleteProject(
             },
          },
       );
-      logger.info("Project deleted successfully");
+      logger.info("Environment deleted successfully");
    } catch (e) {
-      logger.error("Failed to delete project");
+      logger.error("Failed to delete environment");
       printOutError(e, debug);
    }
 }