@embeddable.com/sdk-core 3.8.0-next.0 → 3.8.0

package/lib/workspaceUtils.d.ts

@@ -0,0 +1,2 @@
+export declare function getWorkspaces(ctx: any, token: string, workspaceSpinner: any): Promise<any>;
+export declare function selectWorkspace(ora: any, ctx: any, token: string): Promise<any>;

package/loader/custom-esm-loader.mjs

@@ -59,8 +59,6 @@ const currentDir = dirname(fileURLToPath(import.meta.url));
 
 const isWindows = process.platform === "win32";
 
-const moduleCache = new Map();
-
 export const resolve = async (specifier, context, nextResolve) => {
   if (NON_JS_TS_EXTENSIONS.test(specifier)) {
     const mockModulePath = pathToFileURL(
@@ -74,10 +72,6 @@ export const resolve = async (specifier, context, nextResolve) => {
     };
   }
 
-  if (moduleCache.has(specifier)) {
-    return moduleCache.get(specifier);
-  }
-
   const isTS = EXTENSIONS.some((ext) => specifier.endsWith(ext));
 
   // Entry point
@@ -88,15 +82,11 @@ export const resolve = async (specifier, context, nextResolve) => {
       ? pathToFileURL(specifier.replace(`${processCwd}/file:/`, "")).href
       : specifier;
 
-    const resolved = {
+    return {
       format: isTS ? "ts" : undefined,
       url: entryPointPath,
       shortCircuit: true,
     };
-
-    moduleCache.set(specifier, resolved);
-
-    return resolved;
   }
 
   // Determine if this is a package import
@@ -131,17 +121,13 @@ export const resolve = async (specifier, context, nextResolve) => {
     !resolvedModule.resolvedFileName.includes("/node_modules/") &&
     EXTENSIONS.includes(resolvedModule.extension)
   ) {
-    const resolved = {
+    return {
       format: "ts",
       url:
         pathToFileURL(resolvedModule.resolvedFileName).href +
         `?update=${Date.now()}`,
       shortCircuit: true,
     };
-
-    moduleCache.set(specifier, resolved);
-
-    return resolved;
   }
 
   // Fallback for non-TS files or unresolved modules
@@ -153,13 +139,7 @@ export const resolve = async (specifier, context, nextResolve) => {
   return nextResolve(specifierPathOrUrl);
 };
 
-const compiledModuleCache = new Map();
-
 export const load = async (url, context, nextLoad) => {
-  if (compiledModuleCache.has(url)) {
-    return compiledModuleCache.get(url);
-  }
-
   if (context.format === "ts") {
     const { source } = await nextLoad(url, context);
     const code =
@@ -167,15 +147,11 @@ export const load = async (url, context, nextLoad) => {
 
     // Compile the code using @swc-node with the customer's tsconfig
     const compiled = await compile(code, fileURLToPath(url), tsconfig, true);
-    const resolved = {
+    return {
       format: "module",
       source: compiled,
       shortCircuit: true,
     };
-
-    compiledModuleCache.set(url, resolved);
-
-    return resolved;
   } else {
     if (
       isWindows &&

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@embeddable.com/sdk-core",
-  "version": "3.8.0-next.0",
+  "version": "3.8.0",
   "description": "Core Embeddable SDK module responsible for web-components bundling and publishing.",
   "keywords": [
     "embeddable",
@@ -34,14 +34,14 @@
     "embeddable": "bin/embeddable"
   },
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=20.0.0"
   },
   "license": "MIT",
   "dependencies": {
     "@embeddable.com/sdk-utils": "*",
-    "@inquirer/select": "^1.3.0",
-    "@stencil/core": "^4.18.2",
-    "@swc-node/register": "^1.10.9",
+    "@inquirer/prompts": "^7.0.0",
+    "@stencil/core": "^4.22.0",
+    "@swc-node/register": "^1.9.0",
     "archiver": "^5.3.1",
     "axios": "^1.7.2",
     "chokidar": "^3.6.0",
@@ -52,7 +52,7 @@
     "ora": "^8.0.1",
     "serve-static": "^1.15.0",
     "sorcery": "^0.11.0",
-    "vite": "^5.3.2",
+    "vite": "^5.4.8",
     "ws": "^8.17.0",
     "yaml": "^2.3.3"
   },

package/src/dev.ts

@@ -11,7 +11,6 @@ import {
   createNodeSys,
 } from "@stencil/core/sys/node";
 import { RollupWatcher } from "rollup";
-import * as http from "node:http";
 import { IncomingMessage, Server, ServerResponse } from "http";
 import { ChildProcess } from "node:child_process";
 import { WebSocketServer, Server as WSServer } from "ws";
@@ -25,6 +24,7 @@ import { archive, YAML_OR_JS_FILES, sendBuild } from "./push";
 import validate from "./validate";
 import { checkNodeVersion } from "./utils";
 import { createManifest } from "./cleanup";
+import { selectWorkspace } from "./workspaceUtils";
 const minimist = require("minimist");
 
 const oraP = import("ora");
@@ -57,24 +57,16 @@ const addToGitingore = async () => {
   }
 };
 
-const chokidarWatchOptions = {
-  ignoreInitial: true,
-  usePolling: false, // Ensure polling is disabled
-  awaitWriteFinish: {
-    stabilityThreshold: 200,
-    pollInterval: 100,
-  },
-};
-
 export default async () => {
   checkNodeVersion();
   addToGitingore();
 
+  const http = require("http");
   ora = (await oraP).default;
 
   process.on("warning", (e) => console.warn(e.stack));
 
-  const logger = createNodeLogger();
+  const logger = createNodeLogger({ process });
   const sys = createNodeSys({ process });
 
   const defaultConfig = await provideConfig();
@@ -108,9 +100,11 @@ export default async () => {
   const workspacePreparation = ora("Preparing workspace...").start();
 
   try {
-    previewWorkspace = await getPreviewWorkspace(config);
+    previewWorkspace = await getPreviewWorkspace(workspacePreparation, config);
   } catch (e: any) {
-    workspacePreparation.fail(e.response.data?.errorMessage);
+    workspacePreparation.fail(
+      e.response?.data?.errorMessage || "Unknown error: " + e.message,
+    );
     process.exit(1);
   }
 
@@ -182,7 +176,6 @@ export default async () => {
 
       await plugin.validate(config);
       const watcher = await plugin.build(config);
-
       await configureWatcher(watcher, config);
       watchers.push(watcher);
     }
@@ -253,7 +246,9 @@ const onBundleBuildEnd = async (ctx: any) => {
 const dataModelAndSecurityContextWatcher = (ctx: any): FSWatcher => {
   const fsWatcher = chokidar.watch(
     [path.resolve(ctx.client.modelsSrc, "**/*.{cube,sc}.{yaml,yml,js}")],
-    chokidarWatchOptions,
+    {
+      ignoreInitial: true,
+    },
   );
   fsWatcher.on("all", async () => {
     await sendDataModelsAndSecurityContextsChanges(ctx);
@@ -268,7 +263,9 @@ const customSelfServeWatcher = (ctx: any): FSWatcher => {
       path.resolve(ctx.client.selfServeCustomizationDir, "style.css"),
       path.resolve(ctx.client.selfServeCustomizationDir, "*.svg"),
     ],
-    chokidarWatchOptions,
+    {
+      ignoreInitial: true,
+    },
   );
 
   fsWatcher.on("all", async () => {
@@ -326,11 +323,21 @@ const onClose = async (
   process.exit(0);
 };
 
-const getPreviewWorkspace = async (ctx: any): Promise<string> => {
+const getPreviewWorkspace = async (
+  startedOra: any,
+  ctx: any,
+): Promise<string> => {
   const token = await getToken();
 
   const params = minimist(process.argv.slice(2));
-  const primaryWorkspace = params.w || params.workspace;
+  let primaryWorkspace = params.w || params.workspace;
+
+  if (!primaryWorkspace) {
+    startedOra.stop(); // Stop current Ora, otherwise the last option will get hidden by it.
+    const { workspaceId } = await selectWorkspace(ora, ctx, token);
+    primaryWorkspace = workspaceId;
+    startedOra.start();
+  }
 
   try {
     const response = await axios.get(
@@ -347,7 +354,7 @@ const getPreviewWorkspace = async (ctx: any): Promise<string> => {
     if (e.response.status === 401) {
       // login and retry
       await login();
-      return await getPreviewWorkspace(ctx);
+      return await getPreviewWorkspace(startedOra, ctx);
     } else {
       throw e;
     }

package/src/generate.test.ts

@@ -79,9 +79,7 @@ describe("generate", () => {
       config: {},
     } as any);
     vi.mocked(createCompiler).mockResolvedValue({
-      build: vi.fn().mockResolvedValue({
-        hasError: false,
-      }),
+      build: vi.fn(),
       destroy: vi.fn(),
     } as any);
 
@@ -114,51 +112,4 @@ describe("generate", () => {
       "stencilBuild/embeddable-wrapper.esm-hash.js",
     );
   });
-
-  it("should generate bundle in dev mode", async () => {
-    const ctx = {
-      ...config,
-      dev: {
-        logger: vi.fn(),
-        sys: vi.fn(),
-      },
-    };
-
-    vi.mocked(fs.readFile).mockResolvedValue(
-      "replace-this-with-component-name",
-    );
-    await generate(ctx, "sdk-react");
-
-    expect(createCompiler).toHaveBeenCalled();
-
-    expect(fs.writeFile).toHaveBeenCalledWith(
-      "componentDir/component.tsx",
-      expect.stringContaining("embeddable-component"),
-    );
-
-    expect(loadConfig).toHaveBeenCalledWith({
-      config: {
-        configPath: "buildDir/stencil.config.ts",
-        devMode: true,
-        enableCache: true,
-        maxConcurrentWorkers: 8,
-        minifyCss: false,
-        minifyJs: false,
-        namespace: "embeddable-wrapper",
-        outputTargets: [
-          {
-            type: "dist",
-          },
-        ],
-        rootDir: "buildDir",
-        sourceMap: false,
-        srcDir: "buildDir/component",
-        tsconfig: "buildDir/tsconfig.json",
-        watchDirs: ["buildDir/buildName"],
-      },
-      initTsConfig: true,
-      logger: expect.any(Function),
-      sys: expect.any(Function),
-    });
-  });
 });

package/src/generate.ts

@@ -96,8 +96,8 @@ async function addComponentTagName(filePath: string, bundleHash: string) {
   ]);
 }
 
-async function runStencil(ctx: any): Promise<void> {
-  const logger = ctx.dev?.logger || createNodeLogger();
+async function runStencil(ctx: any) {
+  const logger = ctx.dev?.logger || createNodeLogger({ process });
   const sys = ctx.dev?.sys || createNodeSys({ process });
   const devMode = !!ctx.dev;
 
@@ -109,56 +109,23 @@ async function runStencil(ctx: any): Promise<void> {
     sys,
     config: {
       devMode,
-      enableCache: true,
       maxConcurrentWorkers: isWindows ? 0 : 8, // workers break on windows
       rootDir: ctx.client.buildDir,
       configPath: path.resolve(ctx.client.buildDir, "stencil.config.ts"),
       tsconfig: path.resolve(ctx.client.buildDir, "tsconfig.json"),
       namespace: "embeddable-wrapper",
       srcDir: path.resolve(ctx.client.buildDir, "component"),
-      sourceMap: !devMode,
-      minifyJs: !devMode,
-      minifyCss: !devMode,
       outputTargets: [
         {
           type: "dist",
         },
       ],
-      watchDirs: [
-        path.resolve(
-          ctx.client.buildDir,
-          ctx["sdk-react"].outputOptions.buildName,
-        ),
-      ],
     },
   });
 
   const compiler = await createCompiler(validated.config);
-  const buildResults = await compiler.build();
-
-  if (devMode) {
-    // Handle process exit to clean up resources
-    const cleanUp = async () => {
-      await compiler.destroy();
-      process.exit(0);
-    };
-
-    process.on("SIGINT", cleanUp);
-    process.on("SIGTERM", cleanUp);
-  } else {
-    if (buildResults.hasError) {
-      console.error("Stencil build error:", buildResults.diagnostics);
-      throw new Error("Stencil build error");
-    } else {
-      await handleStencilBuildOutput(ctx);
-    }
-    await compiler.destroy();
-  }
 
-  process.chdir(ctx.client.rootDir);
-}
-
-async function handleStencilBuildOutput(ctx: any) {
+  await compiler.build();
   const entryFilePath = path.resolve(
     ctx.client.stencilBuild,
     "embeddable-wrapper.esm.js",
@@ -182,6 +149,9 @@ async function handleStencilBuildOutput(ctx: any) {
     entryFilePath,
     path.resolve(ctx.client.stencilBuild, fileName),
   );
+
+  await compiler.destroy();
+  process.chdir(ctx.client.rootDir);
 }
 
 async function generateSourceMap(ctx: any, pluginName: string) {

package/src/push.test.ts

@@ -74,8 +74,8 @@ const config = {
     buildDir: "buildDir",
     archiveFile: "embeddable-build.zip",
   },
-  pushBaseUrl: "pushBaseUrl",
-  previewBaseUrl: "previewBaseUrl",
+  pushBaseUrl: "http://localhost:3000",
+  previewBaseUrl: "http://localhost:3000",
 };
 
 describe("push", () => {
@@ -130,10 +130,10 @@ describe("push", () => {
     expect(fs.rm).toHaveBeenCalledWith(config.client.archiveFile);
 
     expect(infoMock.info).toHaveBeenCalledWith(
-      "Publishing to mocked-workspace-name using previewBaseUrl/workspace/mocked-workspace-id...",
+      "Publishing to mocked-workspace-name using http://localhost:3000/workspace/mocked-workspace-id...",
     );
     expect(infoMock.succeed).toHaveBeenCalledWith(
-      "Published to mocked-workspace-name using previewBaseUrl/workspace/mocked-workspace-id",
+      "Published to mocked-workspace-name using http://localhost:3000/workspace/mocked-workspace-id",
     );
   });
 

package/src/push.ts

@@ -3,7 +3,7 @@ import * as fsSync from "node:fs";
 import * as archiver from "archiver";
 import axios from "axios";
 const oraP = import("ora");
-const inquirerSelect = import("@inquirer/select");
+
 import provideConfig from "./provideConfig";
 // @ts-ignore
 import reportErrorToRollbar from "./rollbar.mjs";
@@ -11,6 +11,7 @@ import reportErrorToRollbar from "./rollbar.mjs";
 import { findFiles } from "@embeddable.com/sdk-utils";
 import { getToken } from "./login";
 import { checkBuildSuccess, checkNodeVersion, getArgumentByKey } from "./utils";
+import { selectWorkspace } from "./workspaceUtils";
 
 // grab .cube.yml|js and .sc.yml|js files
 export const YAML_OR_JS_FILES = /^(.*)\.(cube|sc)\.(ya?ml|js)$/;
@@ -53,6 +54,7 @@ export default async () => {
       .info("No API Key provided. Standard login will be used.");
 
     const { workspaceId, name: workspaceName } = await selectWorkspace(
+      ora,
       config,
       token,
     );
@@ -110,44 +112,6 @@ async function pushByApiKey(config: any, spinner: any) {
   });
 }
 
-async function selectWorkspace(ctx: any, token: string) {
-  const workspaceSpinner = ora({
-    text: `Fetching workspaces using ${ctx.pushBaseUrl}...`,
-    color: "green",
-    discardStdin: false,
-  }).start();
-
-  const availableWorkspaces = await getWorkspaces(ctx, token, workspaceSpinner);
-
-  let selectedWorkspace;
-
-  if (availableWorkspaces.length === 0) {
-    workspaceSpinner.fail("No workspaces found");
-    process.exit(1);
-  }
-
-  workspaceSpinner.info(`Found ${availableWorkspaces.length} workspace(s)`);
-
-  if (availableWorkspaces.length === 1) {
-    selectedWorkspace = availableWorkspaces[0];
-  } else {
-    const select = (await inquirerSelect).default;
-    selectedWorkspace = await select({
-      message: "Select workspace to push changes",
-      choices: availableWorkspaces.map((workspace: any) => ({
-        name: `${workspace.name} (${workspace.workspaceId})`,
-        value: workspace,
-      })),
-    });
-  }
-
-  workspaceSpinner.succeed(
-    `Workspace: ${selectedWorkspace.name} (${selectedWorkspace.workspaceId})`,
-  );
-
-  return selectedWorkspace;
-}
-
 async function verify(ctx: any) {
   try {
     await fs.access(ctx.client.buildDir);
@@ -297,24 +261,3 @@ async function uploadFile(formData: any, url: string, token: string) {
     maxBodyLength: Infinity,
   });
 }
-
-async function getWorkspaces(ctx: any, token: string, workspaceSpinner: any) {
-  try {
-    const response = await axios.get(`${ctx.pushBaseUrl}/workspace`, {
-      headers: {
-        Authorization: `Bearer ${token}`,
-      },
-    });
-
-    return response.data?.filter((w: any) => !w.devWorkspace);
-  } catch (e: any) {
-    if (e.response.status === 401) {
-      workspaceSpinner.fail(
-        'Unauthorized. Please login using "embeddable login" command.',
-      );
-    } else {
-      workspaceSpinner.fail("Failed to fetch workspaces");
-    }
-    process.exit(1);
-  }
-}

package/src/utils.test.ts

@@ -10,6 +10,7 @@ import {
 const startMock = {
   succeed: vi.fn(),
   fail: vi.fn(),
+  stop: vi.fn(),
 };
 
 const failMock = vi.fn();
@@ -58,11 +59,9 @@ describe("utils", () => {
       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(startMock.fail).toHaveBeenCalledWith(
+        "Node version 16.0 or higher is required. You are running 14.0.",
+      );
 
       expect(result).toBe(undefined);
     });

package/src/utils.ts

@@ -3,10 +3,9 @@ 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;
-  const spinner = ora("Checking node version...");
+  const ora = (await oraP).default;
+  const spinner = ora("Checking node version...").start();
   const [major, minor] = process.versions.node.split(".").map(Number);
 
   const packageJson = await import("../package.json");
@@ -20,13 +19,13 @@ export const checkNodeVersion = async () => {
     .map(Number);
 
   if (major < minMajor || (major === minMajor && minor < minMinor)) {
-    spinner.fail({
-      text: `Node version ${minMajor}.${minMinor} or higher is required. You are running ${major}.${minor}.`,
-      color: "red",
-    });
+    spinner.fail(
+      `Node version ${minMajor}.${minMinor} or higher is required. You are running ${major}.${minor}.`,
+    );
 
     process.exit(1);
   } else {
+    spinner.stop();
     return true;
   }
 };

package/src/workspaceUtils.test.ts

@@ -0,0 +1,135 @@
+import { describe, it, expect, vi } from "vitest";
+import axios from "axios";
+import { getWorkspaces, selectWorkspace } from "./workspaceUtils";
+import { select } from "@inquirer/prompts";
+
+vi.mock("axios");
+
+vi.mock("@inquirer/prompts", () => ({
+  select: vi.fn(),
+}));
+
+describe("workspaceUtils", () => {
+  describe("getWorkspaces", () => {
+    it("should fetch workspaces and filter out dev workspaces", async () => {
+      const ctx = { pushBaseUrl: "http://example.com" };
+      const token = "test-token";
+      const workspaceSpinner = { fail: vi.fn() };
+
+      const workspaces = [
+        { name: "Workspace 1", workspaceId: "1", devWorkspace: false },
+        { name: "Workspace 2", workspaceId: "2", devWorkspace: true },
+      ];
+
+      (axios.get as any).mockResolvedValue({ data: workspaces });
+
+      const result = await getWorkspaces(ctx, token, workspaceSpinner);
+
+      expect(result).toEqual([
+        { name: "Workspace 1", workspaceId: "1", devWorkspace: false },
+      ]);
+    });
+
+    it("should handle unauthorized error", async () => {
+      const ctx = { pushBaseUrl: "http://example.com" };
+      const token = "test-token";
+      const workspaceSpinner = { fail: vi.fn() };
+
+      (axios.get as any).mockRejectedValue({ response: { status: 401 } });
+
+      await expect(
+        getWorkspaces(ctx, token, workspaceSpinner),
+      ).rejects.toThrow();
+      expect(workspaceSpinner.fail).toHaveBeenCalledWith(
+        'Unauthorized. Please login using "embeddable login" command.',
+      );
+    });
+
+    it("should handle other errors", async () => {
+      const ctx = { pushBaseUrl: "http://example.com" };
+      const token = "test-token";
+      const workspaceSpinner = { fail: vi.fn() };
+
+      (axios.get as any).mockRejectedValue({ response: { status: 500 } });
+
+      await expect(
+        getWorkspaces(ctx, token, workspaceSpinner),
+      ).rejects.toThrow();
+      expect(workspaceSpinner.fail).toHaveBeenCalledWith(
+        "Failed to fetch workspaces",
+      );
+    });
+  });
+
+  describe("selectWorkspace", () => {
+    beforeEach(() => {
+      vi.mocked(select).mockResolvedValue({
+        name: "Workspace 2",
+        workspaceId: "2",
+        devWorkspace: false,
+      });
+    });
+
+    it("should select a workspace when only one is available", async () => {
+      const ora = vi.fn().mockReturnValue({
+        start: vi.fn().mockReturnThis(),
+        fail: vi.fn(),
+        info: vi.fn(),
+        succeed: vi.fn(),
+      });
+
+      const ctx = { pushBaseUrl: "http://example.com" };
+      const token = "test-token";
+
+      const workspaces = [
+        { name: "Workspace 1", workspaceId: "1", devWorkspace: false },
+      ];
+
+      (axios.get as any).mockResolvedValue({ data: workspaces });
+
+      const selectedWorkspace = await selectWorkspace(ora, ctx, token);
+
+      expect(selectedWorkspace).toEqual(workspaces[0]);
+      expect(ora().succeed).toHaveBeenCalledWith(`Workspace: Workspace 1 (1)`);
+    });
+
+    it("should prompt user to select a workspace when multiple are available", async () => {
+      const ora = vi.fn().mockReturnValue({
+        start: vi.fn().mockReturnThis(),
+        fail: vi.fn(),
+        info: vi.fn(),
+        succeed: vi.fn(),
+      });
+      const ctx = { pushBaseUrl: "http://example.com" };
+      const token = "test-token";
+
+      const workspaces = [
+        { name: "Workspace 1", workspaceId: "1", devWorkspace: false },
+        { name: "Workspace 2", workspaceId: "2", devWorkspace: false },
+      ];
+
+      (axios.get as any).mockResolvedValue({ data: workspaces });
+
+      const selectedWorkspace = await selectWorkspace(ora, ctx, token);
+
+      expect(selectedWorkspace).toEqual(workspaces[1]);
+      expect(ora().succeed).toHaveBeenCalledWith(`Workspace: Workspace 2 (2)`);
+    });
+
+    it("should handle no workspaces found", async () => {
+      const ora = vi.fn().mockReturnValue({
+        start: vi.fn().mockReturnThis(),
+        fail: vi.fn(),
+        info: vi.fn(),
+        succeed: vi.fn(),
+      });
+      const ctx = { pushBaseUrl: "http://example.com" };
+      const token = "test-token";
+
+      (axios.get as any).mockResolvedValue({ data: [] });
+
+      await expect(selectWorkspace(ora, ctx, token)).rejects.toThrow();
+      expect(ora().fail).toHaveBeenCalledWith("No workspaces found");
+    });
+  });
+});