@credibledata/cred-cli 0.0.103 → 0.0.105

package/src/commands/package/publish.ts

@@ -1,236 +0,0 @@
-import "../../polyfills/file.polyfill"; // Native support for File is only available on Node 19.2 or above
-
-import archiver from "archiver";
-import crypto from "crypto";
-import fs from "fs";
-import path from "path";
-import { Package, PackagesApi } from "../../client/api";
-import { Configuration } from "../../client/configuration";
-import { ClientConfiguration } from "../../clientconfiguration";
-import { logger } from "../../logger";
-import { getConfirmation, prettifyJson, printOutError } from "../../utils";
-import { validateManifest } from "../../validator";
-const packagesApi = new PackagesApi(new Configuration());
-const PACKAGE_MANIFEST_NAME = "publisher.json";
-
-/**
- * Record a publish failure: log it (when the caller has a message of its own to give)
- * and mark the process failed.
- *
- * Every early return below is a publish that did not happen, so each one has to carry the
- * same non-zero exit as a server rejection. CI and scripts wrap `cred publish` and read
- * its exit code; exiting 0 tells them a package is there when it is not. Declining the
- * confirmation prompt is deliberately NOT routed through here — that is an answer rather
- * than a failure, and it can only happen interactively.
- */
-function failPublish(message?: string): void {
-   if (message) {
-      logger.error(message);
-   }
-   process.exitCode = 1;
-}
-
-export async function publish(
-   controlPlane: string,
-   replicationCount: number,
-   debug: boolean,
-   autoConfirm: boolean,
-   setLatest: boolean,
-) {
-   const clientConfig = new ClientConfiguration();
-
-   if (!clientConfig.doesConfigExists()) {
-      failPublish("Please, make sure that you are logged in");
-      return;
-   }
-
-   const tokenValidation = clientConfig.isTokenValid();
-   if (!tokenValidation.valid) {
-      failPublish(
-         tokenValidation.reason || "Please, make sure that you are logged in",
-      );
-      return;
-   }
-
-   if (!validateManifest()) {
-      // validateManifest logs its own reason; only the exit code is missing.
-      failPublish();
-      return;
-   }
-
-   const environmentName = clientConfig.getProject();
-   const organizationName = clientConfig.getOrganization();
-
-   if (!organizationName) {
-      failPublish("Please, make sure that you are logged in");
-      return;
-   }
-
-   if (!environmentName) {
-      failPublish("Please, make sure to set an environment");
-      return;
-   }
-
-   if (!fs.existsSync(PACKAGE_MANIFEST_NAME)) {
-      failPublish(
-         `Failed to publish the package. Could not find ${PACKAGE_MANIFEST_NAME}, please ensure you are in a directory containing ${PACKAGE_MANIFEST_NAME}`,
-      );
-      return;
-   }
-
-   const packageManifestJson = fs.readFileSync(PACKAGE_MANIFEST_NAME);
-   const packageManifest = JSON.parse(packageManifestJson.toString());
-
-   const workingDirectory = process.cwd();
-   const packageName = workingDirectory.substring(
-      workingDirectory.lastIndexOf("/") + 1,
-   );
-   const tmpPackagePath = path.join("/tmp", packageName + ".zip");
-   if (!autoConfirm) {
-      const confirmation = await getConfirmation(
-         `Are you sure you that want to publish a package named ${packageName}?`,
-      );
-      if (!confirmation) {
-         logger.info("Operation cancelled.");
-         return;
-      }
-   }
-   await createTmpPackageArchive(tmpPackagePath);
-   await pushTmpPackageToRemoteServer(
-      clientConfig,
-      controlPlane,
-      replicationCount,
-      organizationName,
-      environmentName,
-      tmpPackagePath,
-      packageManifest.name,
-      packageManifest.description,
-      packageManifest.version,
-      debug,
-      setLatest,
-   );
-   await removeTmpPackage(tmpPackagePath);
-}
-
-async function createTmpPackageArchive(
-   packagePath: string,
-): Promise<undefined> {
-   logger.info("Creating new package version in " + packagePath);
-   const output = fs.createWriteStream(packagePath);
-   const archive = archiver("zip", {
-      zlib: { level: 9 }, // Sets the compression level.
-   });
-
-   return new Promise((resolve, reject) => {
-      archive
-         .on("warning", function (err) {
-            reject(err);
-         })
-         .on("error", function (err) {
-            reject(err);
-         })
-         .directory(".", false)
-         .pipe(output);
-
-      output.on("close", function () {
-         logger.info(archive.pointer() + " total bytes");
-         resolve(undefined);
-      });
-      archive.finalize();
-   });
-}
-
-async function pushTmpPackageToRemoteServer(
-   clientConfig: ClientConfiguration,
-   controlPlane: string,
-   replicationCount: number,
-   organizationName: string,
-   environmentName: string,
-   tmpPackagePath: string,
-   name: string,
-   description: string,
-   versionId: string,
-   debug: boolean,
-   setLatest: boolean,
-): Promise<undefined> {
-   logger.info("Pushing package " + name + " version " + versionId);
-
-   const packageContents = new File(
-      [fs.readFileSync(tmpPackagePath)],
-      tmpPackagePath,
-   );
-
-   // Build the post string from an object
-   const _package: Package = {
-      name: name,
-      description: description,
-      replicationCount: replicationCount,
-   };
-
-   // Set latest version based on the setLatest flag
-   if (setLatest) {
-      _package.latestVersion = versionId;
-   }
-
-   const version = {
-      id: versionId,
-   };
-   try {
-      const md5Hash = crypto
-         .createHash("md5")
-         .update(fs.readFileSync(tmpPackagePath))
-         .digest("hex");
-      if (debug) {
-         logger.debug("Package contents: " + packageContents);
-         logger.debug("Organization name: " + organizationName);
-         logger.debug("Environment name: " + environmentName);
-         logger.debug("Name: " + name);
-         logger.debug("Package: " + JSON.stringify(_package));
-         logger.debug("Version: " + JSON.stringify(version));
-         logger.debug("Control plane: " + controlPlane);
-         logger.debug(
-            "Client config: " + JSON.stringify(clientConfig.getHeaders()),
-         );
-      }
-      const response = await packagesApi.createOrUpdatePackage(
-         organizationName,
-         environmentName,
-         name,
-         _package,
-         version,
-         packageContents,
-         md5Hash,
-         // draftId / workspace: a zip upload has no git-backed draft, so the server
-         // records no provenance. Positional because `options` must stay last.
-         undefined,
-         undefined,
-         {
-            baseURL: controlPlane,
-            headers: clientConfig.getHeaders(),
-         },
-      );
-
-      logger.info(prettifyJson(response.data));
-      const packageUrl = path.join(
-         organizationName,
-         environmentName,
-         name,
-         versionId,
-      );
-      logger.info(`Package available at: ${packageUrl}`);
-   } catch (e) {
-      // The server rejected it: a model that does not compile, or a `#@ persist`
-      // declaration the publisher refuses to load.
-      failPublish("Failed to publish package");
-      printOutError(e, debug);
-   }
-}
-
-async function removeTmpPackage(tmpPackagePath: string): Promise<undefined> {
-   return new Promise((resolve) => {
-      fs.unlink(tmpPackagePath, (err) => {
-         if (err) throw err;
-         resolve(undefined);
-      });
-   });
-}

