@credibledata/cred-cli 0.0.103 → 0.0.105

package/src/logger.spec.ts

@@ -1,158 +0,0 @@
-import { expect } from "chai";
-import sinon from "sinon";
-import { AxiosError } from "axios";
-import { logger, logAxiosError } from "./logger";
-
-describe("logAxiosError", () => {
-   let loggerStub: sinon.SinonStubbedInstance<typeof logger>;
-   let sandbox: sinon.SinonSandbox;
-
-   beforeEach(() => {
-      sandbox = sinon.createSandbox();
-      loggerStub = sandbox.stub(logger);
-   });
-
-   afterEach(() => {
-      sandbox.restore();
-   });
-
-   it("should log 401 Unauthorized error", () => {
-      const error = {
-         response: {
-            status: 401,
-            data: null,
-         },
-         request: { path: "/api/test" },
-         isAxiosError: true,
-      } as unknown as AxiosError;
-
-      logAxiosError(error, false);
-
-      expect(loggerStub.error.calledWith(sinon.match("Unauthorized"))).to.be
-         .true;
-   });
-
-   it("should log 403 Forbidden error", () => {
-      const error = {
-         response: {
-            status: 403,
-            data: null,
-         },
-         request: { path: "/api/test" },
-         isAxiosError: true,
-      } as unknown as AxiosError;
-
-      logAxiosError(error, false);
-
-      expect(loggerStub.error.calledWith(sinon.match("Forbidden"))).to.be.true;
-   });
-
-   it("should log 500 Internal Server Error", () => {
-      const error = {
-         response: {
-            status: 500,
-            data: null,
-         },
-         request: { path: "/api/test" },
-         isAxiosError: true,
-      } as unknown as AxiosError;
-
-      logAxiosError(error, false);
-
-      expect(loggerStub.error.calledWith(sinon.match("Internal Server Error")))
-         .to.be.true;
-   });
-
-   it("should log response data when present", () => {
-      const error = {
-         response: {
-            status: 400,
-            data: "Bad request details",
-         },
-         request: { path: "/api/test" },
-         isAxiosError: true,
-      } as unknown as AxiosError;
-
-      logAxiosError(error, false);
-
-      expect(loggerStub.error.calledWith(sinon.match("Bad request details"))).to
-         .be.true;
-   });
-
-   it("should log debug info with status and path when debug is true", () => {
-      const error = {
-         response: {
-            status: 401,
-            data: null,
-         },
-         request: { path: "/api/test" },
-         isAxiosError: true,
-      } as unknown as AxiosError;
-
-      logAxiosError(error, true);
-
-      expect(loggerStub.error.calledWith(sinon.match("Error 401 at /api/test")))
-         .to.be.true;
-   });
-
-   it("should not log debug info when debug is false", () => {
-      const error = {
-         response: {
-            status: 401,
-            data: null,
-         },
-         request: { path: "/api/test" },
-         isAxiosError: true,
-      } as unknown as AxiosError;
-
-      logAxiosError(error, false);
-
-      expect(loggerStub.error.calledWith(sinon.match("Error 401 at"))).to.be
-         .false;
-   });
-
-   it("should handle request error with no response", () => {
-      const error = {
-         response: undefined,
-         request: {
-            _options: {
-               method: "GET",
-               path: "/api/resource",
-               hostname: "example.com",
-               port: 443,
-            },
-         },
-         code: "ECONNREFUSED",
-         message: "Connection refused",
-         isAxiosError: true,
-      } as unknown as AxiosError;
-
-      logAxiosError(error, false);
-
-      expect(
-         loggerStub.error.calledWith(
-            sinon.match(
-               "Failed to GET resource /api/resource on example.com:443",
-            ),
-         ),
-      ).to.be.true;
-   });
-
-   it("should handle setup error with no request or response", () => {
-      const error = {
-         response: undefined,
-         request: undefined,
-         message: "Invalid URL",
-         isAxiosError: true,
-      } as unknown as AxiosError;
-
-      logAxiosError(error, false);
-
-      expect(
-         (loggerStub.error as sinon.SinonStub).calledWith(
-            "Error",
-            "Invalid URL",
-         ),
-      ).to.be.true;
-   });
-});

