@embeddable.com/sdk-core 3.13.6 → 3.14.0-next.1

package/src/buildGlobalHooks.unit.test.ts

@@ -0,0 +1,273 @@
+// buildGlobalHooks.unit.test.ts
+import { describe, it, expect, beforeEach, vi, Mock } from "vitest";
+import * as fs from "node:fs/promises";
+import * as fsSync from "node:fs";
+import * as vite from "vite";
+import {
+  findFiles,
+  getContentHash,
+  getGlobalHooksMeta,
+  getComponentLibraryConfig,
+} from "@embeddable.com/sdk-utils";
+
+import buildGlobalHooks from "../src/buildGlobalHooks";
+import { ResolvedEmbeddableConfig } from "./defineConfig";
+import path from "node:path";
+
+// Mock implementations
+vi.mock("node:fs/promises");
+vi.mock("node:fs");
+vi.mock("vite");
+vi.mock("@embeddable.com/sdk-utils", async () => {
+  const actual = await vi.importActual<
+    typeof import("@embeddable.com/sdk-utils")
+  >("@embeddable.com/sdk-utils");
+  return {
+    ...actual,
+    findFiles: vi.fn(),
+    getContentHash: vi.fn(),
+    getGlobalHooksMeta: vi.fn(),
+    getComponentLibraryConfig: vi.fn(),
+  };
+});
+
+const lifecyclePath = path.resolve(
+  process.cwd(),
+  "fake",
+  "root",
+  "embeddable.lifecycle.ts",
+);
+const themePath = path.resolve(
+  process.cwd(),
+  "fake",
+  "root",
+  "embeddable.theme.ts",
+);
+
+describe("buildGlobalHooks (Unit Tests)", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("should skip lifecycle building if file doesn't exist", async () => {
+    vi.spyOn(fsSync, "existsSync").mockImplementation((p: any) => {
+      // We want the code to see that /fake/root/embeddable.lifecycle.ts does NOT exist
+      if (p === lifecyclePath) {
+        return false;
+      }
+      // Otherwise, default to false
+      return false;
+    });
+
+    // Possibly not used, but let's mock anyway
+    (findFiles as Mock).mockResolvedValue([]);
+
+    // The aggregator template might be read if there's some library with a theme
+    (fs.readFile as Mock).mockResolvedValue("some template content");
+    (getContentHash as Mock).mockReturnValue("abc123");
+
+    const ctx: ResolvedEmbeddableConfig = {
+      client: {
+        srcDir: path.resolve(process.cwd(), "fake", "src"),
+        buildDir: path.resolve(process.cwd(), "fake", "build"),
+        rootDir: path.resolve(process.cwd(), "fake", "root"),
+        lifecycleHooksFile: lifecyclePath,
+        componentLibraries: [],
+        customizationFile: themePath,
+      },
+      core: {
+        templatesDir: "/fake/templates",
+      },
+    } as any;
+
+    await buildGlobalHooks(ctx);
+
+    // Because we skip building the repo lifecycle, no call to vite.build with that entry
+    expect(vite.build).not.toHaveBeenCalledWith(
+      expect.objectContaining({
+        build: expect.objectContaining({
+          lib: expect.objectContaining({
+            entry: lifecyclePath,
+          }),
+        }),
+      }),
+    );
+  });
+
+  it("should build lifecycle file if it exists", async () => {
+    // Now we say "repo lifecycle does exist"
+    vi.spyOn(fsSync, "existsSync").mockImplementation((p: any) => {
+      // If path is exactly the lifecycle file => true
+      return p === lifecyclePath;
+    });
+
+    // Just in case, but not strictly used here
+    (findFiles as Mock).mockResolvedValue([]);
+    // The aggregator template might or might not be read
+    (fs.readFile as Mock).mockResolvedValue("some file content");
+    (getContentHash as Mock).mockReturnValue("abc123");
+    (fs.rename as Mock).mockResolvedValue(undefined);
+    (vite.build as Mock).mockResolvedValue(undefined);
+
+    const ctx: ResolvedEmbeddableConfig = {
+      client: {
+        srcDir: path.resolve(process.cwd(), "fake", "src"),
+        buildDir: path.resolve(process.cwd(), "fake", "build"),
+        rootDir: path.resolve(process.cwd(), "fake", "root"),
+        lifecycleHooksFile: lifecyclePath,
+        customizationFile: themePath,
+        componentLibraries: [],
+      },
+      core: {
+        templatesDir: "/fake/templates",
+      },
+    } as any;
+
+    await buildGlobalHooks(ctx);
+
+    // We expect a call to build the lifecycle
+    expect(vite.build).toHaveBeenCalledWith(
+      expect.objectContaining({
+        build: expect.objectContaining({
+          lib: expect.objectContaining({
+            entry: lifecyclePath,
+            fileName: "embeddable-lifecycle",
+          }),
+        }),
+      }),
+    );
+  });
+
+  it("should build theme aggregator if libraries exist with themeProvider references", async () => {
+    // aggregator template read is guaranteed
+    (fs.readFile as Mock).mockResolvedValue("template content");
+    (getContentHash as Mock).mockReturnValue("xyz777");
+    (fs.rename as Mock).mockResolvedValue(undefined);
+    (vite.build as Mock).mockResolvedValue(undefined);
+
+    // Suppose we skip the lifecycle, but aggregator is still built
+    vi.spyOn(fsSync, "existsSync").mockImplementation((p: any) => {
+      // lifecycle => false
+      if (p === lifecyclePath) return false;
+      // local theme => true
+      if (p === themePath) return true;
+      return false;
+    });
+
+    (getComponentLibraryConfig as Mock).mockImplementation((cfg: any) => ({
+      libraryName: cfg.name,
+    }));
+
+    // Each library call to getGlobalHooksMeta occurs twice:
+    // 1) buildThemeHook -> aggregator
+    // 2) buildLifecycleHooks -> but we skip it if lifecycle doesn't exist
+    // The code still calls getGlobalHooksMeta for each library in buildLifecycleHooks
+    // So we must provide 4 total mock results for 2 libraries => aggregator + lifecycle each.
+
+    (getGlobalHooksMeta as Mock)
+      // aggregator call #1: libA
+      .mockResolvedValueOnce({
+        themeProvider: "libA-theme.js",
+        lifecycleHooks: [],
+      })
+      // aggregator call #2: libB
+      .mockResolvedValueOnce({
+        themeProvider: "libB-theme.js",
+        lifecycleHooks: [],
+      })
+      // lifecycle call #1: libA
+      .mockResolvedValueOnce({
+        themeProvider: "libA-theme.js",
+        lifecycleHooks: [],
+      })
+      // lifecycle call #2: libB
+      .mockResolvedValueOnce({
+        themeProvider: "libB-theme.js",
+        lifecycleHooks: [],
+      });
+
+    const ctx: ResolvedEmbeddableConfig = {
+      client: {
+        srcDir: path.resolve(process.cwd(), "fake", "src"),
+        buildDir: path.resolve(process.cwd(), "fake", "build"),
+        rootDir: path.resolve(process.cwd(), "fake", "root"),
+        lifecycleHooksFile: lifecyclePath,
+        customizationFile: themePath,
+        componentLibraries: [{ name: "libA" }, { name: "libB" }],
+      },
+      core: {
+        templatesDir: "/fake/templates",
+      },
+    } as any;
+
+    await buildGlobalHooks(ctx);
+
+    // aggregator => build with entry = /fake/build/embeddableThemeHook.js
+    expect(vite.build).toHaveBeenCalledWith(
+      expect.objectContaining({
+        build: expect.objectContaining({
+          lib: expect.objectContaining({
+            entry: expect.stringContaining("embeddableThemeHook.js"),
+            fileName: `embeddable-theme-xyz777`, // from getContentHash
+          }),
+        }),
+      }),
+    );
+  });
+
+  it("should skip aggregator if no library has themeProvider and no local theme", async () => {
+    (fs.readFile as Mock).mockResolvedValue("template content");
+    (getContentHash as Mock).mockReturnValue("someHash");
+    (fs.rename as Mock).mockResolvedValue(undefined);
+    (vite.build as Mock).mockResolvedValue(undefined);
+
+    vi.spyOn(fsSync, "existsSync").mockImplementation((p: any) => {
+      // Suppose no local theme => false
+      if (p === themePath) return false;
+      if (p === lifecyclePath) return false;
+      return false;
+    });
+
+    // Each library is missing a themeProvider
+    (getComponentLibraryConfig as Mock).mockImplementation((cfg: any) => ({
+      libraryName: cfg.name,
+    }));
+    // no theme, so aggregator is skipped
+    (getGlobalHooksMeta as Mock).mockResolvedValue({
+      themeProvider: null,
+      lifecycleHooks: [],
+    });
+
+    const ctx: ResolvedEmbeddableConfig = {
+      client: {
+        srcDir: path.resolve(process.cwd(), "fake", "src"),
+        buildDir: path.resolve(process.cwd(), "fake", "build"),
+        rootDir: path.resolve(process.cwd(), "fake", "root"),
+        lifecycleHooksFile: lifecyclePath,
+        customizationFile: themePath,
+        componentLibraries: [
+          { name: "libA" }, // no theme
+        ],
+      },
+      core: {
+        templatesDir: "/fake/templates",
+      },
+    } as any;
+
+    await buildGlobalHooks(ctx);
+
+    // aggregator not built
+    // We do an exact check: "not toHaveBeenCalledWith"
+    // But the code might still do a build for the lifecycle if it existed.
+    // We said the lifecycle is false => so no build for aggregator
+    expect(vite.build).not.toHaveBeenCalledWith(
+      expect.objectContaining({
+        build: expect.objectContaining({
+          lib: expect.objectContaining({
+            entry: expect.stringContaining("embeddableThemeHook.js"),
+          }),
+        }),
+      }),
+    );
+  });
+});

