Dereference framework directories

Author: kraenhansen

packages/cmake-rn/src/platforms/apple.ts

@@ -8,6 +8,7 @@ import {
   AppleTriplet as Triplet,
   createAppleFramework,
   createXCframework,
+  dereferenceDirectory,
 } from "react-native-node-api";
 
 import type { Platform } from "./types.js";
@@ -372,6 +373,18 @@ export const platform: Platform<Triplet[], AppleOpts> = {
       }
     }
 
+    // Make sure none of the frameworks are symlinks
+    // We do this before creating an xcframework to avoid symlink paths being invalidated
+    // as the xcframework might be moved to a different location
+    await Promise.all(
+      frameworkPaths.map(async (frameworkPath) => {
+        const stat = await fs.promises.lstat(frameworkPath);
+        if (stat.isSymbolicLink()) {
+          await dereferenceDirectory(frameworkPath);
+        }
+      }),
+    );
+
     const extension = xcframeworkExtension ? ".xcframework" : ".apple.node";
 
     assert(

packages/host/src/node/index.ts

@@ -22,6 +22,9 @@ export {
   determineXCFrameworkFilename,
 } from "./prebuilds/apple.js";
 
-export { determineLibraryBasename } from "./path-utils.js";
+export {
+  determineLibraryBasename,
+  dereferenceDirectory,
+} from "./path-utils.js";
 
 export { weakNodeApiPath } from "./weak-node-api.js";

packages/host/src/node/path-utils.test.ts

@@ -13,6 +13,7 @@ import {
   isNodeApiModule,
   stripExtension,
   findNodeApiModulePathsByDependency,
+  dereferenceDirectory,
 } from "./path-utils.js";
 import { setupTempDirectory } from "./test-utils.js";
 
@@ -502,3 +503,37 @@ describe("findNodeAddonForBindings()", () => {
     });
   }
 });
+
+describe("dereferenceDirectory", () => {
+  describe("when directory contains symlinks", () => {
+    it("should dereference symlinks", async (context) => {
+      // Create a temp directory with a symlink
+      const tempDir = setupTempDirectory(context, {
+        "original/file.txt": "Hello, world!",
+      });
+      const originalPath = path.join(tempDir, "original");
+      const symlinkPath = path.join(tempDir, "link");
+      // Create a link to the original directory
+      fs.symlinkSync(originalPath, symlinkPath, "dir");
+      // And an internal link
+      fs.symlinkSync(
+        path.join(originalPath, "file.txt"),
+        path.join(originalPath, "linked-file.txt"),
+        "file",
+      );
+
+      await dereferenceDirectory(symlinkPath);
+
+      // Verify that outer link is no longer a link
+      const symlinkStat = await fs.promises.lstat(symlinkPath);
+      assert(!symlinkStat.isSymbolicLink());
+
+      // Verify that the internal link is still a link to a readable file
+      const internalLinkPath = path.join(symlinkPath, "linked-file.txt");
+      const internalLinkStat = await fs.promises.lstat(internalLinkPath);
+      assert(internalLinkStat.isSymbolicLink());
+      const content = await fs.promises.readFile(internalLinkPath, "utf8");
+      assert.equal(content, "Hello, world!");
+    });
+  });
+});

packages/host/src/node/path-utils.ts

@@ -483,3 +483,16 @@ export function findNodeAddonForBindings(id: string, fromDir: string) {
   }
   return undefined;
 }
+
+export async function dereferenceDirectory(dirPath: string) {
+  const tempPath = dirPath + ".tmp";
+  // Move the existing framework out of the way
+  await fs.promises.rename(dirPath, tempPath);
+  // Only dereference the symlink at tempPath (not recursively)
+  const realPath = await fs.promises.realpath(tempPath);
+  await fs.promises.cp(realPath, dirPath, {
+    recursive: true,
+    verbatimSymlinks: true,
+  });
+  await fs.promises.unlink(tempPath);
+}