package/src/commands/package/updatepackage.spec.ts

@@ -1,319 +0,0 @@
-import { expect } from "chai";
-import sinon from "sinon";
-import { PackagesApi } from "../../client/api";
-import { ClientConfiguration } from "../../clientconfiguration";
-import { logger } from "../../logger";
-import { updatePackage } from "./updatepackage";
-
-describe("set-replication-count", () => {
-   let sandbox: sinon.SinonSandbox;
-   let updatePackageStub: sinon.SinonStub;
-   let loggerStub: sinon.SinonStubbedInstance<typeof logger>;
-
-   beforeEach(() => {
-      sandbox = sinon.createSandbox();
-      updatePackageStub = sandbox.stub();
-      loggerStub = sandbox.stub(logger);
-
-      // Mock ClientConfiguration constructor
-      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" });
-
-      // Mock PackagesApi constructor and method
-      sandbox
-         .stub(PackagesApi.prototype, "updatePackage")
-         .callsFake(updatePackageStub);
-   });
-
-   afterEach(() => {
-      sandbox.restore();
-   });
-
-   describe("setReplicationCount", () => {
-      it("should set replication count successfully", async () => {
-         const mockResponse = { status: 200 };
-         updatePackageStub.resolves(mockResponse);
-
-         await updatePackage(
-            "http://test-server",
-            "test-package",
-            { replicationCount: 3 },
-            false,
-            true,
-         );
-
-         expect(updatePackageStub.calledOnce).to.be.true;
-         expect(updatePackageStub.firstCall.args[0]).to.equal("test-org");
-         expect(updatePackageStub.firstCall.args[1]).to.equal("test-project");
-         expect(updatePackageStub.firstCall.args[2]).to.equal("test-package");
-         expect(updatePackageStub.firstCall.args[3]).to.include({
-            replicationCount: 3,
-         });
-         expect(updatePackageStub.firstCall.args[4]).to.deep.include({
-            baseURL: "http://test-server",
-            headers: { Authorization: "Bearer test-token" },
-         });
-         expect(
-            loggerStub.info.calledWith(
-               sinon.match(
-                  "Successfully set replication count for package test-package to 3",
-               ),
-            ),
-         ).to.be.true;
-      });
-
-      it("should handle missing package name", async () => {
-         await updatePackage(
-            "http://test-server",
-            "",
-            { replicationCount: 3 },
-            false,
-            true,
-         );
-
-         expect(updatePackageStub.called).to.be.false;
-         expect(
-            loggerStub.error.calledWith(
-               sinon.match("Please provide a package name"),
-            ),
-         ).to.be.true;
-      });
-
-      it("should handle API errors", async () => {
-         const mockError = new Error("API Error");
-         updatePackageStub.rejects(mockError);
-
-         await updatePackage(
-            "http://test-server",
-            "test-package",
-            { replicationCount: 3 },
-            true,
-            true,
-         );
-
-         expect(updatePackageStub.calledOnce).to.be.true;
-         expect(
-            loggerStub.error.calledWith(
-               sinon.match(
-                  "Failed to set replication count for package test-package",
-               ),
-            ),
-         ).to.be.true;
-      });
-
-      it("should handle non-200 response status", async () => {
-         const mockResponse = { status: 400 };
-         updatePackageStub.resolves(mockResponse);
-
-         await updatePackage(
-            "http://test-server",
-            "test-package",
-            { replicationCount: 3 },
-            false,
-            true,
-         );
-
-         expect(updatePackageStub.calledOnce).to.be.true;
-         expect(
-            loggerStub.error.calledWith(
-               sinon.match("Failed to set replication count. Status: 400"),
-            ),
-         ).to.be.true;
-      });
-   });
-
-   describe("validators", () => {
-      describe("authentication validation", () => {
-         it("should fail when user is not logged in", async () => {
-            sandbox.restore();
-            sandbox = sinon.createSandbox();
-            updatePackageStub = sandbox.stub();
-            loggerStub = sandbox.stub(logger);
-
-            sandbox
-               .stub(ClientConfiguration.prototype, "doesConfigExists")
-               .returns(false);
-            sandbox
-               .stub(PackagesApi.prototype, "updatePackage")
-               .callsFake(updatePackageStub);
-
-            await updatePackage(
-               "http://test-server",
-               "test-package",
-               { replicationCount: 3 },
-               false,
-               true,
-            );
-
-            expect(
-               loggerStub.error.calledWith(
-                  sinon.match("Please, make sure that you are logged in"),
-               ),
-            ).to.be.true;
-         });
-
-         it("should fail when no project is set", async () => {
-            sandbox.restore();
-            sandbox = sinon.createSandbox();
-            updatePackageStub = sandbox.stub();
-            loggerStub = sandbox.stub(logger);
-
-            sandbox
-               .stub(ClientConfiguration.prototype, "doesConfigExists")
-               .returns(true);
-            sandbox
-               .stub(ClientConfiguration.prototype, "getProject")
-               .returns("");
-            sandbox
-               .stub(PackagesApi.prototype, "updatePackage")
-               .callsFake(updatePackageStub);
-
-            await updatePackage(
-               "http://test-server",
-               "test-package",
-               { replicationCount: 3 },
-               false,
-               true,
-            );
-
-            expect(
-               loggerStub.error.calledWith(
-                  sinon.match("Please, make sure to set an environment"),
-               ),
-            ).to.be.true;
-         });
-      });
-
-      describe("replication count validation", () => {
-         it("should accept valid replication counts", async () => {
-            const mockResponse = { status: 200 };
-            updatePackageStub.resolves(mockResponse);
-
-            const validCounts = [1, 2, 5, 10, 100];
-
-            for (const count of validCounts) {
-               await updatePackage(
-                  "http://test-server",
-                  "test-package",
-                  { replicationCount: count },
-                  false,
-                  true,
-               );
-               expect(updatePackageStub.called).to.be.true;
-               expect(updatePackageStub.firstCall.args[3]).to.include({
-                  replicationCount: count,
-               });
-               updatePackageStub.reset();
-            }
-         });
-      });
-   });
-
-   describe("updatePackage params", () => {
-      it("should pass latestVersion when provided", async () => {
-         const mockResponse = { status: 200 };
-         updatePackageStub.resolves(mockResponse);
-
-         await updatePackage(
-            "http://test-server",
-            "test-package",
-            { latestVersion: "2.0.0" },
-            false,
-            true,
-         );
-
-         expect(updatePackageStub.calledOnce).to.be.true;
-         expect(updatePackageStub.firstCall.args[3]).to.deep.include({
-            latestVersion: "2.0.0",
-         });
-      });
-
-      it("should pass description when provided", async () => {
-         const mockResponse = { status: 200 };
-         updatePackageStub.resolves(mockResponse);
-
-         await updatePackage(
-            "http://test-server",
-            "test-package",
-            { description: "Updated description" },
-            false,
-            true,
-         );
-
-         expect(updatePackageStub.calledOnce).to.be.true;
-         expect(updatePackageStub.firstCall.args[3]).to.deep.include({
-            description: "Updated description",
-         });
-      });
-
-      it("should reject invalid package path with multiple segments", async () => {
-         await updatePackage(
-            "http://test-server",
-            "foo/bar",
-            { replicationCount: 3 },
-            false,
-            true,
-         );
-
-         expect(updatePackageStub.called).to.be.false;
-         expect(
-            loggerStub.error.calledWith(sinon.match("Invalid package path")),
-         ).to.be.true;
-      });
-   });
-
-   describe("confirmation flow", () => {
-      let getConfirmationStub: sinon.SinonStub;
-
-      beforeEach(() => {
-         getConfirmationStub = sandbox.stub();
-         sandbox
-            .stub(require("../../utils"), "getConfirmation")
-            .callsFake(getConfirmationStub);
-      });
-
-      it("should request confirmation when autoConfirm is false", async () => {
-         const mockResponse = { status: 200 };
-         updatePackageStub.resolves(mockResponse);
-         getConfirmationStub.resolves(true);
-
-         await updatePackage(
-            "http://test-server",
-            "test-package",
-            { replicationCount: 3 },
-            false,
-            false,
-         );
-
-         expect(getConfirmationStub.calledOnce).to.be.true;
-         expect(updatePackageStub.calledOnce).to.be.true;
-      });
-
-      it("should cancel when confirmation is denied", async () => {
-         getConfirmationStub.resolves(false);
-
-         await updatePackage(
-            "http://test-server",
-            "test-package",
-            { replicationCount: 3 },
-            false,
-            false,
-         );
-
-         expect(getConfirmationStub.calledOnce).to.be.true;
-         expect(updatePackageStub.called).to.be.false;
-         expect(loggerStub.info.calledWith(sinon.match("Operation cancelled.")))
-            .to.be.true;
-      });
-   });
-});