package/src/buildPackage.test.ts

@@ -0,0 +1,167 @@
+import path from "node:path";
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import * as fs from "node:fs/promises";
+import * as fsSync from "node:fs";
+import process from "node:process";
+
+import buildPackage from "./buildPackage";
+import buildTypes from "./buildTypes";
+import buildGlobalHooks from "./buildGlobalHooks";
+import provideConfig from "./provideConfig";
+import {
+  checkNodeVersion,
+  removeBuildSuccessFlag,
+  storeBuildSuccessFlag,
+} from "./utils";
+import { initLogger, logError } from "./logger";
+import { ResolvedEmbeddableConfig } from "./defineConfig";
+
+// ----------------- MOCKS ----------------- //
+vi.mock("node:fs/promises");
+vi.mock("node:fs");
+
+// Mock buildTypes
+vi.mock("./buildTypes", () => ({
+  default: vi.fn(),
+}));
+
+// Mock buildGlobalHooks
+vi.mock("./buildGlobalHooks", () => ({
+  default: vi.fn(),
+}));
+
+// Mock provideConfig
+vi.mock("./provideConfig", () => ({
+  default: vi.fn(),
+}));
+
+// Mock utils
+vi.mock("./utils", async () => {
+  const actualUtils =
+    await vi.importActual<typeof import("./utils")>("./utils");
+  return {
+    ...actualUtils,
+    checkNodeVersion: vi.fn(),
+    removeBuildSuccessFlag: vi.fn(),
+    storeBuildSuccessFlag: vi.fn(),
+  };
+});
+
+// Mock logger
+vi.mock("./logger", () => ({
+  initLogger: vi.fn().mockResolvedValue(undefined),
+  logError: vi.fn().mockResolvedValue(undefined),
+}));
+
+// ----------------- TESTS ----------------- //
+describe("buildPackage", () => {
+  // We'll create a sample plugin for testing
+  const mockPlugin = {
+    pluginName: "testPlugin",
+    validate: vi.fn(),
+    buildPackage: vi.fn(),
+  };
+
+  const rootDir = path.resolve("fake", "root");
+  const buildDir = path.resolve("fake", "build");
+  const distDir = path.resolve(rootDir, "dist");
+
+  // We'll also create a sample config
+  const config = {
+    client: {
+      rootDir,
+      buildDir,
+    },
+    plugins: [() => mockPlugin],
+  } as unknown as ResolvedEmbeddableConfig;
+
+  beforeEach(() => {
+    // Clear mocks before each test to avoid cross-test interference
+    vi.clearAllMocks();
+
+    // By default, provideConfig will return our sample config
+    vi.mocked(provideConfig).mockResolvedValue(config);
+
+    // Let's ensure fsSync.existsSync returns false by default
+    // (so that our prepare() logic tries to mkdir, etc.)
+    vi.spyOn(fsSync, "existsSync").mockReturnValue(false);
+  });
+
+  it("should call all main steps in a successful scenario", async () => {
+    await buildPackage();
+
+    // 1. Logger
+    expect(initLogger).toHaveBeenCalledWith("package");
+
+    // 2. checkNodeVersion and removeBuildSuccessFlag
+    expect(checkNodeVersion).toHaveBeenCalled();
+    expect(removeBuildSuccessFlag).toHaveBeenCalled();
+
+    // 3. provideConfig -> must be called, returns our config
+    expect(provideConfig).toHaveBeenCalled();
+
+    // 4. prepare() logic -> it checks if buildDir exists, removes if so, then mkdir
+    // Because we do cross-platform checks, we confirm the path used is distDir
+    expect(fsSync.existsSync).toHaveBeenCalledWith(distDir);
+    // Because it returned false, we do not remove
+    expect(fs.rm).toHaveBeenCalledTimes(0);
+    // Instead we create it
+    expect(fs.mkdir).toHaveBeenCalledWith(distDir);
+
+    // 5. buildTypes & buildGlobalHooks
+    expect(buildTypes).toHaveBeenCalledWith(config);
+    expect(buildGlobalHooks).toHaveBeenCalledWith(config);
+
+    // 6. Plugin calls
+    expect(mockPlugin.validate).toHaveBeenCalledWith(config);
+    expect(mockPlugin.buildPackage).toHaveBeenCalledWith(config);
+
+    // 7. storeBuildSuccessFlag
+    expect(storeBuildSuccessFlag).toHaveBeenCalled();
+  });
+
+  it("should remove and recreate buildDir if it already exists", async () => {
+    // This time let's simulate that buildDir already exists
+    vi.mocked(fsSync.existsSync).mockReturnValue(true);
+
+    await buildPackage();
+
+    // Because buildDir exists, prepare() should remove it
+    expect(fs.rm).toHaveBeenCalledWith(distDir, { recursive: true });
+    // Then re-create it
+    expect(fs.mkdir).toHaveBeenCalledWith(distDir);
+  });
+
+  it("should log an error, call logError, and exit(1) if an error occurs", async () => {
+    // We'll simulate an error in removeBuildSuccessFlag
+    const error = new Error("test error");
+    vi.mocked(removeBuildSuccessFlag).mockRejectedValueOnce(error);
+
+    // We want to check process.exit(1) is called
+    // but calling exit actually kills the process, so we mock it
+    const originalConsoleLog = console.log;
+    console.log = vi.fn();
+    const exitSpy = vi.spyOn(process, "exit").mockImplementation(() => {
+      throw new Error("process.exit called");
+    });
+
+    // We expect buildPackage to throw because exit is called
+    await expect(buildPackage()).rejects.toThrow("process.exit called");
+
+    // We also expect that logError has been called with the correct params
+    expect(logError).toHaveBeenCalledWith({
+      command: "package",
+      breadcrumbs: ["checkNodeVersion"], // because it fails after calling checkNodeVersion
+      error,
+    });
+
+    // And the error is printed
+    expect(console.log).toHaveBeenCalledWith(error);
+
+    // Finally, we confirm process.exit(1) was triggered
+    expect(process.exit).toHaveBeenCalledWith(1);
+
+    console.log = originalConsoleLog;
+    exitSpy.mockRestore();
+  });
+});

