@credibledata/cred-cli 0.0.102 → 0.0.103

package/src/clientconfiguration.spec.ts

@@ -313,6 +313,74 @@ describe("ClientConfiguration", () => {
       expect(writeFileSyncStub.called).to.be.false;
    });
 
+   describe("recoverIfCorrupt", () => {
+      it("returns null and writes nothing when the config is already valid", () => {
+         readFileSyncStub.returns(
+            JSON.stringify({
+               configPerEnvironment: {},
+               activeEnvironment: "staging",
+            }),
+         );
+
+         expect(clientConfig.recoverIfCorrupt()).to.be.null;
+         expect(renameSyncStub.called).to.be.false;
+         // Valid config preserved — active environment untouched.
+         expect(clientConfig.getEnvironment()).to.equal("staging");
+      });
+
+      it("backs up an unparseable file and resets to defaults", () => {
+         readFileSyncStub.returns("{ not json");
+
+         const backupPath = clientConfig.recoverIfCorrupt();
+
+         expect(backupPath).to.match(
+            new RegExp(`${customConfigPath}\\.corrupt-[0-9a-f]{16}$`),
+         );
+         // Renamed aside, never deleted, so the bad file is recoverable.
+         expect(renameSyncStub.calledWith(customConfigPath, backupPath!)).to.be
+            .true;
+         expect(lastWrittenConfig()).to.deep.equal({
+            configPerEnvironment: fullPerEnv(),
+            activeEnvironment: "production",
+         });
+      });
+
+      it("backs up a structurally-invalid file and resets to defaults", () => {
+         readFileSyncStub.returns(JSON.stringify({ configPerEnvironment: {} }));
+
+         const backupPath = clientConfig.recoverIfCorrupt();
+
+         expect(backupPath).to.be.a("string");
+         expect(renameSyncStub.calledWith(customConfigPath, backupPath!)).to.be
+            .true;
+         expect(lastWrittenConfig().activeEnvironment).to.equal("production");
+      });
+
+      it("rethrows fs errors (e.g. EACCES) instead of masking them as a reset", () => {
+         // A permissions problem must surface — resetting would just fail to
+         // write anyway, and silently "recovering" would hide the real cause.
+         const eacces = Object.assign(new Error("EACCES"), { code: "EACCES" });
+         readFileSyncStub.throws(eacces);
+
+         expect(() => clientConfig.recoverIfCorrupt()).to.throw(/EACCES/);
+         expect(renameSyncStub.called).to.be.false;
+      });
+
+      it("creates a fresh default when the file is absent (ENOENT)", () => {
+         readFileSyncStub.throws(enoent());
+
+         // First-time setup is not corruption — nothing to back up. (The atomic
+         // write of the new default does call renameSync, but never to a
+         // `.corrupt-` backup path.)
+         expect(clientConfig.recoverIfCorrupt()).to.be.null;
+         expect(
+            renameSyncStub
+               .getCalls()
+               .some((c) => String(c.args[1]).includes(".corrupt-")),
+         ).to.be.false;
+      });
+   });
+
    describe("isTokenValid", () => {
       it("should return invalid when no token exists", () => {
          const mockConfig = {
@@ -468,6 +536,64 @@ describe("ClientConfiguration", () => {
             .true;
       });
 
+      it("should name the targeted cell when the 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: {},
+               staging: {},
+               localhost: {},
+               dev: {
+                  accessToken: fakeJwt,
+                  isServiceAccountToken: false,
+                  organization: "demo",
+                  project: "demo",
+               },
+            },
+            activeEnvironment: "dev",
+         };
+         readFileSyncStub.returns(JSON.stringify(mockConfig));
+
+         clientConfig.printStatus();
+
+         expect(loggerStub.info.calledWith(sinon.match("Cell:"))).to.be.true;
+         expect(loggerStub.info.calledWith(sinon.match("dev"))).to.be.true;
+         expect(
+            loggerStub.info.calledWith(
+               sinon.match("https://dev-admin.credibledata.com/api/v0"),
+            ),
+         ).to.be.true;
+      });
+
+      it("should name the targeted cell even when the token is invalid", () => {
+         const mockConfig = {
+            configPerEnvironment: {
+               production: {},
+               staging: {},
+               localhost: {},
+            },
+            activeEnvironment: "localhost",
+         };
+         readFileSyncStub.returns(JSON.stringify(mockConfig));
+
+         clientConfig.printStatus();
+
+         expect(loggerStub.info.calledWith(sinon.match("Cell:"))).to.be.true;
+         expect(
+            loggerStub.info.calledWith(
+               sinon.match("http://admin.ms2.localhost/api/v0"),
+            ),
+         ).to.be.true;
+      });
+
       it("should print error when token is invalid", () => {
          const mockConfig = {
             configPerEnvironment: {

package/src/clientconfiguration.ts

@@ -3,7 +3,12 @@ import fs from "fs";
 import { jwtDecode } from "jwt-decode";
 import kleur from "kleur";
 import os from "os";
-import { ALL_ENVIRONMENTS, ASCII_TITLE, Environment } from "./constants";
+import {
+   ALL_ENVIRONMENTS,
+   ASCII_TITLE,
+   controlPlanesByEnv,
+   Environment,
+} from "./constants";
 import { logger } from "./logger";
 
 interface ConfigFile {
@@ -34,6 +39,15 @@ interface JwtPayload {
    sub?: string;
 }
 
+/**
+ * Thrown when `.cred` exists but cannot be used: either it does not parse as
+ * JSON or it parses but lacks the required top-level shape. Distinct from fs
+ * errors (ENOENT, EACCES) so callers that want to recover — `cred login` —
+ * can target *only* a corrupt-content failure and leave permission/IO errors
+ * to surface loudly.
+ */
+export class InvalidConfigError extends Error {}
+
 export class ClientConfiguration {
    private configPath = `${os.homedir()}/.cred`;
    private config: ConfigFile;
@@ -65,13 +79,13 @@ export class ClientConfiguration {
          // can leave `.cred` unparseable. Fail loud rather than silently
          // overwriting — a silent reset erases the access token for every
          // subsequent caller on the same machine.
-         throw new Error(
+         throw new InvalidConfigError(
             `Failed to parse ${this.configPath}: ${error}. The file may be corrupt; re-run \`cred login\` to reset.`,
          );
       }
 
       if (!this.config.activeEnvironment || !this.config.configPerEnvironment) {
-         throw new Error(
+         throw new InvalidConfigError(
             `Invalid config structure in ${this.configPath}; re-run \`cred login\` to reset.`,
          );
       }
@@ -85,6 +99,46 @@ export class ClientConfiguration {
       return this.config;
    }
 
+   /**
+    * Ensure `.cred` is usable, recovering from a corrupt file if needed.
+    *
+    * `loadConfig` deliberately fails loud on a corrupt/invalid file so a read
+    * path never silently erases tokens. But `cred login` exists precisely to
+    * (re)establish config, so it must be able to get past a bad file — that is
+    * what the "re-run `cred login` to reset" message promises. We make the
+    * message true here: the bad file is renamed aside (never deleted, so a
+    * support engineer can still inspect it) and a fresh default is written.
+    *
+    * Only an {@link InvalidConfigError} triggers recovery. fs errors such as
+    * EACCES are real environment problems and are rethrown — resetting would
+    * just fail to write anyway, and we must not mask a permissions issue as a
+    * successful reset.
+    *
+    * @returns the path the corrupt file was backed up to, or null if the
+    *          existing config was already valid.
+    */
+   public recoverIfCorrupt(): string | null {
+      try {
+         this.loadConfig();
+         return null;
+      } catch (error) {
+         if (!(error instanceof InvalidConfigError)) {
+            throw error;
+         }
+         const backupPath = `${this.configPath}.corrupt-${crypto
+            .randomBytes(8)
+            .toString("hex")}`;
+         fs.renameSync(this.configPath, backupPath);
+         logger.warn(
+            `Existing config at ${this.configPath} was invalid and could not be read. ` +
+               `Backed it up to ${backupPath} and reset to defaults.`,
+         );
+         this.config = this.defaultConfig();
+         this.writeConfig();
+         return backupPath;
+      }
+   }
+
    private defaultConfig(): ConfigFile {
       const configPerEnvironment: ConfigFile["configPerEnvironment"] = {};
       for (const env of ALL_ENVIRONMENTS) {
@@ -286,12 +340,18 @@ export class ClientConfiguration {
    public printStatus() {
       this.loadConfig();
       const tokenStatus = this.isTokenValid();
+      const cell = this.getEnvironment();
+
+      // The cell prints on both branches, and before anything else: an org and an
+      // environment name alone do not identify a cell (two cells can both hold a
+      // `demo`), and a stale token is most often a token for the wrong one.
+      console.log(kleur.green(ASCII_TITLE));
+      logger.info(`Cell: ${kleur.green(cell)} (${controlPlanesByEnv[cell]})`);
 
       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(`Environment: ${kleur.green(project || "Not set")}`);
       } else {

package/src/commands/add.ts

@@ -7,6 +7,7 @@ import { createGroup } from "./group/creategroup";
 import { createGroupAccessToken } from "./groupaccesstoken/createToken";
 import { createEnvironment } from "./environment/createenvironment";
 import { warnProjectDeprecated } from "./legacy";
+import { createPermission } from "./permission/createpermission";
 
 export const registerAddCommands = (cli: Command, environment: Environment) => {
    const add = cli
@@ -125,6 +126,48 @@ export const registerAddCommands = (cli: Command, environment: Environment) => {
          );
       });
 
+   add.command("permission")
+      .description(
+         "Grant a user or group a permission on the organization, an environment, or a package.",
+      )
+      .argument(
+         "<userGroupId>",
+         "Who to grant it to [user:{email}|group:{groupName}|user:*]",
+      )
+      .argument(
+         "<role>",
+         "The role to grant (organization: admin|modeler|member; environment: admin|modeler|viewer; package: viewer)",
+      )
+      .option(
+         "--environment <environmentName>",
+         "Grant on this environment instead of the organization.",
+      )
+      .option(
+         "--package <packageName>",
+         "Grant on this package. Uses --environment, or the current environment.",
+      )
+      .option(
+         "--notifyPeople",
+         "Email the person about the new access. Applies to an environment or a package; an organization grant always notifies a user subject.",
+         false,
+      )
+      .option("--debug")
+      .option("-y, --yes", "Skip confirmation.")
+      .action((userGroupId, role, options) => {
+         createPermission(
+            controlPlanesByEnv[environment],
+            userGroupId,
+            role,
+            options.debug || false,
+            {
+               environment: options.environment,
+               package: options.package,
+               notifyPeople: options.notifyPeople === true,
+               yes: options.yes === true,
+            },
+         );
+      });
+
    add.command("group-access-token")
       .description("Create an access token for a group.")
       .argument("<groupName>", "The name of the group")

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

@@ -158,6 +158,173 @@ describe("update-environment", () => {
          });
       });
 
+      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 };

package/src/commands/environment/updateenvironment.ts

@@ -8,8 +8,60 @@ 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,
@@ -38,6 +90,21 @@ export async function updateEnvironment(
       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(
@@ -49,12 +116,17 @@ export async function updateEnvironment(
          }
       }
 
-      const environmentUpdate: Environment = {};
+      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,
@@ -72,6 +144,18 @@ export async function updateEnvironment(
                `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}`,