@embeddable.com/sdk-core 3.4.0 → 3.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@embeddable.com/sdk-core",
-  "version": "3.4.0",
+  "version": "3.4.1",
   "description": "Core Embeddable SDK module responsible for web-components bundling and publishing.",
   "keywords": [
     "embeddable",
@@ -51,7 +51,7 @@
     "ora": "^8.0.1",
     "serve-static": "^1.15.0",
     "sorcery": "^0.11.0",
-    "vite": "^5.3.1",
+    "vite": "^5.3.2",
     "ws": "^8.17.0",
     "yaml": "^2.3.3"
   },

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/utils.test.ts

@@ -3,6 +3,7 @@ import {
   checkNodeVersion,
   getArgumentByKey,
   storeBuildSuccessFlag,
+  checkBuildSuccess,
   SUCCESS_FLAG_FILE,
 } from "./utils";
 
@@ -96,4 +97,22 @@ describe("utils", () => {
       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/validate.test.ts

@@ -20,6 +20,15 @@ const validYaml = `cubes:
         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:
@@ -66,6 +75,25 @@ describe("validate", () => {
         "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", () => {

package/src/validate.ts

@@ -60,25 +60,28 @@ 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}`);
     }
   }