package/src/buildPackage.ts

@@ -0,0 +1,53 @@
+import buildTypes from "./buildTypes";
+import buildGlobalHooks from "./buildGlobalHooks";
+import provideConfig from "./provideConfig";
+import {
+  checkNodeVersion,
+  removeBuildSuccessFlag,
+  storeBuildSuccessFlag,
+} from "./utils";
+import { initLogger, logError } from "./logger";
+import * as path from "node:path";
+import * as fs from "node:fs/promises";
+import * as fsSync from "node:fs";
+
+export default async () => {
+  await initLogger("package");
+  const breadcrumbs: string[] = [];
+
+  try {
+    const startTime = process.hrtime();
+    await checkNodeVersion();
+    breadcrumbs.push("checkNodeVersion");
+    await removeBuildSuccessFlag();
+
+    const config = await provideConfig();
+    config.client.buildDir = path.resolve(config.client.rootDir, "dist");
+    await prepare(config);
+    await buildTypes(config);
+    await buildGlobalHooks(config);
+
+    for (const getPlugin of config.plugins) {
+      const plugin = getPlugin();
+
+      breadcrumbs.push(`${plugin.pluginName}: validate`);
+      await plugin.validate(config);
+      breadcrumbs.push(`${plugin.pluginName}: buildPackage`);
+      await plugin.buildPackage(config);
+    }
+
+    // Calculating build time in seconds
+    config.buildTime = process.hrtime(startTime);
+    await storeBuildSuccessFlag();
+  } catch (error: any) {
+    await logError({ command: "package", breadcrumbs, error });
+    console.log(error);
+    process.exit(1);
+  }
+};
+
+const prepare = async (config: any) => {
+  if (fsSync.existsSync(config.client.buildDir))
+    await fs.rm(config.client.buildDir, { recursive: true });
+  await fs.mkdir(config.client.buildDir);
+};

