@embeddable.com/sdk-core 3.13.2 → 3.13.3-next.0

package/package.json

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

package/src/cleanup.test.ts

@@ -14,6 +14,7 @@ const ctx = {
 
 vi.mock("node:fs/promises", () => ({
   writeFile: vi.fn(),
+  readFile: vi.fn(),
   rename: vi.fn(),
 }));
 

package/src/utils.test.ts

@@ -6,6 +6,7 @@ import {
   checkBuildSuccess,
   SUCCESS_FLAG_FILE,
   hrtimeToISO8601,
+  getSDKVersions,
 } from "./utils";
 
 const startMock = {
@@ -16,6 +17,11 @@ const startMock = {
 
 const failMock = vi.fn();
 
+// Mock for testing resolveLocalFileVersion
+const mockPackageJson = {
+  version: "1.2.3",
+};
+
 vi.mock("ora", () => ({
   default: () => ({
     start: vi.fn().mockImplementation(() => startMock),
@@ -35,6 +41,7 @@ vi.mock("fs/promises", () => ({
   writeFile: vi.fn(),
   access: vi.fn(),
   mkdir: vi.fn(),
+  unlink: vi.fn(),
 }));
 
 describe("utils", () => {
@@ -135,6 +142,109 @@ describe("utils", () => {
     });
   });
 
+  describe("getSDKVersions", () => {
+    beforeEach(() => {
+      process.env.NODE_ENV = "local";
+      vi.resetAllMocks();
+      process.cwd = vi.fn().mockReturnValue("/test/path");
+    });
+
+    afterEach(() => {
+      process.env.NODE_ENV = "test";
+    });
+
+    it("should get versions from node_modules", async () => {
+      // Mock the readFile to return a version for the first package
+      vi.mocked(fs.readFile).mockResolvedValueOnce(
+        JSON.stringify(mockPackageJson),
+      );
+
+      const result = await getSDKVersions();
+
+      expect(result).toHaveProperty("@embeddable.com/core", "1.2.3");
+    });
+
+    it("should handle local file references", async () => {
+      // Mock package.json with local file references
+      const mockProjectPackageJson = {
+        dependencies: {
+          "@embeddable.com/core": "file:../packages/core",
+        },
+      };
+
+      // First readFile calls for node_modules fail
+      vi.mocked(fs.readFile)
+        .mockRejectedValueOnce(new Error("Not found")) // core
+        .mockRejectedValueOnce(new Error("Not found")) // react
+        .mockRejectedValueOnce(new Error("Not found")) // sdk-core
+        .mockRejectedValueOnce(new Error("Not found")) // sdk-react
+        .mockRejectedValueOnce(new Error("Not found")) // sdk-utils
+        // Then project package.json succeeds
+        .mockResolvedValueOnce(JSON.stringify(mockProjectPackageJson))
+        // Then the referenced package.json succeeds
+        .mockResolvedValueOnce(JSON.stringify({ version: "2.0.0" }));
+
+      const result = await getSDKVersions();
+
+      expect(result).toHaveProperty("@embeddable.com/core", "2.0.0");
+    });
+
+    it("should handle errors when resolving local file references", async () => {
+      // Mock console.warn to avoid test output noise
+      const consoleWarnSpy = vi
+        .spyOn(console, "warn")
+        .mockImplementation(() => {});
+
+      // Mock package.json with local file references
+      const mockProjectPackageJson = {
+        dependencies: {
+          "@embeddable.com/core": "file:../packages/core",
+        },
+      };
+
+      // First readFile calls for node_modules fail
+      vi.mocked(fs.readFile)
+        .mockRejectedValueOnce(new Error("Not found")) // core
+        .mockRejectedValueOnce(new Error("Not found")) // react
+        .mockRejectedValueOnce(new Error("Not found")) // sdk-core
+        .mockRejectedValueOnce(new Error("Not found")) // sdk-react
+        .mockRejectedValueOnce(new Error("Not found")) // sdk-utils
+        // Then project package.json succeeds
+        .mockResolvedValueOnce(JSON.stringify(mockProjectPackageJson))
+        // Then the referenced package.json fails
+        .mockRejectedValueOnce(new Error("Cannot read file"));
+
+      const result = await getSDKVersions();
+
+      expect(consoleWarnSpy).toHaveBeenCalled();
+      expect(result).toHaveProperty("@embeddable.com/core", "local-dev");
+
+      consoleWarnSpy.mockRestore();
+    });
+
+    it("should use fallback values in test environment when no versions found", async () => {
+      // Mock console.warn to avoid test output noise
+      const consoleWarnSpy = vi
+        .spyOn(console, "warn")
+        .mockImplementation(() => {});
+
+      // Mock all readFile calls to fail
+      vi.mocked(fs.readFile).mockRejectedValue(new Error("Not found"));
+
+      // Mock process.cwd to return a test-sdk path
+      process.cwd = vi.fn().mockReturnValue("/test/path/test-sdk");
+
+      const result = await getSDKVersions();
+
+      // Should have fallback values for all packages
+      expect(Object.keys(result).length).toBeGreaterThan(0);
+      expect(result["@embeddable.com/core"]).toBe("local-dev");
+      expect(result["@embeddable.com/sdk-core"]).toBe("local-dev");
+
+      consoleWarnSpy.mockRestore();
+    });
+  });
+
   describe("hrtimeToISO8601", () => {
     test.each([
       { input: [0, 0], expected: "PT0.000S" },

package/src/utils.ts

@@ -115,6 +115,30 @@ const getPackageVersion = async (packageName: string) => {
   }
 };
 
+/**
+ * Attempts to resolve a local file reference to get the actual package version
+ * @param packageName The name of the package
+ * @param filePath The file path reference (e.g. "file:../packages/core")
+ * @returns The resolved version or "local-dev" if not found
+ */
+const resolveLocalFileVersion = async (
+  packageName: string,
+  filePath: string,
+) => {
+  try {
+    // Remove the file: prefix and resolve the path
+    const refPath = filePath.replace(/^file:/, "");
+    const absPath = path.resolve(process.cwd(), refPath, "package.json");
+
+    // Read the package.json from the referenced path
+    const refPackageJson = JSON.parse(await fs.readFile(absPath, "utf-8"));
+    return refPackageJson.version || "local-dev";
+  } catch (e) {
+    console.warn(`Failed to resolve local version for ${packageName}`, e);
+    return "local-dev";
+  }
+};
+
 export const getSDKVersions = async () => {
   const packageNames = [
     "@embeddable.com/core",
@@ -124,6 +148,7 @@ export const getSDKVersions = async () => {
     "@embeddable.com/sdk-utils",
   ];
 
+  // First try to get versions from node_modules
   const sdkVersions = await packageNames.reduce<
     Promise<Record<string, string>>
   >(
@@ -138,6 +163,49 @@ export const getSDKVersions = async () => {
     Promise.resolve({}), // Start with a resolved promise containing an empty object
   );
 
+  // If no versions were found, try to get them from package.json dependencies/devDependencies
+  if (
+    Object.keys(sdkVersions).length === 0 &&
+    process.env.NODE_ENV !== "test"
+  ) {
+    try {
+      const packageJsonPath = path.join(process.cwd(), "package.json");
+      const packageJson = JSON.parse(
+        await fs.readFile(packageJsonPath, "utf-8"),
+      );
+
+      const { dependencies = {}, devDependencies = {} } = packageJson;
+      const allDeps = { ...dependencies, ...devDependencies };
+
+      for (const packageName of packageNames) {
+        if (allDeps[packageName]) {
+          // For file: references, try to get the actual version from the referenced package
+          if (allDeps[packageName].startsWith("file:")) {
+            sdkVersions[packageName] = await resolveLocalFileVersion(
+              packageName,
+              allDeps[packageName],
+            );
+          } else {
+            sdkVersions[packageName] = allDeps[packageName];
+          }
+        }
+      }
+    } catch (e) {
+      console.warn("Failed to read package.json for SDK versions", e);
+    }
+  }
+
+  // If we're in a test environment and still have no versions, add fallback values
+  if (Object.keys(sdkVersions).length === 0) {
+    const isTestEnv = process.cwd().includes("test-sdk");
+    if (isTestEnv) {
+      console.warn("Test environment detected, using fallback SDK versions");
+      packageNames.forEach((pkg) => {
+        sdkVersions[pkg] = "local-dev";
+      });
+    }
+  }
+
   return sdkVersions;
 };