@embeddable.com/sdk-core 3.13.0-next.2 → 3.13.0-next.4

package/src/push.test.ts

@@ -1,14 +1,17 @@
-import push from "./push";
+import push, { buildArchive } from "./push";
 import provideConfig from "./provideConfig";
 import { fileFromPath } from "formdata-node/file-from-path";
 import archiver from "archiver";
 import * as fs from "node:fs/promises";
 import * as fsSync from "node:fs";
 import { findFiles } from "@embeddable.com/sdk-utils";
+import { ResolvedEmbeddableConfig } from "./defineConfig";
+import { vi, describe, it, expect, beforeEach } from "vitest";
+import { getArgumentByKey } from "./utils";
 
 // @ts-ignore
 import reportErrorToRollbar from "./rollbar.mjs";
-import { checkBuildSuccess, checkNodeVersion, getArgumentByKey } from "./utils";
+import { checkBuildSuccess, checkNodeVersion } from "./utils";
 import { server } from "../../../mocks/server";
 import { http, HttpResponse } from "msw";
 
@@ -85,9 +88,11 @@ const config = {
     rootDir: "rootDir",
     buildDir: "buildDir",
     archiveFile: "embeddable-build.zip",
+    globalCss: "src/global.css",
   },
   pushBaseUrl: "http://localhost:3000",
   previewBaseUrl: "http://localhost:3000",
