@credibledata/cred-cli 0.1.4 → 0.1.5

package/src/commands/connection/createconnections.spec.ts

@@ -0,0 +1,403 @@
+import { expect } from "chai";
+import fs from "fs";
+import sinon from "sinon";
+import { ConnectionsApi } from "../../client/api";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import { getConfirmation } from "../../utils";
+import { createConnections } from "./createconnections";
+
+describe("create-connections", () => {
+   let sandbox: sinon.SinonSandbox;
+   let createConnectionStub: sinon.SinonStub;
+   let loggerStub: sinon.SinonStubbedInstance<typeof logger>;
+   let getConfirmationStub: sinon.SinonStub;
+   let readFileSyncStub: sinon.SinonStub;
+
+   beforeEach(() => {
+      sandbox = sinon.createSandbox();
+      createConnectionStub = sandbox.stub();
+      loggerStub = sandbox.stub(logger);
+      getConfirmationStub = sandbox.stub();
+      readFileSyncStub = sandbox.stub(fs, "readFileSync");
+
+      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(ConnectionsApi.prototype, "createConnection")
+         .callsFake(createConnectionStub);
+      sandbox
+         .stub(require("../../utils"), "getConfirmation")
+         .callsFake(getConfirmationStub);
+   });
+
+   afterEach(() => {
+      sandbox.restore();
+   });
+
+   it("should create connection successfully", async () => {
+      const mockConnections = [
+         {
+            name: "test_connection",
+            type: "postgres",
+            host: "localhost",
+            port: 5432,
+         },
+      ];
+      readFileSyncStub.returns(JSON.stringify(mockConnections));
+      getConfirmationStub.resolves(true);
+      createConnectionStub.resolves({ data: {} });
+
+      await createConnections(
+         "http://test-server",
+         "/path/to/connections.json",
+         null,
+         null,
+         false,
+         false,
+         true,
+      );
+
+      expect(readFileSyncStub.calledWith("/path/to/connections.json", "utf8"))
+         .to.be.true;
+      expect(createConnectionStub.calledOnce).to.be.true;
+      expect(createConnectionStub.firstCall.args[0]).to.equal("test-org");
+      expect(createConnectionStub.firstCall.args[1]).to.equal("test-project");
+      expect(createConnectionStub.firstCall.args[2]).to.deep.include({
+         name: "test_connection",
+      });
+      expect(
+         loggerStub.info.calledWith(
+            sinon.match("Connection test_connection created successfully"),
+         ),
+      ).to.be.true;
+   });
+
+   it("should create multiple connections", async () => {
+      const mockConnections = [
+         { name: "conn1", type: "postgres" },
+         { name: "conn2", type: "mysql" },
+      ];
+      readFileSyncStub.returns(JSON.stringify(mockConnections));
+      getConfirmationStub.resolves(true);
+      createConnectionStub.resolves({ data: {} });
+
+      await createConnections(
+         "http://test-server",
+         "/path/to/connections.json",
+         null,
+         null,
+         false,
+         false,
+         true,
+      );
+
+      expect(createConnectionStub.calledTwice).to.be.true;
+   });
+
+   it("should handle includeTables", async () => {
+      const mockConnections = [{ name: "test_conn", type: "postgres" }];
+      readFileSyncStub.returns(JSON.stringify(mockConnections));
+      getConfirmationStub.resolves(true);
+      createConnectionStub.resolves({ data: {} });
+
+      await createConnections(
+         "http://test-server",
+         "/path/to/connections.json",
+         "table1, table2",
+         null,
+         false,
+         false,
+         true,
+      );
+
+      expect(createConnectionStub.firstCall.args[2]).to.deep.include({
+         includeTables: ["table1", "table2"],
+      });
+   });
+
+   it("should handle excludeTables", async () => {
+      const mockConnections = [{ name: "test_conn", type: "postgres" }];
+      readFileSyncStub.returns(JSON.stringify(mockConnections));
+      getConfirmationStub.resolves(true);
+      createConnectionStub.resolves({ data: {} });
+
+      await createConnections(
+         "http://test-server",
+         "/path/to/connections.json",
+         null,
+         "table1, table2",
+         false,
+         false,
+         true,
+      );
+
+      expect(createConnectionStub.firstCall.args[2]).to.deep.include({
+         excludeTables: ["table1", "table2"],
+      });
+   });
+
+   it("should handle skipIndexing", async () => {
+      const mockConnections = [{ name: "test_conn", type: "postgres" }];
+      readFileSyncStub.returns(JSON.stringify(mockConnections));
+      getConfirmationStub.resolves(true);
+      createConnectionStub.resolves({ data: {} });
+
+      await createConnections(
+         "http://test-server",
+         "/path/to/connections.json",
+         null,
+         null,
+         true,
+         false,
+         true,
+      );
+
+      expect(createConnectionStub.firstCall.args[2]).to.deep.include({
+         excludeAllTables: true,
+      });
+   });
+
+   it("should reject includeTables and excludeTables together", async () => {
+      await createConnections(
+         "http://test-server",
+         "/path/to/connections.json",
+         "table1",
+         "table2",
+         false,
+         false,
+         true,
+      );
+
+      expect(createConnectionStub.called).to.be.false;
+      expect(
+         loggerStub.error.calledWith(
+            sinon.match(
+               "includeTables and excludeTables cannot be set at the same time",
+            ),
+         ),
+      ).to.be.true;
+   });
+
+   it("should reject skipIndexing with includeTables", async () => {
+      await createConnections(
+         "http://test-server",
+         "/path/to/connections.json",
+         "table1",
+         null,
+         true,
+         false,
+         true,
+      );
+
+      expect(createConnectionStub.called).to.be.false;
+      expect(
+         loggerStub.error.calledWith(
+            sinon.match(
+               "skipIndexing and includeTables cannot be set at the same time",
+            ),
+         ),
+      ).to.be.true;
+   });
+
+   it("should reject skipIndexing with excludeTables", async () => {
+      await createConnections(
+         "http://test-server",
+         "/path/to/connections.json",
+         null,
+         "table1",
+         true,
+         false,
+         true,
+      );
+
+      expect(createConnectionStub.called).to.be.false;
+      expect(
+         loggerStub.error.calledWith(
+            sinon.match(
+               "skipIndexing and excludeTables cannot be set at the same time",
+            ),
+         ),
+      ).to.be.true;
+   });
+
+   it("should reject invalid connection name", async () => {
+      const mockConnections = [
+         { name: "123invalid", type: "postgres" },
+         { name: "valid_connection", type: "postgres" },
+      ];
+      readFileSyncStub.returns(JSON.stringify(mockConnections));
+      getConfirmationStub.resolves(true);
+      createConnectionStub.resolves({ data: {} });
+
+      await createConnections(
+         "http://test-server",
+         "/path/to/connections.json",
+         null,
+         null,
+         false,
+         false,
+         true,
+      );
+
+      expect(
+         loggerStub.error.calledWith(
+            sinon.match(/Connection name can only contain letters/),
+         ),
+      ).to.be.true;
+      expect(createConnectionStub.calledOnce).to.be.true;
+      expect(createConnectionStub.firstCall.args[2].name).to.equal(
+         "valid_connection",
+      );
+   });
+
+   it("should handle missing config", async () => {
+      sandbox.restore();
+      sandbox = sinon.createSandbox();
+      createConnectionStub = sandbox.stub();
+      loggerStub = sandbox.stub(logger);
+      getConfirmationStub = sandbox.stub();
+      readFileSyncStub = sandbox.stub(fs, "readFileSync");
+
+      sandbox
+         .stub(ClientConfiguration.prototype, "doesConfigExists")
+         .returns(false);
+      sandbox
+         .stub(ConnectionsApi.prototype, "createConnection")
+         .callsFake(createConnectionStub);
+      sandbox
+         .stub(require("../../utils"), "getConfirmation")
+         .callsFake(getConfirmationStub);
+
+      await createConnections(
+         "http://test-server",
+         "/path/to/connections.json",
+         null,
+         null,
+         false,
+         false,
+         true,
+      );
+
+      expect(createConnectionStub.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();
+      createConnectionStub = sandbox.stub();
+      loggerStub = sandbox.stub(logger);
+      getConfirmationStub = sandbox.stub();
+      readFileSyncStub = sandbox.stub(fs, "readFileSync");
+
+      sandbox
+         .stub(ClientConfiguration.prototype, "doesConfigExists")
+         .returns(true);
+      sandbox.stub(ClientConfiguration.prototype, "getProject").returns("");
+      sandbox
+         .stub(ConnectionsApi.prototype, "createConnection")
+         .callsFake(createConnectionStub);
+      sandbox
+         .stub(require("../../utils"), "getConfirmation")
+         .callsFake(getConfirmationStub);
+
+      await createConnections(
+         "http://test-server",
+         "/path/to/connections.json",
+         null,
+         null,
+         false,
+         false,
+         true,
+      );
+
+      expect(createConnectionStub.called).to.be.false;
+      expect(
+         loggerStub.error.calledWith(
+            sinon.match("Please, make sure to set a project"),
+         ),
+      ).to.be.true;
+   });
+
+   it("should request confirmation when autoConfirm is false", async () => {
+      const mockConnections = [{ name: "test_conn", type: "postgres" }];
+      readFileSyncStub.returns(JSON.stringify(mockConnections));
+      getConfirmationStub.resolves(true);
+      createConnectionStub.resolves({ data: {} });
+
+      await createConnections(
+         "http://test-server",
+         "/path/to/connections.json",
+         null,
+         null,
+         false,
+         false,
+         false,
+      );
+
+      expect(getConfirmationStub.calledOnce).to.be.true;
+      expect(createConnectionStub.calledOnce).to.be.true;
+   });
+
+   it("should cancel when confirmation is denied", async () => {
+      const mockConnections = [{ name: "test_conn", type: "postgres" }];
+      readFileSyncStub.returns(JSON.stringify(mockConnections));
+      getConfirmationStub.resolves(false);
+
+      await createConnections(
+         "http://test-server",
+         "/path/to/connections.json",
+         null,
+         null,
+         false,
+         false,
+         false,
+      );
+
+      expect(getConfirmationStub.calledOnce).to.be.true;
+      expect(createConnectionStub.called).to.be.false;
+      expect(loggerStub.info.calledWith(sinon.match("Operation cancelled."))).to
+         .be.true;
+   });
+
+   it("should handle API errors", async () => {
+      const mockConnections = [{ name: "test_conn", type: "postgres" }];
+      readFileSyncStub.returns(JSON.stringify(mockConnections));
+      getConfirmationStub.resolves(true);
+      const mockError = new Error("API Error");
+      createConnectionStub.rejects(mockError);
+
+      await createConnections(
+         "http://test-server",
+         "/path/to/connections.json",
+         null,
+         null,
+         false,
+         true,
+         true,
+      );
+
+      expect(createConnectionStub.calledOnce).to.be.true;
+      expect(
+         loggerStub.error.calledWith(
+            sinon.match("Failed to create connection test_conn"),
+         ),
+      ).to.be.true;
+   });
+});

package/src/commands/connection/createconnections.ts

@@ -12,6 +12,7 @@ export const createConnections = async (
    connectionFileName: string,
    includeTables: string | null,
    excludeTables: string | null,
+   skipIndexing: boolean,
    debug: boolean,
    autoConfirm: boolean,
 ) => {
@@ -30,7 +31,23 @@ export const createConnections = async (
    }
 
    if (includeTables && excludeTables) {
-      logger.error("includeTables and excludeTables cannot be set at the same time");
+      logger.error(
+         "includeTables and excludeTables cannot be set at the same time",
+      );
+      return;
+   }
+
+   if (skipIndexing && includeTables) {
+      logger.error(
+         "skipIndexing and includeTables cannot be set at the same time",
+      );
+      return;
+   }
+
+   if (skipIndexing && excludeTables) {
+      logger.error(
+         "skipIndexing and excludeTables cannot be set at the same time",
+      );
       return;
    }
 
@@ -39,9 +56,10 @@ export const createConnections = async (
    ) as Connection[];
 
    for (const connection of connections) {
-
       if (!/^[a-zA-Z_][a-zA-Z0-9_]+$/.test(connection.name)) {
-         logger.error(`Connection name can only contain letters, numbers, and underscores for connection and should start with a letter or underscore: ${connection.name}`);
+         logger.error(
+            `Connection name can only contain letters, numbers, and underscores for connection and should start with a letter or underscore: ${connection.name}`,
+         );
          continue;
       }
 
@@ -55,8 +73,12 @@ export const createConnections = async (
          }
       }
       try {
-         const parsedIncludeTables = includeTables ? includeTables.split(',').map(s => s.trim()) : undefined;
-         const parsedExcludeTables = excludeTables ? excludeTables.split(',').map(s => s.trim()) : undefined;
+         const parsedIncludeTables = includeTables
+            ? includeTables.split(",").map((s) => s.trim())
+            : undefined;
+         const parsedExcludeTables = excludeTables
+            ? excludeTables.split(",").map((s) => s.trim())
+            : undefined;
 
          if (parsedIncludeTables) {
             connection.includeTables = parsedIncludeTables;
@@ -64,6 +86,9 @@ export const createConnections = async (
          if (parsedExcludeTables) {
             connection.excludeTables = parsedExcludeTables;
          }
+         if (skipIndexing) {
+            connection.excludeAllTables = true;
+         }
 
          await connectionsApi.createConnection(
             organizationName,

package/src/commands/connection/deleteconnection.spec.ts

@@ -0,0 +1,189 @@
+import { expect } from "chai";
+import sinon from "sinon";
+import { ConnectionsApi } from "../../client/api";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import { getConfirmation } from "../../utils";
+import { deleteConnection } from "./deleteconnection";
+
+describe("delete-connection", () => {
+   let sandbox: sinon.SinonSandbox;
+   let deleteConnectionStub: sinon.SinonStub;
+   let loggerStub: sinon.SinonStubbedInstance<typeof logger>;
+   let getConfirmationStub: sinon.SinonStub;
+
+   beforeEach(() => {
+      sandbox = sinon.createSandbox();
+      deleteConnectionStub = sandbox.stub();
+      loggerStub = sandbox.stub(logger);
+      getConfirmationStub = sandbox.stub();
+
+      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(ConnectionsApi.prototype, "deleteConnection")
+         .callsFake(deleteConnectionStub);
+      sandbox
+         .stub(require("../../utils"), "getConfirmation")
+         .callsFake(getConfirmationStub);
+   });
+
+   afterEach(() => {
+      sandbox.restore();
+   });
+
+   it("should delete connection successfully", async () => {
+      deleteConnectionStub.resolves({ status: 200 });
+      getConfirmationStub.resolves(true);
+
+      await deleteConnection(
+         "http://test-server",
+         "test-connection",
+         false,
+         true,
+      );
+
+      expect(deleteConnectionStub.calledOnce).to.be.true;
+      expect(deleteConnectionStub.firstCall.args[0]).to.equal("test-org");
+      expect(deleteConnectionStub.firstCall.args[1]).to.equal("test-project");
+      expect(deleteConnectionStub.firstCall.args[2]).to.equal(
+         "test-connection",
+      );
+      expect(deleteConnectionStub.firstCall.args[3]).to.deep.include({
+         baseURL: "http://test-server",
+         headers: { Authorization: "Bearer test-token" },
+      });
+      expect(
+         loggerStub.info.calledWith(
+            sinon.match("Connection deleted successfully"),
+         ),
+      ).to.be.true;
+   });
+
+   it("should handle missing config", async () => {
+      sandbox.restore();
+      sandbox = sinon.createSandbox();
+      deleteConnectionStub = sandbox.stub();
+      loggerStub = sandbox.stub(logger);
+      getConfirmationStub = sandbox.stub();
+
+      sandbox
+         .stub(ClientConfiguration.prototype, "doesConfigExists")
+         .returns(false);
+      sandbox
+         .stub(ConnectionsApi.prototype, "deleteConnection")
+         .callsFake(deleteConnectionStub);
+      sandbox
+         .stub(require("../../utils"), "getConfirmation")
+         .callsFake(getConfirmationStub);
+
+      await deleteConnection(
+         "http://test-server",
+         "test-connection",
+         false,
+         true,
+      );
+
+      expect(deleteConnectionStub.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();
+      deleteConnectionStub = sandbox.stub();
+      loggerStub = sandbox.stub(logger);
+      getConfirmationStub = sandbox.stub();
+
+      sandbox
+         .stub(ClientConfiguration.prototype, "doesConfigExists")
+         .returns(true);
+      sandbox.stub(ClientConfiguration.prototype, "getProject").returns("");
+      sandbox
+         .stub(ConnectionsApi.prototype, "deleteConnection")
+         .callsFake(deleteConnectionStub);
+      sandbox
+         .stub(require("../../utils"), "getConfirmation")
+         .callsFake(getConfirmationStub);
+
+      await deleteConnection(
+         "http://test-server",
+         "test-connection",
+         false,
+         true,
+      );
+
+      expect(deleteConnectionStub.called).to.be.false;
+      expect(
+         loggerStub.error.calledWith(
+            sinon.match("Please, make sure to set a project"),
+         ),
+      ).to.be.true;
+   });
+
+   it("should request confirmation when autoConfirm is false", async () => {
+      deleteConnectionStub.resolves({ status: 200 });
+      getConfirmationStub.resolves(true);
+
+      await deleteConnection(
+         "http://test-server",
+         "test-connection",
+         false,
+         false,
+      );
+
+      expect(getConfirmationStub.calledOnce).to.be.true;
+      expect(deleteConnectionStub.calledOnce).to.be.true;
+   });
+
+   it("should cancel when confirmation is denied", async () => {
+      getConfirmationStub.resolves(false);
+
+      await deleteConnection(
+         "http://test-server",
+         "test-connection",
+         false,
+         false,
+      );
+
+      expect(getConfirmationStub.calledOnce).to.be.true;
+      expect(deleteConnectionStub.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");
+      deleteConnectionStub.rejects(mockError);
+      getConfirmationStub.resolves(true);
+
+      await deleteConnection(
+         "http://test-server",
+         "test-connection",
+         true,
+         true,
+      );
+
+      expect(deleteConnectionStub.calledOnce).to.be.true;
+      expect(
+         loggerStub.error.calledWith(
+            sinon.match("Failed to delete connection"),
+         ),
+      ).to.be.true;
+   });
+});