feat(fslib): add fchmod support (#4466)

Author: merceyz

.pnp.cjs

@@ -0,0 +1,39 @@
+releases:
+  "@yarnpkg/cli": patch
+  "@yarnpkg/fslib": minor
+  "@yarnpkg/pnp": patch
+  "@yarnpkg/pnpify": patch
+
+declined:
+  - "@yarnpkg/esbuild-plugin-pnp"
+  - "@yarnpkg/plugin-compat"
+  - "@yarnpkg/plugin-constraints"
+  - "@yarnpkg/plugin-dlx"
+  - "@yarnpkg/plugin-essentials"
+  - "@yarnpkg/plugin-exec"
+  - "@yarnpkg/plugin-file"
+  - "@yarnpkg/plugin-git"
+  - "@yarnpkg/plugin-github"
+  - "@yarnpkg/plugin-http"
+  - "@yarnpkg/plugin-init"
+  - "@yarnpkg/plugin-interactive-tools"
+  - "@yarnpkg/plugin-link"
+  - "@yarnpkg/plugin-nm"
+  - "@yarnpkg/plugin-npm"
+  - "@yarnpkg/plugin-npm-cli"
+  - "@yarnpkg/plugin-pack"
+  - "@yarnpkg/plugin-patch"
+  - "@yarnpkg/plugin-pnp"
+  - "@yarnpkg/plugin-pnpm"
+  - "@yarnpkg/plugin-stage"
+  - "@yarnpkg/plugin-typescript"
+  - "@yarnpkg/plugin-version"
+  - "@yarnpkg/plugin-workspace-tools"
+  - vscode-zipfs
+  - "@yarnpkg/builder"
+  - "@yarnpkg/core"
+  - "@yarnpkg/doctor"
+  - "@yarnpkg/json-proxy"
+  - "@yarnpkg/nm"
+  - "@yarnpkg/sdks"
+  - "@yarnpkg/shell"

.yarn/versions/64fa7941.yml

@@ -38,6 +38,7 @@ The following changes only affect people writing Yarn plugins:
 ### Compatibility
 
 - The patched filesystem now supports `ftruncate`.
+- The patched filesystem now supports `fchmod`.
 - Updates the PnP compatibility layer for TypeScript 4.8 Beta
 
 ## 3.2.1

CHANGELOG.md

@@ -189,6 +189,8 @@ export abstract class FakeFS<P extends Path> {
 
   abstract chmodPromise(p: P, mask: number): Promise<void>;
   abstract chmodSync(p: P, mask: number): void;
+  abstract fchmodPromise(fd: number, mask: number): Promise<void>;
+  abstract fchmodSync(fd: number, mask: number): void;
 
   abstract chownPromise(p: P, uid: number, gid: number): Promise<void>;
   abstract chownSync(p: P, uid: number, gid: number): void;

packages/yarnpkg-core/sources/worker-zip/index.js

@@ -126,6 +126,14 @@ export class NoFS extends FakeFS<PortablePath> {
     throw makeError();
   }
 
+  async fchmodPromise(): Promise<never> {
+    throw makeError();
+  }
+
+  fchmodSync(): never {
+    throw makeError();
+  }
+
   async chmodPromise(): Promise<never> {
     throw makeError();
   }

packages/yarnpkg-fslib/sources/FakeFS.ts

@@ -230,6 +230,16 @@ export class NodeFS extends BasePortableFakeFS {
     }
   }
 
+  async fchmodPromise(fd: number, mask: number): Promise<void> {
+    return await new Promise<void>((resolve, reject) => {
+      this.realFs.fchmod(fd, mask, this.makeCallback(resolve, reject));
+    });
+  }
+
+  fchmodSync(fd: number, mask: number): void {
+    return this.realFs.fchmodSync(fd, mask);
+  }
+
   async chmodPromise(p: PortablePath, mask: number) {
     return await new Promise<void>((resolve, reject) => {
       this.realFs.chmod(npath.fromPortablePath(p), mask, this.makeCallback(resolve, reject));

packages/yarnpkg-fslib/sources/NoFS.ts

@@ -156,6 +156,14 @@ export abstract class ProxiedFS<P extends Path, IP extends Path> extends FakeFS<
     return this.baseFs.lstatSync(this.mapToBase(p), opts);
   }
 
+  async fchmodPromise(fd: number, mask: number): Promise<void> {
+    return this.baseFs.fchmodPromise(fd, mask);
+  }
+
+  fchmodSync(fd: number, mask: number): void {
+    return this.baseFs.fchmodSync(fd, mask);
+  }
+
   async chmodPromise(p: P, mask: number) {
     return this.baseFs.chmodPromise(this.mapToBase(p), mask);
   }

packages/yarnpkg-fslib/sources/NodeFS.ts

@@ -983,6 +983,14 @@ export class ZipFS extends BasePortableFakeFS {
     }
   }
 
+  async fchmodPromise(fd: number, mask: number): Promise<void> {
+    return this.chmodPromise(this.fdToPath(fd, `fchmod`), mask);
+  }
+
+  fchmodSync(fd: number, mask: number): void {
+    return this.chmodSync(this.fdToPath(fd, `fchmodSync`), mask);
+  }
+
   async chmodPromise(p: PortablePath, mask: number) {
     return this.chmodSync(p, mask);
   }

packages/yarnpkg-fslib/sources/ProxiedFS.ts

@@ -457,6 +457,30 @@ export class ZipOpenFS extends BasePortableFakeFS {
     });
   }
 
