@embeddable.com/sdk-core 4.2.0 → 4.3.0-next.1

package/src/utils/dev.utils.test.ts

@@ -0,0 +1,126 @@
+import {
+  createWatcherLock,
+  preventContentLength,
+  waitUntilFileStable,
+} from "./dev.utils";
+import { ServerResponse } from "http";
+import * as fs from "node:fs/promises";
+import {createReadStream} from "node:fs";
+import { Readable } from "node:stream";
+
+vi.mock("node:fs/promises", async () => {
+  let size = 100;
+  return {
+    stat: vi.fn().mockImplementation(() => ({ size })),
+  };
+});
+
+vi.mock("node:fs", async () => ({
+  createReadStream: vi.fn()
+}));
+
+describe("preventContentLength", () => {
+  it("should not allow setting 'content-length' header", () => {
+    const headers: Record<string, string> = {};
+    const res = {
+      setHeader: (key: string, value: any) => {
+        headers[key.toLowerCase()] = value;
+      },
+    } as unknown as ServerResponse;
+
+    preventContentLength(res);
+    res.setHeader("content-length", "1234");
+    res.setHeader("x-custom-header", "abc");
+
+    expect(headers["content-length"]).toBeUndefined();
+    expect(headers["x-custom-header"]).toBe("abc");
+  });
+});
+
+describe("createWatcherLock", () => {
+  it("should block and unblock correctly", async () => {
+    const lock = createWatcherLock();
+
+    lock.lock();
+    let unlocked = false;
+
+    const waiter = lock.waitUntilFree().then(() => {
+      unlocked = true;
+    });
+
+    // Still locked
+    expect(unlocked).toBe(false);
+
+    lock.unlock();
+
+    // Wait for Promise resolution
+    await waiter;
+    expect(unlocked).toBe(true);
+  });
+
+  it("should resolve immediately if not locked", async () => {
+    const lock = createWatcherLock();
+    await expect(lock.waitUntilFree()).resolves.toBeUndefined();
+  });
+
+  it("should not resolve until unlock is called", async () => {
+    const lock = createWatcherLock();
+    lock.lock();
+
+    let resolved = false;
+    lock.waitUntilFree().then(() => {
+      resolved = true;
+    });
+
+    await new Promise((r) => setTimeout(r, 20));
+    expect(resolved).toBe(false);
+
+    lock.unlock();
+    await new Promise((r) => setTimeout(r, 0)); // allow promise to resolve
+    expect(resolved).toBe(true);
+  });
+});
+
+describe("waitUntilFileStable", () => {
+  it("should resolve when file becomes stable and has the expected tail", async () => {
+    const filePath = "mock/path.js";
+    const expectedTail = "sourceMappingURL";
+    let size = 10;
+
+    const mockStat = vi.fn().mockImplementation(() => {
+      return Promise.resolve({ size });
+    });
+
+    vi.mocked(fs.stat).mockImplementation(mockStat);
+
+    const streamData = "some data\n// sourceMappingURL=something.js";
+
+    vi.mocked(createReadStream).mockImplementation(() => {
+      return Readable.from([streamData]) as any;
+    });
+
+    await expect(waitUntilFileStable(filePath, expectedTail, {
+      maxAttempts: 5,
+    })).resolves.toBeUndefined();
+
+    expect(fs.stat).toHaveBeenCalled();
+    expect(createReadStream).toHaveBeenCalled();
+  });
+
+  it("should throw if file never stabilizes", async () => {
+    const filePath = "mock/path.js";
+    const expectedTail = "sourceMappingURL";
+
+    vi.mocked(fs.stat).mockResolvedValue({ size: 0 } as any);
+
+    vi.mocked(createReadStream).mockImplementation(() => {
+      return Readable.from([""]) as any;
+    });
+
+    await expect(waitUntilFileStable(filePath, expectedTail, {
+      maxAttempts: 3,
+    })).rejects.toThrow("File did not stabilize");
+
+    expect(fs.stat).toHaveBeenCalled();
+  });
+});

package/src/utils/dev.utils.ts

@@ -0,0 +1,117 @@
+import * as fs from "node:fs/promises";
+import { ServerResponse } from "http";
+import { createReadStream } from "node:fs";
+
+/**
+ * Wraps a ServerResponse object to prevent setting the Content-Length header.
+ */
+export function preventContentLength(res: ServerResponse) {
+  const originalSetHeader = res.setHeader.bind(res);
+  res.setHeader = function (key: string, value: any) {
+    if (key.toLowerCase() === "content-length") {
+      return this;
+    }
+    return originalSetHeader(key, value);
+  };
+}
+
+export function createWatcherLock() {
+  let locked = false;
+  let waiters: (() => void)[] = [];
+
+  return {
+    lock() {
+      if (!locked) {
+        locked = true;
+      }
+    },
+
+    unlock() {
+      if (locked) {
+        locked = false;
+        waiters.forEach((fn) => fn());
+        waiters = [];
+      }
+    },
+
+    async waitUntilFree() {
+      if (!locked) return;
+      await new Promise<void>((resolve) => {
+        waiters.push(resolve);
+      });
+    },
+  };
+}
+
+export const delay = (ms: number) => new Promise((res) => setTimeout(res, ms));
+
+/**
+ * This function waits until a file stabilizes, meaning its size does not change for a certain number of attempts
+ * and the content ends with a specific expected tail.
+ * It uses stream reading to check the file's content, the same wait serve-static uses.
+ * This will help to prevent when serve-static serves a file that is still being written to.
+ * One of the issues, related to this, is "Constructor for "embeddable-component#undefined" was not found", that we saw quite often in the past.
+ * @param filePath
+ * @param expectedTail
+ * @param maxAttempts
+ * @param stableCount
+ */
+export async function waitUntilFileStable(
+  filePath: string,
+  expectedTail: string,
+  {
+    maxAttempts = 100,
+    requiredStableCount = 2,
+  }: {
+    maxAttempts?: number;
+    requiredStableCount?: number;
+  } = {}
+): Promise<void> {
+  let lastSize = -1;
+  let stableCounter = 0;
+
+  for (let i = 0; i < maxAttempts; i++) {
+    try {
+      const { size, tailMatches } = await checkFileTail(filePath, expectedTail);
+
+      if (size === lastSize && size > 0 && tailMatches) {
+        stableCounter++;
+        if (stableCounter >= requiredStableCount) {
+          return;
+        }
+      } else {
+        stableCounter = 0;
+      }
+
+      lastSize = size;
+    } catch {
+    }
+
+    await delay(50);
+  }
+
+  throw new Error("File did not stabilize");
+}
+
+async function checkFileTail(
+  filePath: string,
+  expectedTail: string,
+  tailLength = 500
+): Promise<{ size: number; tailMatches: boolean }> {
+  const stats = await fs.stat(filePath);
+  const size = stats.size;
+  const start = Math.max(0, size - tailLength);
+
+  return new Promise((resolve, reject) => {
+    let tailBuffer = "";
+
+    createReadStream(filePath, { encoding: "utf-8", start })
+      .on("data", (chunk) => {
+        tailBuffer += chunk;
+      })
+      .on("end", () => {
+        resolve({ size, tailMatches: tailBuffer.includes(expectedTail) });
+      })
+      .on("error", reject);
+  });
+}