@credibledata/cred-cli 0.1.0

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,70 @@
+export type Environment =
+   | "production"
+   | "staging"
+   | "dev"
+   | "localhost"
+   | "e2e-test";
+
+export const controlPlanesByEnv: Record<Environment, string> = {
+   production: "https://admin.ms2.co/api/v0",
+   dev: "https://dev-admin.ms2.co/api/v0",
+   staging: "https://staging-admin.ms2.co/api/v0",
+   localhost: "http://admin.ms2.localhost/api/v0",
+   "e2e-test": "http://admin.ms2.localhost/api/v0",
+};
+
+export const auth0ConfigsByEnv: Record<
+   Environment,
+   {
+      domain: string;
+      clientId: string;
+      clientSecret?: string;
+      audience: string;
+   }
+> = {
+   production: {
+      domain: "https://ms2data.us.auth0.com",
+      clientId: "ge8JL5TJNwqy7bygAaJkD92KdluqEZgO",
+      audience: "https://ms2data.us.auth0.com/api/v2/",
+   },
+   dev: {
+      domain: "https://dev-ohaafogw5p8uyx1m.us.auth0.com",
+      clientId: "rr6mzJNj9b104MjCc9xWKPPehq1MJx0L",
+      audience: "https://dev-ohaafogw5p8uyx1m.us.auth0.com/api/v2/",
+   },
+   staging: {
+      domain: "https://dev-ohaafogw5p8uyx1m.us.auth0.com",
+      clientId: "rr6mzJNj9b104MjCc9xWKPPehq1MJx0L",
+      audience: "https://dev-ohaafogw5p8uyx1m.us.auth0.com/api/v2/",
+   },
+   localhost: {
+      domain: "https://dev-ohaafogw5p8uyx1m.us.auth0.com",
+      clientId: "rr6mzJNj9b104MjCc9xWKPPehq1MJx0L",
+      audience: "https://dev-ohaafogw5p8uyx1m.us.auth0.com/api/v2/",
+   },
+   "e2e-test": {
+      domain: "https://dev-ohaafogw5p8uyx1m.us.auth0.com",
+      clientId: "atd8n8dEiGUiNRM7Geuvg41fi5s8ZKqY",
+      clientSecret:
+         "ZrEvs86WLqKO9EPp4y_cOvUn3NQT1qc3XC8111f6DBt9oyaclV5sWHz6Nkyo_bEF",
+      audience: "https://dev-ohaafogw5p8uyx1m.us.auth0.com/api/v2/",
+   },
+};
+
+// 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 = `
+   _____              _ _ _     _         _____ _      _____ 
+  / ____|            | (_) |   | |       / ____| |    |_   _|
+ | |     _ __ ___  __| |_| |__ | | ___  | |    | |      | |  
+ | |    | '__/ _ \\/ _\` | | '_ \\| |/ _ \\ | |    | |      | |  
+ | |____| | |  __/ (_| | | |_) | |  __/ | |____| |____ _| |_ 
+  \\_____|_|  \\___|\\__,_|_|_.__/|_|\\___|  \\_____|______|_____|
+`;

package/src/index.ts

@@ -0,0 +1,183 @@
+#!/usr/bin/env node
+import axios from "axios";
+import { program } from "commander";
+import kleur from "kleur";
+import omelette from "omelette";
+import cliPackage from "../package.json";
+import { ClientConfiguration } from "./clientconfiguration";
+import { registerAddCommands } from "./commands/add";
+import { registerGetCommands } from "./commands/get";
+import { registerListCommands } from "./commands/list";
+import { login } from "./commands/misc/login";
+import { logout } from "./commands/misc/logout";
+import { setAccessToken } from "./commands/misc/set-access-token";
+import { listPackages } from "./commands/package/listpackages";
+import { publish } from "./commands/package/publish";
+import { listProjects } from "./commands/project/listprojects";
+import { registerRmCommands } from "./commands/rm";
+import { registerSetCommands } from "./commands/set";
+import { registerUpdateCommands } from "./commands/update";
+import {
+   archiveVersion,
+   unarchiveVersion,
+} from "./commands/version/archive-unarchive-version";
+import { ASCII_TITLE, controlPlanesByEnv } from "./constants";
+
+const clientConfig = new ClientConfiguration();
+
+const activeEnvironment = clientConfig.getEnvironment();
+axios.defaults.baseURL = controlPlanesByEnv[activeEnvironment];
+
+const cli = program
+   .version(cliPackage.version)
+   .description(kleur.green(ASCII_TITLE));
+
+// Nested CRUD commands for resource management
+registerGetCommands(cli, activeEnvironment);
+registerListCommands(cli, activeEnvironment);
+registerUpdateCommands(cli, activeEnvironment);
+registerRmCommands(cli, activeEnvironment);
+registerAddCommands(cli, activeEnvironment);
+registerSetCommands(cli);
+
+// Root commands
+cli.command("publish")
+   .description("Publish a new version of the package.")
+   .option("--debug")
+   .option("-y, --yes", "Skip confirmation.")
+   .option(
+      "--replication <replication_count>",
+      "The number of replicas to create.",
+      (v) => (v === undefined ? undefined : parseInt(v)),
+      undefined,
+   )
+   .option(
+      "--set-latest",
+      "Set this version as the latest version of the package.",
+      false,
+   )
+   .action((options) => {
+      publish(
+         controlPlanesByEnv[activeEnvironment],
+         options.replicationCount,
+         options.debug,
+         options.yes,
+         options.setLatest,
+      );
+   });
+
+cli.command("archive")
+   .description("Archive a version of a package.")
+   .argument(
+      "<packageName>",
+      "The name of the package to archive the version of.",
+   )
+   .argument("<versionId>", "The id of the version to archive.")
+   .option("--debug")
+   .option("-y, --yes", "Skip confirmation.")
+   .action((packageName, versionId, options) => {
+      archiveVersion(
+         controlPlanesByEnv[activeEnvironment],
+         packageName,
+         versionId,
+         options.debug,
+         options.yes,
+      );
+   });
+
+cli.command("unarchive")
+   .description("Unarchive a version of a package.")
+   .argument(
+      "<packageName>",
+      "The name of the package to unarchive the version of.",
+   )
+   .argument("<versionId>", "The id of the version to unarchive.")
+   .option("--debug")
+   .option("-y, --yes", "Skip confirmation.")
+   .action((packageName, versionId, options) => {
+      unarchiveVersion(
+         controlPlanesByEnv[activeEnvironment],
+         packageName,
+         versionId,
+         options.debug,
+         options.yes,
+      );
+   });
+
+cli.command("login")
+   .description("Login into Credible service.")
+   .argument("<organizationName>", "The organization to login to.")
+   .action((organizationName) => {
+      login(organizationName);
+   });
+
+cli.command("logout")
+   .description("Resets Credible service credentials")
+   .action(logout);
+
+cli.command("set-access-token")
+   .description("Set a service account JWT token for CLI authentication")
+   .argument("<jwtToken>", "The JWT token to use for authentication")
+   .option("-o, --organization <organizationName>", "Organization name to set")
+   .action((jwtToken, options) => {
+      setAccessToken(jwtToken, options.organization);
+   });
+
+cli.command("status")
+   .description("Shows the currently active organization and project.")
+   .action(() => {
+      const config = new ClientConfiguration();
+      config.printStatus();
+   });
+
+const complete = omelette("cred").tree({
+   // CRUD commands
+   get: ["project", "group"],
+   ls: ["project", "connection", "package", "version", "group", "group-access-token"],
+   update: ["package"],
+   rm: ["project", "connection", "package", "group", "member", "group-access-token"],
+   add: ["project", "connection", "group", "member", "group-access-token"],
+   // Misc commands
+   set: ["project"],
+   login: [],
+   logout: [],
+   "set-access-token": [],
+   status: [],
+   publish: [],
+   archive: [],
+   unarchive: [],
+});
+
+complete.onAsync("$3", async ({ reply, line }) => {
+   const projectRelatedCommands = ["set project", "get project", "rm project"];
+   if (projectRelatedCommands.some((cmd) => line.includes(cmd))) {
+      reply(
+         listProjects(controlPlanesByEnv[activeEnvironment], false).then(
+            (projects) => projects.map((project) => project.name),
+         ),
+      );
+   }
+   const packageRelatedCommands = ["rm package", "ls version"];
+   if (packageRelatedCommands.some((cmd) => line.includes(cmd))) {
+      reply(
+         listPackages(controlPlanesByEnv[activeEnvironment], false).then(
+            (packages) => packages.map((_package) => _package.name),
+         ),
+      );
+   }
+});
+
+complete.next(() => {
+   program.parse(process.argv);
+});
+
+if (~process.argv.indexOf("--cleanup")) {
+   complete.cleanupShellInitFile();
+}
+
+if (~process.argv.indexOf("--install")) {
+   complete.setupShellInitFile();
+   console.log("CLI installed successfully!");
+}
+
+complete.init();

package/src/logger.ts

@@ -0,0 +1,86 @@
+import { AxiosError } from "axios";
+import kleur from "kleur";
+import winston from "winston";
+
+const logColors = {
+   error: kleur.red,
+   warn: kleur.yellow,
+   info: kleur.cyan,
+   http: kleur.magenta,
+   debug: kleur.gray,
+};
+
+// Custom console log format
+const consoleFormat = winston.format.printf(({ level, message, timestamp }) => {
+   const colorFn = logColors[level] || ((text: string) => text);
+   return `[${kleur.gray(timestamp as string)}] ${colorFn(level.toUpperCase())}: ${message}`;
+});
+
+// Create Winston logger
+export const logger = winston.createLogger({
+   level: "debug",
+   format: winston.format.combine(
+      winston.format.timestamp({ format: "YYYY-MM-DD HH:mm:ss" }),
+      winston.format.errors({ stack: true }),
+      winston.format.splat(),
+   ),
+   transports: [
+      // Console transport with colored logs
+      new winston.transports.Console({
+         format: consoleFormat,
+      }),
+
+      // NOTE disabled app.log logging
+      // File transport (logs without colors)
+      // new winston.transports.File({
+      //    filename: "app.log",
+      //    level: "info",
+      //    format: winston.format.json(),
+      // }),
+   ],
+});
+
+export const logAxiosError = (error: AxiosError, debug: boolean) => {
+   if (error.response) {
+      // The request was made and the server responded with a status code
+      // that falls out of the range of 2xx
+      if (debug) {
+         logger.error(
+            `Error ${error.response.status} at ${error.request.path}`,
+         );
+      }
+      switch (error.response.status) {
+         case 401:
+            logger.error(
+               "Unauthorized: Please double check that you are logged in",
+            );
+            break;
+         case 403:
+            logger.error(
+               "Forbidden: You're not allowed to perform this operation",
+            );
+            break;
+         case 500:
+            logger.error("Internal Server Error");
+            break;
+         default:
+            break;
+      }
+      if (error.response.data) {
+         logger.error(error.response.data);
+      }
+   } else if (error.request) {
+      // The request was made but no response was received
+      // `error.request` is an instance of XMLHttpRequest in the browser and an instance of
+      // http.ClientRequest in node.js
+      const requestOptions = error.request._options;
+      logger.error(
+         `Failed to ${requestOptions.method} resource ${requestOptions.path} on ${requestOptions.hostname}:${requestOptions.port}`,
+      );
+
+      logger.error(error.code, error.message);
+   } else {
+      // Something happened in setting up the request that triggered an Error
+      logger.error("Error", error.message);
+   }
+};

package/src/polyfills/file.polyfill.ts

@@ -0,0 +1,5 @@
+import { File, Blob } from "formdata-node";
+
+// TODO: Polyfill leads to errors when pushing packages.
+//globalThis.File = File as unknown as typeof globalThis.File;
+//globalThis.Blob = Blob as unknown as typeof globalThis.Blob;

package/src/utils.ts

@@ -0,0 +1,34 @@
+import axios from "axios";
+import inquirer from "inquirer";
+import { logAxiosError, logger } from "./logger";
+
+export function sleep(time_in_ms: number): Promise<void> {
+   return new Promise((resolve) => setTimeout(resolve, time_in_ms));
+}
+
+export function prettifyJson(payload: object): string {
+   return JSON.stringify(payload, null, 2);
+}
+
+export function printOutError(e: Error, debug: boolean) {
+   if (axios.isAxiosError(e)) {
+      logAxiosError(e, debug);
+   } else {
+      logger.error("Unexpected error", e);
+   }
+
+   if (debug) {
+      logger.debug(e);
+   }
+}
+
+export async function getConfirmation(message: string): Promise<boolean> {
+   const answer = await inquirer.prompt([
+      {
+         type: "confirm",
+         name: "confirm",
+         message,
+      },
+   ]);
+   return answer.confirm;
+}

package/src/validator.spec.ts

@@ -0,0 +1,51 @@
+import { expect } from "chai";
+import { validatePath, PathType, validateManifest } from "./validator";
+
+describe("validator", () => {
+   describe("validatePath", () => {
+      it("should return PathType.Invalid for a path not starting with '/'", () => {
+         expect(validatePath("invalidPath")).to.equal(PathType.Invalid);
+      });
+
+      it("should return PathType.Root for '/'", () => {
+         expect(validatePath("/")).to.equal(PathType.Root);
+      });
+
+      it("should return PathType.Package for a valid package path", () => {
+         expect(validatePath("/package123")).to.equal(PathType.Package);
+         expect(validatePath("/abc-def")).to.equal(PathType.Package);
+      });
+
+      it("should return PathType.Invalid for a package path with invalid characters", () => {
+         expect(validatePath("/package@123")).to.equal(PathType.Invalid);
+      });
+
+      it("should return PathType.Version for a valid package and version path", () => {
+         expect(validatePath("/package123/1.0.0")).to.equal(PathType.Version);
+         expect(validatePath("/abc-def/2.3.4")).to.equal(PathType.Version);
+      });
+
+      it("should return PathType.Invalid for a version path with invalid characters", () => {
+         expect(validatePath("/package123/1.0.0-beta")).to.equal(
+            PathType.Invalid,
+         );
+         expect(validatePath("/abc-def/2.3.4!")).to.equal(PathType.Invalid);
+      });
+
+      it("should return PathType.Invalid for a path with too many segments", () => {
+         expect(validatePath("/package123/1.0.0/extra")).to.equal(
+            PathType.Invalid,
+         );
+      });
+   });
+
+   describe("validateManifest", () => {
+      it("should return true if manifest validation passes", () => {
+         expect(validateManifest()).to.be.true;
+      });
+
+      // it("should log an error and return false if manifest validation fails", () => {
+      //    expect(validateManifest()).to.be.false;
+      // });
+   });
+});

package/src/validator.ts

@@ -0,0 +1,44 @@
+import { logger } from "./logger";
+
+const idRegex = new RegExp("^[a-zA-Z0-9\\-]+$");
+const versionRegex = new RegExp("^[a-zA-Z0-9\\.]+$");
+export enum PathType {
+   Root,
+   Package,
+   Version,
+   Invalid,
+}
+export function validatePath(path: string): PathType {
+   if (!path.startsWith("/")) {
+      return PathType.Invalid;
+   }
+   const pathParts = path.split("/");
+   if (pathParts.length === 2 && !pathParts[1]) {
+      return PathType.Root;
+   } else if (pathParts.length === 2 && idRegex.test(pathParts[1])) {
+      return PathType.Package;
+   } else if (
+      pathParts.length === 3 &&
+      idRegex.test(pathParts[1]) &&
+      versionRegex.test(pathParts[2])
+   ) {
+      return PathType.Version;
+   } else {
+      return PathType.Invalid;
+   }
+}
+
+export function validateManifest(): boolean {
+   try {
+      // const packageManifestJson = fs.readFileSync("malloy-package.json");
+      // const packageManifest = JSON.parse(packageManifestJson.toString());
+      // TODO: Validate packageManigfest.
+      return true;
+   } catch (error) {
+      let message;
+      if (error instanceof Error) message = error.message;
+      else message = String(error);
+      logger.error("Unable to open and parse manifest: " + message);
+      return false;
+   }
+}

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": false,
+    "target": "es6",
+    "module": "commonjs",
+    "sourceMap": true,
+    "esModuleInterop": true,
+    "moduleResolution": "node",
+    "resolveJsonModule": true
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist"
+  ]
+}