@credibledata/cred-cli 0.0.103 → 0.0.105

package/src/commands/environment/updateenvironment.spec.ts

@@ -1,386 +0,0 @@
-import { expect } from "chai";
-import sinon from "sinon";
-import { EnvironmentsApi } from "../../client/api";
-import { ClientConfiguration } from "../../clientconfiguration";
-import { logger } from "../../logger";
-import { updateEnvironment } from "./updateenvironment";
-
-describe("update-environment", () => {
-   let sandbox: sinon.SinonSandbox;
-   let updateEnvironmentStub: sinon.SinonStub;
-   let loggerStub: sinon.SinonStubbedInstance<typeof logger>;
-
-   beforeEach(() => {
-      sandbox = sinon.createSandbox();
-      updateEnvironmentStub = sandbox.stub();
-      loggerStub = sandbox.stub(logger);
-
-      // Mock ClientConfiguration constructor
-      sandbox
-         .stub(ClientConfiguration.prototype, "getOrganization")
-         .returns("test-org");
-      sandbox
-         .stub(ClientConfiguration.prototype, "doesConfigExists")
-         .returns(true);
-      sandbox
-         .stub(ClientConfiguration.prototype, "getHeaders")
-         .returns({ Authorization: "Bearer test-token" });
-
-      // Mock EnvironmentsApi constructor and method
-      sandbox
-         .stub(EnvironmentsApi.prototype, "updateEnvironment")
-         .callsFake(updateEnvironmentStub);
-   });
-
-   afterEach(() => {
-      sandbox.restore();
-   });
-
-   describe("updateEnvironment", () => {
-      it("should update environment successfully", async () => {
-         const mockResponse = { status: 200 };
-         updateEnvironmentStub.resolves(mockResponse);
-
-         await updateEnvironment(
-            "http://test-server",
-            "test-environment",
-            { replicationCount: 3 },
-            false,
-            true,
-         );
-
-         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(updateEnvironmentStub.firstCall.args[3]).to.deep.include({
-            baseURL: "http://test-server",
-            headers: { Authorization: "Bearer test-token" },
-         });
-         expect(
-            loggerStub.info.calledWith(
-               sinon.match("Successfully updated environment test-environment"),
-            ),
-         ).to.be.true;
-      });
-
-      it("should handle missing environment name", async () => {
-         await updateEnvironment(
-            "http://test-server",
-            "",
-            { replicationCount: 3 },
-            false,
-            true,
-         );
-
-         expect(updateEnvironmentStub.called).to.be.false;
-         expect(
-            loggerStub.error.calledWith(
-               sinon.match("Please provide an environment name"),
-            ),
-         ).to.be.true;
-      });
-
-      it("should handle API errors", async () => {
-         const mockError = new Error("API Error");
-         updateEnvironmentStub.rejects(mockError);
-
-         await updateEnvironment(
-            "http://test-server",
-            "test-environment",
-            { replicationCount: 3 },
-            true,
-            true,
-         );
-
-         expect(updateEnvironmentStub.calledOnce).to.be.true;
-         expect(
-            loggerStub.error.calledWith(
-               sinon.match("Failed to update environment test-environment"),
-            ),
-         ).to.be.true;
-      });
-
-      it("should handle non-200 response status", async () => {
-         const mockResponse = { status: 400 };
-         updateEnvironmentStub.resolves(mockResponse);
-
-         await updateEnvironment(
-            "http://test-server",
-            "test-environment",
-            { replicationCount: 3 },
-            false,
-            true,
-         );
-
-         expect(updateEnvironmentStub.calledOnce).to.be.true;
-         expect(
-            loggerStub.error.calledWith(
-               sinon.match("Failed to update environment. Status: 400"),
-            ),
-         ).to.be.true;
-      });
-   });
-
-   describe("validators", () => {
-      describe("authentication validation", () => {
-         it("should fail when user is not logged in", async () => {
-            sandbox.restore();
-            sandbox = sinon.createSandbox();
-            updateEnvironmentStub = sandbox.stub();
-            loggerStub = sandbox.stub(logger);
-
-            sandbox
-               .stub(ClientConfiguration.prototype, "doesConfigExists")
-               .returns(false);
-            sandbox
-               .stub(EnvironmentsApi.prototype, "updateEnvironment")
-               .callsFake(updateEnvironmentStub);
-
-            await updateEnvironment(
-               "http://test-server",
-               "test-environment",
-               { replicationCount: 3 },
-               false,
-               true,
-            );
-
-            expect(updateEnvironmentStub.called).to.be.false;
-            expect(
-               loggerStub.error.calledWith(
-                  sinon.match("Please, make sure that you are logged in"),
-               ),
-            ).to.be.true;
-         });
-      });
-
-      describe("git-backed modeling", () => {
-         it("sends the enrolment flag on its own", async () => {
-            updateEnvironmentStub.resolves({ status: 200 });
-
-            await updateEnvironment(
-               "http://test-server",
-               "test-environment",
-               { gitModeling: "true" },
-               false,
-               true,
-            );
-
-            expect(updateEnvironmentStub.calledOnce).to.be.true;
-            expect(updateEnvironmentStub.firstCall.args[2]).to.deep.equal({
-               gitModelingEnabled: true,
-            });
-         });
-
-         it("rejects a --git-modeling value that is neither true nor false", async () => {
-            await updateEnvironment(
-               "http://test-server",
-               "test-environment",
-               { gitModeling: "yes" },
-               false,
-               true,
-            );
-
-            expect(updateEnvironmentStub.called).to.be.false;
-            expect(
-               loggerStub.error.calledWith(
-                  sinon.match("--git-modeling must be true or false"),
-               ),
-            ).to.be.true;
-         });
-
-         it("sends all three coordinates together", async () => {
-            updateEnvironmentStub.resolves({ status: 200 });
-
-            await updateEnvironment(
-               "http://test-server",
-               "test-environment",
-               {
-                  gitRepositoryOwner: "credible-data-repos",
-                  gitRepositoryName: "models",
-                  gitBaseBranch: "main",
-               },
-               false,
-               true,
-            );
-
-            expect(updateEnvironmentStub.firstCall.args[2]).to.deep.equal({
-               gitRepositoryOwner: "credible-data-repos",
-               gitRepositoryName: "models",
-               gitBaseBranch: "main",
-            });
-         });
-
-         it("refuses a partial coordinate locally rather than sending a 400", async () => {
-            // The API rejects this as GIT_REPOSITORY_INCOMPLETE. Refusing here means a
-            // script gets the rule from the tool it is driving.
-            await updateEnvironment(
-               "http://test-server",
-               "test-environment",
-               { gitRepositoryOwner: "credible-data-repos" },
-               false,
-               true,
-            );
-
-            expect(updateEnvironmentStub.called).to.be.false;
-            expect(loggerStub.error.calledWith(sinon.match("change together")))
-               .to.be.true;
-         });
-
-         it("refuses a mix of set and cleared coordinates", async () => {
-            await updateEnvironment(
-               "http://test-server",
-               "test-environment",
-               {
-                  gitRepositoryOwner: "credible-data-repos",
-                  gitRepositoryName: "",
-                  gitBaseBranch: "main",
-               },
-               false,
-               true,
-            );
-
-            expect(updateEnvironmentStub.called).to.be.false;
-            expect(
-               loggerStub.error.calledWith(sinon.match("unset the repository")),
-            ).to.be.true;
-         });
-
-         it("sends nulls when all three are emptied, which is how a record is unset", async () => {
-            updateEnvironmentStub.resolves({ status: 200 });
-
-            await updateEnvironment(
-               "http://test-server",
-               "test-environment",
-               {
-                  gitRepositoryOwner: "",
-                  gitRepositoryName: "",
-                  gitBaseBranch: " ",
-               },
-               false,
-               true,
-            );
-
-            expect(updateEnvironmentStub.firstCall.args[2]).to.deep.equal({
-               gitRepositoryOwner: null,
-               gitRepositoryName: null,
-               gitBaseBranch: null,
-            });
-         });
-
-         it("carries the enrolment and the coordinates in one request", async () => {
-            updateEnvironmentStub.resolves({ status: 200 });
-
-            await updateEnvironment(
-               "http://test-server",
-               "test-environment",
-               {
-                  gitModeling: "true",
-                  gitRepositoryOwner: "credible-data-repos",
-                  gitRepositoryName: "models",
-                  gitBaseBranch: "main",
-               },
-               false,
-               true,
-            );
-
-            expect(updateEnvironmentStub.firstCall.args[2]).to.deep.equal({
-               gitModelingEnabled: true,
-               gitRepositoryOwner: "credible-data-repos",
-               gitRepositoryName: "models",
-               gitBaseBranch: "main",
-            });
-         });
-
-         it("reports a refusal from the server rather than claiming success", async () => {
-            updateEnvironmentStub.rejects(
-               Object.assign(new Error("Request failed with status code 400"), {
-                  response: {
-                     status: 400,
-                     data: { code: "GIT_REPOSITORY_NOT_REGISTERED" },
-                  },
-               }),
-            );
-
-            await updateEnvironment(
-               "http://test-server",
-               "test-environment",
-               { gitModeling: "true" },
-               false,
-               true,
-            );
-
-            expect(
-               loggerStub.error.calledWith(
-                  sinon.match("Failed to update environment test-environment"),
-               ),
-            ).to.be.true;
-            expect(
-               loggerStub.info.calledWith(sinon.match("Successfully updated")),
-            ).to.be.false;
-         });
-      });
-
-      describe("replication count validation", () => {
-         it("should accept valid replication counts", async () => {
-            const mockResponse = { status: 200 };
-            updateEnvironmentStub.resolves(mockResponse);
-
-            const validCounts = [1, 2, 5, 10, 100];
-
-            for (const count of validCounts) {
-               await updateEnvironment(
-                  "http://test-server",
-                  "test-environment",
-                  { replicationCount: count },
-                  false,
-                  true,
-               );
-               expect(updateEnvironmentStub.called).to.be.true;
-               expect(updateEnvironmentStub.firstCall.args[2]).to.include({
-                  replicationCount: count,
-               });
-               updateEnvironmentStub.reset();
-            }
-         });
-
-         it("should reject replication count less than 1", async () => {
-            await updateEnvironment(
-               "http://test-server",
-               "test-environment",
-               { replicationCount: 0 },
-               false,
-               true,
-            );
-
-            expect(updateEnvironmentStub.called).to.be.false;
-            expect(
-               loggerStub.error.calledWith(
-                  sinon.match("Replication count must be at least 1"),
-               ),
-            ).to.be.true;
-         });
-
-         it("should reject negative replication count", async () => {
-            await updateEnvironment(
-               "http://test-server",
-               "test-environment",
-               { replicationCount: -1 },
-               false,
-               true,
-            );
-
-            expect(updateEnvironmentStub.called).to.be.false;
-            expect(
-               loggerStub.error.calledWith(
-                  sinon.match("Replication count must be at least 1"),
-               ),
-            ).to.be.true;
-         });
-      });
-   });
-});

