@embeddable.com/sdk-core 3.7.2 → 3.7.4

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/package.json

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

package/src/dev.ts

@@ -24,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");
@@ -99,7 +100,7 @@ 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);
     process.exit(1);
@@ -320,11 +321,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(
@@ -341,7 +352,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/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,131 @@
+import { describe, it, expect, vi } from "vitest";
+import axios from "axios";
+import { getWorkspaces, selectWorkspace } from "./workspaceUtils";
+const inquirerSelect = import("@inquirer/select");
+
+vi.mock("axios");
+
+vi.mock("@inquirer/select", () => ({
+  default: 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", () => {
+    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 });
+
+      vi.mocked((await inquirerSelect).default).mockResolvedValue(
+        workspaces[1],
+      );
+
+      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");
+    });
+  });
+});

package/src/workspaceUtils.ts

@@ -0,0 +1,65 @@
+const inquirerSelect = import("@inquirer/select");
+import axios from "axios";
+
+export 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);
+  }
+}
+
+export async function selectWorkspace(ora: any, 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;
+}