@credibledata/cred-cli 0.1.4 → 0.1.5

package/src/commands/groupaccesstoken/listTokens.spec.ts

@@ -0,0 +1,147 @@
+import { expect } from "chai";
+import sinon from "sinon";
+import { GroupsApi } from "../../client/api";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import { listGroupAccessTokens } from "./listTokens";
+
+describe("list-group-access-tokens", () => {
+   let sandbox: sinon.SinonSandbox;
+   let listGroupAccessTokensStub: sinon.SinonStub;
+   let loggerStub: sinon.SinonStubbedInstance<typeof logger>;
+   let consoleLogStub: sinon.SinonStub;
+   let processExitStub: sinon.SinonStub;
+
+   beforeEach(() => {
+      sandbox = sinon.createSandbox();
+      listGroupAccessTokensStub = sandbox.stub();
+      loggerStub = sandbox.stub(logger);
+      consoleLogStub = sandbox.stub(console, "log");
+      processExitStub = sandbox.stub(process, "exit");
+
+      sandbox
+         .stub(ClientConfiguration.prototype, "getOrganization")
+         .returns("test-org");
+      sandbox
+         .stub(ClientConfiguration.prototype, "doesConfigExists")
+         .returns(true);
+      sandbox
+         .stub(ClientConfiguration.prototype, "getAuthenticationHeader")
+         .returns("Bearer test-token");
+
+      sandbox
+         .stub(GroupsApi.prototype, "listGroupAccessTokens")
+         .callsFake(listGroupAccessTokensStub);
+   });
+
+   afterEach(() => {
+      sandbox.restore();
+   });
+
+   it("should list group access tokens successfully", async () => {
+      const mockTokens = [
+         { tokenName: "token1", createdAt: "2024-01-01" },
+         { tokenName: "token2", createdAt: "2024-01-02" },
+      ];
+      const mockResponse = {
+         data: mockTokens,
+      };
+      listGroupAccessTokensStub.resolves(mockResponse);
+
+      const result = await listGroupAccessTokens(
+         "http://test-server",
+         "test-group",
+         false,
+      );
+
+      expect(listGroupAccessTokensStub.calledOnce).to.be.true;
+      expect(listGroupAccessTokensStub.firstCall.args[0]).to.equal("test-org");
+      expect(listGroupAccessTokensStub.firstCall.args[1]).to.equal(
+         "test-group",
+      );
+      expect(consoleLogStub.called).to.be.true;
+      expect(
+         loggerStub.info.calledWith(
+            sinon.match("Group access tokens listed successfully"),
+         ),
+      ).to.be.true;
+      expect(result).to.deep.equal(mockTokens);
+   });
+
+   it("should handle missing config", async () => {
+      sandbox.restore();
+      sandbox = sinon.createSandbox();
+      listGroupAccessTokensStub = sandbox.stub();
+      loggerStub = sandbox.stub(logger);
+      consoleLogStub = sandbox.stub(console, "log");
+      processExitStub = sandbox.stub(process, "exit");
+
+      sandbox
+         .stub(ClientConfiguration.prototype, "doesConfigExists")
+         .returns(false);
+      sandbox
+         .stub(GroupsApi.prototype, "listGroupAccessTokens")
+         .callsFake(listGroupAccessTokensStub);
+
+      const result = await listGroupAccessTokens(
+         "http://test-server",
+         "test-group",
+         false,
+      );
+
+      expect(listGroupAccessTokensStub.called).to.be.false;
+      expect(result).to.be.undefined;
+      expect(
+         loggerStub.error.calledWith(
+            sinon.match("Please, make sure that you are logged in"),
+         ),
+      ).to.be.true;
+   });
+
+   it("should handle missing organization", async () => {
+      sandbox.restore();
+      sandbox = sinon.createSandbox();
+      listGroupAccessTokensStub = sandbox.stub();
+      loggerStub = sandbox.stub(logger);
+      consoleLogStub = sandbox.stub(console, "log");
+      processExitStub = sandbox.stub(process, "exit");
+
+      sandbox
+         .stub(ClientConfiguration.prototype, "doesConfigExists")
+         .returns(true);
+      sandbox
+         .stub(ClientConfiguration.prototype, "getOrganization")
+         .returns(undefined);
+      sandbox
+         .stub(GroupsApi.prototype, "listGroupAccessTokens")
+         .callsFake(listGroupAccessTokensStub);
+
+      const result = await listGroupAccessTokens(
+         "http://test-server",
+         "test-group",
+         false,
+      );
+
+      expect(listGroupAccessTokensStub.called).to.be.false;
+      expect(result).to.be.undefined;
+      expect(
+         loggerStub.error.calledWith(
+            sinon.match(
+               "No organization set. Please login or set an organization.",
+            ),
+         ),
+      ).to.be.true;
+   });
+
+   it("should handle API errors", async () => {
+      const mockError = new Error("API Error");
+      listGroupAccessTokensStub.rejects(mockError);
+
+      await listGroupAccessTokens("http://test-server", "test-group", true);
+
+      expect(listGroupAccessTokensStub.calledOnce).to.be.true;
+      expect(loggerStub.error.calledWith(sinon.match("Operation failed"))).to.be
+         .true;
+      expect(processExitStub.calledWith(1)).to.be.true;
+   });
+});

