@embeddable.com/sdk-core 4.1.12 → 4.2.0-next.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@embeddable.com/sdk-core",
-  "version": "4.1.12",
+  "version": "4.2.0-next.0",
   "description": "Core Embeddable SDK module responsible for web-components bundling and publishing.",
   "keywords": [
     "embeddable",
@@ -36,7 +36,7 @@
     "embeddable": "bin/embeddable"
   },
   "engines": {
-    "node": ">=20.0.0"
+    "node": ">=20.1.0"
   },
   "license": "MIT",
   "dependencies": {
@@ -45,7 +45,7 @@
     "@inquirer/prompts": "^7.2.1",
     "@stencil/core": "^4.23.0",
     "@swc-node/register": "^1.10.9",
-    "archiver": "^7.0.1",
+    "yazl": "^2.5.1",
     "axios": "^1.7.9",
     "chokidar": "^4.0.3",
     "dotenv": "^16.4.7",
@@ -66,8 +66,16 @@
       "prettier --write"
     ]
   },
+  "peerDependencies": {
+    "typescript": ">=5.0.0"
+  },
+  "peerDependenciesMeta": {
+    "typescript": {
+      "optional": true
+    }
+  },
   "devDependencies": {
-    "@types/archiver": "^6.0.3",
+    "@types/yazl": "^2.4.5",
     "@types/finalhandler": "^1.2.3",
     "@types/minimist": "^1.2.5",
     "@types/serve-static": "^1.15.7",

package/src/push.test.ts

@@ -1,7 +1,8 @@
 import push, { buildArchive } from "./push";
 import provideConfig from "./provideConfig";
 import { fileFromPath } from "formdata-node/file-from-path";
-import archiver from "archiver";
+import * as path from "path";
+import yazl from "yazl";
 import * as fs from "node:fs/promises";
 import * as fsSync from "node:fs";
 import { findFiles } from "@embeddable.com/sdk-utils";
@@ -53,6 +54,9 @@ vi.mock("node:fs/promises", () => ({
 
 vi.mock("node:fs", () => ({
   createWriteStream: vi.fn(),
+  readdirSync: vi.fn().mockReturnValue([]),
+  statSync: vi.fn().mockReturnValue({ isFile: () => true }),
+  existsSync: vi.fn().mockReturnValue(true),
 }));
 
 vi.mock("./provideConfig", () => ({
@@ -73,9 +77,13 @@ vi.mock("@embeddable.com/sdk-utils", () => ({
   findFiles: vi.fn(),
 }));
 
-vi.mock("archiver", () => ({
+const { zipRef } = vi.hoisted(() => ({
+  zipRef: { current: null as any },
+}));
+
+vi.mock("yazl", () => ({
   default: {
-    create: vi.fn(),
+    ZipFile: vi.fn(function () { return zipRef.current; }),
   },
 }));
 
@@ -96,11 +104,10 @@ const config = {
 };
 
 describe("push", () => {
-  const archiveMock = {
-    finalize: vi.fn(),
-    pipe: vi.fn(),
-    directory: vi.fn(),
-    file: vi.fn(),
+  const zipMock = {
+    addFile: vi.fn(),
+    end: vi.fn(),
+    outputStream: { pipe: vi.fn() },
   };
 
   beforeEach(() => {
@@ -121,7 +128,9 @@ describe("push", () => {
     vi.mocked(fileFromPath).mockReturnValue(
       new Blob([new ArrayBuffer(8)]) as any
     );
-    vi.mocked(archiver.create).mockReturnValue(archiveMock as any);
+    zipRef.current = zipMock;
+    vi.mocked(fsSync.readdirSync).mockReturnValue([]);
+    vi.mocked(fsSync.existsSync).mockReturnValue(true);
 
     vi.mocked(fsSync.createWriteStream).mockReturnValue({
       on: (event: string, cb: () => void) => {
@@ -142,19 +151,19 @@ describe("push", () => {
 
     expect(fs.access).toHaveBeenCalledWith(config.client.buildDir);
 
-    expect(archiver.create).toHaveBeenCalledWith("zip", {
-      zlib: { level: 9 },
-    });
+    expect(yazl.ZipFile).toHaveBeenCalled();
     expect(fsSync.createWriteStream).toHaveBeenCalledWith(
       config.client.archiveFile
     );
 
-    expect(archiveMock.pipe).toHaveBeenCalled();
-    expect(archiveMock.file).toHaveBeenCalledWith("src/custom-canvas.css", {
-      name: "global.css",
-    });
-    expect(archiveMock.directory).toHaveBeenCalledWith("buildDir", false);
-    expect(archiveMock.finalize).toHaveBeenCalled();
+    expect(zipMock.outputStream.pipe).toHaveBeenCalled();
+    expect(zipMock.addFile).toHaveBeenCalledWith(
+      "src/custom-canvas.css", "global.css", expect.objectContaining({ compress: true })
+    );
+    expect(fsSync.readdirSync).toHaveBeenCalledWith(
+      "buildDir", expect.objectContaining({ recursive: true })
+    );
+    expect(zipMock.end).toHaveBeenCalled();
     // after publishing the file gets removed
     expect(fs.rm).toHaveBeenCalledWith(config.client.archiveFile);
 
@@ -230,13 +239,12 @@ describe("push", () => {
     });
 
     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(),
+      const localZipMock = {
+        addFile: vi.fn(),
+        end: vi.fn(),
+        outputStream: { pipe: vi.fn() },
       };
-      vi.mocked(archiver.create).mockReturnValue(mockArchiver as any);
+      zipRef.current = localZipMock;
 
       vi.mocked(provideConfig).mockResolvedValue({
         ...config,
@@ -246,13 +254,14 @@ describe("push", () => {
 
       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(2);
-      expect(mockArchiver.file).toHaveBeenCalledWith(expect.anything(), {
-        name: "global.css",
-      });
+      // Should read component build directory
+      expect(fsSync.readdirSync).toHaveBeenCalledWith(
+        "buildDir", expect.objectContaining({ recursive: true })
+      );
+      // Should include global.css and client context files
+      expect(localZipMock.addFile).toHaveBeenCalledWith(
+        expect.anything(), "global.css", expect.objectContaining({ compress: true })
+      );
     });
   });
 
@@ -398,29 +407,24 @@ describe("push", () => {
   });
 
   describe("buildArchive", () => {
-    type MockArchiver = {
-      finalize: ReturnType<typeof vi.fn>;
-      pipe: ReturnType<typeof vi.fn>;
-      directory: ReturnType<typeof vi.fn>;
-      file: ReturnType<typeof vi.fn>;
+    type MockZip = {
+      addFile: ReturnType<typeof vi.fn>;
+      end: ReturnType<typeof vi.fn>;
+      outputStream: { pipe: ReturnType<typeof vi.fn> };
     };
 
-    let mockArchiver: MockArchiver;
-    let mockOra: {
-      start: ReturnType<typeof vi.fn>;
-      succeed: ReturnType<typeof vi.fn>;
-      fail: ReturnType<typeof vi.fn>;
-    };
+    let mockZipLocal: MockZip;
 
     beforeEach(() => {
-      mockArchiver = {
-        finalize: vi.fn(),
-        pipe: vi.fn(),
-        directory: vi.fn(),
-        file: vi.fn(),
+      mockZipLocal = {
+        addFile: vi.fn(),
+        end: vi.fn(),
+        outputStream: { pipe: vi.fn() },
       };
 
-      vi.mocked(archiver.create).mockReturnValue(mockArchiver as any);
+      zipRef.current = mockZipLocal;
+      vi.mocked(fsSync.readdirSync).mockReturnValue([]);
+      vi.mocked(fsSync.existsSync).mockReturnValue(true);
       vi.mocked(findFiles).mockResolvedValue([]);
     });
 
@@ -447,43 +451,38 @@ describe("push", () => {
 
       await buildArchive(testConfig);
 
-      // Should include component build directory
-      expect(mockArchiver.directory).toHaveBeenCalledWith(
+      // Should read component build directory
+      expect(fsSync.readdirSync).toHaveBeenCalledWith(
         testConfig.client.buildDir,
-        false
+        expect.objectContaining({ recursive: true })
       );
       // Should include global.css
-      expect(mockArchiver.file).toHaveBeenCalledWith(
+      expect(mockZipLocal.addFile).toHaveBeenCalledWith(
         testConfig.client.customCanvasCss,
-        {
-          name: "global.css",
-        }
+        "global.css",
+        expect.objectContaining({ compress: true })
       );
       // Should include all model files
-      expect(mockArchiver.file).toHaveBeenCalledWith(
+      expect(mockZipLocal.addFile).toHaveBeenCalledWith(
         "/path/to/model1.cube.yml",
-        {
-          name: "model1.cube.yml",
-        }
+        "model1.cube.yml",
+        expect.objectContaining({ compress: true })
       );
-      expect(mockArchiver.file).toHaveBeenCalledWith(
+      expect(mockZipLocal.addFile).toHaveBeenCalledWith(
         "/path/to/model2.cube.yaml",
-        {
-          name: "model2.cube.yaml",
-        }
+        "model2.cube.yaml",
+        expect.objectContaining({ compress: true })
       );
       // Should include all preset files
-      expect(mockArchiver.file).toHaveBeenCalledWith(
+      expect(mockZipLocal.addFile).toHaveBeenCalledWith(
         "/path/to/context1.sc.yml",
-        {
-          name: "context1.sc.yml",
-        }
+        "context1.sc.yml",
+        expect.objectContaining({ compress: true })
       );
-      expect(mockArchiver.file).toHaveBeenCalledWith(
+      expect(mockZipLocal.addFile).toHaveBeenCalledWith(
         "/path/to/context2.cc.yml",
-        {
-          name: "context2.cc.yml",
-        }
+        "context2.cc.yml",
+        expect.objectContaining({ compress: true })
       );
     });
 
@@ -500,17 +499,16 @@ describe("push", () => {
 
       await buildArchive(testConfig);
 
-      // Should include component build directory
-      expect(mockArchiver.directory).toHaveBeenCalledWith(
+      // Should read component build directory
+      expect(fsSync.readdirSync).toHaveBeenCalledWith(
         testConfig.client.buildDir,
-        false
+        expect.objectContaining({ recursive: true })
       );
       // Should include global.css
-      expect(mockArchiver.file).toHaveBeenCalledWith(
+      expect(mockZipLocal.addFile).toHaveBeenCalledWith(
         testConfig.client.customCanvasCss,
-        {
-          name: "global.css",
-        }
+        "global.css",
+        expect.objectContaining({ compress: true })
       );
       // Should only find client context files
       expect(findFiles).toHaveBeenCalledOnce();
@@ -541,6 +539,82 @@ describe("push", () => {
       );
     });
 
+    it("should add directory files to zip with correct relative paths", async () => {
+      vi.mocked(fsSync.readdirSync).mockReturnValue([
+        "index.js",
+        "components/widget.js",
+      ] as any);
+      vi.mocked(fsSync.statSync).mockReturnValue({ isFile: () => true } as any);
+
+      const testConfig = {
+        ...config,
+        pushModels: false,
+        pushComponents: true,
+        client: {
+          ...config.client,
+          srcDir: "/src",
+        },
+      } as ResolvedEmbeddableConfig;
+
+      await buildArchive(testConfig);
+
+      expect(mockZipLocal.addFile).toHaveBeenCalledWith(
+        path.join("buildDir", "index.js"),
+        "index.js",
+        expect.objectContaining({ compress: true })
+      );
+      expect(mockZipLocal.addFile).toHaveBeenCalledWith(
+        path.join("buildDir", "components/widget.js"),
+        "components/widget.js",
+        expect.objectContaining({ compress: true })
+      );
+    });
+
+    it("should skip directories when adding directory contents to zip", async () => {
+      vi.mocked(fsSync.readdirSync).mockReturnValue(["components"] as any);
+      vi.mocked(fsSync.statSync).mockReturnValue({ isFile: () => false } as any);
+
+      const testConfig = {
+        ...config,
+        pushModels: false,
+        pushComponents: true,
+        client: {
+          ...config.client,
+          srcDir: "/src",
+        },
+      } as ResolvedEmbeddableConfig;
+
+      await buildArchive(testConfig);
+
+      const addFileCalls = mockZipLocal.addFile.mock.calls;
+      const dirCall = addFileCalls.find(
+        (call: any) => call[1] === "components"
+      );
+      expect(dirCall).toBeUndefined();
+    });
+
+    it("should skip customCanvasCss when file does not exist", async () => {
+      vi.mocked(fsSync.existsSync).mockReturnValue(false);
+
+      const testConfig = {
+        ...config,
+        pushModels: false,
+        pushComponents: true,
+        client: {
+          ...config.client,
+          srcDir: "/src",
+        },
+      } as ResolvedEmbeddableConfig;
+
+      await buildArchive(testConfig);
+
+      const addFileCalls = mockZipLocal.addFile.mock.calls;
+      const cssCall = addFileCalls.find(
+        (call: any) => call[1] === "global.css"
+      );
+      expect(cssCall).toBeUndefined();
+    });
+
     it("should use srcDir as fallback when modelsSrc/presetsSrc are not defined", async () => {
       const testConfig = {
         ...config,

package/src/push.ts

@@ -1,6 +1,6 @@
 import * as fs from "node:fs/promises";
 import * as fsSync from "node:fs";
-import archiver from "archiver";
+import yazl from "yazl";
 import axios, {AxiosResponse} from "axios";
 import ora, { Ora } from "ora";
 import { initLogger, logError } from "./logger";
@@ -231,34 +231,41 @@ export async function archive(args: {
   isDev: boolean;
 }) {
   const { ctx, filesList, isDev } = args;
-  const output = fsSync.createWriteStream(ctx.client.archiveFile);
+  const zip = new yazl.ZipFile();
 
-  const archive = archiver.create("zip", {
-    zlib: { level: 9 },
-  });
-
-  archive.pipe(output);
   if (!isDev) {
-    archive.directory(ctx.client.buildDir, false);
+    addDirectoryToZip(zip, ctx.client.buildDir);
     // NOTE: for backward compatibility, keep the file name as global.css
-    archive.file(ctx.client.customCanvasCss, {
-      name: "global.css",
-    });
+    if (fsSync.existsSync(ctx.client.customCanvasCss)) {
+      zip.addFile(ctx.client.customCanvasCss, "global.css", { compress: true });
+    }
   }
 
-  for (const fileData of filesList) {
-    archive.file(fileData[1], {
-      name: fileData[0],
-    });
+  for (const [name, filePath] of filesList) {
+    zip.addFile(filePath, name, { compress: true });
   }
 
-  await archive.finalize();
+  zip.end();
 
-  return new Promise<void>((resolve: any, _reject) => {
-    output.on("close", () => resolve());
+  return new Promise<void>((resolve, reject) => {
+    const output = fsSync.createWriteStream(ctx.client.archiveFile);
+    zip.outputStream.pipe(output);
+    output.on("close", resolve);
+    output.on("error", reject);
   });
 }
 
+function addDirectoryToZip(zip: yazl.ZipFile, dir: string) {
+  const entries = fsSync.readdirSync(dir, { recursive: true });
+  for (const entry of entries) {
+    const relativePath = String(entry);
+    const fullPath = path.join(dir, relativePath);
+    if (fsSync.statSync(fullPath).isFile()) {
+      zip.addFile(fullPath, relativePath, { compress: true });
+    }
+  }
+}
+
 export async function createFormData(
   filePath: string,
   metadata: Record<string, any>,