@embeddable.com/sdk-core 3.3.1 → 3.4.1

package/lib/login.d.ts

@@ -1,3 +1,4 @@
 declare const _default: () => Promise<void>;
 export default _default;
 export declare function getToken(): Promise<any>;
+export declare function resolveFiles(): Promise<void>;

package/lib/utils.d.ts

@@ -1,4 +1,4 @@
-export declare const checkNodeVersion: () => Promise<void>;
+export declare const checkNodeVersion: () => Promise<boolean>;
 /**
  *  Get the value of a process argument by key
  *  Example: getArgumentByKey("--email") or getArgumentByKey(["--email", "-e"])
@@ -6,6 +6,7 @@ export declare const checkNodeVersion: () => Promise<void>;
  * @returns
  */
 export declare const getArgumentByKey: (key: string | string[]) => string | undefined;
+export declare const SUCCESS_FLAG_FILE: string;
 /**
  *  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/lib/validate.d.ts

@@ -1,3 +1,4 @@
 declare const _default: (ctx: any, exitIfInvalid?: boolean) => Promise<boolean>;
 export default _default;
 export declare function dataModelsValidation(filesList: [string, string][]): Promise<string[]>;
+export declare function securityContextValidation(filesList: [string, string][]): Promise<string[]>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@embeddable.com/sdk-core",
-  "version": "3.3.1",
+  "version": "3.4.1",
   "description": "Core Embeddable SDK module responsible for web-components bundling and publishing.",
   "keywords": [
     "embeddable",
@@ -16,7 +16,9 @@
     "directory": "packages/core-sdk"
   },
   "scripts": {
-    "build": "rollup -c"
+    "build": "rollup -c",
+    "test": "vitest run",
+    "test:watch": "vitest"
   },
   "author": "Embeddable.com <engineering@embeddable.com>",
   "files": [
@@ -49,7 +51,7 @@
     "ora": "^8.0.1",
     "serve-static": "^1.15.0",
     "sorcery": "^0.11.0",
-    "vite": "^4.5.0",
+    "vite": "^5.3.2",
     "ws": "^8.17.0",
     "yaml": "^2.3.3"
   },

package/src/build.test.ts

@@ -0,0 +1,96 @@
+import build from "./build";
+import prepare from "./prepare";
+import validate from "./validate";
+import buildTypes from "./buildTypes";
+import provideConfig from "./provideConfig";
+import generate from "./generate";
+import cleanup from "./cleanup";
+
+// @ts-ignore
+import reportErrorToRollbar from "./rollbar.mjs";
+import { storeBuildSuccessFlag } from "./utils";
+
+const mockPlugin = {
+  validate: vi.fn(),
+  build: vi.fn(),
+  cleanup: vi.fn(),
+};
+
+vi.mock("./provideConfig", () => ({
+  default: vi.fn(),
+}));
+
+vi.mock("./buildTypes", () => ({
+  default: vi.fn(),
+}));
+
+vi.mock("./rollbar.mjs", () => ({
+  default: vi.fn(),
+}));
+
+vi.mock("./validate", () => ({
+  default: vi.fn(),
+}));
+
+vi.mock("./prepare", () => ({
+  default: vi.fn(),
+}));
+
+vi.mock("./generate", () => ({
+  default: vi.fn(),
+}));
+
+vi.mock("./cleanup", () => ({
+  default: vi.fn(),
+}));
+
+vi.mock("./utils", async () => {
+  const actual = await vi.importActual("./utils");
+  return {
+    ...actual,
+    storeBuildSuccessFlag: vi.fn(),
+  };
+});
+
+const config = {
+  plugins: [() => mockPlugin],
+};
+
+describe("build", () => {
+  beforeEach(() => {
+    vi.mocked(provideConfig).mockResolvedValue(config);
+  });
+
+  it("should call all the necessary functions", async () => {
+    await build();
+
+    expect(validate).toHaveBeenCalledWith(config);
+    expect(prepare).toHaveBeenCalledWith(config);
+    expect(buildTypes).toHaveBeenCalledWith(config);
+
+    // Plugin
+    expect(mockPlugin.validate).toHaveBeenCalledWith(config);
+    expect(mockPlugin.build).toHaveBeenCalledWith(config);
+    expect(mockPlugin.cleanup).toHaveBeenCalledWith(config);
+
+    expect(generate).toHaveBeenCalledWith(config, "sdk-react");
+
+    expect(cleanup).toHaveBeenCalledWith(config);
+    expect(storeBuildSuccessFlag).toHaveBeenCalled();
+  });
+
+  it("should call reportErrorToRollbar and exit if an error occurs", async () => {
+    vi.spyOn(process, "exit").mockImplementation(() => null as never);
+    vi.spyOn(console, "log").mockImplementation(() => undefined);
+    const error = new Error("test error");
+
+    vi.mocked(validate).mockRejectedValue(error);
+    vi.mocked(reportErrorToRollbar).mockResolvedValue(undefined);
+
+    await build();
+
+    expect(reportErrorToRollbar).toHaveBeenCalledWith(error);
+    expect(console.log).toHaveBeenCalledWith(error);
+    expect(process.exit).toHaveBeenCalledWith(1);
+  });
+});

package/src/buildTypes.test.ts

@@ -0,0 +1,98 @@
+import * as fs from "node:fs/promises";
+import buildTypes, { EMB_TYPE_FILE_REGEX } from "./buildTypes";
+import * as path from "node:path";
+import { build } from "vite";
+import { findFiles, getContentHash } from "@embeddable.com/sdk-utils";
+
+const config = {
+  client: {
+    srcDir: "src",
+    rootDir: "root",
+    buildDir: "build",
+  },
+  outputOptions: {
+    typesEntryPointFilename: "typesEntryPointFilename",
+  },
+};
+
+const startMock = {
+  succeed: vi.fn(),
+  fail: vi.fn(),
+};
+
+vi.mock("ora", () => ({
+  default: () => ({
+    start: vi.fn().mockImplementation(() => startMock),
+    info: vi.fn(),
+    fail: vi.fn(),
+  }),
+}));
+
+vi.mock("@embeddable.com/sdk-utils", () => ({
+  findFiles: vi.fn(),
+  getContentHash: vi.fn(),
+}));
+
+vi.mock("node:path", () => ({
+  resolve: vi.fn(),
+  relative: vi.fn(),
+}));
+
+vi.mock("node:fs/promises", () => ({
+  writeFile: vi.fn(),
+  rm: vi.fn(),
+  readFile: vi.fn(),
+  rename: vi.fn(),
+}));
+
+vi.mock("vite", () => ({
+  build: vi.fn(),
+}));
+
+describe("buildTypes", () => {
+  beforeEach(() => {
+    vi.mocked(findFiles).mockResolvedValue([["fileName", "filePath"]]);
+    vi.mocked(path.relative).mockReturnValue("relativePath");
+    vi.mocked(path.resolve).mockReturnValue("resolvedPath");
+    vi.mocked(fs.readFile).mockResolvedValue("fileContent");
+  });
+
+  it("should build types", async () => {
+    await buildTypes(config);
+
+    expect(findFiles).toHaveBeenCalledWith("src", EMB_TYPE_FILE_REGEX);
+
+    expect(build).toHaveBeenCalledWith({
+      build: {
+        emptyOutDir: false,
+        lib: {
+          entry: "resolvedPath",
+          fileName: "embeddable-types",
+          formats: ["es"],
+        },
+        outDir: "build",
+      },
+      logLevel: "error",
+    });
+
+    expect(fs.readFile).toHaveBeenCalledWith("resolvedPath", "utf8");
+    expect(getContentHash).toHaveBeenCalledWith("fileContent");
+
+    expect(startMock.succeed).toHaveBeenCalledWith("Types built completed");
+
+    expect(fs.writeFile).toHaveBeenCalledWith(
+      "resolvedPath",
+      `import '../relativePath';
+import '../relativePath';`,
+    );
+
+    expect(fs.rm).toHaveBeenCalledWith("resolvedPath");
+  });
+
+  it("should not add hash to the file name when watch is enabled", async () => {
+    await buildTypes({ ...config, dev: { watch: true } });
+
+    expect(getContentHash).not.toHaveBeenCalled();
+    expect(fs.rename).not.toHaveBeenCalled();
+  });
+});

package/src/buildTypes.ts

@@ -2,7 +2,7 @@ import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import * as vite from "vite";
 const oraP = import("ora");
-import { findFiles } from "@embeddable.com/sdk-utils";
+import { findFiles, getContentHash } from "@embeddable.com/sdk-utils";
 
 export const EMB_TYPE_FILE_REGEX = /^(.*)\.type\.emb\.[jt]s$/;
 export const EMB_OPTIONS_FILE_REGEX = /^(.*)\.options\.emb\.[jt]s$/;
@@ -48,28 +48,36 @@ async function generate(ctx: any) {
 }
 
 async function build(ctx: any) {
+  const typesFilePath = path.resolve(
+    ctx.client.buildDir,
+    ctx.outputOptions.typesEntryPointFilename,
+  );
+
   await vite.build({
     logLevel: "error",
     build: {
       emptyOutDir: false,
       lib: {
-        entry: path.resolve(
-          ctx.client.buildDir,
-          ctx.outputOptions.typesEntryPointFilename,
-        ),
+        entry: typesFilePath,
         formats: ["es"],
         fileName: "embeddable-types",
       },
-      rollupOptions: ctx.dev?.watch
-        ? undefined
-        : {
-            output: {
-              entryFileNames: "embeddable-types-[hash].js",
-            },
-          },
       outDir: ctx.client.buildDir,
     },
   });
+
+  if (!ctx.dev?.watch) {
+    const fileContent = await fs.readFile(typesFilePath, "utf8");
+
+    const fileHash = getContentHash(fileContent);
+
+    const fileName = `embeddable-types-${fileHash}.js`;
+
+    await fs.rename(
+      path.resolve(ctx.client.buildDir, "embeddable-types.js"),
+      path.resolve(ctx.client.buildDir, fileName),
+    );
+  }
 }
 
 async function cleanup(ctx: any) {

package/src/cleanup.test.ts

@@ -0,0 +1,85 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { createManifest } from "./cleanup";
+import { findFiles } from "@embeddable.com/sdk-utils";
+
+const ctx = {
+  client: {
+    tmpDir: "tmpDir",
+    stencilBuild: "stencilBuild",
+    buildDir: "buildDir",
+  },
+};
+
+vi.mock("node:fs/promises", () => ({
+  writeFile: vi.fn(),
+  rename: vi.fn(),
+}));
+
+vi.mock("@embeddable.com/sdk-utils", () => ({
+  findFiles: vi.fn(),
+}));
+
+vi.mock("node:path", async () => {
+  const actual = await vi.importActual("node:path");
+  return {
+    ...actual,
+    resolve: vi.fn(),
+    basename: vi.fn(),
+    join: vi.fn(),
+  };
+});
+
+describe("cleanup", () => {
+  describe("createManifest", () => {
+    beforeEach(() => {
+      vi.mocked(fs.writeFile).mockImplementation(async () => undefined);
+      vi.mocked(fs.rename).mockImplementation(async () => undefined);
+      vi.mocked(findFiles).mockResolvedValue([["", ""]]);
+      vi.mocked(path.basename).mockReturnValue("basename");
+      vi.mocked(path.join).mockImplementation((...args) => args.join("/"));
+
+      Object.defineProperties(process, {
+        platform: {
+          value: "darwin",
+        },
+        version: {
+          value: "v18.20.2",
+        },
+        env: {
+          value: {
+            npm_config_user_agent: "npm/10.7.0",
+          },
+        },
+      });
+    });
+    it("should create manifest", async () => {
+      await createManifest({
+        ctx,
+        typesFileName: "typesFileName",
+        metaFileName: "metaFileName",
+        editorsMetaFileName: "editorsMetaFileName",
+        stencilWrapperFileName: "stencilWrapperFileName",
+      });
+
+      expect(fs.writeFile).toHaveBeenCalledWith(
+        "tmpDir/embeddable-manifest.json",
+        JSON.stringify({
+          entryFiles: {
+            "embeddable-types.js": "typesFileName",
+            "embeddable-components-meta.js": "metaFileName",
+            "embeddable-editors-meta.js": "editorsMetaFileName",
+            "embeddable-wrapper.esm.js": "stencilWrapperFileName",
+          },
+          metadata: {
+            nodeVersion: "v18.20.2",
+            platform: "darwin",
+            sdkVersions: {},
+            packageManager: "npm",
+            packageManagerVersion: "10.7.0",
+          },
+        }),
+      );
+    });
+  });
+});

package/src/cleanup.ts

@@ -19,7 +19,7 @@ type ManifestArgs = {
   stencilWrapperFileName: string;
 };
 
-async function createManifest({
+export async function createManifest({
   ctx,
   typesFileName,
   metaFileName,
@@ -81,36 +81,44 @@ async function createManifest({
 }
 
 async function extractBuild(ctx: any) {
-  const [[, stencilWrapperFilePath]] = await findFiles(
+  const stencilBuildFiles = await findFiles(
     ctx.client.stencilBuild,
     /embeddable-wrapper.esm-[a-z0-9]+\.js/,
   );
 
+  const [[, stencilWrapperFilePath]] = stencilBuildFiles || [];
+
   const stencilWrapperFileName = path.basename(stencilWrapperFilePath);
   await fs.rename(
     path.resolve(ctx.client.buildDir, ctx.client.stencilBuild),
     ctx.client.tmpDir,
   );
 
-  const [[, typesFilePath]] = await findFiles(
+  const typesBuildFiles = await findFiles(
     ctx.client.buildDir,
     /embeddable-types-[a-z0-9]+\.js/,
   );
 
+  const [[, typesFilePath]] = typesBuildFiles || [];
+
   const typesFileName = path.basename(typesFilePath);
   await fs.rename(typesFilePath, path.join(ctx.client.tmpDir, typesFileName));
 
-  const [[, metaFilePath]] = await findFiles(
+  const metaBuildFiles = await findFiles(
     ctx.client.buildDir,
     /embeddable-components-meta-[a-z0-9]+\.js/,
   );
+
+  const [[, metaFilePath]] = metaBuildFiles || [];
   const metaFileName = path.basename(metaFilePath);
   await fs.rename(metaFilePath, path.join(ctx.client.tmpDir, metaFileName));
 
-  const [[, editorsMetaFilePath]] = await findFiles(
+  const editorsMetaBuildFiles = await findFiles(
     ctx.client.buildDir,
     /embeddable-editors-meta-[a-z0-9]+\.js/,
   );
+
+  const [[, editorsMetaFilePath]] = editorsMetaBuildFiles || [];
   const editorsMetaFileName = path.basename(editorsMetaFilePath);
   await fs.rename(
     editorsMetaFilePath,

package/src/login.test.ts

@@ -0,0 +1,121 @@
+import { server } from "./../../../mocks/server";
+import login, { resolveFiles, getToken } from "./login";
+import { vi } from "vitest";
+import { pathToFileURL } from "node:url";
+import { existsSync } from "node:fs";
+import { mkdir, access, writeFile, readFile } from "fs/promises";
+import { CREDENTIALS_DIR, CREDENTIALS_FILE } from "./credentials";
+import { http, HttpResponse } from "msw";
+import { AxiosError } from "axios";
+
+vi.mock("fs/promises", () => ({
+  readFile: vi.fn(),
+  writeFile: vi.fn(),
+  access: vi.fn(),
+  mkdir: vi.fn(),
+}));
+
+const startMock = {
+  succeed: vi.fn(),
+  fail: vi.fn(),
+};
+
+vi.mock("ora", () => ({
+  default: () => ({
+    start: vi.fn().mockImplementation(() => startMock),
+    info: vi.fn(),
+  }),
+}));
+
+vi.mock("./rollbar.mjs", () => ({
+  default: vi.fn(),
+}));
+
+vi.mock("open", () => ({
+  default: vi.fn(),
+}));
+
+vi.mock("node:fs", () => ({
+  existsSync: vi.fn(),
+}));
+
+vi.mock("node:url", () => ({
+  pathToFileURL: vi.fn(),
+}));
+
+vi.mock(`${process.cwd()}/embeddable.config.ts`, () => ({
+  default: {
+    authDomain: "test-domain.com",
+  },
+}));
+
+describe("login", () => {
+  beforeEach(async () => {
+    vi.mocked(readFile).mockImplementation(async () =>
+      Buffer.from(`{"access_token":"mocked-token"}`),
+    );
+
+    vi.mocked(access).mockImplementation(async () => {
+      throw new Error();
+    });
+
+    vi.mocked(mkdir).mockImplementation(async () => "mocked");
+
+    vi.mocked(writeFile).mockImplementation(async () => undefined);
+
+    vi.mocked(existsSync).mockImplementation(() => true);
+    vi.mocked(pathToFileURL).mockImplementation(
+      () => new URL("mocked-config-path"),
+    );
+  });
+
+  vi.mock("./reportErrorToRollbar", () => vi.fn());
+  vi.mock("./sleep", () => vi.fn());
+
+  it("should resolve files", async () => {
+    await resolveFiles();
+
+    expect(access).toHaveBeenCalledWith(CREDENTIALS_DIR);
+    expect(mkdir).toHaveBeenCalledWith(CREDENTIALS_DIR);
+    expect(writeFile).toHaveBeenCalledWith(CREDENTIALS_FILE, "");
+  });
+
+  it("should get token", async () => {
+    const token = await getToken();
+
+    expect(token).toBe("mocked-token");
+  });
+
+  it("should login by saving token in the credentials file", async () => {
+    await login();
+    expect(startMock.succeed).toHaveBeenCalledWith(
+      "You are successfully authenticated now!",
+    );
+
+    expect(writeFile).toHaveBeenCalledWith(
+      CREDENTIALS_FILE,
+      JSON.stringify({ access_token: "mocked-token " }),
+    );
+  });
+
+  it("should fail to login when the response returns 500 error", async () => {
+    vi.spyOn(console, "log").mockImplementation(() => undefined);
+    vi.spyOn(process, "exit").mockImplementation(() => undefined as never);
+
+    server.use(
+      http.post("**/oauth/device/code", () => {
+        return new HttpResponse(null, { status: 500 });
+      }),
+    );
+
+    await login();
+
+    expect(startMock.fail).toHaveBeenCalledWith(
+      "Authentication failed. Please try again.",
+    );
+
+    expect(console.log).toHaveBeenCalledWith(
+      new AxiosError("Request failed with status code 500"),
+    );
+  });
+});

package/src/login.ts

@@ -94,7 +94,7 @@ function sleep(ms: number) {
   return new Promise((res) => setTimeout(res, ms));
 }
 
-async function resolveFiles() {
+export async function resolveFiles() {
   try {
     await fs.access(CREDENTIALS_DIR);
   } catch (_e) {

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");
+  });
+});