@embeddable.com/sdk-core 4.3.3-next.0 → 4.4.0-next.0

package/lib/push.d.ts

@@ -3,6 +3,7 @@ import { ResolvedEmbeddableConfig } from "./defineConfig";
 export declare const CUBE_FILES: RegExp;
 export declare const CLIENT_CONTEXT_FILES: RegExp;
 export declare const SECURITY_CONTEXT_FILES: RegExp;
+export declare const EMBEDDABLE_FILES: RegExp;
 declare const _default: () => Promise<void>;
 export default _default;
 export declare function buildArchive(config: ResolvedEmbeddableConfig): Promise<Ora>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@embeddable.com/sdk-core",
-  "version": "4.3.3-next.0",
+  "version": "4.4.0-next.0",
   "description": "Core Embeddable SDK module responsible for web-components bundling and publishing.",
   "keywords": [
     "embeddable",

package/src/defineConfig.test.ts

@@ -89,6 +89,7 @@ describe("defineConfig", () => {
         "previewBaseUrl": "previewBaseUrl",
         "pushBaseUrl": "pushBaseUrl",
         "pushComponents": true,
+        "pushEmbeddables": true,
         "pushModels": true,
         "region": "legacy-US",
         "rollbarAccessToken": "rollbarAccessToken",

package/src/defineConfig.ts

@@ -19,6 +19,7 @@ export type EmbeddableConfig = {
   })[];
   pushModels?: boolean;
   pushComponents?: boolean;
+  pushEmbeddables?: boolean;
   pushBaseUrl?: string;
   audienceUrl?: string;
   authDomain?: string;
@@ -83,6 +84,7 @@ export type ResolvedEmbeddableConfig = {
   };
   pushModels: boolean;
   pushComponents: boolean;
+  pushEmbeddables: boolean;
   pushBaseUrl: string;
   audienceUrl: string;
   previewBaseUrl: string;
@@ -152,6 +154,7 @@ export const embeddableConfigSchema = z
     ).optional(),
     pushModels: z.boolean().optional(),
     pushComponents: z.boolean().optional(),
+    pushEmbeddables: z.boolean().optional(),
     pushBaseUrl: z.string().optional(),
     audienceUrl: z.string().optional(),
     authDomain: z.string().optional(),
@@ -202,6 +205,7 @@ export default (config: EmbeddableConfig) => {
     pushModels = true,
     starterEmbeddables,
     pushComponents = true,
+    pushEmbeddables = true,
     pushBaseUrl,
     audienceUrl,
     authDomain,
@@ -308,6 +312,7 @@ export default (config: EmbeddableConfig) => {
     starterEmbeddables,
     pushModels,
     pushComponents,
+    pushEmbeddables,
     pushBaseUrl: pushBaseUrl ?? regionConfig.pushBaseUrl,
     audienceUrl: audienceUrl ?? regionConfig.audienceUrl,
     previewBaseUrl: previewBaseUrl ?? regionConfig.previewBaseUrl,

package/src/dev.test.ts

@@ -29,7 +29,8 @@ import { logError } from "./logger";
 import { ResolvedEmbeddableConfig } from "./defineConfig";
 import { RollupWatcher } from "rollup";
 import ora from "ora";
-import { archive } from "./push";
+import { archive, EMBEDDABLE_FILES } from "./push";
+import fg from "fast-glob";
 import { selectWorkspace } from "./workspaceUtils";
 import serveStatic from "serve-static";
 import { createNodeSys } from "@stencil/core/sys/node";
@@ -107,6 +108,8 @@ vi.mock("serve-static", () => ({
   default: vi.fn(() => vi.fn()),
 }));
 
+vi.mock("fast-glob", () => ({ default: vi.fn() }));
+
 vi.mock("./dev", async (importOriginal) => {
   const actual = await importOriginal<typeof dev>();
   return {
@@ -221,6 +224,8 @@ describe("dev command", () => {
       ["mock-model.json", "/mock/root/models/mock-model.json"],
     ]);
 
+    vi.mocked(fg).mockResolvedValue([]);
+
     // Mock fs functions
     vi.mocked(fs.readFile).mockResolvedValue("default content");
     vi.mocked(fs.appendFile).mockResolvedValue(undefined);
@@ -417,6 +422,49 @@ describe("dev command", () => {
         isDev: true,
       });
     });
+
+    it("should include embeddable files in archive when pushEmbeddables is true", async () => {
+      const embeddableConfig = {
+        ...mockConfig,
+        pushEmbeddables: true,
+        client: { ...mockConfig.client, srcDir: "/mock/src" },
+      } as unknown as ResolvedEmbeddableConfig;
+
+      vi.mocked(findFiles).mockImplementation(async (_dir, pattern) => {
+        if (pattern === EMBEDDABLE_FILES) {
+          return [["dashboard.embeddable.yaml", "/mock/src/dashboard.embeddable.yaml"]];
+        }
+        return [["mock-model.json", "/mock/root/models/mock-model.json"]];
+      });
+
+      await sendBuildChanges(embeddableConfig);
+
+      expect(findFiles).toHaveBeenCalledWith("/mock/src", EMBEDDABLE_FILES);
+      expect(archive).toHaveBeenCalledWith(
+        expect.objectContaining({
+          filesList: expect.arrayContaining([
+            ["dashboard.embeddable.yaml", "/mock/src/dashboard.embeddable.yaml"],
+          ]),
+        }),
+      );
+    });
+
+    it("should not call findFiles with EMBEDDABLE_FILES when pushEmbeddables is false", async () => {
+      const embeddableConfig = {
+        ...mockConfig,
+        pushEmbeddables: false,
+        client: { ...mockConfig.client, srcDir: "/mock/src" },
+      } as unknown as ResolvedEmbeddableConfig;
+
+      vi.mocked(findFiles).mockClear();
+
+      await sendBuildChanges(embeddableConfig);
+
+      const embeddableFilesCall = vi.mocked(findFiles).mock.calls.find(
+        (call) => call[1] === EMBEDDABLE_FILES,
+      );
+      expect(embeddableFilesCall).toBeUndefined();
+    });
   });
 
   describe("sendBuildChanges error handling", () => {
@@ -439,7 +487,7 @@ describe("dev command", () => {
       await sendBuildChanges(mockConfig as unknown as ResolvedEmbeddableConfig);
 
       expect(ora().fail).toHaveBeenCalledWith(
-        `Data models and/or security context synchronization failed with error: ${error.message}`,
+        `Data models and/or security context and/or embeddables synchronization failed with error: ${error.message}`,
       );
       expect(mockWss.clients[0].send).toHaveBeenCalledWith(
         JSON.stringify({ type: "dataModelsAndOrSecurityContextUpdateError", error: error.message }),
@@ -447,6 +495,77 @@ describe("dev command", () => {
     });
   });
 
+  describe("cubeSecurityContextAndClientContextWatcher (pushEmbeddables)", () => {
+    it("should call fg with embeddable pattern and pass results to chokidar.watch when pushEmbeddables is true", async () => {
+      const mockEmbeddableFiles = [
+        "/mock/src/dashboard.embeddable.yaml",
+        "/mock/src/report.embeddable.yml",
+      ];
+
+      vi.mocked(fg).mockImplementation(async (pattern: any) => {
+        if (pattern === "**/*.embeddable.{yaml,yml}") {
+          return mockEmbeddableFiles as any;
+        }
+        return [];
+      });
+
+      vi.mocked(provideConfig).mockResolvedValue({
+        ...mockConfig,
+        pushEmbeddables: true,
+        client: { ...mockConfig.client, srcDir: "/mock/src" },
+      } as unknown as ResolvedEmbeddableConfig);
+
+      await dev();
+      await listenMock.mock.calls[0][1]();
+
+      expect(vi.mocked(fg)).toHaveBeenCalledWith(
+        "**/*.embeddable.{yaml,yml}",
+        expect.objectContaining({ cwd: "/mock/src", absolute: true }),
+      );
+
+      expect(chokidar.watch).toHaveBeenCalledWith(
+        expect.arrayContaining(mockEmbeddableFiles),
+        expect.anything(),
+      );
+    });
+
+    it("should not call fg with embeddable pattern when pushEmbeddables is false", async () => {
+      vi.mocked(provideConfig).mockResolvedValue({
+        ...mockConfig,
+        pushEmbeddables: false,
+        client: { ...mockConfig.client, srcDir: "/mock/src" },
+      } as unknown as ResolvedEmbeddableConfig);
+
+      vi.mocked(fg).mockClear();
+
+      await dev();
+      await listenMock.mock.calls[0][1]();
+
+      const embeddableCall = vi.mocked(fg).mock.calls.find(
+        (call) => call[0] === "**/*.embeddable.{yaml,yml}",
+      );
+      expect(embeddableCall).toBeUndefined();
+    });
+
+    it("should not call fg with embeddable pattern when pushEmbeddables is undefined", async () => {
+      vi.mocked(provideConfig).mockResolvedValue({
+        ...mockConfig,
+        // pushEmbeddables not set → undefined → falsy
+        client: { ...mockConfig.client, srcDir: "/mock/src" },
+      } as unknown as ResolvedEmbeddableConfig);
+
+      vi.mocked(fg).mockClear();
+
+      await dev();
+      await listenMock.mock.calls[0][1]();
+
+      const embeddableCall = vi.mocked(fg).mock.calls.find(
+        (call) => call[0] === "**/*.embeddable.{yaml,yml}",
+      );
+      expect(embeddableCall).toBeUndefined();
+    });
+  });
+
   describe("Plugin build coordination", () => {
     it("should handle configs with no plugins when pushComponents is true", async () => {
       vi.mocked(provideConfig).mockResolvedValue({

package/src/dev.ts

@@ -28,6 +28,7 @@ import {
   sendBuild,
   SECURITY_CONTEXT_FILES,
   CLIENT_CONTEXT_FILES,
+  EMBEDDABLE_FILES,
 } from "./push";
 import validate from "./validate";
 import { checkNodeVersion } from "./utils";
@@ -494,6 +495,14 @@ const cubeSecurityContextAndClientContextWatcher = async (
     filesToWatch = [...filesToWatch, ...cubeFiles, ...securityContextFiles];
   }
 
+  if (ctx.pushEmbeddables) {
+    const embeddableFiles = await fg("**/*.embeddable.{yaml,yml}", {
+      cwd: ctx.client.srcDir,
+      absolute: true,
+    });
+    filesToWatch = [...filesToWatch, ...embeddableFiles];
+  }
+
   const fsWatcher = chokidar.watch(filesToWatch, chokidarWatchOptions);
 
   fsWatcher.on("all", () => sendBuildChanges(ctx));
@@ -526,7 +535,7 @@ export const sendBuildChanges = async (ctx: ResolvedEmbeddableConfig) => {
   sendMessage("dataModelsAndOrSecurityContextUpdateStart");
 
   const sending = ora(
-    "Synchronising data models and/or security contexts...",
+    "Synchronising data models and/or security contexts and/or embeddables...",
   ).start();
 
   let filesList: [string, string][] = [];
@@ -567,6 +576,21 @@ export const sendBuildChanges = async (ctx: ResolvedEmbeddableConfig) => {
     filesList = [...filesList, ...cubeAndSecurityContextFileList];
   }
 
+  if (ctx.pushEmbeddables) {
+    const embeddableFilesList = await findFiles(
+      ctx.client.srcDir,
+      EMBEDDABLE_FILES,
+    );
+
+    filesList = [
+      ...filesList,
+      ...embeddableFilesList.map((entry): [string, string] => [
+        path.basename(entry[1]),
+        entry[1],
+      ]),
+    ];
+  }
+
   try {
     const token = await getToken();
     await archive({
@@ -578,12 +602,12 @@ export const sendBuildChanges = async (ctx: ResolvedEmbeddableConfig) => {
   } catch (e: any) {
     const errorMessage = e.response?.data?.errorMessage ?? e.message ?? "Unknown error";
     sending.fail(
-      `Data models and/or security context synchronization failed with error: ${errorMessage}`,
+      `Data models and/or security context and/or embeddables synchronization failed with error: ${errorMessage}`,
     );
     return sendMessage("dataModelsAndOrSecurityContextUpdateError", { error: errorMessage });
   }
 
-  sending.succeed(`Data models and/or security context synchronized`);
+  sending.succeed(`Data models and/or security context and/or embeddables synchronized`);
   sendMessage("dataModelsAndOrSecurityContextUpdateSuccess");
 };
 

package/src/push.test.ts

@@ -1,4 +1,4 @@
-import push, { buildArchive } from "./push";
+import push, { buildArchive, EMBEDDABLE_FILES } from "./push";
 import provideConfig from "./provideConfig";
 import { fileFromPath } from "formdata-node/file-from-path";
 import * as path from "path";
@@ -222,22 +222,24 @@ describe("push", () => {
   });
 
   describe("push configuration", () => {
-    it("should fail if both pushModels and pushComponents are disabled", async () => {
+    it("should fail if pushModels, pushComponents, and pushEmbeddables are all disabled", async () => {
       vi.spyOn(console, "error").mockImplementation(() => undefined);
       vi.mocked(provideConfig).mockResolvedValue({
         ...config,
         pushModels: false,
         pushComponents: false,
+        pushEmbeddables: false,
       } as ResolvedEmbeddableConfig);
 
       await push();
 
       expect(startMock.fail).toHaveBeenCalledWith(
-        "Cannot push: both pushModels and pushComponents are disabled"
+        "Cannot push: pushModels, pushComponents, and pushEmbeddables are all disabled"
       );
       expect(process.exit).toHaveBeenCalledWith(1);
     });
 
+
     it("should only include component files when pushModels is false", async () => {
       const localZipMock = {
         addFile: vi.fn(),
@@ -633,5 +635,116 @@ describe("push", () => {
       expect(findFiles).toHaveBeenCalledWith("/src", expect.any(RegExp));
       expect(findFiles).toHaveBeenCalledWith("/src", expect.any(RegExp));
     });
+
+    it("should include embeddable files when pushEmbeddables is true", async () => {
+      vi.mocked(findFiles)
+        .mockResolvedValueOnce([]) // cube files
+        .mockResolvedValueOnce([]) // security context files
+        .mockResolvedValueOnce([]) // client context files
+        .mockResolvedValueOnce([
+          ["dashboard.embeddable.yaml", "/src/dashboard.embeddable.yaml"],
+          ["report.embeddable.yml", "/src/report.embeddable.yml"],
+        ]); // embeddable files
+
+      const testConfig = {
+        ...config,
+        pushModels: true,
+        pushComponents: true,
+        pushEmbeddables: true,
+        client: {
+          ...config.client,
+          srcDir: "/src",
+        },
+      } as ResolvedEmbeddableConfig;
+
+      await buildArchive(testConfig);
+
+      expect(findFiles).toHaveBeenCalledWith("/src", EMBEDDABLE_FILES);
+      expect(mockZipLocal.addFile).toHaveBeenCalledWith(
+        "/src/dashboard.embeddable.yaml",
+        "dashboard.embeddable.yaml",
+        expect.objectContaining({ compress: true }),
+      );
+      expect(mockZipLocal.addFile).toHaveBeenCalledWith(
+        "/src/report.embeddable.yml",
+        "report.embeddable.yml",
+        expect.objectContaining({ compress: true }),
+      );
+    });
+
+    it("should not search for embeddable files when pushEmbeddables is false", async () => {
+      // Reset call history to avoid interference from previous tests
+      vi.mocked(findFiles).mockClear();
+
+      const testConfig = {
+        ...config,
+        pushModels: true,
+        pushComponents: true,
+        pushEmbeddables: false,
+        client: {
+          ...config.client,
+          srcDir: "/src",
+        },
+      } as ResolvedEmbeddableConfig;
+
+      await buildArchive(testConfig);
+
+      // findFiles should have been called for models and components but NOT for embeddable files
+      const embeddableFilesCall = vi
+        .mocked(findFiles)
+        .mock.calls.find((call) => call[1] === EMBEDDABLE_FILES);
+      expect(embeddableFilesCall).toBeUndefined();
+    });
+
+    it("should exit when all three push flags are disabled", async () => {
+      vi.spyOn(process, "exit").mockImplementation(() => null as never);
+
+      const testConfig = {
+        ...config,
+        pushModels: false,
+        pushComponents: false,
+        pushEmbeddables: false,
+        client: {
+          ...config.client,
+          srcDir: "/src",
+        },
+      } as ResolvedEmbeddableConfig;
+
+      await buildArchive(testConfig);
+
+      expect(process.exit).toHaveBeenCalledWith(1);
+    });
+  });
+
+  describe("EMBEDDABLE_FILES", () => {
+    it("should match .embeddable.yaml files", () => {
+      expect(EMBEDDABLE_FILES.test("my-dashboard.embeddable.yaml")).toBe(true);
+      expect(EMBEDDABLE_FILES.test("src/dashboards/sales.embeddable.yaml")).toBe(
+        true,
+      );
+    });
+
+    it("should match .embeddable.yml files", () => {
+      expect(EMBEDDABLE_FILES.test("my-dashboard.embeddable.yml")).toBe(true);
+      expect(EMBEDDABLE_FILES.test("src/widgets/chart.embeddable.yml")).toBe(
+        true,
+      );
+    });
+
+    it("should not match unrelated yaml files", () => {
+      expect(EMBEDDABLE_FILES.test("config.yaml")).toBe(false);
+      expect(EMBEDDABLE_FILES.test("my-dashboard.cc.yaml")).toBe(false);
+      expect(EMBEDDABLE_FILES.test("my-dashboard.sc.yaml")).toBe(false);
+    });
+
+    it("should not match cube files", () => {
+      expect(EMBEDDABLE_FILES.test("my-model.cube.yaml")).toBe(false);
+      expect(EMBEDDABLE_FILES.test("my-model.cube.yml")).toBe(false);
+    });
+
+    it("should not match non-yaml extensions", () => {
+      expect(EMBEDDABLE_FILES.test("my-dashboard.embeddable.json")).toBe(false);
+      expect(EMBEDDABLE_FILES.test("my-dashboard.embeddable.ts")).toBe(false);
+    });
   });
 });

package/src/push.ts

@@ -21,6 +21,7 @@ export const CUBE_FILES = /^(.*)\.cube\.(ya?ml|js)$/;
 
 export const CLIENT_CONTEXT_FILES = /^(.*)\.cc\.ya?ml$/;
 export const SECURITY_CONTEXT_FILES = /^(.*)\.sc\.ya?ml$/;
+export const EMBEDDABLE_FILES = /^(.*)\.embeddable\.ya?ml$/;
 
 export default async () => {
   await initLogger("push");
@@ -110,6 +111,7 @@ const publishedSectionFeedback = (
 ) => {
   config.pushModels && spinnerPushing.succeed("Models published");
   config.pushComponents && spinnerPushing.succeed("Components published");
+  config.pushEmbeddables && spinnerPushing.succeed("Embeddables published");
 };
 
 async function pushByApiKey(
@@ -170,9 +172,9 @@ async function verify(ctx: ResolvedEmbeddableConfig) {
 export async function buildArchive(config: ResolvedEmbeddableConfig) {
   const spinnerArchive = ora("Building...").start();
 
-  if (!config.pushModels && !config.pushComponents) {
+  if (!config.pushModels && !config.pushComponents && !config.pushEmbeddables) {
     spinnerArchive.fail(
-      "Cannot push: both pushModels and pushComponents are disabled",
+      "Cannot push: pushModels, pushComponents, and pushEmbeddables are all disabled",
     );
     process.exit(1);
   }
@@ -217,6 +219,20 @@ export async function buildArchive(config: ResolvedEmbeddableConfig) {
     );
   }
 
+  if (config.pushEmbeddables) {
+    const embeddableFilesList = await findFiles(
+      config.client.srcDir,
+      EMBEDDABLE_FILES,
+    );
+
+    filesList.push(
+      ...embeddableFilesList.map((entry): [string, string] => [
+        path.basename(entry[1]),
+        entry[1],
+      ]),
+    );
+  }
+
   await archive({
     ctx: config,
     filesList,