package/src/commands/groupaccesstoken/listTokens.ts

@@ -2,23 +2,28 @@ import { logger } from "../../logger";
 import { withGroupContext } from "./groupContainer";
 
 export async function listGroupAccessTokens(
-    controlPlane: string,
-    groupName: string,
-    debug: boolean,
+   controlPlane: string,
+   groupName: string,
+   debug: boolean,
 ) {
-    return withGroupContext(controlPlane, async (context) => {
-        const { organizationName, groupsApi, options } = context;
+   return withGroupContext(
+      controlPlane,
+      async (context) => {
+         const { organizationName, groupsApi, options } = context;
 
-        logger.info(
+         logger.info(
             `Listing access tokens for group ${groupName} in organization ${organizationName}`,
-        );
+         );
 
-        const response = await groupsApi.listGroupAccessTokens(
+         const response = await groupsApi.listGroupAccessTokens(
             organizationName,
             groupName,
             options,
-        );
+         );
 
-        return response.data;
-    }, "Group access tokens listed successfully", debug);
+         return response.data;
+      },
+      "Group access tokens listed successfully",
+      debug,
+   );
 }

package/src/commands/list.ts

@@ -1,5 +1,6 @@
 import { Command } from "commander";
 import { controlPlanesByEnv, Environment } from "../constants";
+import { DEFAULT_PAGE_SIZE, DEFAULT_PAGE } from "../utils";
 import { listConnections } from "./connection/listconnections";
 import { printOutGroups } from "./group/listgroups";
 import { listGroupAccessTokens } from "./groupaccesstoken/listTokens";