package/src/commands/environment/updateenvironment.ts

@@ -1,168 +0,0 @@
-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 environmentsApi = new EnvironmentsApi(new Configuration());
-
-type UpdateEnvironmentProperties = {
-   replicationCount?: number;
-   /** Raw `--git-modeling` value; parsed here so a typo is refused rather than sent. */
-   gitModeling?: string;
-   gitRepositoryOwner?: string;
-   gitRepositoryName?: string;
-   gitBaseBranch?: string;
-};
-
-/**
- * The three repository coordinates change as a unit, and the API rejects any other
- * shape (`GIT_REPOSITORY_INCOMPLETE`, `GIT_REPOSITORY_INCOHERENT`). Refused here too, so
- * a scripted caller gets the rule from the tool it is driving rather than from a 400.
- *
- * Returns the body fragment, or a message to print instead of sending anything.
- */
-function gitRepositoryRecord(
-   properties: UpdateEnvironmentProperties,
-): { changes: Partial<Environment> } | { error: string } {
-   const mentioned = [
-      properties.gitRepositoryOwner,
-      properties.gitRepositoryName,
-      properties.gitBaseBranch,
-   ].filter((value) => value !== undefined) as string[];
-
-   if (mentioned.length === 0) {
-      return { changes: {} };
-   }
-   if (mentioned.length !== 3) {
-      return {
-         error:
-            "--git-repository-owner, --git-repository-name and --git-base-branch change " +
-            "together. Pass all three, or none.",
-      };
-   }
-
-   const trimmed = mentioned.map((value) => value.trim());
-   const cleared = trimmed.filter((value) => value === "").length;
-   if (cleared !== 0 && cleared !== 3) {
-      return {
-         error:
-            "Set all three of --git-repository-owner, --git-repository-name and " +
-            '--git-base-branch, or pass "" for all three to unset the repository.',
-      };
-   }
-
-   const [owner, name, baseBranch] = trimmed;
-   return {
-      changes: {
-         gitRepositoryOwner: owner || null,
-         gitRepositoryName: name || null,
-         gitBaseBranch: baseBranch || null,
-      },
-   };
-}
-
-export async function updateEnvironment(
-   controlPlane: string,
-   environmentName: string,
-   properties: UpdateEnvironmentProperties,
-   debug?: boolean,
-   skipConfirmation?: boolean,
-) {
-   const clientConfig = new ClientConfiguration();
-   if (!clientConfig.doesConfigExists()) {
-      logger.error("Please, make sure that you are logged in");
-      return;
-   }
-
-   if (!environmentName) {
-      logger.error("Please provide an environment name");
-      return;
-   }
-
-   const organizationName = clientConfig.getOrganization();
-
-   if (
-      properties.replicationCount !== undefined &&
-      properties.replicationCount < 1
-   ) {
-      logger.error("Replication count must be at least 1");
-      return;
-   }
-
-   if (
-      properties.gitModeling !== undefined &&
-      properties.gitModeling !== "true" &&
-      properties.gitModeling !== "false"
-   ) {
-      logger.error("--git-modeling must be true or false");
-      return;
-   }
-
-   const repositoryRecord = gitRepositoryRecord(properties);
-   if ("error" in repositoryRecord) {
-      logger.error(repositoryRecord.error);
-      return;
-   }
-
-   try {
-      if (!skipConfirmation) {
-         const confirmation = await getConfirmation(
-            `Are you sure you want to update environment ${environmentName}?`,
-         );
-         if (!confirmation) {
-            logger.info("Operation cancelled.");
-            return;
-         }
-      }
-
-      const environmentUpdate: Environment = { ...repositoryRecord.changes };
-
-      if (properties.replicationCount !== undefined) {
-         environmentUpdate.replicationCount = properties.replicationCount;
-      }
-
-      if (properties.gitModeling !== undefined) {
-         environmentUpdate.gitModelingEnabled =
-            properties.gitModeling === "true";
-      }
-
-      const response = await environmentsApi.updateEnvironment(
-         organizationName,
-         environmentName,
-         environmentUpdate,
-         {
-            baseURL: controlPlane,
-            headers: clientConfig.getHeaders(),
-         },
-      );
-
-      if (response.status === 200) {
-         logger.info(`Successfully updated environment ${environmentName}`);
-         if (properties.replicationCount !== undefined) {
-            logger.info(
-               `Replication count set to ${properties.replicationCount}`,
-            );
-         }
-         if (properties.gitModeling !== undefined) {
-            logger.info(
-               `Git-backed modeling ${properties.gitModeling === "true" ? "enabled" : "disabled"}`,
-            );
-         }
-         if (environmentUpdate.gitRepositoryOwner !== undefined) {
-            logger.info(
-               environmentUpdate.gitRepositoryOwner
-                  ? `Repository set to ${environmentUpdate.gitRepositoryOwner}/${environmentUpdate.gitRepositoryName} (${environmentUpdate.gitBaseBranch})`
-                  : "Repository unset",
-            );
-         }
-      } else {
-         logger.error(
-            `Failed to update environment. Status: ${response.status}`,
-         );
-      }
-   } catch (e) {
-      logger.error(`Failed to update environment ${environmentName}`);
-      printOutError(e, debug);
-   }
-}

