@credibledata/cred-cli 0.0.6

package/src/commands/version/listversions.spec.ts

@@ -0,0 +1,138 @@
+import { expect } from "chai";
+import sinon from "sinon";
+import { VersionsApi } from "../../client/api";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import { prettifyJson } from "../../utils";
+import { listVersions } from "./listversions";
+
+describe("list-versions", () => {
+   let sandbox: sinon.SinonSandbox;
+   let listVersionsStub: sinon.SinonStub;
+   let loggerStub: sinon.SinonStubbedInstance<typeof logger>;
+   let consoleLogStub: sinon.SinonStub;
+
+   beforeEach(() => {
+      sandbox = sinon.createSandbox();
+      listVersionsStub = sandbox.stub();
+      loggerStub = sandbox.stub(logger);
+      consoleLogStub = sandbox.stub(console, "log");
+
+      sandbox
+         .stub(ClientConfiguration.prototype, "getOrganization")
+         .returns("test-org");
+      sandbox
+         .stub(ClientConfiguration.prototype, "getProject")
+         .returns("test-project");
+      sandbox
+         .stub(ClientConfiguration.prototype, "doesConfigExists")
+         .returns(true);
+      sandbox
+         .stub(ClientConfiguration.prototype, "getHeaders")
+         .returns({ Authorization: "Bearer test-token" });
+
+      sandbox
+         .stub(VersionsApi.prototype, "listVersions")
+         .callsFake(listVersionsStub);
+   });
+
+   afterEach(() => {
+      sandbox.restore();
+   });
+
+   it("should list versions successfully", async () => {
+      const mockVersions = [
+         { id: "1.0.0", archiveStatus: "active" },
+         { id: "2.0.0", archiveStatus: "active" },
+      ];
+      const mockResponse = {
+         data: mockVersions,
+      };
+      listVersionsStub.resolves(mockResponse);
+
+      await listVersions("http://test-server", "/test-package", false);
+
+      expect(listVersionsStub.calledOnce).to.be.true;
+      expect(listVersionsStub.firstCall.args[0]).to.equal("test-org");
+      expect(listVersionsStub.firstCall.args[1]).to.equal("test-project");
+      expect(listVersionsStub.firstCall.args[2]).to.equal("test-package");
+      expect(listVersionsStub.firstCall.args[3]).to.deep.include({
+         baseURL: "http://test-server",
+         headers: { Authorization: "Bearer test-token" },
+      });
+      expect(consoleLogStub.calledWith(prettifyJson(mockVersions))).to.be.true;
+   });
+
+   it("should handle package path without leading slash", async () => {
+      const mockVersions = [{ id: "1.0.0" }];
+      const mockResponse = {
+         data: mockVersions,
+      };
+      listVersionsStub.resolves(mockResponse);
+
+      await listVersions("http://test-server", "test-package", false);
+
+      expect(listVersionsStub.firstCall.args[2]).to.equal("test-package");
+   });
+
+   it("should handle missing config", async () => {
+      sandbox.restore();
+      sandbox = sinon.createSandbox();
+      listVersionsStub = sandbox.stub();
+      loggerStub = sandbox.stub(logger);
+      consoleLogStub = sandbox.stub(console, "log");
+
+      sandbox
+         .stub(ClientConfiguration.prototype, "doesConfigExists")
+         .returns(false);
+      sandbox
+         .stub(VersionsApi.prototype, "listVersions")
+         .callsFake(listVersionsStub);
+
+      await listVersions("http://test-server", "/test-package", false);
+
+      expect(listVersionsStub.called).to.be.false;
+      expect(
+         loggerStub.error.calledWith(
+            sinon.match("Please, make sure that you are logged in"),
+         ),
+      ).to.be.true;
+   });
+
+   it("should handle missing project", async () => {
+      sandbox.restore();
+      sandbox = sinon.createSandbox();
+      listVersionsStub = sandbox.stub();
+      loggerStub = sandbox.stub(logger);
+      consoleLogStub = sandbox.stub(console, "log");
+
+      sandbox
+         .stub(ClientConfiguration.prototype, "doesConfigExists")
+         .returns(true);
+      sandbox.stub(ClientConfiguration.prototype, "getProject").returns("");
+      sandbox
+         .stub(VersionsApi.prototype, "listVersions")
+         .callsFake(listVersionsStub);
+
+      await listVersions("http://test-server", "/test-package", false);
+
+      expect(listVersionsStub.called).to.be.false;
+      expect(
+         loggerStub.error.calledWith(
+            sinon.match("Please, make sure to set a project"),
+         ),
+      ).to.be.true;
+   });
+
+   it("should handle API errors", async () => {
+      const mockError = new Error("API Error");
+      listVersionsStub.rejects(mockError);
+
+      await listVersions("http://test-server", "/test-package", true);
+
+      expect(listVersionsStub.calledOnce).to.be.true;
+      expect(
+         loggerStub.error.calledWith(sinon.match("Failed to list versions")),
+      ).to.be.true;
+   });
+});

