@credibledata/cred-cli 0.1.4 → 0.1.5

package/src/utils.spec.ts

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

@@ -32,3 +32,84 @@ export async function getConfirmation(message: string): Promise<boolean> {
    ]);
    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/tsconfig.json

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

package/.eslintrc

@@ -1,33 +0,0 @@
-{
-   // Specify the environments where the code will run
-   "env": {
-      "jest": true, // Enable Jest for testing
-      "browser": true, // Enable browser environment
-   },
-
-   // Stop ESLint from searching for configuration in parent folders
-   "root": true,
-
-   // Specify the parser for TypeScript (using @typescript-eslint/parser)
-   "parser": "@typescript-eslint/parser", // Leverages TS ESTree to lint TypeScript
-
-   // Add additional rules and configuration options
-   "plugins": ["@typescript-eslint"],
-
-   // Extend various ESLint configurations and plugins
-   "extends": [
-      "eslint:recommended", // ESLint recommended rules
-      "plugin:react/recommended", // React recommended rules
-      "plugin:@typescript-eslint/recommended", // TypeScript recommended rules
-      "plugin:@typescript-eslint/eslint-recommended", // ESLint overrides for TypeScript
-      "prettier", // Prettier rules
-      "plugin:prettier/recommended", // Prettier plugin integration
-      "plugin:react-hooks/recommended", // Recommended rules for React hooks
-      "plugin:storybook/recommended", // Recommended rules for Storybook
-   ],
-   "rules": {
-      "react/react-in-jsx-scope": "off",
-      "@typescript-eslint/no-unused-expressions": "off",
-      "no-constant-condition": "off",
-   },
-}