feat: support transitive injected dependency

packages/pnpm-sync-lib/etc/pnpm-sync-lib.api.md

@@ -16,6 +16,8 @@ export interface ILockfile {
     importers: Record<string, ILockfileImporter>;
     // (undocumented)
     lockfileVersion: number | string;
+    // (undocumented)
+    packages: Record<string, ILockfilePackage>;
 }
 
 // @beta (undocumented)
@@ -30,6 +32,12 @@ export interface ILockfileImporter {
     optionalDependencies?: Record<string, IVersionSpecifier>;
 }
 
+// @beta (undocumented)
+export interface ILockfilePackage {
+    dependencies?: Record<string, IVersionSpecifier>;
+    optionalDependencies?: Record<string, IVersionSpecifier>;
+}
+
 // @beta (undocumented)
 export interface ILogMessageCallbackOptions {
     // (undocumented)
@@ -82,6 +90,8 @@ export interface IPnpmSyncCopyOptions {
 
 // @beta (undocumented)
 export interface IPnpmSyncPrepareOptions {
+    // (undocumented)
+    ensureFolder: (folderPath: string) => Promise<void>;
     // (undocumented)
     lockfilePath: string;
     // (undocumented)
@@ -131,6 +141,6 @@ export enum LogMessageKind {
 export function pnpmSyncCopyAsync({ pnpmSyncJsonPath, getPackageIncludedFiles, forEachAsyncWithConcurrency, ensureFolder, logMessageCallback }: IPnpmSyncCopyOptions): Promise<void>;
 
 // @beta
-export function pnpmSyncPrepareAsync({ lockfilePath, storePath, readPnpmLockfile, logMessageCallback }: IPnpmSyncPrepareOptions): Promise<void>;
+export function pnpmSyncPrepareAsync({ lockfilePath, storePath, ensureFolder, readPnpmLockfile, logMessageCallback }: IPnpmSyncPrepareOptions): Promise<void>;
 
 ```

packages/pnpm-sync-lib/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pnpm-sync-lib",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "API library for integrating \"pnpm-sync\" with your toolchain",
   "repository": {
     "type": "git",

packages/pnpm-sync-lib/src/index.ts

@@ -11,6 +11,7 @@ export { LogMessageIdentifier, LogMessageKind } from './interfaces';
 export type {
   ILockfile,
   ILockfileImporter,
+  ILockfilePackage,
   IVersionSpecifier,
   IDependencyMeta,
   ILogMessageCallbackOptions

packages/pnpm-sync-lib/src/interfaces.ts

@@ -102,6 +102,16 @@ export interface ILockfileImporter {
   dependenciesMeta?: Record<string, IDependencyMeta>;
 }
 
+/**
+ * @beta
+ */
+export interface ILockfilePackage {
+  /** The list of dependencies and the resolved version */
+  dependencies?: Record<string, IVersionSpecifier>;
+  /** The list of optional dependencies and the resolved version */
+  optionalDependencies?: Record<string, IVersionSpecifier>;
+}
+
 /**
  * An abstraction of the pnpm lockfile
  *
@@ -110,4 +120,5 @@ export interface ILockfileImporter {
 export interface ILockfile {
   lockfileVersion: number | string;
   importers: Record<string, ILockfileImporter>;
+  packages: Record<string, ILockfilePackage>;
 }

packages/pnpm-sync-lib/src/pnpmSyncPrepare.ts

@@ -8,7 +8,8 @@ import {
   LogMessageKind,
   LogMessageIdentifier,
   IPnpmSyncJson,
-  IVersionSpecifier
+  IVersionSpecifier,
+  ILockfilePackage
 } from './interfaces';
 
 /**
@@ -17,6 +18,7 @@ import {
 export interface IPnpmSyncPrepareOptions {
   lockfilePath: string;
   storePath: string;
+  ensureFolder: (folderPath: string) => Promise<void>;
   readPnpmLockfile: (
     lockfilePath: string,
     options: { ignoreIncompatible: boolean }
@@ -38,6 +40,7 @@ export interface IPnpmSyncPrepareOptions {
 export async function pnpmSyncPrepareAsync({
   lockfilePath,
   storePath,
+  ensureFolder,
   readPnpmLockfile,
   logMessageCallback
 }: IPnpmSyncPrepareOptions): Promise<void> {
@@ -78,6 +81,9 @@ export async function pnpmSyncPrepareAsync({
   // find injected dependency and all its available versions
   const injectedDependencyToVersion: Map<string, Set<string>> = getInjectedDependencyToVersion(pnpmLockfile);
 
+  // check and process transitive injected dependency
+  processTransitiveInjectedDependency(pnpmLockfile, injectedDependencyToVersion);
+
   // get pnpm-lock.yaml folder path
   const pnpmLockFolder = lockfilePath.slice(0, lockfilePath.length - 'pnpm-lock.yaml'.length);
 
@@ -107,9 +113,14 @@ export async function pnpmSyncPrepareAsync({
       continue;
     }
 
-    // make sure the node_modules folder exists
-    if (!fs.existsSync(`${projectFolder}/node_modules`)) {
-      continue;
+    // make sure the node_modules folder exists, if not, create it
+    // why?
+    // in the transitive injected dependencies case
+    // it is possible that node_modules folder a package is not exist
+    // but we need to generate .pnpm-sync.json for that package
+    const projectNodeModulesFolderPath = `${projectFolder}/node_modules`;
+    if (!fs.existsSync(projectNodeModulesFolderPath)) {
+      await ensureFolder(projectNodeModulesFolderPath);
     }
 
     const pnpmSyncJsonPath = `${projectFolder}/node_modules/.pnpm-sync.json`;
@@ -229,3 +240,59 @@ function processDependencies(
     }
   }
 }
+
+// process all dependencies and devDependencies to find potential transitive injected dependencies
+// and add to injectedDependencyToFilePath map
+function processTransitiveInjectedDependency(
+  pnpmLockfile: ILockfile | undefined,
+  injectedDependencyToVersion: Map<string, Set<string>>
+): void {
+  const potentialTransitiveInjectedDependencyVersionQueue: Array<string> = [];
+  for (const injectedDependencyVersion of [...injectedDependencyToVersion.values()]) {
+    for (const version of [...injectedDependencyVersion]) {
+      potentialTransitiveInjectedDependencyVersionQueue.push(version);
+    }
+  }
+
+  const lockfilePackages: Record<string, ILockfilePackage> | undefined = pnpmLockfile?.packages;
+
+  if (lockfilePackages) {
+    while (potentialTransitiveInjectedDependencyVersionQueue.length > 0) {
+      const transitiveInjectedDependencyVersion: string | undefined =
+        potentialTransitiveInjectedDependencyVersionQueue.shift();
+      if (transitiveInjectedDependencyVersion) {
+        const { dependencies, optionalDependencies } = lockfilePackages[transitiveInjectedDependencyVersion];
+        processInjectedDependencies(
+          dependencies,
+          injectedDependencyToVersion,
+          potentialTransitiveInjectedDependencyVersionQueue
+        );
+        processInjectedDependencies(
+          optionalDependencies,
+          injectedDependencyToVersion,
+          potentialTransitiveInjectedDependencyVersionQueue
+        );
+      }
+    }
+  }
+}
+function processInjectedDependencies(
+  dependencies: Record<string, IVersionSpecifier> | undefined,
+  injectedDependencyToVersion: Map<string, Set<string>>,
+  potentialTransitiveInjectedDependencyVersionQueue: Array<string>
+): void {
+  if (dependencies) {
+    for (const [dependency, specifier] of Object.entries(dependencies)) {
+      const specifierToUse: string = typeof specifier === 'string' ? specifier : specifier.version;
+
+      // if the version is set with file: protocol, then it is a transitive injected dependency
+      if (specifierToUse.startsWith('file:')) {
+        if (!injectedDependencyToVersion.has(dependency)) {
+          injectedDependencyToVersion.set(dependency, new Set());
+        }
+        injectedDependencyToVersion.get(dependency)?.add(specifierToUse);
+        potentialTransitiveInjectedDependencyVersionQueue.push(specifierToUse);
+      }
+    }
+  }
+}

packages/pnpm-sync/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pnpm-sync",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "Recopy injected dependencies whenever a project is rebuilt in your PNPM workspace",
   "keywords": [
     "rush",

packages/pnpm-sync/src/start.ts

@@ -1,5 +1,11 @@
 import { Command } from 'commander';
-import { pnpmSyncCopyAsync, pnpmSyncPrepareAsync, type ILogMessageCallbackOptions } from 'pnpm-sync-lib';
+import {
+  type ILockfile,
+  type ILockfilePackage,
+  pnpmSyncCopyAsync,
+  pnpmSyncPrepareAsync,
+  type ILogMessageCallbackOptions
+} from 'pnpm-sync-lib';
 import { FileSystem, Async } from '@rushstack/node-core-library';
 import { PackageExtractor } from '@rushstack/package-extractor';
 import { readWantedLockfile, Lockfile } from '@pnpm/lockfile-file';
@@ -45,6 +51,7 @@ program
       await pnpmSyncPrepareAsync({
         lockfilePath: lockfile,
         storePath: store,
+        ensureFolder: FileSystem.ensureFolderAsync,
         readPnpmLockfile: async (
           lockfilePath: string,
           options: {
@@ -58,7 +65,23 @@ program
           if (lockfile === null) {
             return undefined;
           } else {
-            return lockfile;
+            const lockfilePackages: Record<string, ILockfilePackage> = {};
+            for (const packagePath in lockfile.packages) {
+              if (lockfile.packages[packagePath]) {
+                lockfilePackages[packagePath] = {
+                  dependencies: lockfile.packages[packagePath].dependencies,
+                  optionalDependencies: lockfile.packages[packagePath].optionalDependencies
+                };
+              }
+            }
+
+            const result: ILockfile = {
+              lockfileVersion: lockfile.lockfileVersion,
+              importers: lockfile.importers,
+              packages: lockfilePackages
+            };
+
+            return result;
           }
         },
         logMessageCallback: (options: ILogMessageCallbackOptions) => {