package/src/commands/version/listversions.ts

@@ -0,0 +1,45 @@
+import { VersionsApi } from "../../client/api";
+import { Configuration } from "../../client/configuration";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import { prettifyJson, printOutError } from "../../utils";
+
+const versionsApi = new VersionsApi(new Configuration());
+
+export async function listVersions(
+   controlPlane: string,
+   packagePath: string,
+   debug: boolean,
+) {
+   const clientConfig = new ClientConfiguration();
+   const organizationName = clientConfig.getOrganization();
+   const projectName = 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");
+      return;
+   }
+
+   try {
+      const packageName = packagePath.replace("/", "");
+      const response = await versionsApi.listVersions(
+         organizationName,
+         projectName,
+         packageName,
+         {
+            baseURL: controlPlane,
+            headers: clientConfig.getHeaders(),
+         },
+      );
+
+      console.log(prettifyJson(response.data));
+   } catch (e) {
+      logger.error("Failed to list versions");
+      printOutError(e, debug);
+   }
+}

package/src/common/UserGroupId.spec.ts

@@ -0,0 +1,117 @@
+import { expect } from "chai";
+import { ResourceType, UserGroupId } from "./UserGroupId";
+
+describe("UserGroupId", () => {
+   describe("constructor", () => {
+      it("should parse a valid user id", () => {
+         const id = new UserGroupId("user:john");
+         expect(id.getResourceType()).to.equal(ResourceType.USER);
+         expect(id.getResourceName()).to.equal("john");
+         expect(id.getValue()).to.equal("user:john");
+      });
+
+      it("should parse a valid group id", () => {
+         const id = new UserGroupId("group:admins");
+         expect(id.getResourceType()).to.equal(ResourceType.GROUP);
+         expect(id.getResourceName()).to.equal("admins");
+         expect(id.getValue()).to.equal("group:admins");
+      });
+
+      it("should trim whitespace from input", () => {
+         const id = new UserGroupId("  user:john  ");
+         expect(id.getValue()).to.equal("user:john");
+         expect(id.getResourceName()).to.equal("john");
+      });
+
+      it("should throw for null or empty input", () => {
+         expect(() => new UserGroupId("")).to.throw("cannot be null or empty");
+         expect(() => new UserGroupId("   ")).to.throw(
+            "cannot be null or empty",
+         );
+      });
+
+      it("should throw for invalid format", () => {
+         expect(() => new UserGroupId("invalid")).to.throw(
+            "Invalid UserGroupId format",
+         );
+         expect(() => new UserGroupId("user:")).to.throw(
+            "Invalid UserGroupId format",
+         );
+         expect(() => new UserGroupId("foo:bar")).to.throw(
+            "Invalid UserGroupId format",
+         );
+         expect(() => new UserGroupId("user:a:b")).to.throw(
+            "Invalid UserGroupId format",
+         );
+      });
+   });
+
+   describe("static factory methods", () => {
+      it("forPublicAccess should create user:* id", () => {
+         const id = UserGroupId.forPublicAccess();
+         expect(id.getResourceType()).to.equal(ResourceType.USER);
+         expect(id.getResourceName()).to.equal("*");
+         expect(id.getValue()).to.equal("user:*");
+      });
+
+      it("forUser should create a user id", () => {
+         const id = UserGroupId.forUser("alice");
+         expect(id.getResourceType()).to.equal(ResourceType.USER);
+         expect(id.getResourceName()).to.equal("alice");
+      });
+
+      it("forUser should throw for undefined user name", () => {
+         expect(() => UserGroupId.forUser(undefined)).to.throw(
+            "cannot be undefined",
+         );
+      });
+
+      it("forGroup should create a group id", () => {
+         const id = UserGroupId.forGroup("developers");
+         expect(id.getResourceType()).to.equal(ResourceType.GROUP);
+         expect(id.getResourceName()).to.equal("developers");
+      });
+
+      it("create should build from ResourceType and name", () => {
+         const userId = UserGroupId.create(ResourceType.USER, "bob");
+         expect(userId.getResourceType()).to.equal(ResourceType.USER);
+         expect(userId.getResourceName()).to.equal("bob");
+
+         const groupId = UserGroupId.create(ResourceType.GROUP, "team");
+         expect(groupId.getResourceType()).to.equal(ResourceType.GROUP);
+         expect(groupId.getResourceName()).to.equal("team");
+      });
+   });
+
+   describe("serialization", () => {
+      it("toString should return original value", () => {
+         const id = new UserGroupId("user:john");
+         expect(id.toString()).to.equal("user:john");
+      });
+
+      it("toJSON should return original value for JSON serialization", () => {
+         const id = new UserGroupId("group:admins");
+         expect(id.toJSON()).to.equal("group:admins");
+         expect(JSON.stringify(id)).to.equal('"group:admins"');
+      });
+   });
+
+   describe("isPublicAccess", () => {
+      it("should return false for regular user ids", () => {
+         const id = new UserGroupId("user:john");
+         expect(id.isPublicAccess()).to.be.false;
+      });
+
+      it("should return false for group ids", () => {
+         const id = new UserGroupId("group:admins");
+         expect(id.isPublicAccess()).to.be.false;
+      });
+
+      it("should return false for user:* (checks originalValue not resourceName)", () => {
+         // isPublicAccess checks this.originalValue === "*" which is never true
+         // since originalValue is the full string "user:*"
+         const id = UserGroupId.forPublicAccess();
+         expect(id.isPublicAccess()).to.be.false;
+      });
+   });
+});