package/src/commands/get.ts

@@ -1,153 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { Command } from "commander";
-import { controlPlanesByEnv, Environment } from "../constants";
-import { getGroup } from "./group/getgroup";
-import { getEnvironment } from "./environment/getenvironment";
-import { getMaterialization } from "./materialization/getmaterialization";
-import { getIndex } from "./materialization/getindex";
-import { getPreaggregate } from "./materialization/getpreaggregate";
-import { getRun } from "./materialization/getrun";
-import { warnProjectDeprecated } from "./legacy";
-import { getPermission } from "./permission/getpermission";
-
-export const registerGetCommands = (cli: Command, environment: Environment) => {
-   const get = cli
-      .command("get")
-      .description("Get a resource")
-      .argument(
-         "<resource>",
-         "The resource to get (environment | group | permission | materialization | index | preaggregate | run)",
-      );
-
-   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("[deprecated] Alias for 'get environment'.")
-      .argument("<projectName>", "The name of the environment to get.")
-      .option("--debug")
-      .action((projectName, options) => {
-         warnProjectDeprecated("get environment");
-         getEnvironmentAction(projectName, options);
-      });
-
-   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);
-      });
-
-   get.command("permission")
-      .description(
-         "Get a user or group's permission on the organization, an environment, or a package.",
-      )
-      .argument(
-         "<userGroupId>",
-         "Whose permission to get [user:{email}|group:{groupName}|user:*]",
-      )
-      .option(
-         "--environment <environmentName>",
-         "Get the permission on this environment instead of the organization.",
-      )
-      .option(
-         "--package <packageName>",
-         "Get the permission on this package. Uses --environment, or the current environment.",
-      )
-      .option("--debug")
-      .action((userGroupId, options) => {
-         getPermission(
-            controlPlanesByEnv[environment],
-            userGroupId,
-            options.debug || false,
-            { environment: options.environment, package: options.package },
-         );
-      });
-
-   get.command("materialization")
-      .alias("mat")
-      .description(
-         "Get a materialization anchor by id (status, physical table + connection, serving build, freshness, staleness).",
-      )
-      .argument("<packageName>", "The package that owns the materialization.")
-      .argument("<versionId>", "The version that binds it (e.g. 0.1.21).")
-      .argument("<materializationId>", "The materialization id.")
-      .option("--debug")
-      .action((packageName, versionId, materializationId, options) => {
-         getMaterialization(
-            controlPlanesByEnv[environment],
-            packageName,
-            versionId,
-            materializationId,
-            options.debug,
-         );
-      });
-
-   get.command("index")
-      .description(
-         "Get a dimensional index anchor by id (status, row count, lastIndexedAt, freshness, staleness).",
-      )
-      .argument("<packageName>", "The package that owns the index.")
-      .argument("<versionId>", "The version that binds it (e.g. 0.1.21).")
-      .argument("<indexId>", "The index (binding) id.")
-      .option("--debug")
-      .action((packageName, versionId, indexId, options) => {
-         getIndex(
-            controlPlanesByEnv[environment],
-            packageName,
-            versionId,
-            indexId,
-            options.debug,
-         );
-      });
-
-   get.command("preaggregate")
-      .alias("preagg")
-      .description(
-         "Get a pre-aggregated measure by id (status, grain, row count, lastBuiltAt, freshness, staleness).",
-      )
-      .argument("<packageName>", "The package that owns the pre-aggregation.")
-      .argument("<versionId>", "The version that binds it (e.g. 0.1.21).")
-      .argument(
-         "<preaggregateId>",
-         "The pre-aggregation id, as printed by `cred ls preaggregate`. It addresses a measure within a rollup — do not construct one by hand.",
-      )
-      .option("--debug")
-      .action((packageName, versionId, preaggregateId, options) => {
-         getPreaggregate(
-            controlPlanesByEnv[environment],
-            packageName,
-            versionId,
-            preaggregateId,
-            options.debug,
-         );
-      });
-
-   get.command("run")
-      .description(
-         "Get a run by id, including its build-plan graph (per-unit state, physical table names, row counts).",
-      )
-      .argument("<packageName>", "The package that owns the run.")
-      .argument("<runId>", "The run id.")
-      .option("--debug")
-      .action((packageName, runId, options) => {
-         getRun(
-            controlPlanesByEnv[environment],
-            packageName,
-            runId,
-            options.debug,
-         );
-      });
-};