@embeddable.com/sdk-core 3.3.1 → 3.4.1

package/src/push.test.ts

@@ -0,0 +1,184 @@
+import push from "./push";
+import provideConfig from "./provideConfig";
+import { fileFromPath } from "formdata-node/file-from-path";
+import * as archiver from "archiver";
+import * as fs from "node:fs/promises";
+import * as fsSync from "node:fs";
+import { findFiles } from "@embeddable.com/sdk-utils";
+
+// @ts-ignore
+import reportErrorToRollbar from "./rollbar.mjs";
+import { checkBuildSuccess, checkNodeVersion, getArgumentByKey } from "./utils";
+import { server } from "../../../mocks/server";
+import { http, HttpResponse } from "msw";
+
+const infoMock = {
+  info: vi.fn(),
+  succeed: vi.fn(),
+  fail: vi.fn(),
+};
+
+const startMock = {
+  succeed: vi.fn(),
+  info: () => infoMock,
+  fail: vi.fn(),
+};
+
+vi.mock("ora", () => ({
+  default: () => ({
+    start: vi.fn().mockReturnValue(startMock),
+    info: vi.fn(),
+  }),
+}));
+
+vi.mock("./utils", () => ({
+  checkNodeVersion: vi.fn(),
+  checkBuildSuccess: vi.fn(),
+  getArgumentByKey: vi.fn(),
+}));
+
+vi.mock("node:fs/promises", () => ({
+  writeFile: vi.fn(),
+  readFile: vi.fn(),
+  access: vi.fn(),
+  rm: vi.fn(),
+}));
+
+vi.mock("node:fs", () => ({
+  createWriteStream: vi.fn(),
+}));
+
+vi.mock("./provideConfig", () => ({
+  default: vi.fn(),
+}));
+
+vi.mock("./rollbar.mjs", () => ({
+  default: vi.fn(),
+}));
+
+vi.mock("@embeddable.com/sdk-utils", () => ({
+  findFiles: vi.fn(),
+}));
+
+vi.mock("archiver", () => ({
+  create: vi.fn(),
+}));
+
+vi.mock("formdata-node/file-from-path", () => ({
+  fileFromPath: vi.fn().mockReturnValue(new Blob([new ArrayBuffer(8)])),
+}));
+
+const config = {
+  client: {
+    rootDir: "rootDir",
+    buildDir: "buildDir",
+    archiveFile: "embeddable-build.zip",
+  },
+  pushBaseUrl: "pushBaseUrl",
+  previewBaseUrl: "previewBaseUrl",
+};
+
+describe("push", () => {
+  beforeEach(() => {
+    vi.mocked(checkNodeVersion).mockResolvedValue(true);
+    vi.mocked(checkBuildSuccess).mockResolvedValue(true);
+    vi.mocked(getArgumentByKey).mockReturnValue(undefined);
+    vi.mocked(provideConfig).mockResolvedValue(config);
+    vi.mocked(fs.access).mockResolvedValue(undefined);
+    vi.mocked(fs.readFile).mockImplementation(async () =>
+      Buffer.from(`{"access_token":"mocked-token"}`),
+    );
+
+    vi.mocked(findFiles).mockResolvedValue([["fileName", "filePath"]]);
+    vi.mocked(fileFromPath).mockReturnValue(
+      new Blob([new ArrayBuffer(8)]) as any,
+    );
+    vi.mocked(archiver.create).mockReturnValue({
+      finalize: vi.fn(),
+      pipe: vi.fn(),
+      directory: vi.fn(),
+      file: vi.fn(),
+    } as any);
+
+    vi.mocked(fsSync.createWriteStream).mockReturnValue({
+      on: (event: string, cb: () => void) => {
+        cb();
+      },
+      end: vi.fn(),
+    } as any);
+
+    vi.spyOn(process, "exit").mockImplementation(() => null as never);
+  });
+
+  it("should push the build", async () => {
+    await push();
+
+    expect(provideConfig).toHaveBeenCalled();
+    expect(checkNodeVersion).toHaveBeenCalled();
+    expect(checkBuildSuccess).toHaveBeenCalled();
+
+    expect(fs.access).toHaveBeenCalledWith(config.client.buildDir);
+
+    expect(archiver.create).toHaveBeenCalledWith("zip", {
+      zlib: { level: 9 },
+    });
+    expect(fsSync.createWriteStream).toHaveBeenCalledWith(
+      config.client.archiveFile,
+    );
+
+    // after publishing the file gets removed
+    expect(fs.rm).toHaveBeenCalledWith(config.client.archiveFile);
+
+    expect(infoMock.info).toHaveBeenCalledWith(
+      "Publishing to mocked-workspace-name using previewBaseUrl/workspace/mocked-workspace-id...",
+    );
+    expect(infoMock.succeed).toHaveBeenCalledWith(
+      "Published to mocked-workspace-name using previewBaseUrl/workspace/mocked-workspace-id",
+    );
+  });
+
+  it("should fail if there are no workspaces", async () => {
+    vi.spyOn(console, "error").mockImplementation(() => undefined);
+    server.use(
+      http.get("**/workspace", () => {
+        return HttpResponse.json([]);
+      }),
+    );
+
+    await push();
+
+    expect(startMock.fail).toHaveBeenCalledWith("No workspaces found");
+    expect(process.exit).toHaveBeenCalledWith(1);
+    expect(reportErrorToRollbar).toHaveBeenCalled();
+  });
+
+  it("should fail if the build is not successful", async () => {
+    vi.mocked(checkBuildSuccess).mockResolvedValue(false);
+
+    await push();
+
+    expect(process.exit).toHaveBeenCalledWith(1);
+
+    expect(console.error).toHaveBeenCalledWith(
+      "Build failed or not completed. Please run `embeddable:build` first.",
+    );
+  });
+
+  it("should push by api key provided in the arguments", async () => {
+    vi.mocked(getArgumentByKey).mockReturnValue("mocked-api-key");
+    Object.defineProperties(process, {
+      argv: {
+        value: [
+          "--api-key",
+          "mocked-api-key",
+          "--email",
+          "mocked-email@valid.com",
+        ],
+      },
+    });
+
+    await push();
+
+    expect(startMock.succeed).toHaveBeenCalledWith("Published using API key");
+  });
+});