package/src/common/UserGroupId.ts

@@ -0,0 +1,137 @@
+/**
+ * Enum representing the different types of user/group resources.
+ */
+export enum ResourceType {
+   USER = "USER",
+   GROUP = "GROUP",
+}
+
+/**
+ * Represents a user or group identifier in the format 'user:userId' or 'group:groupId'.
+ * This class parses the input string and provides methods to extract the
+ * resource type and name.
+ */
+export class UserGroupId {
+   private readonly resourceType: ResourceType;
+   private readonly resourceName: string;
+   private readonly originalValue: string;
+
+   static forPublicAccess(): UserGroupId {
+      return new UserGroupId(`user:*`);
+   }
+
+   static forUser(userName: string | undefined): UserGroupId {
+      if (!userName) {
+         throw new Error("User name cannot be undefined");
+      }
+      return new UserGroupId(`user:${userName}`);
+   }
+
+   static forGroup(groupName: string): UserGroupId {
+      return new UserGroupId(`group:${groupName}`);
+   }
+   /**
+    * Creates a UserGroupId from a string in the format 'user:userId' or 'group:groupId'.
+    *
+    * @param value the string to parse
+    * @throws BadRequestException if the format is invalid
+    */
+   constructor(value: string) {
+      if (!value || value.trim().length === 0) {
+         throw new Error("UserGroupId cannot be null or empty");
+      }
+
+      this.originalValue = value.trim();
+
+      if (!this.originalValue.match(/^(user:[^:]+|group:[^:]+)$/)) {
+         throw new Error(
+            `Invalid UserGroupId format. Expected 'user:userId' or 'group:groupId', got: ${this.originalValue}`,
+         );
+      }
+
+      const parts = this.originalValue.split(":", 2);
+      const typeStr = parts[0];
+      const name = parts[1];
+
+      if (!name || name.length === 0) {
+         throw new Error(
+            `UserGroupId name cannot be empty. Expected 'user:userId' or 'group:groupId', got: ${this.originalValue}`,
+         );
+      }
+
+      switch (typeStr) {
+         case "user":
+            this.resourceType = ResourceType.USER;
+            break;
+         case "group":
+            this.resourceType = ResourceType.GROUP;
+            break;
+         default:
+            throw new Error(
+               `Invalid UserGroupId type. Expected 'user' or 'group', got: ${typeStr}`,
+            );
+      }
+
+      this.resourceName = name;
+   }
+
+   /**
+    * Creates a UserGroupId from resource type and name.
+    *
+    * @param resourceType the resource type
+    * @param userName the user or group name
+    */
+   public static create(
+      resourceType: ResourceType,
+      userName: string,
+   ): UserGroupId {
+      return new UserGroupId(`${resourceType.toLowerCase()}:${userName}`);
+   }
+
+   /**
+    * Returns the resource type (USER or GROUP).
+    *
+    * @return the resource type
+    */
+   public getResourceType(): ResourceType {
+      return this.resourceType;
+   }
+
+   /**
+    * Returns the resource name (the part after the colon).
+    *
+    * @return the resource name
+    */
+   public getResourceName(): string {
+      return this.resourceName;
+   }
+
+   /**
+    * Returns the original string value.
+    *
+    * @return the original string value
+    */
+   public getValue(): string {
+      return this.originalValue;
+   }
+
+   public toString(): string {
+      return this.originalValue;
+   }
+
+   /**
+    * Custom JSON serialization method for axios/openapi.
+    * This ensures UserGroupId is serialized as a string (originalValue) instead of an object.
+    *
+    * @return the original string value for JSON serialization
+    */
+   public toJSON(): string {
+      return this.originalValue;
+   }
+
+   public isPublicAccess(): boolean {
+      return (
+         this.resourceType === ResourceType.USER && this.originalValue === "*"
+      );
+   }
+}