+  pushComponents: true,
 };
 
 describe("push", () => {
@@ -110,7 +115,6 @@ describe("push", () => {
     vi.mocked(fs.stat).mockResolvedValue({
       size: 100,
     } as any);
-
     vi.mocked(findFiles).mockResolvedValue([["fileName", "filePath"]]);
     vi.mocked(fileFromPath).mockReturnValue(
       new Blob([new ArrayBuffer(8)]) as any,
@@ -144,8 +148,8 @@ describe("push", () => {
     );
 
     expect(archiveMock.pipe).toHaveBeenCalled();
-    expect(archiveMock.file).toHaveBeenCalledWith("filePath", {
-      name: "filePath",
+    expect(archiveMock.file).toHaveBeenCalledWith("src/global.css", {
+      name: "global.css",
     });
     expect(archiveMock.directory).toHaveBeenCalledWith("buildDir", false);
     expect(archiveMock.finalize).toHaveBeenCalled();
@@ -205,4 +209,405 @@ describe("push", () => {
 
     expect(startMock.succeed).toHaveBeenCalledWith("Published using API key");
   });
+
+  describe("push configuration", () => {
+    it("should fail if both pushModels and pushComponents are disabled", async () => {
+      vi.spyOn(console, "error").mockImplementation(() => undefined);
+      vi.mocked(provideConfig).mockResolvedValue({
+        ...config,
+        pushModels: false,
+        pushComponents: false,
+      });
+
+      await push();
+
+      expect(startMock.fail).toHaveBeenCalledWith(
+        "Cannot push: both pushModels and pushComponents are disabled",
+      );
+      expect(process.exit).toHaveBeenCalledWith(1);
+    });
+
+    it("should only include model files when pushComponents is false", async () => {
+      const mockArchiver = {
+        finalize: vi.fn(),
+        pipe: vi.fn(),
+        directory: vi.fn(),
+        file: vi.fn(),
+      };
+      vi.mocked(archiver.create).mockReturnValue(mockArchiver as any);
+
+      vi.mocked(provideConfig).mockResolvedValue({
+        ...config,
+        pushModels: true,
+        pushComponents: false,
+      });
+
+      await push();
+
+      // Should not include component build directory
+      expect(mockArchiver.directory).not.toHaveBeenCalled();
+      // Should include model files
+      expect(mockArchiver.file).toHaveBeenCalled();
+    });
+
+    it("should only include component files when pushModels is false", async () => {
+      const mockArchiver = {
+        finalize: vi.fn(),
+        pipe: vi.fn(),
+        directory: vi.fn(),
+        file: vi.fn(),
+      };
+      vi.mocked(archiver.create).mockReturnValue(mockArchiver as any);
+
+      vi.mocked(provideConfig).mockResolvedValue({
+        ...config,
+        pushModels: false,
+        pushComponents: true,
+      });
+
+      await push();
+
+      // Should include component build directory
+      expect(mockArchiver.directory).toHaveBeenCalled();
+      // Should not include model files (except global.css which is part of components)
+      expect(mockArchiver.file).toHaveBeenCalledTimes(1);
+      expect(mockArchiver.file).toHaveBeenCalledWith(expect.anything(), {
+        name: "global.css",
+      });
+    });
+  });
+
+  describe("API key validation", () => {
+    it("should fail if API key is not provided", async () => {
+      vi.spyOn(console, "error").mockImplementation(() => undefined);
+      Object.defineProperties(process, {
+        argv: {
+          value: ["--api-key"],
+        },
+      });
+      vi.mocked(getArgumentByKey).mockReturnValue(undefined);
+
+      await push();
+
+      expect(startMock.fail).toHaveBeenCalledWith("No API key provided");
+      expect(process.exit).toHaveBeenCalledWith(1);
+    });
+
+    it("should fail if email is not provided with API key", async () => {
+      vi.spyOn(console, "error").mockImplementation(() => undefined);
+      Object.defineProperties(process, {
+        argv: {
+          value: ["--api-key", "some-key"],
+        },
+      });
+      vi.mocked(getArgumentByKey)
+        .mockReturnValueOnce("some-key") // API key
+        .mockReturnValueOnce(undefined); // Email
+
+      await push();
+
+      expect(startMock.fail).toHaveBeenCalledWith(
+        "Invalid email provided. Please provide a valid email using --email (-e) flag",
+      );
+      expect(process.exit).toHaveBeenCalledWith(1);
+    });
+
+    it("should fail if email is invalid", async () => {
+      vi.spyOn(console, "error").mockImplementation(() => undefined);
+      Object.defineProperties(process, {
+        argv: {
+          value: ["--api-key", "some-key", "--email", "invalid-email"],
+        },
+      });
+      vi.mocked(getArgumentByKey)
+        .mockReturnValueOnce("some-key") // API key
+        .mockReturnValueOnce("invalid-email"); // Invalid email
+
+      await push();
+
+      expect(startMock.fail).toHaveBeenCalledWith(
+        "Invalid email provided. Please provide a valid email using --email (-e) flag",
+      );
+      expect(process.exit).toHaveBeenCalledWith(1);
+    });
+
+    it("should accept optional message parameter", async () => {
+      Object.defineProperties(process, {
+        argv: {
+          value: [
+            "--api-key",
+            "some-key",
+            "--email",
+            "valid@email.com",
+            "--message",
+            "test message",
+          ],
+        },
+      });
+      vi.mocked(getArgumentByKey)
+        .mockReturnValueOnce("some-key") // API key
+        .mockReturnValueOnce("valid@email.com") // Email
+        .mockReturnValueOnce("test message"); // Message
+
+      await push();
+
+      expect(startMock.succeed).toHaveBeenCalledWith("Published using API key");
+    });
+  });
+
+  describe("error handling", () => {
+    beforeEach(() => {
+      // Reset all mocks to their default state
+      vi.mocked(getArgumentByKey).mockReturnValue(undefined);
+      Object.defineProperties(process, {
+        argv: {
+          value: [],
+        },
+      });
+    });
+
+    it("should fail if build directory does not exist", async () => {
+      vi.spyOn(console, "error").mockImplementation(() => undefined);
+      vi.mocked(fs.access).mockRejectedValue(new Error("No such directory"));
+      vi.mocked(provideConfig).mockResolvedValue(config);
+
+      await push();
+
+      expect(console.error).toHaveBeenCalledWith(
+        "No embeddable build was produced.",
+      );
+      expect(process.exit).toHaveBeenCalledWith(1);
+    });
+
+    it("should fail if token is not available", async () => {
+      vi.spyOn(console, "error").mockImplementation(() => undefined);
+      vi.mocked(fs.access).mockResolvedValue(undefined);
+      vi.mocked(fs.readFile).mockResolvedValue(Buffer.from("{}"));
+      vi.mocked(provideConfig).mockResolvedValue(config);
+
+      await push();
+
+      expect(console.error).toHaveBeenCalledWith(
+        "Expired token. Please login again.",
+      );
+      expect(process.exit).toHaveBeenCalledWith(1);
+    });
+
+    it("should handle and report errors during push", async () => {
+      const testError = new Error("Test error");
+      vi.mocked(provideConfig).mockRejectedValue(testError);
+      vi.mocked(fs.access).mockResolvedValue(undefined);
+      vi.mocked(fs.readFile).mockImplementation(async () =>
+        Buffer.from(`{"access_token":"mocked-token"}`),
+      );
+
+      await push();
+
+      expect(reportErrorToRollbar).toHaveBeenCalledWith(testError);
+      expect(process.exit).toHaveBeenCalledWith(1);
+    });
+  });
+
+  describe("buildArchive", () => {
+    type MockArchiver = {
+      finalize: ReturnType<typeof vi.fn>;
+      pipe: ReturnType<typeof vi.fn>;
+      directory: ReturnType<typeof vi.fn>;
+      file: ReturnType<typeof vi.fn>;
+    };
+
+    let mockArchiver: MockArchiver;
+    let mockOra: {
+      start: ReturnType<typeof vi.fn>;
+      succeed: ReturnType<typeof vi.fn>;
+      fail: ReturnType<typeof vi.fn>;
+    };
+
+    beforeEach(() => {
+      mockArchiver = {
+        finalize: vi.fn(),
+        pipe: vi.fn(),
+        directory: vi.fn(),
+        file: vi.fn(),
+      };
+
+      vi.mocked(archiver.create).mockReturnValue(mockArchiver as any);
+      vi.mocked(findFiles).mockResolvedValue([]);
+    });
+
+    it("should include all file types when both flags are true", async () => {
+      vi.mocked(findFiles)
+        .mockResolvedValueOnce([
+          ["model1.cube.yml", "/path/to/model1.cube.yml"],
+          ["model2.cube.yaml", "/path/to/model2.cube.yaml"],
+        ])
+        .mockResolvedValueOnce([
+          ["context1.sc.yml", "/path/to/context1.sc.yml"],
+          ["context2.cc.yml", "/path/to/context2.cc.yml"],
+        ]);
+
+      const testConfig = {
+        ...config,
+        pushModels: true,
+        pushComponents: true,
+        client: {
+          ...config.client,
+          srcDir: "/src",
+        },
+      } as ResolvedEmbeddableConfig;
+
+      await buildArchive(testConfig);
+
+      // Should include component build directory
+      expect(mockArchiver.directory).toHaveBeenCalledWith(
+        testConfig.client.buildDir,
+        false,
+      );
+      // Should include global.css
+      expect(mockArchiver.file).toHaveBeenCalledWith(
+        testConfig.client.globalCss,
+        {
+          name: "global.css",
+        },
+      );
+      // Should include all model files
+      expect(mockArchiver.file).toHaveBeenCalledWith(
+        "/path/to/model1.cube.yml",
+        {
+          name: "model1.cube.yml",
+        },
+      );
+      expect(mockArchiver.file).toHaveBeenCalledWith(
+        "/path/to/model2.cube.yaml",
+        {
+          name: "model2.cube.yaml",
+        },
+      );
+      // Should include all preset files
+      expect(mockArchiver.file).toHaveBeenCalledWith(
+        "/path/to/context1.sc.yml",
+        {
+          name: "context1.sc.yml",
+        },
+      );
+      expect(mockArchiver.file).toHaveBeenCalledWith(
+        "/path/to/context2.cc.yml",
+        {
+          name: "context2.cc.yml",
+        },
+      );
+    });
+
+    it("should only include model files when pushComponents is false", async () => {
+      vi.mocked(findFiles)
+        .mockResolvedValueOnce([["model.cube.yml", "/path/to/model.cube.yml"]])
+        .mockResolvedValueOnce([["context.sc.yml", "/path/to/context.sc.yml"]]);
+
+      const testConfig = {
+        ...config,
+        pushModels: true,
+        pushComponents: false,
+        client: {
+          ...config.client,
+          srcDir: "/src",
+        },
+      } as ResolvedEmbeddableConfig;
+
+      await buildArchive(testConfig);
+
+      // Should not include component build directory
+      expect(mockArchiver.directory).not.toHaveBeenCalled();
+      // Should not include global.css
+      expect(mockArchiver.file).not.toHaveBeenCalledWith(
+        expect.anything(),
+        expect.objectContaining({ name: "global.css" }),
+      );
+      // Should include model files
+      expect(mockArchiver.file).toHaveBeenCalledWith(
+        "/path/to/model.cube.yml",
+        {
+          name: "model.cube.yml",
+        },
+      );
+      expect(mockArchiver.file).toHaveBeenCalledWith(
+        "/path/to/context.sc.yml",
+        {
+          name: "context.sc.yml",
+        },
+      );
+    });
+
+    it("should only include component files when pushModels is false", async () => {
+      const testConfig = {
+        ...config,
+        pushModels: false,
+        pushComponents: true,
+        client: {
+          ...config.client,
+          srcDir: "/src",
+        },
+      } as ResolvedEmbeddableConfig;
+
+      await buildArchive(testConfig);
+
+      // Should include component build directory
+      expect(mockArchiver.directory).toHaveBeenCalledWith(
+        testConfig.client.buildDir,
+        false,
+      );
+      // Should include global.css
+      expect(mockArchiver.file).toHaveBeenCalledWith(
+        testConfig.client.globalCss,
+        {
+          name: "global.css",
+        },
+      );
+      // Should not include any model files
+      expect(findFiles).not.toHaveBeenCalled();
+    });
+
+    it("should search in custom directories for model files", async () => {
+      const testConfig = {
+        ...config,
+        pushModels: true,
+        pushComponents: true,
+        client: {
+          ...config.client,
+          srcDir: "/src",
+          modelsSrc: "/custom/models/path",
+          presetsSrc: "/custom/presets/path",
+        },
+      } as ResolvedEmbeddableConfig;
+
+      await buildArchive(testConfig);
+
+      expect(findFiles).toHaveBeenCalledWith(
+        "/custom/models/path",
+        expect.any(RegExp),
+      );
+      expect(findFiles).toHaveBeenCalledWith(
+        "/custom/presets/path",
+        expect.any(RegExp),
+      );
+    });
+
+    it("should use srcDir as fallback when modelsSrc/presetsSrc are not defined", async () => {
+      const testConfig = {
+        ...config,
+        pushModels: true,
+        pushComponents: true,
+        client: {
+          ...config.client,
+          srcDir: "/src",
+          modelsSrc: undefined,
+          presetsSrc: undefined,
+        },
+      } as ResolvedEmbeddableConfig;
+
+      await buildArchive(testConfig);
+
+      expect(findFiles).toHaveBeenCalledWith("/src", expect.any(RegExp));
+      expect(findFiles).toHaveBeenCalledWith("/src", expect.any(RegExp));
+    });
+  });
 });

package/src/push.ts

@@ -14,6 +14,7 @@ import { findFiles } from "@embeddable.com/sdk-utils";
 import { getToken } from "./login";
 import { checkBuildSuccess, checkNodeVersion, getArgumentByKey } from "./utils";
 import { selectWorkspace } from "./workspaceUtils";
+import { ResolvedEmbeddableConfig } from "./defineConfig";
 
 // grab cube files
 export const CUBE_FILES = /^(.*)\.cube\.(ya?ml|js)$/;
@@ -84,7 +85,7 @@ export default async () => {
   }
 };
 
-async function pushByApiKey(config: any, spinner: any) {
+async function pushByApiKey(config: ResolvedEmbeddableConfig, spinner: any) {
   const apiKey = getArgumentByKey(["--api-key", "-k"]);
 
   if (!apiKey) {
@@ -113,7 +114,7 @@ async function pushByApiKey(config: any, spinner: any) {
   });
 }
 
-async function verify(ctx: any) {
+async function verify(ctx: ResolvedEmbeddableConfig) {
   try {
     await fs.access(ctx.client.buildDir);
   } catch (_e) {
@@ -132,33 +133,55 @@ async function verify(ctx: any) {
   return token;
 }
 
-async function buildArchive(config: any) {
+export async function buildArchive(config: ResolvedEmbeddableConfig) {
   const spinnerArchive = ora("Building...").start();
 
-  const cubeFilesList = await findFiles(
-    config.client.modelsSrc || config.client.srcDir,
-    CUBE_FILES,
-  );
+  if (!config.pushModels && !config.pushComponents) {
+    spinnerArchive.fail(
+      "Cannot push: both pushModels and pushComponents are disabled",
+    );
+    process.exit(1);
+  }
 
-  const contextFilesList = await findFiles(
-    config.client.presetsSrc || config.client.srcDir,
-    PRESET_FILES,
-  );
+  const filesList: [string, string][] = [];
 
-  // Map the files to include their full filenames
-  const filesList = [...cubeFilesList, ...contextFilesList].map(
-    (entry): [string, string] => [path.basename(entry[1]), entry[1]],
-  );
+  if (config.pushModels) {
+    const cubeFilesList = await findFiles(
+      config.client.modelsSrc || config.client.srcDir,
+      CUBE_FILES,
+    );
+    const contextFilesList = await findFiles(
+      config.client.presetsSrc || config.client.srcDir,
+      PRESET_FILES,
+    );
+    filesList.push(
+      ...cubeFilesList.map((entry): [string, string] => [
+        path.basename(entry[1]),
+        entry[1],
+      ]),
+      ...contextFilesList.map((entry): [string, string] => [
+        path.basename(entry[1]),
+        entry[1],
+      ]),
+    );
+  }
 
-  await archive(config, filesList);
+  await archive({
+    ctx: config,
+    filesList,
+    isDev: false,
+    includeComponents: config.pushComponents,
+  });
   return spinnerArchive.succeed("Bundling completed");
 }
 
-export async function archive(
-  ctx: any,
-  yamlFiles: [string, string][],
-  isDev: boolean = false,
-) {
+export async function archive(args: {
+  ctx: ResolvedEmbeddableConfig;
+  filesList: [string, string][];
+  isDev: boolean;
+  includeComponents: boolean;
+}) {
+  const { ctx, filesList, isDev, includeComponents } = args;
   const output = fsSync.createWriteStream(ctx.client.archiveFile);
 
   const archive = archiver.create("zip", {
@@ -166,14 +189,14 @@ export async function archive(
   });
 
   archive.pipe(output);
-  if (!isDev) {
+  if (!isDev && includeComponents) {
     archive.directory(ctx.client.buildDir, false);
     archive.file(ctx.client.globalCss, {
       name: "global.css",
     });
   }
 
-  for (const fileData of yamlFiles) {
+  for (const fileData of filesList) {
     archive.file(fileData[1], {
       name: fileData[0],
     });
@@ -187,8 +210,12 @@ export async function archive(
 }
 
 export async function sendBuildByApiKey(
-  ctx: any,
-  { apiKey, email, message }: any,
+  ctx: ResolvedEmbeddableConfig,
+  {
+    apiKey,
+    email,
+    message,
+  }: { apiKey: string; email: string; message?: string },
 ) {
   const { FormData, Blob } = await import("formdata-node");
   const { fileFromPath } = await import("formdata-node/file-from-path");
@@ -218,7 +245,7 @@ export async function sendBuildByApiKey(
 }
 
 export async function sendBuild(
-  ctx: any,
+  ctx: ResolvedEmbeddableConfig,
   { workspaceId, token }: { workspaceId: string; token: string },
 ) {
   const { FormData } = await import("formdata-node");