Implements a fs layer to convert paths before they reach zipopenfs

packages/berry-fslib/sources/JailFS.ts

@@ -122,11 +122,11 @@ export class JailFS extends FakeFS {
   }
 
   async unlinkPromise(p: string) {
-    return await this.baseFs.rmdirPromise(this.fromJailedPath(p));
+    return await this.baseFs.unlinkPromise(this.fromJailedPath(p));
   }
 
   unlinkSync(p: string) {
-    return this.baseFs.rmdirSync(this.fromJailedPath(p));
+    return this.baseFs.unlinkSync(this.fromJailedPath(p));
   }
 
   async utimesPromise(p: string, atime: Date | string | number, mtime: Date | string | number) {

packages/berry-fslib/sources/NodeFS.ts

@@ -236,13 +236,15 @@ export class NodeFS extends FakeFS {
   }
 
   static fromPortablePath(p: string) {
-    if (process.platform !== `win32`) return p;
+    if (process.platform !== `win32`)
+      return p;
 
     // Path should look like "/mnt/n/berry/scripts/plugin-pack.js"
     // And transform to "N:\berry/scripts/plugin-pack.js"
 
     const match = p.match(PORTABLE_PREFIX_REGEXP);
-    if (!match) return p;
+    if (!match)
+      return p;
 
     const [, drive, pathWithoutPrefix = ''] = match;
     const windowsPath = pathWithoutPrefix.replace(/\//g, '\\');
@@ -251,18 +253,21 @@ export class NodeFS extends FakeFS {
   }
 
   static toPortablePath(p: string) {
-    if (process.platform !== `win32`) return p;
+    if (process.platform !== `win32`)
+      return p;
 
     // Path should look like "N:\berry/scripts/plugin-pack.js"
     // And transform to "/mnt/n/berry/scripts/plugin-pack.js"
 
     // Skip if the path is already portable
-    if (p.startsWith(PORTABLE_PATH_PREFIX)) return p;
+    if (p.startsWith(PORTABLE_PATH_PREFIX))
+      return p;
 
     const {root} = win32.parse(p);
 
     // If relative path, just replace win32 slashes by posix slashes
-    if (!root) return p.replace(/\\/g, '/');
+    if (!root)
+      return p.replace(/\\/g, '/');
 
     const driveLetter = root[0].toLowerCase();
     const pathWithoutRoot = p.substr(root.length);

packages/berry-fslib/sources/PosixFS.ts

@@ -0,0 +1,187 @@
+import {posix}                                             from 'path';
+
+import {CreateReadStreamOptions, CreateWriteStreamOptions} from './FakeFS';
+import {FakeFS, WriteFileOptions}                          from './FakeFS';
+import {NodeFS}                                            from './NodeFS';
+
+export class PosixFS extends FakeFS {
+  private readonly baseFs: FakeFS;
+
+  constructor(baseFs: FakeFS) {
+    super();
+
+    this.baseFs = baseFs;
+  }
+
+  getRealPath() {
+    return NodeFS.fromPortablePath(this.baseFs.getRealPath());
+  }
+
+  async openPromise(p: string, flags: string, mode?: number) {
+    return await this.baseFs.openPromise(NodeFS.toPortablePath(p), flags, mode);
+  }
+
+  openSync(p: string, flags: string, mode?: number) {
+    return this.baseFs.openSync(NodeFS.toPortablePath(p), flags, mode);
+  }
+
+  async closePromise(fd: number) {
+    await this.baseFs.closePromise(fd);
+  }
+
+  closeSync(fd: number) {
+    this.baseFs.closeSync(fd);
+  }
+
+  createReadStream(p: string, opts?: CreateReadStreamOptions) {
+    return this.baseFs.createReadStream(NodeFS.toPortablePath(p), opts);
+  }
+
+  createWriteStream(p: string, opts?: CreateWriteStreamOptions) {
+    return this.baseFs.createWriteStream(NodeFS.toPortablePath(p), opts);
+  }
+
+  async realpathPromise(p: string) {
+    return NodeFS.fromPortablePath(await this.baseFs.realpathPromise(NodeFS.toPortablePath(p)));
+  }
+
+  realpathSync(p: string) {
+    return NodeFS.fromPortablePath(this.baseFs.realpathSync(NodeFS.toPortablePath(p)));
+  }
+
+  async existsPromise(p: string) {
+    return await this.baseFs.existsPromise(NodeFS.toPortablePath(p));
+  }
+
+  existsSync(p: string) {
+    return this.baseFs.existsSync(NodeFS.toPortablePath(p));
+  }
+
+  async statPromise(p: string) {
+    return await this.baseFs.statPromise(NodeFS.toPortablePath(p));
+  }
+
+  statSync(p: string) {
+    return this.baseFs.statSync(NodeFS.toPortablePath(p));
+  }
+
+  async lstatPromise(p: string) {
+    return await this.baseFs.lstatPromise(NodeFS.toPortablePath(p));
+  }
+
+  lstatSync(p: string) {
+    return this.baseFs.lstatSync(NodeFS.toPortablePath(p));
+  }
+
+  async chmodPromise(p: string, mask: number) {
+    return await this.baseFs.chmodPromise(NodeFS.toPortablePath(p), mask);
+  }
+
+  chmodSync(p: string, mask: number) {
+    return this.baseFs.chmodSync(NodeFS.toPortablePath(p), mask);
+  }
+
+  async renamePromise(oldP: string, newP: string) {
+    return await this.baseFs.renamePromise(NodeFS.toPortablePath(oldP), NodeFS.toPortablePath(newP));
+  }
+
+  renameSync(oldP: string, newP: string) {
+    return this.baseFs.renameSync(NodeFS.toPortablePath(oldP), NodeFS.toPortablePath(newP));
+  }
+
+  async copyFilePromise(sourceP: string, destP: string, flags?: number) {
+    return await this.baseFs.copyFilePromise(NodeFS.toPortablePath(sourceP), NodeFS.toPortablePath(destP), flags);
+  }
+
+  copyFileSync(sourceP: string, destP: string, flags?: number) {
+    return this.baseFs.copyFileSync(NodeFS.toPortablePath(sourceP), NodeFS.toPortablePath(destP), flags);
+  }
+
+  async writeFilePromise(p: string, content: string | Buffer | ArrayBuffer | DataView, opts?: WriteFileOptions) {
+    return await this.baseFs.writeFilePromise(NodeFS.toPortablePath(p), content, opts);
+  }
+
+  writeFileSync(p: string, content: string | Buffer | ArrayBuffer | DataView, opts?: WriteFileOptions) {
+    return this.baseFs.writeFileSync(NodeFS.toPortablePath(p), content, opts);
+  }
+
+  async unlinkPromise(p: string) {
+    return await this.baseFs.unlinkPromise(NodeFS.toPortablePath(p));
+  }
+
+  unlinkSync(p: string) {
+    return this.baseFs.unlinkSync(NodeFS.toPortablePath(p));
+  }
+
+  async utimesPromise(p: string, atime: Date | string | number, mtime: Date | string | number) {
+    return await this.baseFs.utimesPromise(NodeFS.toPortablePath(p), atime, mtime);
+  }
+
+  utimesSync(p: string, atime: Date | string | number, mtime: Date | string | number) {
+    return this.baseFs.utimesSync(NodeFS.toPortablePath(p), atime, mtime);
+  }
+
+  async mkdirPromise(p: string) {
+    return await this.baseFs.mkdirPromise(NodeFS.toPortablePath(p));
+  }
+
+  mkdirSync(p: string) {
+    return this.baseFs.mkdirSync(NodeFS.toPortablePath(p));
+  }
+
+  async rmdirPromise(p: string) {
+    return await this.baseFs.rmdirPromise(NodeFS.toPortablePath(p));
+  }
+
+  rmdirSync(p: string) {
+    return this.baseFs.rmdirSync(NodeFS.toPortablePath(p));
+  }
+
+  async symlinkPromise(target: string, p: string) {
+    return await this.baseFs.symlinkPromise(target, NodeFS.toPortablePath(p));
+  }
+
+  symlinkSync(target: string, p: string) {
+    return this.baseFs.symlinkSync(target, NodeFS.toPortablePath(p));
+  }
+
+  readFilePromise(p: string, encoding: 'utf8'): Promise<string>;
+  readFilePromise(p: string, encoding?: string): Promise<Buffer>;
+  async readFilePromise(p: string, encoding?: string) {
+    // This weird switch is required to tell TypeScript that the signatures are proper (otherwise it thinks that only the generic one is covered)
+    switch (encoding) {
+      case `utf8`:
+        return await this.baseFs.readFilePromise(NodeFS.toPortablePath(p), encoding);
+      default:
+        return await this.baseFs.readFilePromise(NodeFS.toPortablePath(p), encoding);
+    }
+  }
+
+  readFileSync(p: string, encoding: 'utf8'): string;
+  readFileSync(p: string, encoding?: string): Buffer;
+  readFileSync(p: string, encoding?: string) {
+    // This weird switch is required to tell TypeScript that the signatures are proper (otherwise it thinks that only the generic one is covered)
+    switch (encoding) {
+      case `utf8`:
+        return this.baseFs.readFileSync(NodeFS.toPortablePath(p), encoding);
+      default:
+        return this.baseFs.readFileSync(NodeFS.toPortablePath(p), encoding);
+    }
+  }
+
+  async readdirPromise(p: string) {
+    return await this.baseFs.readdirPromise(NodeFS.toPortablePath(p));
+  }
+
+  readdirSync(p: string) {
+    return this.baseFs.readdirSync(NodeFS.toPortablePath(p));
+  }
+
+  async readlinkPromise(p: string) {
+    return NodeFS.fromPortablePath(await this.baseFs.readlinkPromise(NodeFS.toPortablePath(p)));
+  }
+
+  readlinkSync(p: string) {
+    return NodeFS.fromPortablePath(this.baseFs.readlinkSync(NodeFS.toPortablePath(p)));
+  }
+}

packages/berry-fslib/sources/index.ts

@@ -4,10 +4,11 @@ import {FakeFS}    from './FakeFS';
 import {NodeFS}    from './NodeFS';
 
 export {AliasFS}   from './AliasFS';
+export {FakeFS}    from './FakeFS';
 export {CwdFS}     from './CwdFS';
 export {JailFS}    from './JailFS';
 export {NodeFS}    from './NodeFS';
-export {FakeFS}    from './FakeFS';
+export {PosixFS}   from './PosixFS';
 export {ZipFS}     from './ZipFS';
 export {ZipOpenFS} from './ZipOpenFS';
 

packages/berry-pnp/sources/loader/applyPatch.ts

@@ -1,11 +1,11 @@
-import {FakeFS, NodeFS, patchFs}    from '@berry/fslib';
-import fs                           from 'fs';
-import Module                       from 'module';
-import path                         from 'path';
+import {FakeFS, NodeFS, PosixFS, patchFs} from '@berry/fslib';
+import fs                                 from 'fs';
+import Module                             from 'module';
+import path                               from 'path';
 
-import {PackageLocator, PnpApi}     from '../types';
+import {PackageLocator, PnpApi}           from '../types';
 
-import {makeError, getIssuerModule} from './internalTools';
+import {makeError, getIssuerModule}       from './internalTools';
 
 export type ApplyPatchOptions = {
   compatibilityMode?: boolean,
@@ -261,5 +261,5 @@ export function applyPatch(pnpapi: PnpApi, opts: ApplyPatchOptions) {
     return false;
   };
 
-  patchFs(fs, opts.fakeFs);
+  patchFs(fs, new PosixFS(opts.fakeFs));
 };