@credibledata/cred-cli 0.0.6

package/src/utils.ts

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

@@ -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,17 @@
+{
+   "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"]
+}