@embeddable.com/sdk-core 3.3.0 → 3.4.0

package/src/provideConfig.test.ts

@@ -0,0 +1,32 @@
+import { pathToFileURL } from "node:url";
+import { existsSync } from "node:fs";
+import provideConfig from "./provideConfig";
+import { vi } from "vitest";
+
+vi.mock("node:fs", () => ({
+  existsSync: vi.fn(),
+}));
+
+vi.mock("node:url", () => ({
+  pathToFileURL: vi.fn(),
+}));
+
+vi.mock(`${process.cwd()}/embeddable.config.ts`, () => ({
+  default: "mocked-config",
+}));
+
+describe("provideConfig", () => {
+  beforeEach(() => {
+    vi.mocked(existsSync).mockImplementation(() => true);
+    vi.mocked(pathToFileURL).mockImplementation(
+      () => new URL("mocked-config-path"),
+    );
+  });
+
+  it("should return the default config when the config file exists", async () => {
+    const result = await provideConfig();
+
+    // Assert the result
+    expect(result).toEqual("mocked-config");
+  });
+});

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,99 @@
+import * as fs from "node:fs/promises";
+import {
+  checkNodeVersion,
+  getArgumentByKey,
+  storeBuildSuccessFlag,
+  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();
+    });
+  });
+});

package/src/utils.ts

@@ -1,27 +1,33 @@
 const oraP = import("ora");
 import * as fs from "node:fs/promises";
 import { CREDENTIALS_DIR } from "./credentials";
+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;
   }
 };
 
@@ -47,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
@@ -82,3 +88,18 @@ export const checkBuildSuccess = async () => {
     return false;
   }
 };
+
+export const getPackageVersion = (packageName: string) => {
+  const packageJsonPath = path.join(
+    process.cwd(),
+    "node_modules",
+    packageName,
+    "package.json",
+  );
+  try {
+    const packageJson = require(packageJsonPath);
+    return packageJson.version;
+  } catch (e) {
+    return undefined;
+  }
+};

package/src/validate.test.ts

@@ -0,0 +1,96 @@
+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 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",
+      ]);
+    });
+  });
+
+  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;
@@ -98,7 +85,7 @@ export async function dataModelsValidation(filesList: [string, string][]) {
   return errors;
 }
 
-async function securityContextValidation(filesList: [string, string][]) {
+export async function securityContextValidation(filesList: [string, string][]) {
   const errors: string[] = [];
 
   const nameSet = new Set<string>();