@credibledata/cred-cli 0.0.103 → 0.0.105

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

@@ -1,413 +0,0 @@
-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");
-
-      // Short-circuit loadConfig — createconnections calls getOrganization
-      // before it checks doesConfigExists, so we need to stub it or loadConfig
-      // would run against the stubbed readFileSync.
-      sandbox
-         .stub(ClientConfiguration.prototype, "getOrganization")
-         .returns("");
-      sandbox.stub(ClientConfiguration.prototype, "getProject").returns("");
-      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, "getOrganization")
-         .returns("test-org");
-      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 an environment"),
-         ),
-      ).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

@@ -1,109 +0,0 @@
-import fs from "fs";
-import { Connection, ConnectionsApi } from "../../client/api";
-import { Configuration } from "../../client/configuration";
-import { ClientConfiguration } from "../../clientconfiguration";
-import { logger } from "../../logger";
-import { getConfirmation, printOutError } from "../../utils";
-
-const connectionsApi = new ConnectionsApi(new Configuration());
-
-export const createConnections = async (
-   controlPlane: string,
-   connectionFileName: string,
-   includeTables: string | null,
-   excludeTables: string | null,
-   skipIndexing: boolean,
-   debug: boolean,
-   autoConfirm: boolean,
-) => {
-   const clientConfig = new ClientConfiguration();
-   const organizationName = clientConfig.getOrganization();
-   const environmentName = clientConfig.getProject();
-
-   if (!clientConfig.doesConfigExists()) {
-      logger.error("Please, make sure that you are logged in");
-      return;
-   }
-
-   if (!environmentName) {
-      logger.error("Please, make sure to set an environment");
-      return;
-   }
-
-   if (includeTables && excludeTables) {
-      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;
-   }
-
-   const connections = JSON.parse(
-      fs.readFileSync(connectionFileName, "utf8"),
-   ) 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}`,
-         );
-         continue;
-      }
-
-      if (!autoConfirm) {
-         const confirmation = await getConfirmation(
-            `Are you sure you that want to create a connection named ${connection.name}?`,
-         );
-         if (!confirmation) {
-            logger.info("Operation cancelled.");
-            return;
-         }
-      }
-      try {
-         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;
-         }
-         if (parsedExcludeTables) {
-            connection.excludeTables = parsedExcludeTables;
-         }
-         if (skipIndexing) {
-            connection.excludeAllTables = true;
-         }
-
-         await connectionsApi.createConnection(
-            organizationName,
-            environmentName,
-            connection,
-            false,
-            {
-               baseURL: controlPlane,
-               headers: clientConfig.getHeaders(),
-            },
-         );
-         logger.info(`Connection ${connection.name} created successfully`);
-      } catch (error) {
-         logger.error(`Failed to create connection ${connection.name}`);
-         printOutError(error, debug);
-      }
-   }
-};

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

@@ -1,189 +0,0 @@
-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 an environment"),
-         ),
-      ).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;
-   });
-});