package/src/constants.ts

@@ -0,0 +1,116 @@
+export type Environment =
+   | "production"
+   | "staging"
+   | "dev"
+   | "localhost"
+   | "e2e-test"
+   | "videoamp";
+
+export const controlPlanesByEnv: Record<Environment, string> = {
+   production: "https://admin.credibledata.com/api/v0",
+   dev: "https://dev-admin.credibledata.com/api/v0",
+   staging: "https://staging-admin.credibledata.com/api/v0",
+   localhost: "http://admin.ms2.localhost/api/v0",
+   "e2e-test": "http://admin.ms2.localhost/api/v0",
+   videoamp: "https://admin.videoamp-aws-us-east-1.credibledata.com/api/v0",
+};
+
+/** Environments that must have an object in `~/.cred` `configPerEnvironment` (avoids undefined on write). */
+export const ALL_ENVIRONMENTS = Object.keys(
+   controlPlanesByEnv,
+) as Environment[];
+
+export const auth0ConfigsByEnv: Record<
+   Environment,
+   {
+      domain: string;
+      clientId: string;
+      clientSecret?: string;
+      audience: string;
+   }
+> = {
+   production: {
+      domain: "https://auth.credibledata.com",
+      clientId: "ge8JL5TJNwqy7bygAaJkD92KdluqEZgO",
+      audience: "https://ms2data.us.auth0.com/api/v2/",
+   },
+   dev: {
+      domain: "https://dev-auth.credibledata.com",
+      clientId: "rr6mzJNj9b104MjCc9xWKPPehq1MJx0L",
+      audience: "https://dev-ohaafogw5p8uyx1m.us.auth0.com/api/v2/",
+   },
+   staging: {
+      domain: "https://dev-auth.credibledata.com",
+      clientId: "rr6mzJNj9b104MjCc9xWKPPehq1MJx0L",
+      audience: "https://dev-ohaafogw5p8uyx1m.us.auth0.com/api/v2/",
+   },
+   localhost: {
+      domain: "https://dev-auth.credibledata.com",
+      clientId: "rr6mzJNj9b104MjCc9xWKPPehq1MJx0L",
+      audience: "https://dev-ohaafogw5p8uyx1m.us.auth0.com/api/v2/",
+   },
+   "e2e-test": {
+      domain: "https://dev-auth.credibledata.com",
+      clientId: "atd8n8dEiGUiNRM7Geuvg41fi5s8ZKqY",
+      clientSecret:
+         "ZrEvs86WLqKO9EPp4y_cOvUn3NQT1qc3XC8111f6DBt9oyaclV5sWHz6Nkyo_bEF",
+      audience: "https://dev-ohaafogw5p8uyx1m.us.auth0.com/api/v2/",
+   },
+   videoamp: {
+      domain: "https://auth.credibledata.com",
+      clientId: "ge8JL5TJNwqy7bygAaJkD92KdluqEZgO",
+      audience: "https://ms2data.us.auth0.com/api/v2/",
+   },
+};
+
+/**
+ * `cred login <organizationName>` → Auth0 Organization ID for org-branded Universal Login.
+ *
+ * Auth0 documents the `organization` parameter on `/authorize` for Organizations
+ * (https://auth0.com/docs/manage-users/organizations/configure-organizations/use-org-name-authentication-api).
+ * The Device Authorization Flow documents only `client_id`, `scope`, and `audience` on
+ * `POST /oauth/device/code` — not `organization`
+ * (https://auth0.com/docs/get-started/authentication-and-authorization-flow/device-authorization-flow/call-your-api-using-the-device-authorization-flow#device-code-parameters),
+ * so mapped orgs use Authorization Code + PKCE with `organization` on `/authorize` and
+ * {@link AUTH_CLI_LOOPBACK_REDIRECT_URI}.
+ *
+ * Align with app `ORGANIZATION_HOST_ORG_ID_MAP` / `getAuth0OrganizationAuthorizationParams`.
+ *
+ * Entries are added when PKCE + Auth0 org id is ready for that CLI name; until then the map may
+ * stay empty and `login.spec` stubs {@link getAuth0OrganizationIdForCliLogin} for PKCE coverage.
+ */
+export const AUTH0_ORGANIZATION_IDS_BY_CLI_ORG_NAME: Record<string, string> = {
+   // videoamp: "org_nMRKafeSuxOiuJeG",
+};
+
+/**
+ * Allowlisted on the Auth0 Native application (CLI) as an Allowed Callback URL for PKCE logins
+ * that pass `organization` on `/authorize` (see Auth0 Organizations + Authentication API docs above).
+ */
+export const AUTH_CLI_LOOPBACK_REDIRECT_URI = "http://127.0.0.1:18240/callback";
+
+export function getAuth0OrganizationIdForCliLogin(
+   organizationName: string,
+): string | undefined {
+   return AUTH0_ORGANIZATION_IDS_BY_CLI_ORG_NAME[
+      organizationName.toLowerCase()
+   ];
+}
+
+// Time constants in ms
+export const SECOND = 1000;
+export const MINUTE = SECOND * 60;
+export const HOUR = MINUTE * 60;
+export const DAY = HOUR * 24;
+
+// Login related
+export const LOGIN_TIMEOUT_MS = MINUTE * 5;
+
+export const ASCII_TITLE = `
+   _____              _ _ _     _         _____ _      _____
+  / ____|            | (_) |   | |       / ____| |    |_   _|
+ | |     _ __ ___  __| |_| |__ | | ___  | |    | |      | |
+ | |    | '__/ _ \\/ _\` | | '_ \\| |/ _ \\ | |    | |      | |
+ | |____| | |  __/ (_| | | |_) | |  __/ | |____| |____ _| |_
+  \\_____|_|  \\___|\\__,_|_|_.__/|_|\\___|  \\_____|______|_____|
+`;