package/src/commands/package/updatepackage.ts

@@ -1,95 +0,0 @@
-import { Package, PackagesApi } from "../../client/api";
-import { Configuration } from "../../client/configuration";
-import { ClientConfiguration } from "../../clientconfiguration";
-import { logger } from "../../logger";
-import { getConfirmation, printOutError } from "../../utils";
-
-const packagesApi = new PackagesApi(new Configuration());
-
-type NewParams = {
-   latestVersion?: string;
-   replicationCount?: number;
-   description?: string;
-};
-export async function updatePackage(
-   packageServer: string,
-   packageName: string,
-   newParams: NewParams,
-   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 (!packageName) {
-      logger.error("Please provide a package name");
-      return;
-   }
-
-   logger.info(
-      `Setting replication count for package ${packageName} to ${newParams.replicationCount}`,
-   );
-
-   try {
-      if (!autoConfirm) {
-         const confirmation = await getConfirmation(
-            `Are you sure you that want to update the replication count for package ${packageName} to ${newParams.replicationCount}?`,
-         );
-         if (!confirmation) {
-            logger.info("Operation cancelled.");
-            return;
-         }
-      }
-      const packageUpdate: Package = {
-         replicationCount: newParams.replicationCount || undefined,
-         latestVersion: newParams.latestVersion || undefined,
-         description: newParams.description || undefined,
-      };
-      const pathParts = packageName
-         .split("/")
-         .filter((part) => part.length > 0);
-      if (pathParts.length !== 1) {
-         logger.error("Invalid package path. Expected format: /<packageName>");
-         return;
-      }
-
-      packageName = pathParts[0];
-
-      const response = await packagesApi.updatePackage(
-         organizationName,
-         environmentName,
-         packageName,
-         packageUpdate,
-         {
-            baseURL: packageServer,
-            headers: clientConfig.getHeaders(),
-         },
-      );
-
-      if (response.status === 200) {
-         logger.info(
-            `Successfully set replication count for package ${packageName} to ${newParams.replicationCount}`,
-         );
-      } else {
-         logger.error(
-            `Failed to set replication count. Status: ${response.status}`,
-         );
-      }
-   } catch (e) {
-      logger.error(
-         `Failed to set replication count for package ${packageName}`,
-      );
-      printOutError(e, debug);
-   }
-}