Stuck on an issue?

Lightrun Answers was designed to reduce the constant googling that comes with debugging 3rd party libraries. It collects links to all the places you might be looking at while hunting down a tough bug.

And, if you’re still stuck at the end, we’re happy to hop on a call to see how we can help out.

`electron-builder install-app-deps` does not work with yarn PNP

See original GitHub issue

Version: 22.9.1

Electron Version: 11.1.0
Electron Type (current, beta, nightly): current

Target: MacOS

The “install-app-deps” command does not work at all with yarn PNP due app-builder-bin being unable to handle finding modules using the PNP api, and so no rebuilding for any modules are executed.

I’ve hacked together a script to use electron-rebuilder and the pnp-api to rebuild the dependencies explicitly, as I don’t expect this to be resolved anytime soon.

const pnp = require(`pnpapi`);
const { rebuild } = require("electron-rebuild");
const {
  dependencies,
  devDependencies,
  name: workspaceName,
} = require("./package.json");

const findDeps = (workspace, productionDeps, searchedDeps = []) => {
  const seen = new Set();
  const resolvedDeps = [];

  const getKey = (locator) => JSON.stringify(locator);

  const isPeerDependency = (pkg, parentPkg, name) =>
    getKey(pkg.packageDependencies.get(name)) ===
    getKey(parentPkg.packageDependencies.get(name));

  const traverseDependencyTree = (locator, parentPkg = null) => {
    // Prevent infinite recursion when A depends on B which depends on A
    const key = getKey(locator);
    if (seen.has(key)) return;

    const { name: packageName } = locator;
    const pkg = pnp.getPackageInformation(locator);

    if (searchedDeps.includes(packageName)) {
      resolvedDeps.push([packageName, pkg.packageLocation]);
    }

    console.assert(pkg, `The package information should be available`);

    seen.add(key);

    pkg.packageDependencies.forEach((referencish, name) => {
      // Unmet peer dependencies
      if (referencish === null) {
        return;
      }

      // Avoid iterating on peer dependencies - very expensive
      if (parentPkg !== null && isPeerDependency(pkg, parentPkg, name)) {
        return;
      }

      // Skip non production deps for the workspace
      if (parentPkg === null && !productionDeps[name]) {
        return;
      }

      const childLocator = pnp.getLocator(name, referencish);
      traverseDependencyTree(childLocator, pkg);
    });
  };

  traverseDependencyTree(workspace);

  return resolvedDeps;
};

(async () => {
  // Set your list of modules which you are expecting to rebuild here
  const REBUILD_MODULES = [];
  const ELECTRON_VERSION = devDependencies.electron.replace("^", "");

  console.log("Rebuilding native modules for electron");

  const workspace = pnp
    .getDependencyTreeRoots()
    .find(({ name }) => name === workspaceName);

  const modulesToBuild = findDeps(workspace, dependencies, REBUILD_MODULES);
  const results = await Promise.all(
    modulesToBuild.map(([name, folder]) => {
      console.log(`Rebuilding ${name}...`);
      return rebuild({
        buildPath: folder,
        electronVersion: ELECTRON_VERSION,
      })
        .then(() => ({ name }))
        .catch((e) => ({ name, error: e }));
    })
  );
  results.forEach(({ name, error }) => {
    if (error) {
      console.error(`Could not rebuild ${name}`, error);
    }
  });

  if (results.some(({ error }) => error)) {
    process.exit(1);
  } else {
    console.log("Native modules built");
  }
})();