package/src/logger.ts

@@ -1,90 +0,0 @@
-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. Error/warn go to stderr so they
-      // never pollute stdout — commands like `cred ls packages` print JSON to
-      // stdout, and a log line landing there makes downstream `JSON.parse`
-      // (e.g. the e2e harness) fail cryptically.
-      new winston.transports.Console({
-         format: consoleFormat,
-         stderrLevels: ["error", "warn"],
-      }),
-
-      // 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

@@ -1,6 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars -- reserved for future globalThis polyfill */
-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.spec.ts

@@ -1,135 +0,0 @@
-import axios from "axios";
-import { expect } from "chai";
-import inquirer from "inquirer";
-import sinon from "sinon";
-import * as loggerModule from "./logger";
-import { getConfirmation, prettifyJson, printOutError, sleep } from "./utils";
-
-describe("utils", () => {
-   let sandbox: sinon.SinonSandbox;
-   let loggerStub: sinon.SinonStubbedInstance<typeof loggerModule.logger>;
-   let logAxiosErrorStub: sinon.SinonStub;
-
-   beforeEach(() => {
-      sandbox = sinon.createSandbox();
-      loggerStub = sandbox.stub(loggerModule.logger);
-      logAxiosErrorStub = sandbox.stub(loggerModule, "logAxiosError");
-   });
-
-   afterEach(() => {
-      sandbox.restore();
-   });
-
-   describe("sleep", () => {
-      it("should wait for the specified time", async function () {
-         this.timeout(100);
-         const start = Date.now();
-         await sleep(50);
-         const elapsed = Date.now() - start;
-         expect(elapsed).to.be.at.least(45);
-      });
-   });
-
-   describe("prettifyJson", () => {
-      it("should format JSON with 2-space indentation", () => {
-         const obj = { name: "test", value: 123 };
-         const result = prettifyJson(obj);
-         expect(result).to.equal('{\n  "name": "test",\n  "value": 123\n}');
-      });
-
-      it("should handle empty objects", () => {
-         const result = prettifyJson({});
-         expect(result).to.equal("{}");
-      });
-
-      it("should handle nested objects", () => {
-         const obj = { nested: { key: "value" } };
-         const result = prettifyJson(obj);
-         expect(result).to.include("nested");
-         expect(result).to.include("key");
-         expect(result).to.include("value");
-      });
-   });
-
-   describe("printOutError", () => {
-      it("should handle axios errors", () => {
-         const axiosError = {
-            isAxiosError: true,
-            response: {
-               status: 404,
-               data: { message: "Not found" },
-            },
-            config: {},
-            name: "AxiosError",
-            message: "Request failed",
-         };
-         sandbox.stub(axios, "isAxiosError").returns(true);
-
-         printOutError(axiosError as any, false);
-
-         expect(logAxiosErrorStub.calledOnce).to.be.true;
-         expect(logAxiosErrorStub.firstCall.args[0]).to.equal(axiosError);
-         expect(logAxiosErrorStub.firstCall.args[1]).to.equal(false);
-      });
-
-      it("should handle non-axios errors", () => {
-         const error = new Error("Generic error");
-         sandbox.stub(axios, "isAxiosError").returns(false);
-
-         printOutError(error, false);
-
-         expect(loggerStub.error.calledOnce).to.be.true;
-         expect(loggerStub.error.calledWith(sinon.match("Unexpected error"))).to
-            .be.true;
-         // Check that error was passed as second argument (Winston accepts Error objects)
-         const errorCall = loggerStub.error.getCall(0);
-         expect(errorCall.args.length).to.be.at.least(2);
-         expect((errorCall.args as any)[1]).to.equal(error);
-      });
-
-      it("should log debug info when debug is true", () => {
-         const error = new Error("Test error");
-         sandbox.stub(axios, "isAxiosError").returns(false);
-
-         printOutError(error, true);
-
-         expect(loggerStub.debug.calledWith(error)).to.be.true;
-      });
-
-      it("should not log debug info when debug is false", () => {
-         const error = new Error("Test error");
-         sandbox.stub(axios, "isAxiosError").returns(false);
-
-         printOutError(error, false);
-
-         expect(loggerStub.debug.called).to.be.false;
-      });
-   });
-
-   describe("getConfirmation", () => {
-      it("should return true when user confirms", async () => {
-         const promptStub = sandbox
-            .stub(inquirer, "prompt")
-            .resolves({ confirm: true });
-
-         const result = await getConfirmation("Are you sure?");
-
-         expect(result).to.be.true;
-         expect(promptStub.calledOnce).to.be.true;
-         expect(promptStub.firstCall.args[0][0].message).to.equal(
-            "Are you sure?",
-         );
-      });
-
-      it("should return false when user denies", async () => {
-         const promptStub = sandbox
-            .stub(inquirer, "prompt")
-            .resolves({ confirm: false });
-
-         const result = await getConfirmation("Are you sure?");
-
-         expect(result).to.be.false;
-         expect(promptStub.calledOnce).to.be.true;
-      });
-   });
-});