package/src/buildTypes.test.ts

@@ -1,14 +1,24 @@
 import * as fs from "node:fs/promises";
-import buildTypes, { EMB_TYPE_FILE_REGEX } from "./buildTypes";
 import * as path from "node:path";
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import buildTypes, { EMB_TYPE_FILE_REGEX } from "./buildTypes";
 import { build } from "vite";
-import { findFiles, getContentHash } from "@embeddable.com/sdk-utils";
 import { ResolvedEmbeddableConfig } from "./defineConfig";
+import {
+  findFiles,
+  getContentHash,
+  getComponentLibraryConfig,
+} from "@embeddable.com/sdk-utils";
+
+import fg from "fast-glob";
+
+// The same config you already have
 const config = {
   client: {
     srcDir: "src",
     rootDir: "root",
     buildDir: "build",
+    componentLibraries: [],
   },
   outputOptions: {
     typesEntryPointFilename: "typesEntryPointFilename",
@@ -31,12 +41,20 @@ vi.mock("ora", () => ({
 vi.mock("@embeddable.com/sdk-utils", () => ({
   findFiles: vi.fn(),
   getContentHash: vi.fn(),
+  getComponentLibraryConfig: vi.fn(),
 }));
 
-vi.mock("node:path", () => ({
-  resolve: vi.fn(),
-  relative: vi.fn(),
-}));
+vi.mock("node:path", async () => {
+  const actualPath =
+    await vi.importActual<typeof import("node:path")>("node:path");
+  return {
+    ...actualPath,
+    resolve: vi.fn(),
+    relative: vi.fn(),
+    join: vi.fn(),
+    dirname: vi.fn(),
+  };
+});
 
 vi.mock("node:fs/promises", () => ({
   writeFile: vi.fn(),
@@ -49,12 +67,30 @@ vi.mock("vite", () => ({
   build: vi.fn(),
 }));
 
+vi.mock("fast-glob", () => ({
+  default: {
+    sync: vi.fn(),
+  },
+}));
+
 describe("buildTypes", () => {
   beforeEach(() => {
+    vi.clearAllMocks();
+
     vi.mocked(findFiles).mockResolvedValue([["fileName", "filePath"]]);
     vi.mocked(path.relative).mockReturnValue("relativePath");
     vi.mocked(path.resolve).mockReturnValue("resolvedPath");
     vi.mocked(fs.readFile).mockResolvedValue("fileContent");
+    vi.mocked(getContentHash).mockReturnValue("somehash");
+    // By default, no libraries => no fast-glob usage
+    vi.mocked(fg.sync).mockReturnValue([]);
+
+    // We also default to returning an empty config from getComponentLibraryConfig
+    vi.mocked(getComponentLibraryConfig).mockReturnValue({
+      libraryName: "",
+      include: [],
+      exclude: [],
+    });
   });
 
   it("should build types", async () => {
@@ -98,4 +134,70 @@ import '../relativePath';`,
     expect(getContentHash).not.toHaveBeenCalled();
     expect(fs.rename).not.toHaveBeenCalled();
   });
+  it("should import types from installed libraries if present", async () => {
+    const configWithLibrary = {
+      ...config,
+      client: {
+        ...config.client,
+        componentLibraries: [
+          {
+            /* any library config object */
+          },
+        ],
+      },
+    } as unknown as ResolvedEmbeddableConfig;
+
+    // Mock getComponentLibraryConfig => returns libraryName: "my-lib"
+    vi.mocked(getComponentLibraryConfig).mockReturnValue({
+      libraryName: "my-lib",
+      include: [],
+      exclude: [],
+    });
+
+    vi.mocked(fg.sync).mockReturnValue([
+      "/fake/path/node_modules/my-lib/dist/embeddable-types-abc123.js",
+      "/fake/path/node_modules/my-lib/dist/embeddable-types-xyz987.js",
+    ]);
+
+    // Now run
+    await buildTypes(configWithLibrary);
+
+    const written = vi.mocked(fs.writeFile).mock.calls[0][1];
+
+    expect(written).toContain(
+      `import 'my-lib/dist/embeddable-types-abc123.js';`,
+    );
+    expect(written).toContain(
+      `import 'my-lib/dist/embeddable-types-xyz987.js';`,
+    );
+    expect(written).toContain(`import '../relativePath';`);
+  });
+
+  it("should throw if an error occurs when loading a library", async () => {
+    const configWithLibrary = {
+      ...config,
+      client: {
+        ...config.client,
+        componentLibraries: [
+          {
+            /* any library config object */
+          },
+        ],
+      },
+    } as unknown as ResolvedEmbeddableConfig;
+
+    vi.mocked(getComponentLibraryConfig).mockReturnValue({
+      libraryName: "my-broken-lib",
+      include: [],
+      exclude: [],
+    });
+
+    vi.mocked(fg.sync).mockImplementation(() => {
+      throw new Error("some library error");
+    });
+
+    await expect(buildTypes(configWithLibrary)).rejects.toThrow(
+      "some library error",
+    );
+  });
 });