@embeddable.com/sdk-core 3.14.0-next.2 → 3.14.0-next.3

package/lib/push.d.ts

@@ -1,7 +1,8 @@
 import { Ora } from "ora";
 import { ResolvedEmbeddableConfig } from "./defineConfig";
 export declare const CUBE_FILES: RegExp;
-export declare const PRESET_FILES: RegExp;
+export declare const CLIENT_CONTEXT_FILES: RegExp;
+export declare const SECURITY_CONTEXT_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": "3.14.0-next.2",
+  "version": "3.14.0-next.3",
   "description": "Core Embeddable SDK module responsible for web-components bundling and publishing.",
   "keywords": [
     "embeddable",

package/src/dev.test.ts

@@ -10,9 +10,11 @@ import { checkNodeVersion } from "./utils";
 import { createManifest } from "./cleanup";
 import prepare from "./prepare";
 import { WebSocketServer } from "ws";
+import * as open from "open";
 import { logError } from "./logger";
 import { ResolvedEmbeddableConfig } from "./defineConfig";
 import { RollupWatcher } from "rollup";
+import build from "./build";
 // Mock dependencies
 vi.mock("./buildTypes", () => ({ default: vi.fn() }));
 vi.mock("./buildGlobalHooks", () => ({ default: vi.fn() }));
@@ -23,10 +25,11 @@ vi.mock("@stencil/core/sys/node", () => ({
   createNodeLogger: vi.fn(),
   createNodeSys: vi.fn(),
 }));
+vi.mock("open", () => ({ default: vi.fn() }));
 vi.mock("ws", () => ({ WebSocketServer: vi.fn() }));
-vi.mock("chokidar", () => ({ watch: vi.fn() }));
+vi.mock("chokidar", () => ({ watch: vi.fn((_) => ({ on: vi.fn() })) }));
 vi.mock("./login", () => ({ getToken: vi.fn(), default: vi.fn() }));
-vi.mock("axios", () => ({ default: { get: vi.fn() } }));
+vi.mock("axios", () => ({ default: { get: vi.fn(), post: vi.fn() } }));
 vi.mock("@embeddable.com/sdk-utils", () => ({ findFiles: vi.fn() }));
 vi.mock("./push", () => ({ archive: vi.fn(), sendBuild: vi.fn() }));
 vi.mock("./validate", () => ({ default: vi.fn() }));
@@ -65,7 +68,7 @@ describe("dev command", () => {
       () =>
         ({
           listen: listenMock,
-        }) as any,
+        }) as any
     );
     vi.mocked(WebSocketServer).mockImplementation(() => {
       return {
@@ -73,19 +76,20 @@ describe("dev command", () => {
         on: vi.fn(),
       } as any;
     });
-    vi.mocked(chokidar.watch).mockReturnValue({
-      on: vi.fn(),
-    } as any);
+
     // Mock process.on to avoid actually setting up process listeners
     vi.spyOn(process, "on").mockImplementation(() => process);
     vi.spyOn(process, "exit").mockImplementation(() => undefined as never);
 
     vi.mocked(provideConfig).mockResolvedValue(
-      mockConfig as unknown as ResolvedEmbeddableConfig,
+      mockConfig as unknown as ResolvedEmbeddableConfig
     );
     vi.mocked(getToken).mockResolvedValue("mock-token");
     vi.mocked(axios.get).mockResolvedValue({
-      data: [{ id: "mock-workspace" }],
+      data: [{ workspaceId: "mock-workspace" }],
+    });
+    vi.mocked(axios.post).mockResolvedValue({
+      data: "mock-workspace",
     });
 
     // @ts-ignore
@@ -100,7 +104,69 @@ describe("dev command", () => {
     vi.restoreAllMocks();
   });
 
-  it("should set up the development environment", async () => {
+  it("should set up the development and open workspace page with pushComponents false", async () => {
+    vi.mocked(provideConfig).mockResolvedValue({
+      ...mockConfig,
+      pushComponents: false,
+      pushModels: true,
+    } as unknown as ResolvedEmbeddableConfig);
+
+    // Run the dev command
+    await dev();
+
+    // Verify that the necessary functions were called
+    expect(checkNodeVersion).toHaveBeenCalled();
+    expect(prepare).toHaveBeenCalled();
+    expect(http.createServer).toHaveBeenCalled();
+    expect(WebSocketServer).toHaveBeenCalled();
+
+    // Verify that the server was set up to listen on the correct port
+    expect(listenMock).toHaveBeenCalledWith(8926, expect.any(Function));
+
+    // Call the listen callback to simulate the server being set up
+    listenMock.mock.calls[0][1]();
+    expect(createManifest).toHaveBeenCalled();
+
+    await expect.poll(() => chokidar.watch).toBeCalledTimes(1);
+
+    expect(open.default).toHaveBeenCalledWith(
+      "http://preview.example.com/workspace/mock-workspace"
+    );
+  });
+
+  it("should set up the development with pushComponents false", async () => {
+    vi.mocked(provideConfig).mockResolvedValue({
+      ...mockConfig,
+      pushComponents: false,
+      pushModels: true,
+    } as unknown as ResolvedEmbeddableConfig);
+
+    // Run the dev command
+    await dev();
+
+    // Verify that the necessary functions were called
+    expect(checkNodeVersion).toHaveBeenCalled();
+    expect(prepare).toHaveBeenCalled();
+    expect(http.createServer).toHaveBeenCalled();
+    expect(WebSocketServer).toHaveBeenCalled();
+
+    // Verify that the server was set up to listen on the correct port
+    expect(listenMock).toHaveBeenCalledWith(8926, expect.any(Function));
+
+    // Call the listen callback to simulate the server being set up
+    listenMock.mock.calls[0][1]();
+    expect(createManifest).toHaveBeenCalled();
+
+    await expect.poll(() => chokidar.watch).toBeCalledTimes(1);
+  });
+
+  it("should set up the development environment with pushComponents true", async () => {
+    vi.mocked(provideConfig).mockResolvedValue({
+      ...mockConfig,
+      pushComponents: true,
+      pushModels: true,
+    } as unknown as ResolvedEmbeddableConfig);
+
     // Run the dev command
     await dev();
 
@@ -115,7 +181,6 @@ describe("dev command", () => {
 
     // Call the listen callback to simulate the server being set up
     listenMock.mock.calls[0][1]();
-    expect(buildGlobalHooks).toHaveBeenCalled();
     expect(createManifest).toHaveBeenCalled();
 
     await expect.poll(() => chokidar.watch).toBeCalledTimes(2);

package/src/dev.ts

@@ -17,11 +17,16 @@ import { ChildProcess } from "node:child_process";
 import { WebSocketServer } from "ws";
 import * as chokidar from "chokidar";
 import * as path from "path";
-import { FSWatcher } from "chokidar";
 import { getToken, default as login } from "./login";
 import axios from "axios";
 import { findFiles } from "@embeddable.com/sdk-utils";
-import { archive, PRESET_FILES, CUBE_FILES, sendBuild } from "./push";
+import {
+  archive,
+  CUBE_FILES,
+  sendBuild,
+  SECURITY_CONTEXT_FILES,
+  CLIENT_CONTEXT_FILES,
+} from "./push";
 import validate from "./validate";
 import { checkNodeVersion } from "./utils";
 import { createManifest } from "./cleanup";
@@ -36,6 +41,9 @@ import finalhandler from "finalhandler";
 import serveStatic from "serve-static";
 import { ResolvedEmbeddableConfig } from "./defineConfig";
 import buildGlobalHooks from "./buildGlobalHooks";
+
+type FSWatcher = chokidar.FSWatcher;
+
 dotenv.config();
 
 let wss: WebSocketServer;
@@ -106,7 +114,7 @@ export default async () => {
         stencilBuild: path.resolve(buildDir, "dist", "embeddable-wrapper"),
         tmpDir: path.resolve(
           defaultConfig.client.rootDir,
-          ".embeddable-dev-tmp",
+          ".embeddable-dev-tmp"
         ),
       },
     };
@@ -122,7 +130,7 @@ export default async () => {
     try {
       previewWorkspace = await getPreviewWorkspace(
         workspacePreparation,
-        config,
+        config
       );
     } catch (e: any) {
       if (e.response?.status === 401) {
@@ -131,11 +139,11 @@ export default async () => {
         workspacePreparation = ora("Preparing workspace...").start();
         previewWorkspace = await getPreviewWorkspace(
           workspacePreparation,
-          config,
+          config
         );
       } else {
         workspacePreparation.fail(
-          e.response?.data?.errorMessage || "Unknown error: " + e.message,
+          e.response?.data?.errorMessage || "Unknown error: " + e.message
         );
         process.exit(1);
       }
@@ -143,25 +151,16 @@ export default async () => {
 
     workspacePreparation.succeed("Workspace is ready");
 
-    const { themeWatcher, lifecycleWatcher } = await buildGlobalHooks(config);
-
-    if (themeWatcher) {
-      await globalHookWatcher(themeWatcher, config);
-    }
-    if (lifecycleWatcher) {
-      await globalHookWatcher(lifecycleWatcher, config);
-    }
-
     const server = http.createServer(
       async (request: IncomingMessage, res: ServerResponse) => {
         res.setHeader("Access-Control-Allow-Origin", "*");
         res.setHeader(
           "Access-Control-Allow-Methods",
-          "GET, POST, PUT, DELETE, OPTIONS",
+          "GET, POST, PUT, DELETE, OPTIONS"
         );
         res.setHeader(
           "Access-Control-Allow-Headers",
-          "Content-Type, Authorization",
+          "Content-Type, Authorization"
         );
 
         if (request.method === "OPTIONS") {
@@ -182,16 +181,17 @@ export default async () => {
         } catch {}
 
         serve(request, res, done);
-      },
+      }
     );
 
-    wss = new WebSocketServer({ server });
+    const { themeWatcher, lifecycleWatcher } = await buildGlobalHooks(config);
 
+    wss = new WebSocketServer({ server });
     server.listen(SERVER_PORT, async () => {
       const watchers: Array<RollupWatcher | FSWatcher> = [];
       if (sys?.onProcessInterrupt) {
         sys.onProcessInterrupt(
-          async () => await onClose(server, sys, watchers, config),
+          async () => await onClose(server, sys, watchers, config)
         );
       }
 
@@ -210,31 +210,39 @@ export default async () => {
         editorsMetaFileName: "embeddable-editors-meta.js",
       });
 
-      await sendDataModelsAndContextsChanges(config);
+      await sendBuildChanges(config);
 
-      for (const getPlugin of config.plugins) {
-        const plugin = getPlugin();
+      if (config.pushComponents) {
+        for (const getPlugin of config.plugins) {
+          const plugin = getPlugin();
 
-        breadcrumbs.push("validate plugin");
-        await plugin.validate(config);
-        breadcrumbs.push("build plugin");
-        const watcher = await plugin.build(config);
-        breadcrumbs.push("configure watcher");
-        await configureWatcher(watcher as RollupWatcher, config);
-        watchers.push(watcher as RollupWatcher);
-      }
+          breadcrumbs.push("validate plugin");
+          await plugin.validate(config);
+          breadcrumbs.push("build plugin");
+          const watcher = await plugin.build(config);
+          breadcrumbs.push("configure watcher");
+          await configureWatcher(watcher as RollupWatcher, config);
+          watchers.push(watcher as RollupWatcher);
+        }
 
-      const dataModelAndSecurityContextWatch =
-        await dataModelAndSecurityContextWatcher(config);
-      const customGlobalCssWatch = globalCssWatcher(config);
-      watchers.push(dataModelAndSecurityContextWatch);
-      watchers.push(customGlobalCssWatch);
-      if (themeWatcher) {
-        watchers.push(themeWatcher);
-      }
-      if (lifecycleWatcher) {
-        watchers.push(lifecycleWatcher);
+        const customGlobalCssWatch = globalCssWatcher(config);
+        watchers.push(customGlobalCssWatch);
+
+        if (themeWatcher) {
+          await globalHookWatcher(themeWatcher, config);
+          watchers.push(themeWatcher);
+        }
+        if (lifecycleWatcher) {
+          await globalHookWatcher(lifecycleWatcher, config);
+          watchers.push(lifecycleWatcher);
+        }
+      } else {
+        await openDevWorkspacePage(config.previewBaseUrl);
       }
+
+      const cubeSecurityContextAndClientContextWatch =
+        await cubeSecurityContextAndClientContextWatcher(config);
+      watchers.push(cubeSecurityContextAndClientContextWatch);
     });
   } catch (error: any) {
     await logError({ command: "dev", breadcrumbs, error });
@@ -245,7 +253,7 @@ export default async () => {
 
 const configureWatcher = async (
   watcher: RollupWatcher,
-  ctx: ResolvedEmbeddableConfig,
+  ctx: ResolvedEmbeddableConfig
 ) => {
   watcher.on("change", (path) => {
     changedFiles.push(path);
@@ -306,40 +314,52 @@ const onBuildStart = async (ctx: ResolvedEmbeddableConfig) => {
   sendMessage("componentsBuildStart", { changedFiles });
 };
 
+const openDevWorkspacePage = async (previewBaseUrl: string) => {
+  const open = (await import("open")).default;
+  return await open(`${previewBaseUrl}/workspace/${previewWorkspace}`);
+};
+
 const onBundleBuildEnd = async (ctx: ResolvedEmbeddableConfig) => {
   if (!onlyTypesChanged() || changedFiles.length === 0) {
     await buildWebComponent(ctx);
   }
   if (browserWindow == null) {
-    const open = (await import("open")).default;
-    browserWindow = await open(
-      `${ctx.previewBaseUrl}/workspace/${previewWorkspace}`,
-    );
+    browserWindow = await openDevWorkspacePage(ctx.previewBaseUrl);
   } else {
     sendMessage("componentsBuildSuccess");
   }
 };
 
-const dataModelAndSecurityContextWatcher = async (
-  ctx: ResolvedEmbeddableConfig,
+const cubeSecurityContextAndClientContextWatcher = async (
+  ctx: ResolvedEmbeddableConfig
 ): Promise<FSWatcher> => {
-  const [modelsFiles, presetsFiles] = await Promise.all([
-    fg("**/*.cube.{yaml,yml,js}", {
-      cwd: ctx.client.modelsSrc,
-      absolute: true,
-    }),
-    fg("**/*.{sc,cc}.{yaml,yml}", {
+  let filesToWatch: any = [];
+
+  if (ctx.pushComponents) {
+    const cubeFiles = await fg("**/*.cc.{yaml,yml}", {
       cwd: ctx.client.presetsSrc,
       absolute: true,
-    }),
-  ]);
+    });
+    filesToWatch = [...filesToWatch, ...cubeFiles];
+  }
 
-  const fsWatcher = chokidar.watch(
-    [...modelsFiles, ...presetsFiles],
-    chokidarWatchOptions,
-  );
+  if (ctx.pushModels) {
+    const [modelsFiles, securityContextFiles] = await Promise.all([
+      fg("**/*.cube.{yaml,yml,js}", {
+        cwd: ctx.client.modelsSrc,
+        absolute: true,
+      }),
+      fg("**/*.sc.{yaml,yml}", {
+        cwd: ctx.client.presetsSrc,
+        absolute: true,
+      }),
+    ]);
+    filesToWatch = [...modelsFiles, ...securityContextFiles];
+  }
 
-  fsWatcher.on("all", () => sendDataModelsAndContextsChanges(ctx));
+  const fsWatcher = chokidar.watch(filesToWatch, chokidarWatchOptions);
+
+  fsWatcher.on("all", () => sendBuildChanges(ctx));
 
   return fsWatcher;
 };
@@ -354,51 +374,72 @@ const globalCssWatcher = (ctx: ResolvedEmbeddableConfig): FSWatcher => {
   return fsWatcher;
 };
 
-const sendDataModelsAndContextsChanges = async (
-  ctx: ResolvedEmbeddableConfig,
-) => {
-  sendMessage("dataModelsAndOrSecurityContextUpdateStart");
+const sendBuildChanges = async (ctx: ResolvedEmbeddableConfig) => {
   const isValid = await validate(ctx);
-  if (isValid) {
-    const token = await getToken();
-    const sending = ora(
-      "Synchronising data models and/or security contexts...",
-    ).start();
-    const cubeFilesList = await findFiles(ctx.client.modelsSrc, CUBE_FILES);
-    const contextFilesList = await findFiles(
+
+  if (!isValid) {
+    return sendMessage("dataModelsAndOrSecurityContextUpdateError");
+  }
+
+  const sending = ora(
+    "Synchronising data models and/or security contexts..."
+  ).start();
+
+  let filesList: [string, string][] = [];
+  if (ctx.pushComponents) {
+    const clientContextFilesList = await findFiles(
       ctx.client.presetsSrc,
-      PRESET_FILES,
+      CLIENT_CONTEXT_FILES
     );
 
     // Map the files to include their full filenames
-    const filesList = [...cubeFilesList, ...contextFilesList].map(
-      (entry): [string, string] => [path.basename(entry[1]), entry[1]],
+    const clientContextFileList = [...clientContextFilesList].map(
+      (entry): [string, string] => [path.basename(entry[1]), entry[1]]
     );
 
-    // add manifest to the archive
-    filesList.push([
-      "embeddable-manifest.json",
-      path.resolve(ctx.client.buildDir, "embeddable-manifest.json"),
-    ]);
+    filesList = [...clientContextFileList];
+  }
 
-    await archive({
-      ctx,
-      filesList,
-      isDev: true,
-    });
-    await sendBuild(ctx, { workspaceId: previewWorkspace, token });
-    sending.succeed(`Data models and/or security context synchronized`);
-    sendMessage("dataModelsAndOrSecurityContextUpdateSuccess");
-  } else {
-    sendMessage("dataModelsAndOrSecurityContextUpdateError");
+  if (ctx.pushModels) {
+    const cubeFilesList = await findFiles(ctx.client.modelsSrc, CUBE_FILES);
+    const securityContextFilesList = await findFiles(
+      ctx.client.presetsSrc,
+      SECURITY_CONTEXT_FILES
+    );
+
+    // Map the files to include their full filenames
+    const cubeAndSecurityContextFileList = [
+      ...cubeFilesList,
+      ...securityContextFilesList,
+    ].map((entry): [string, string] => [path.basename(entry[1]), entry[1]]);
+
+    filesList = [
+      ...filesList,
+      ...cubeAndSecurityContextFileList,
+      // add manifest to the archive
+      [
+        "embeddable-manifest.json",
+        path.resolve(ctx.client.buildDir, "embeddable-manifest.json"),
+      ],
+    ];
   }
+
+  const token = await getToken();
+  await archive({
+    ctx,
+    filesList,
+    isDev: true,
+  });
+  await sendBuild(ctx, { workspaceId: previewWorkspace, token });
+  sending.succeed(`Data models and/or security context synchronized`);
+  sendMessage("dataModelsAndOrSecurityContextUpdateSuccess");
 };
 
 const onClose = async (
   server: Server,
   sys: CompilerSystem,
   watchers: Array<RollupWatcher | FSWatcher>,
-  config: ResolvedEmbeddableConfig,
+  config: ResolvedEmbeddableConfig
 ) => {
   server.close();
   wss.close();
@@ -419,33 +460,36 @@ const onClose = async (
 
 const getPreviewWorkspace = async (
   startedOra: Ora,
-  ctx: ResolvedEmbeddableConfig,
+  ctx: ResolvedEmbeddableConfig
 ): Promise<string> => {
   const token = await getToken();
 
   const params = minimist(process.argv.slice(2));
-  let primaryWorkspace = params.w || params.workspace;
+  let primaryWorkspaceId = params.w || params.workspace;
 
-  if (!primaryWorkspace) {
+  if (!primaryWorkspaceId) {
     startedOra.stop(); // Stop current Ora, otherwise the last option will get hidden by it.
     const { workspaceId } = await selectWorkspace(ora, ctx, token);
-    primaryWorkspace = workspaceId;
+    primaryWorkspaceId = workspaceId;
     startedOra.start();
   }
 
   try {
     const instanceUrl = process.env.CUBE_CLOUD_ENDPOINT;
-    const response = await axios.get(
+
+    const response = await axios.post(
       `${ctx.pushBaseUrl}/workspace/dev-workspace`,
       {
-        params: {
-          primaryWorkspace,
-          instanceUrl,
-        },
+        primaryWorkspaceId,
+        instanceUrl,
+        pushModels: ctx.pushModels,
+        pushComponents: ctx.pushComponents,
+      },
+      {
         headers: {
           Authorization: `Bearer ${token}`,
         },
-      },
+      }
     );
     return response.data;
   } catch (e: any) {

package/src/push.ts

@@ -19,8 +19,8 @@ import { ResolvedEmbeddableConfig } from "./defineConfig";
 // grab cube files
 export const CUBE_FILES = /^(.*)\.cube\.(ya?ml|js)$/;
 
-// grab security context and client context files
-export const PRESET_FILES = /^(.*)\.(sc|cc)\.ya?ml$/;
+export const CLIENT_CONTEXT_FILES = /^(.*)\.cc\.ya?ml$/;
+export const SECURITY_CONTEXT_FILES = /^(.*)\.sc\.ya?ml$/;
 
 export default async () => {
   await initLogger("push");
@@ -162,16 +162,25 @@ export async function buildArchive(config: ResolvedEmbeddableConfig) {
       config.client.modelsSrc || config.client.srcDir,
       CUBE_FILES,
     );
-    const contextFilesList = await findFiles(
+    const clientContextFilesList = await findFiles(
       config.client.presetsSrc || config.client.srcDir,
-      PRESET_FILES,
+      CLIENT_CONTEXT_FILES,
     );
+    const securityContextFilesList = await findFiles(
+      config.client.presetsSrc || config.client.srcDir,
+      SECURITY_CONTEXT_FILES,
+    );
+
     filesList.push(
       ...cubeFilesList.map((entry): [string, string] => [
         path.basename(entry[1]),
         entry[1],
       ]),
-      ...contextFilesList.map((entry): [string, string] => [
+      ...clientContextFilesList.map((entry): [string, string] => [
+        path.basename(entry[1]),
+        entry[1],
+      ]),
+      ...securityContextFilesList.map((entry): [string, string] => [
         path.basename(entry[1]),
         entry[1],
       ]),