package/src/utils.ts

@@ -1,115 +0,0 @@
-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;
-}
-
-export const DEFAULT_PAGE_SIZE = -1; // -1 means return all records
-export const DEFAULT_PAGE = 1;
-export const MAX_PAGE_SIZE = 500;
-
-export interface PaginationOptions {
-   page?: number;
-   pageSize?: number;
-}
-
-export function parsePaginationParams(
-   page?: string | number,
-   pageSize?: string | number,
-): { limit: number; offset: number } {
-   // If no page AND no pageSize specified, return all records
-   if (page === undefined && pageSize === undefined) {
-      logger.info("--page-size not passed, returning all records");
-      return { limit: -1, offset: 0 };
-   }
-
-   // Parse pageSize
-   const parsedPageSize =
-      typeof pageSize === "string" ? parseInt(pageSize, 10) : pageSize;
-
-   // If pageSize is explicitly -1, return all records
-   if (parsedPageSize === -1) {
-      return { limit: -1, offset: 0 };
-   }
-
-   // If page OR pageSize is provided, use pagination
-   // Default pageSize to 100 when page is provided but pageSize is not
-   const effectivePageSize =
-      parsedPageSize !== undefined && !isNaN(parsedPageSize)
-         ? parsedPageSize
-         : page !== undefined
-           ? 100
-           : DEFAULT_PAGE_SIZE;
-
-   // If we still have -1 (shouldn't happen, but safety check), return all
-   if (effectivePageSize === -1) {
-      return { limit: -1, offset: 0 };
-   }
-
-   // Use pagination logic
-   const parsedPage =
-      typeof page === "string" ? parseInt(page, 10) : page || DEFAULT_PAGE;
-   const validPage = Math.max(1, isNaN(parsedPage) ? DEFAULT_PAGE : parsedPage);
-
-   const validPageSize = Math.min(
-      Math.max(1, effectivePageSize),
-      MAX_PAGE_SIZE,
-   );
-
-   const offset = (validPage - 1) * validPageSize;
-
-   return {
-      limit: validPageSize,
-      offset: offset,
-   };
-}
-
-export function extractTotalCount(headers: unknown): number | undefined {
-   if (!headers || typeof headers !== "object") {
-      return undefined;
-   }
-   const h = headers as Record<string, unknown>;
-   const candidates = [h["x-total-count"], h["Total-Count"], h["total-count"]];
-   for (const totalCountHeader of candidates) {
-      if (totalCountHeader == null) {
-         continue;
-      }
-      const raw = Array.isArray(totalCountHeader)
-         ? totalCountHeader[0]
-         : totalCountHeader;
-      const count = parseInt(String(raw), 10);
-      if (!isNaN(count)) {
-         return count;
-      }
-   }
-   return undefined;
-}

package/src/validator.spec.ts

@@ -1,51 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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

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