@@ -21,8 +22,23 @@ export const registerListCommands = (
       .alias("projects")
       .description("List all projects.")
       .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((options) => {
-         printOutProjects(controlPlanesByEnv[environment], options.debug);
+         printOutProjects(
+            controlPlanesByEnv[environment],
+            options.debug,
+            options.page,
+            options.pageSize,
+         );
       });
 
    list
@@ -30,8 +46,23 @@ export const registerListCommands = (
       .alias("connections")
       .description("List all connections.")
       .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((options) => {
-         listConnections(controlPlanesByEnv[environment], options.debug);
+         listConnections(
+            controlPlanesByEnv[environment],
+            options.debug,
+            options.page,
+            options.pageSize,
+         );
       });
 
    list
@@ -39,8 +70,23 @@ export const registerListCommands = (
       .alias("packages")
       .description("List the packages in the active project.")
       .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((options) => {
-         printOutPackages(controlPlanesByEnv[environment], options.debug);
+         printOutPackages(
+            controlPlanesByEnv[environment],
+            options.debug,
+            options.page,
+            options.pageSize,
+         );
       });
 
    list
@@ -69,15 +115,11 @@ export const registerListCommands = (
          printOutGroups(controlPlanesByEnv[environment], options.debug);
       });
 
-
    list
       .command("group-access-token")
       .alias("group-access-tokens")
       .description("List all access tokens for a group.")
-      .argument(
-         "<groupName>",
-         "The name of the group",
-      )
+      .argument("<groupName>", "The name of the group")
       .option("--debug")
       .action((groupName, options) => {
          listGroupAccessTokens(
@@ -86,5 +128,4 @@ export const registerListCommands = (
             options.debug,
          );
       });
-
 };

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

@@ -4,8 +4,11 @@ import fs from "fs";
 import os from "os";
 import { join } from "path";
 import sinon from "sinon";
+import * as credConstants from "../../constants";
 import { ClientConfiguration } from "../../clientconfiguration";
 import { login } from "./login";
+import { OrganizationsApi } from "../../client/api";
+import * as loopbackOAuth from "./loopbackOAuth";
 
 function createFakeIdToken(payload: Record<string, unknown>): string {
    const header = Buffer.from(
@@ -18,6 +21,8 @@ function createFakeIdToken(payload: Record<string, unknown>): string {
 describe("login", () => {
    let tmpConfigFilePath: string;
    let axiosStub: sinon.SinonStub;
+   let orgPermissionsStub: sinon.SinonStub;
+
    const mockDeviceCodeResponse = {
       data: {
          verification_uri_complete: "https://example.com",
@@ -40,15 +45,23 @@ describe("login", () => {
       },
    };
 
+   const mockOrgPermissionsResponse = {
+      status: 200,
+      data: {},
+   };
+
    beforeEach(() => {
       tmpConfigFilePath = join(os.tmpdir(), "cred.json");
       fs.writeFileSync(tmpConfigFilePath, "{}");
       axiosStub = sinon.stub(axios, "request");
+      orgPermissionsStub = sinon
+         .stub(OrganizationsApi.prototype, "getOrganization")
+         .resolves(mockOrgPermissionsResponse as any);
    });
 
    afterEach(() => {
       fs.rmSync(tmpConfigFilePath);
-      axiosStub.restore();
+      sinon.restore();
    });
 
    it("should not delete config properties on login", async function () {
@@ -62,7 +75,7 @@ describe("login", () => {
          .resolves(mockDeviceCodeResponse)
          .onSecondCall()
          .resolves(mockedAccessTokenResponse);
-      await login("foo", tmpConfigFilePath);
+      await login("foo", "http://localhost", tmpConfigFilePath);
       expect(config.getOrganization()).to.equal("foo");
       expect(config.getProject()).to.equal("bar");
    });
@@ -78,7 +91,7 @@ describe("login", () => {
       config.setEnvironment("localhost");
       config.setOrganization("foo");
       config.setProject("bar");
-      await login("test", tmpConfigFilePath);
+      await login("test", "http://localhost", tmpConfigFilePath);
       expect(config.getOrganization()).to.equal("test");
    });
 
@@ -90,7 +103,8 @@ describe("login", () => {
          .onSecondCall()
          .resolves(mockedAccessTokenResponse);
       const config = new ClientConfiguration(tmpConfigFilePath);
-      await login("test", tmpConfigFilePath);
+      config.setEnvironment("localhost");
+      await login("test", "http://localhost", tmpConfigFilePath);
       expect(config.getAccessToken()).to.equal(
          mockedAccessTokenResponse.data.access_token,
       );
@@ -107,7 +121,7 @@ describe("login", () => {
       config.setEnvironment("localhost");
       config.setOrganization("foo");
       config.setProject("bar");
-      await login("not-foo", tmpConfigFilePath);
+      await login("not-foo", "http://localhost", tmpConfigFilePath);
       expect(config.getProject()).to.equal(undefined);
    });
 
@@ -122,7 +136,78 @@ describe("login", () => {
       config.setEnvironment("localhost");
       config.setOrganization("foo");
       config.setProject("bar");
-      await login("foo", tmpConfigFilePath);
+      await login("foo", "http://localhost", tmpConfigFilePath);
       expect(config.getProject()).to.equal("bar");
    });
+
+   it("uses auth-code + PKCE with organization in authorize URL for mapped CLI orgs", async function () {
+      this.timeout(2000);
+      const orgIdStub = sinon
+         .stub(credConstants, "getAuth0OrganizationIdForCliLogin")
+         .returns("org_nMRKafeSuxOiuJeG");
+      const loopbackStub = 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,
+      );
+      expect(orgIdStub.calledOnceWithExactly("videoamp")).to.be.true;
+      expect(loopbackStub.calledOnce).to.be.true;
+      const call = loopbackStub.getCall(0);
+      expect(call.args[0].authorizeUrl).to.contain(
+         "organization=org_nMRKafeSuxOiuJeG",
+      );
+   });
+
+   it("uses mapped org id for PKCE flow regardless of org name casing", async function () {
+      this.timeout(2000);
+      const orgIdStub = sinon
+         .stub(credConstants, "getAuth0OrganizationIdForCliLogin")
+         .callsFake((name: string) =>
+            name.toLowerCase() === "videoamp"
+               ? "org_nMRKafeSuxOiuJeG"
+               : undefined,
+         );
+      const loopbackStub = 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,
+      );
+      expect(orgIdStub.calledOnceWithExactly("VideoAmp")).to.be.true;
+      expect(loopbackStub.getCall(0).args[0].authorizeUrl).to.contain(
+         "organization=org_nMRKafeSuxOiuJeG",
+      );
+   });
+
+   it("should not pass Auth0 organization for unmapped org names", async function () {
+      this.timeout(2000);
+      axiosStub
+         .onFirstCall()
+         .resolves(mockDeviceCodeResponse)
+         .onSecondCall()
+         .resolves(mockedAccessTokenResponse);
+      const config = new ClientConfiguration(tmpConfigFilePath);
+      config.setEnvironment("localhost");
+      await login("test", "http://localhost", tmpConfigFilePath);
+      expect(axiosStub.getCall(0).args[0].data).to.not.have.property(
+         "organization",
+      );
+   });
 });