package/src/push.ts

@@ -43,6 +43,9 @@ export default async () => {
     }
 
     const token = await verify(config);
+    spinnerPushing = ora()
+      .start()
+      .info("No API Key provided. Standard login will be used.");
 
     const { workspaceId, name: workspaceName } = await selectWorkspace(
       config,
@@ -52,9 +55,9 @@ export default async () => {
     const workspacePreviewUrl = `${config.previewBaseUrl}/workspace/${workspaceId}`;
 
     await buildArchive(config);
-    spinnerPushing = ora(
+    spinnerPushing.info(
       `Publishing to ${workspaceName} using ${workspacePreviewUrl}...`,
-    ).start();
+    );
 
     await sendBuild(config, { workspaceId, token });
     spinnerPushing.succeed(

package/src/utils.test.ts

@@ -0,0 +1,118 @@
+import * as fs from "node:fs/promises";
+import {
+  checkNodeVersion,
+  getArgumentByKey,
+  storeBuildSuccessFlag,
+  checkBuildSuccess,
+  SUCCESS_FLAG_FILE,
+} from "./utils";
+
+const startMock = {
+  succeed: vi.fn(),
+  fail: vi.fn(),
+};
+
+const failMock = vi.fn();
+
+vi.mock("ora", () => ({
+  default: () => ({
+    start: vi.fn().mockImplementation(() => startMock),
+    info: vi.fn(),
+    fail: failMock,
+  }),
+}));
+
+vi.mock("../package.json", () => ({
+  engines: {
+    node: "14.x",
+  },
+}));
+
+vi.mock("fs/promises", () => ({
+  readFile: vi.fn(),
+  writeFile: vi.fn(),
+  access: vi.fn(),
+  mkdir: vi.fn(),
+}));
+
+describe("utils", () => {
+  describe("checkNodeVersion", () => {
+    it("should return true if the node version is greater than 14", async () => {
+      const result = await checkNodeVersion();
+
+      expect(result).toBe(true);
+    });
+
+    it("should fail if the node version is less than 16", async () => {
+      Object.defineProperty(process.versions, "node", {
+        value: "14.0",
+        configurable: true,
+      });
+
+      vi.mock("../package.json", () => ({
+        engines: {
+          node: "16.x",
+        },
+      }));
+
+      vi.spyOn(process, "exit").mockImplementation(() => null as never);
+
+      const result = await checkNodeVersion();
+
+      expect(failMock).toHaveBeenCalledWith({
+        text: "Node version 16.0 or higher is required. You are running 14.0.",
+        color: "red",
+      });
+
+      expect(result).toBe(undefined);
+    });
+  });
+
+  describe("getArgumentByKey", () => {
+    it("should return the value of the argument", () => {
+      process.argv = ["--email", "test@a.com", "--password", "123456"];
+      const result = getArgumentByKey("--email");
+
+      expect(result).toBe("test@a.com");
+
+      process.argv = ["-e", "test@a.com", "--password", "123456"];
+      const result2 = getArgumentByKey(["--email", "-e"]);
+
+      expect(result2).toBe("test@a.com");
+    });
+  });
+
+  describe("storeBuildSuccessFlag", () => {
+    it("should write a success flag file", async () => {
+      await storeBuildSuccessFlag();
+
+      expect(fs.writeFile).toHaveBeenCalledWith(SUCCESS_FLAG_FILE, "true");
+    });
+
+    it("should throw an error if the file write fails", async () => {
+      vi.mocked(fs.writeFile).mockImplementation(async () => {
+        throw new Error();
+      });
+
+      await expect(storeBuildSuccessFlag()).rejects.toThrow();
+    });
+  });
+
+  describe("checkBuildSuccess", () => {
+    it("should return true if the success flag file exists", async () => {
+      vi.mocked(fs.access).mockResolvedValue(undefined);
+
+      const result = await checkBuildSuccess();
+
+      expect(result).toBe(true);
+    });
+
+    it("should return false if the success flag file does not exist", async () => {
+      vi.mocked(fs.access).mockRejectedValue(undefined);
+
+      const result = await checkBuildSuccess();
+
+      expect(result).toBe(false);
+    });
+  });
+});

package/src/utils.ts

@@ -6,23 +6,28 @@ import path from "node:path";
 let ora: any;
 export const checkNodeVersion = async () => {
   ora = (await oraP).default;
-  ora("Checking node version...");
+  const spinner = ora("Checking node version...");
   const [major, minor] = process.versions.node.split(".").map(Number);
 
-  const engines = require("../package.json").engines.node;
+  const packageJson = await import("../package.json");
+  const {
+    engines: { node },
+  } = packageJson;
 
-  const [minMajor, minMinor] = engines
+  const [minMajor, minMinor] = node
     .split(".")
     .map((v: string) => v.replace(/[^\d]/g, ""))
     .map(Number);
 
   if (major < minMajor || (major === minMajor && minor < minMinor)) {
-    ora({
+    spinner.fail({
       text: `Node version ${minMajor}.${minMinor} or higher is required. You are running ${major}.${minor}.`,
       color: "red",
-    }).fail();
+    });
 
     process.exit(1);
+  } else {
+    return true;
   }
 };
 
@@ -48,7 +53,7 @@ export const getArgumentByKey = (key: string | string[]) => {
   return index !== -1 ? process.argv[index + 1] : undefined;
 };
 
-const SUCCESS_FLAG_FILE = `${CREDENTIALS_DIR}/success`;
+export const SUCCESS_FLAG_FILE = `${CREDENTIALS_DIR}/success`;
 /**
  *  Store a flag in the credentials directory to indicate a successful build
  *  This is used to determine if the build was successful or not

package/src/validate.test.ts

@@ -0,0 +1,124 @@
+import { dataModelsValidation, securityContextValidation } from "./validate";
+import * as fs from "node:fs/promises";
+
+const startMock = {
+  succeed: vi.fn(),
+  fail: vi.fn(),
+};
+
+const failMock = vi.fn();
+
+const validYaml = `cubes:
+  - name: customers
+    title: My customers
+    data_source: default
+    sql_table: public.customers
+
+    dimensions:
+      - name: id
+        sql: id
+        type: number
+        primary_key: true`;
+
+const invalidYaml = `${validYaml}
+    measures:
+      - name: count
+        type: count
+        title: '# of customers'
+      - name: test
+        type: number
+        sql: {count} / 10.0`;
+
+const securityContextYaml = `
+- name: Example customer 1
+  securityContext:
+    country: United States
+  environment: default`;
+
+vi.mock("ora", () => ({
+  default: () => ({
+    start: vi.fn().mockImplementation(() => startMock),
+    info: vi.fn(),
+    fail: failMock,
+  }),
+}));
+
+vi.mock("node:fs/promises", () => ({
+  readFile: vi.fn(),
+  writeFile: vi.fn(),
+  access: vi.fn(),
+  mkdir: vi.fn(),
+}));
+
+describe("validate", () => {
+  describe("dataModelsValidation", () => {
+    it("should return an empty array if the data models are valid", async () => {
+      vi.mocked(fs.readFile).mockImplementation(async () => {
+        return validYaml;
+      });
+      const filesList: [string, string][] = [
+        ["valid-cube.yaml", "path/to/file"],
+      ];
+      const result = await dataModelsValidation(filesList);
+      expect(result).toEqual([]);
+    });
+
+    it("should return an array of error messages if the data models are invalid", async () => {
+      vi.mocked(fs.readFile).mockImplementation(async () => {
+        return "";
+      });
+      const filesList: [string, string][] = [
+        ["invalid-cube.yaml", "path/to/file"],
+      ];
+      const result = await dataModelsValidation(filesList);
+      expect(result).toEqual([
+        "path/to/file: At least one cubes or views must be defined",
+      ]);
+    });
+
+    it("should return an array of error messages if the data models parsing fails", async () => {
+      vi.mocked(fs.readFile).mockImplementation(async () => {
+        return invalidYaml;
+      });
+      const filesList: [string, string][] = [
+        ["invalid-cube.yaml", "path/to/file"],
+      ];
+      const result = await dataModelsValidation(filesList);
+      expect(result).toMatchInlineSnapshot(`
+        [
+          "path/to/file: Unexpected scalar at node end at line 18, column 22:
+
+                sql: {count} / 10.0
+                             ^^^^^^
+        ",
+        ]
+      `);
+    });
+  });
+
+  describe("securityContextValidation", () => {
+    it("should return an empty array if the security context is valid", async () => {
+      vi.mocked(fs.readFile).mockImplementation(async () => {
+        return securityContextYaml;
+      });
+      const filesList: [string, string][] = [
+        ["valid-security-context.json", "path/to/file"],
+      ];
+      const result = await securityContextValidation(filesList);
+      expect(result).toEqual([]);
+    });
+
+    it("should return an array of error messages if the security context is invalid", async () => {
+      vi.mocked(fs.readFile).mockImplementation(async () => {
+        return `${securityContextYaml} ${securityContextYaml}`;
+      });
+      const filesList: [string, string][] = [
+        ["invalid-security-context.json", "path/to/file"],
+      ];
+      const result = await securityContextValidation(filesList);
+      expect(result).toEqual([
+        'path/to/file: security context with name "Example customer 1" already exists',
+      ]);
+    });
+  });
+});

package/src/validate.ts

@@ -2,24 +2,11 @@ import * as fs from "node:fs/promises";
 import * as YAML from "yaml";
 import { errorFormatter, findFiles } from "@embeddable.com/sdk-utils";
 import { z } from "zod";
+import { checkNodeVersion } from "./utils";
 
 const CUBE_YAML_FILE_REGEX = /^(.*)\.cube\.ya?ml$/;
 const SECURITY_CONTEXT_FILE_REGEX = /^(.*)\.sc\.ya?ml$/;
 
-const checkNodeVersion = () => {
-  const [major, minor] = process.versions.node.split(".").map(Number);
-
-  const engines = require("../package.json").engines.node;
-
-  const [minMajor, minMinor] = engines.split(".").map(Number);
-
-  if (major < minMajor || (major === minMajor && minor < minMinor)) {
-    throw new Error(
-      `Node version ${minMajor}.${minMinor} or higher is required. You are running ${major}.${minor}.`,
-    );
-  }
-};
-
 export default async (ctx: any, exitIfInvalid = true) => {
   checkNodeVersion();
   const ora = (await import("ora")).default;
@@ -73,32 +60,35 @@ export async function dataModelsValidation(filesList: [string, string][]) {
   for (const [_, filePath] of filesList) {
     const fileContentRaw = await fs.readFile(filePath, "utf8");
 
-    const cube = YAML.parse(fileContentRaw);
-
-    if (!cube?.cubes && !cube?.views) {
-      return [`${filePath}: At least one cubes or views must be defined`];
-    }
+    try {
+      const cube = YAML.parse(fileContentRaw);
+      if (!cube?.cubes && !cube?.views) {
+        return [`${filePath}: At least one cubes or views must be defined`];
+      }
 
-    const cubeModelSafeParse = cubeModelSchema.safeParse(cube);
-    const viewModelSafeParse = viewModelSchema.safeParse(cube);
+      const cubeModelSafeParse = cubeModelSchema.safeParse(cube);
+      const viewModelSafeParse = viewModelSchema.safeParse(cube);
 
-    if (cube.cubes && !cubeModelSafeParse.success) {
-      errorFormatter(cubeModelSafeParse.error.issues).forEach((error) => {
-        errors.push(`${filePath}: ${error}`);
-      });
-    }
+      if (cube.cubes && !cubeModelSafeParse.success) {
+        errorFormatter(cubeModelSafeParse.error.issues).forEach((error) => {
+          errors.push(`${filePath}: ${error}`);
+        });
+      }
 
-    if (cube.views && !viewModelSafeParse.success) {
-      errorFormatter(viewModelSafeParse.error.issues).forEach((error) => {
-        errors.push(`${filePath}: ${error}`);
-      });
+      if (cube.views && !viewModelSafeParse.success) {
+        errorFormatter(viewModelSafeParse.error.issues).forEach((error) => {
+          errors.push(`${filePath}: ${error}`);
+        });
+      }
+    } catch (e: any) {
+      errors.push(`${filePath}: ${e.message}`);
     }
   }
 
   return errors;
 }
 
-async function securityContextValidation(filesList: [string, string][]) {
+export async function securityContextValidation(filesList: [string, string][]) {
   const errors: string[] = [];
 
   const nameSet = new Set<string>();