Adds a createFolderMount util

packages/yarnpkg-fslib/sources/MountFS.ts

@@ -5,6 +5,7 @@ import {FakeFS, MkdirOptions, RmdirOptions, WriteFileOptions, OpendirOptions}
 import {Dirent, SymlinkType}                                                                                                                         from './FakeFS';
 import {CreateReadStreamOptions, CreateWriteStreamOptions, BasePortableFakeFS, ExtractHintOptions, WatchFileOptions, WatchFileCallback, StatWatcher} from './FakeFS';
 import {NodeFS}                                                                                                                                      from './NodeFS';
+import {SubFS}                                                                                                                                       from './SubFS';
 import {watchFile, unwatchFile, unwatchAllFiles}                                                                                                     from './algorithms/watchFile';
 import * as errors                                                                                                                                   from './errors';
 import {Filename, FSPath, npath, PortablePath}                                                                                                       from './path';
@@ -80,6 +81,37 @@ export class MountFS<MountedFS extends MountableFS> extends BasePortableFakeFS {
   private notMount: Set<PortablePath> = new Set();
   private realPaths: Map<PortablePath, PortablePath> = new Map();
 
+  static createFolderMount({baseFs, mountPoint, targetPath}: {baseFs: FakeFS<PortablePath>, mountPoint: PortablePath, targetPath: PortablePath}) {
+    const subFs = new SubFS(targetPath);
+
+    const getMountPoint = (p: PortablePath) => {
+      const detectedMountPoint = p === mountPoint || p.startsWith(`${mountPoint}/`) ? p.slice(0, mountPoint.length) : null;
+      return detectedMountPoint as PortablePath;
+    };
+
+    const factoryPromise = async (baseFs: FakeFS<PortablePath>, p: PortablePath) => {
+      return () => subFs;
+    };
+
+    const factorySync = (baseFs: FakeFS<PortablePath>, p: PortablePath) => {
+      return subFs;
+    };
+
+    return new MountFS({
+      baseFs,
+
+      getMountPoint,
+
+      factoryPromise,
+      factorySync,
+
+      magicByte: 21,
+      maxAge: Infinity,
+
+      typeCheck: null,
+    });
+  }
+
   constructor({baseFs = new NodeFS(), filter = null, magicByte = 0x2a, maxOpenFiles = Infinity, useCache = true, maxAge = 5000, typeCheck = constants.S_IFREG, getMountPoint, factoryPromise, factorySync}: MountFSOptions<MountedFS>) {
     if (Math.floor(magicByte) !== magicByte || !(magicByte > 1 && magicByte <= 127))
       throw new Error(`The magic byte must be set to a round value between 1 and 127 included`);

packages/yarnpkg-fslib/sources/index.ts

@@ -50,7 +50,7 @@ export {ProxiedFS}                                         from './ProxiedFS';
 export {SubFS}                                             from './SubFS';
 export {VirtualFS}                                         from './VirtualFS';
 
-export {patchFs, extendFs} from './patchFs/patchFs';
+export {applyFsLayer, extendFs, patchFs} from './patchFs/patchFs';
 
 export {xfs} from './xfs';
 export type {XFS} from './xfs';

packages/yarnpkg-fslib/sources/patchFs/patchFs.ts

@@ -1,11 +1,13 @@
-import fs           from 'fs';
-import {promisify}  from 'util';
+import fs                         from 'fs';
+import {promisify}                from 'util';
 
-import {FakeFS}     from '../FakeFS';
-import {NodePathFS} from '../NodePathFS';
-import {NativePath} from '../path';
+import {FakeFS}                   from '../FakeFS';
+import {NodeFS}                   from '../NodeFS';
+import {NodePathFS}               from '../NodePathFS';
+import {PosixFS}                  from '../PosixFS';
+import {NativePath, PortablePath} from '../path';
 
-import {FileHandle} from './FileHandle';
+import {FileHandle}               from './FileHandle';
 
 const SYNC_IMPLEMENTATIONS = new Set([
   `accessSync`,
@@ -136,6 +138,16 @@ type ReadArgumentsOptions = [
 type ReadArgumentsCallback = [fd: number, callback: ReadCallback];
 //#endregion
 
+export function applyFsLayer(origFs: typeof fs, factory: (baseFs: FakeFS<PortablePath>) => FakeFS<PortablePath>) {
+  // We must copy the fs into a local, because otherwise
+  // 1. we would make the NodeFS instance use the function that we patched (infinite loop)
+  // 2. Object.create(fs) isn't enough, since it won't prevent the proto from being modified
+  const localFs = {...origFs};
+  const nodeFs = new NodeFS(localFs);
+
+  patchFs(fs, new PosixFS(factory(nodeFs)));
+}
+
 export function patchFs(patchedFs: typeof fs, fakeFs: FakeFS<NativePath>): void {
   // We wrap the `fakeFs` with a `NodePathFS` to add support for all path types supported by Node
   fakeFs = new NodePathFS(fakeFs);