+  async fchmodPromise(fd: number, mask: number): Promise<void> {
+    if ((fd & ZIP_FD) === 0)
+      return this.baseFs.fchmodPromise(fd, mask);
+
+    const entry = this.fdMap.get(fd);
+    if (typeof entry === `undefined`)
+      throw errors.EBADF(`fchmod`);
+
+    const [zipFs, realFd] = entry;
+    return zipFs.fchmodPromise(realFd, mask);
+  }
+
+  fchmodSync(fd: number, mask: number): void {
+    if ((fd & ZIP_FD) === 0)
+      return this.baseFs.fchmodSync(fd, mask);
+
+    const entry = this.fdMap.get(fd);
+    if (typeof entry === `undefined`)
+      throw errors.EBADF(`fchmodSync`);
+
+    const [zipFs, realFd] = entry;
+    return zipFs.fchmodSync(realFd, mask);
+  }
+
   async chmodPromise(p: PortablePath, mask: number) {
     return await this.makeCallPromise(p, async () => {
       return await this.baseFs.chmodPromise(p, mask);

packages/yarnpkg-fslib/sources/ZipFS.ts

@@ -11,6 +11,7 @@ const SYNC_IMPLEMENTATIONS = new Set([
   `createReadStream`,
   `createWriteStream`,
   `chmodSync`,
+  `fchmodSync`,
   `chownSync`,
   `closeSync`,
   `copyFileSync`,
@@ -44,6 +45,7 @@ const SYNC_IMPLEMENTATIONS = new Set([
 const ASYNC_IMPLEMENTATIONS = new Set([
   `accessPromise`,
   `appendFilePromise`,
+  `fchmodPromise`,
   `chmodPromise`,
   `chownPromise`,
   `closePromise`,

packages/yarnpkg-fslib/sources/ZipOpenFS.ts

@@ -1,8 +1,10 @@
-import {NodeFS}            from '../sources/NodeFS';
-import {xfs, PortablePath} from '../sources';
+import {NodeFS}                             from '../sources/NodeFS';
+import {xfs, PortablePath, ppath, Filename} from '../sources';
 
 const nodeFs = new NodeFS();
 
+const ifNotWin32It = process.platform !== `win32` ? it : it.skip;
+
 describe(`NodeFS`, () => {
   describe(`copyPromise`, () => {
     it(`should support copying files`, async () => {
@@ -65,4 +67,30 @@ describe(`NodeFS`, () => {
       });
     });
   });
+
+  ifNotWin32It(`should support fchmodPromise`, async () => {
+    await xfs.mktempPromise(async dir => {
+      const p = ppath.join(dir, `foo.txt` as Filename);
+      await nodeFs.writeFilePromise(p, ``);
+
+      const fd = await nodeFs.openPromise(p, `w`);
+      await nodeFs.fchmodPromise(fd, 0o744);
+      await nodeFs.closePromise(fd);
+
+      expect((await nodeFs.statPromise(p)).mode & 0o777).toBe(0o744);
+    });
+  });
+
+  ifNotWin32It(`should support fchmodSync`, () => {
+    xfs.mktempSync(dir => {
+      const p = ppath.join(dir, `bar.txt` as Filename);
+      nodeFs.writeFileSync(p, ``);
+
+      const fd = nodeFs.openSync(p, `w`);
+      nodeFs.fchmodSync(fd, 0o744);
+      nodeFs.closeSync(fd);
+
+      expect((nodeFs.statSync(p)).mode & 0o777).toBe(0o744);
+    });
+  });
 });

packages/yarnpkg-fslib/sources/patchFs.ts

@@ -813,6 +813,18 @@ describe(`ZipFS`, () => {
     zipFs.discardAndClose();
   });
 
+  it(`should support fchmodSync`, () => {
+    const zipFs = new ZipFS(null, {libzip: getLibzipSync()});
+
+    zipFs.writeFileSync(`/foo.txt` as Filename, `foo`);
+    const fd = zipFs.openSync(`/foo.txt` as Filename, `rw`);
+    zipFs.fchmodSync(fd, 0o754);
+    zipFs.closeSync(fd);
+    expect(zipFs.statSync(`/foo.txt` as Filename).mode & 0o777).toBe(0o754);
+
+    zipFs.discardAndClose();
+  });
+
   it(`should support writeFile mode`, async () => {
     const zipFs = new ZipFS(null, {libzip: getLibzipSync()});
 

packages/yarnpkg-fslib/tests/NodeFS.test.ts

@@ -12,6 +12,8 @@ import {statUtils, ZipFS, ZipOpenFS}     from '../sources';
 
 import {ZIP_FILE1, ZIP_DIR1}             from './ZipOpenFS.test';
 
+const ifNotWin32It = process.platform !== `win32` ? it : it.skip;
+
 describe(`patchedFs`, () => {
   it(`in case of no error, give null: fs.stat`, done => {
     const file = npath.join(__dirname, `patchedFs.test.ts` as Filename);
@@ -257,4 +259,37 @@ describe(`patchedFs`, () => {
       patchedFs.closeSync(fd);
     }
   });
+
+  ifNotWin32It(`should support fchmodSync`, async () => {
+    await xfs.mktempPromise(async dir => {
+      const patchedFs = extendFs(fs, new PosixFS(new NodeFS()));
+      const p = npath.join(npath.fromPortablePath(dir), `foo.txt`);
+
+      const fd = patchedFs.openSync(p, `w`);
+      patchedFs.fchmodSync(fd, 0o744);
+      patchedFs.closeSync(fd);
+
+      expect((patchedFs.statSync(p)).mode & 0o777).toBe(0o744);
+    });
+  });
+
+  ifNotWin32It(`should support fchmod`, async () => {
+    const patchedFs = extendFs(fs, new PosixFS(new NodeFS()));
+
+    await xfs.mktempPromise(async dir => {
+      const p = npath.join(npath.fromPortablePath(dir), `foo.txt`);
+
+      const fd = patchedFs.openSync(p, `w`);
+
+      await new Promise<void>((resolve, reject) => {
+        patchedFs.fchmod(fd, 0o744, err => {
+          err ? reject(err) : resolve();
+        });
+      });
+
+      patchedFs.closeSync(fd);
+
+      expect((patchedFs.statSync(p)).mode & 0o777).toBe(0o744);
+    });
+  });
 });

packages/yarnpkg-fslib/tests/ZipFS.test.ts

@@ -135,6 +135,7 @@ export class PortableNodeModulesFS extends FakeFS<PortablePath> {
     return pnpPath.resolvedPath;
   }
 
+  private resolveDirOrFilePath(p: number): number;
   private resolveDirOrFilePath(p: PortablePath): PortablePath;
   private resolveDirOrFilePath(p: FSPath<PortablePath>): FSPath<PortablePath>;
   private resolveDirOrFilePath(p: FSPath<PortablePath>): FSPath<PortablePath> {
@@ -361,6 +362,14 @@ export class PortableNodeModulesFS extends FakeFS<PortablePath> {
     });
   }
 
+  async fchmodPromise(fd: number, mask: number): Promise<void> {
+    return this.baseFs.fchmodPromise(this.resolveDirOrFilePath(fd), mask);
+  }
+
+  fchmodSync(fd: number, mask: number): void {
+    return this.baseFs.fchmodSync(this.resolveDirOrFilePath(fd), mask);
+  }
+
   async chmodPromise(p: PortablePath, mask: number) {
     return await this.baseFs.chmodPromise(this.resolveDirOrFilePath(p), mask);
   }