Expose syncInjectedDeps from @pnpm/workspace.injected-deps-syncer in pnpm CLI

[BartoszUrban]

I wanted to get pnpm deploy to work and for that I have set injectWorkspacePackages to true. Even though pnpm now has syncInjectedDepsAfterScripts, some tooling like Nx (or turborepo #9837 ) does not work with this. For me Nx on an outdated version does not seem to call pnpm run under the hood, therefore not using syncInjectedDepsAfterScripts, but even if it did, because Nx caches the output of build, it'd not rerun syncInjectedDeps on a cache hit.

This is expected of course, and direct integration with Nx can solve this but to make this third-party integration easier, I'd like to propose for syncInjectedDeps to be exposed as a pnpm CLI command, or a pnpm install flag to run only the sync, since running just syncInjectedDeps is much faster than rerunning install, even if all caches are in place.

e.g.

pnpm install --filter @pkg/name --sync-injected-deps-only (following naming pattern of --resolution-only)

I have solved this for myself right now, by importing syncInjectedDeps from @pnpm/workspace.injected-deps-syncer and while it was simple, not needing to depend on a pnpm internal would be great

While I see solutions like https://www.npmjs.com/package/pnpm-sync-lib and https://www.npmjs.com/package/pnpm-sync-dependencies-meta-injected, I'd prefer to depend on pnpm itself, since it already handles it during install and after running scripts with pnpm run.

import { syncInjectedDeps } from '@pnpm/workspace.injected-deps-syncer';

/**
 * Re-expose syncInjectedDeps from pnpm SDK as a CLI tool
 */
async function main() {
  const args = process.argv.slice(2);

  let pkgName;
  let pkgRootDir;
  let workspaceDir;

  for (let i = 0; i < args.length; i++) {
    const arg = args[i];

    if (arg === '--pkg-name' && args[i + 1]) {
      pkgName = args[++i];
    } else if (arg === '--pkg-root-dir' && args[i + 1]) {
      pkgRootDir = args[++i];
    } else if (arg === '--workspace-dir' && args[i + 1]) {
      workspaceDir = args[++i];
    }
  }

  if (!pkgRootDir) {
    console.error('Error: --pkg-root-dir is required');
    process.exit(1);
  }

  try {
    await syncInjectedDeps({
      pkgName,
      pkgRootDir,
      workspaceDir,
    });
    // console.log('Successfully synced injected dependencies');
  } catch (error) {
    console.error('Failed to sync injected dependencies:', error);
    process.exit(1);
  }
}

main();

And here's the use case, in Nx (below is for Nx 17.3.1) by creating a custom graph plugin I could replace the node script with a pnpm command instead:

import { CreateNodes, ProjectConfiguration, readJsonFile } from '@nx/devkit';
import path from 'node:path';

type PackageJsonType = {
  dependencies?: Record<string, string>;
  devDependencies?: Record<string, string>;
  name: string;
  scripts?: Record<string, string>;
};

type OptionalType<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;

/**
 * Adds a sync-deps target to projects with a build script in package.json
 *
 * This runs pnpm's syncInjectedDeps function to update the node_modules injected into dependents in a pnpm monorepo setup
 */
export const createNodes: CreateNodes = [
  '**/package.json',
  (
    projectConfigurationFile,
    _,
    context,
  ): { projects: Record<string, OptionalType<ProjectConfiguration, 'root'>> } => {
    const pkg: PackageJsonType = readJsonFile(
      path.resolve(context.workspaceRoot, projectConfigurationFile),
    );
    const hasBuildScript = !!pkg?.scripts?.build;

    if (!hasBuildScript) {
      return { projects: {} };
    }

    const projectRoot = path.dirname(projectConfigurationFile);
    const absoluteProjectRoot = path.resolve(projectRoot);
    const workspaceRoot = context.workspaceRoot;

    // What could be replaced
    const syncDepsScriptPath = path.resolve(__dirname, './sync.js');

    const modifiedNode = {
      projects: {
        [projectRoot]: {
          targets: {
            'sync-deps': {
              executor: 'nx:run-commands',
              options: {
                command: `node "${syncDepsScriptPath}" --pkg-root-dir "${absoluteProjectRoot}" --workspace-dir "${workspaceRoot}" --pkg-name "${pkg.name}"`,
                cwd: projectRoot,
              },
            },
          },
        },
      },
    };

    return modifiedNode;
  },
];

const plugin = {
  name: 'nx-pnpm-sync-deps',
  createNodes,
};

export default plugin;