feat(fslib): add rmPromise/rmSync methods

.yarn/versions/5b3411ac.yml

@@ -0,0 +1,4 @@
+releases:
+  "@yarnpkg/fslib": minor
+  "@yarnpkg/libzip": minor
+  "@yarnpkg/pnpify": minor

packages/yarnpkg-fslib/sources/FakeFS.ts

@@ -71,8 +71,16 @@ export type MkdirOptions = Partial<{
 
 export type RmdirOptions = Partial<{
   maxRetries: number;
+  retryDelay: number;
+  /** @deprecated Use `rm` instead of `rmdir` */
   recursive: boolean;
+}>;
+
+export type RmOptions = Partial<{
+  maxRetries: number;
   retryDelay: number;
+  force: boolean;
+  recursive: boolean;
 }>;
 
 export type WriteFileOptions = Partial<{
@@ -255,6 +263,9 @@ export abstract class FakeFS<P extends Path> {
   abstract rmdirPromise(p: P, opts?: RmdirOptions): Promise<void>;
   abstract rmdirSync(p: P, opts?: RmdirOptions): void;
 
+  abstract rmPromise(p: P, opts?: RmOptions): Promise<void>;
+  abstract rmSync(p: P, opts?: RmOptions): void;
+
   abstract linkPromise(existingP: P, newP: P): Promise<void>;
   abstract linkSync(existingP: P, newP: P): void;
 

packages/yarnpkg-fslib/sources/MountFS.ts

@@ -1,6 +1,6 @@
 import {BigIntStats, constants, Stats}                                                                                                               from 'fs';
 
-import {WatchOptions, WatchCallback, Watcher, StatOptions, StatSyncOptions, ReaddirOptions, DirentNoPath}                                            from './FakeFS';
+import {WatchOptions, WatchCallback, Watcher, StatOptions, StatSyncOptions, ReaddirOptions, DirentNoPath, RmOptions}                                 from './FakeFS';
 import {FakeFS, MkdirOptions, RmdirOptions, WriteFileOptions, OpendirOptions}                                                                        from './FakeFS';
 import {Dirent, SymlinkType}                                                                                                                         from './FakeFS';
 import {CreateReadStreamOptions, CreateWriteStreamOptions, BasePortableFakeFS, ExtractHintOptions, WatchFileOptions, WatchFileCallback, StatWatcher} from './FakeFS';
@@ -752,6 +752,22 @@ export class MountFS<MountedFS extends MountableFS> extends BasePortableFakeFS {
     });
   }
 
+
+  async rmPromise(p: PortablePath, opts?: RmOptions) {
+    return await this.makeCallPromise(p, async () => {
+      return await this.baseFs.rmPromise(p, opts);
+    }, async (mountFs, {subPath}) => {
+      return await mountFs.rmPromise(subPath, opts);
+    });
+  }
+
+  rmSync(p: PortablePath, opts?: RmOptions) {
+    return this.makeCallSync(p, () => {
+      return this.baseFs.rmSync(p, opts);
+    }, (mountFs, {subPath}) => {
+      return mountFs.rmSync(subPath, opts);
+    });
+  }
   async linkPromise(existingP: PortablePath, newP: PortablePath) {
     return await this.makeCallPromise(newP, async () => {
       return await this.baseFs.linkPromise(existingP, newP);

packages/yarnpkg-fslib/sources/NoFS.ts

@@ -174,6 +174,14 @@ export class NoFS extends FakeFS<PortablePath> {
     throw makeError();
   }
 
+  async rmPromise(): Promise<never> {
+    throw makeError();
+  }
+
+  rmSync(): never {
+    throw makeError();
+  }
+
   async linkPromise(): Promise<never> {
     throw makeError();
   }

packages/yarnpkg-fslib/sources/NodeFS.ts

@@ -3,7 +3,7 @@ import fs, {BigIntStats, Stats}
 import {CreateReadStreamOptions, CreateWriteStreamOptions, Dir, StatWatcher, WatchFileCallback, WatchFileOptions, OpendirOptions, ReaddirOptions, DirentNoPath} from './FakeFS';
 import {Dirent, SymlinkType, StatSyncOptions, StatOptions}                                                                                                      from './FakeFS';
 import {BasePortableFakeFS, WriteFileOptions}                                                                                                                   from './FakeFS';
-import {MkdirOptions, RmdirOptions, WatchOptions, WatchCallback, Watcher}                                                                                       from './FakeFS';
+import {MkdirOptions, RmdirOptions, RmOptions, WatchOptions, WatchCallback, Watcher}                                                                            from './FakeFS';
 import {FSPath, PortablePath, Filename, ppath, npath, NativePath}                                                                                               from './path';
 
 function direntToPortable(dirent: Dirent<NativePath>): Dirent<PortablePath> {
@@ -428,6 +428,21 @@ export class NodeFS extends BasePortableFakeFS {
     return this.realFs.rmdirSync(npath.fromPortablePath(p), opts);
   }
 
+  async rmPromise(p: PortablePath, opts?: RmOptions) {
+    return await new Promise<void>((resolve, reject) => {
+      // TODO: always pass opts when min node version is 12.10+
+      if (opts) {
+        this.realFs.rm(npath.fromPortablePath(p), opts, this.makeCallback(resolve, reject));
+      } else {
+        this.realFs.rm(npath.fromPortablePath(p), this.makeCallback(resolve, reject));
+      }
+    });
+  }
+
+  rmSync(p: PortablePath, opts?: RmOptions) {
+    return this.realFs.rmSync(npath.fromPortablePath(p), opts);
+  }
+
   async linkPromise(existingP: PortablePath, newP: PortablePath) {
     return await new Promise<void>((resolve, reject) => {
       this.realFs.link(npath.fromPortablePath(existingP), npath.fromPortablePath(newP), this.makeCallback(resolve, reject));

packages/yarnpkg-fslib/sources/ProxiedFS.ts

@@ -2,7 +2,7 @@ import {Stats, BigIntStats}
 
 import {CreateReadStreamOptions, CreateWriteStreamOptions, FakeFS, ExtractHintOptions, WatchFileCallback, WatchFileOptions, StatWatcher, Dir, OpendirOptions, ReaddirOptions, DirentNoPath} from './FakeFS';
 import {Dirent, SymlinkType, StatSyncOptions, StatOptions}                                                                                                                                  from './FakeFS';
-import {MkdirOptions, RmdirOptions, WriteFileOptions, WatchCallback, WatchOptions, Watcher}                                                                                                 from './FakeFS';
+import {MkdirOptions, RmdirOptions, RmOptions, WriteFileOptions, WatchCallback, WatchOptions, Watcher}                                                                                      from './FakeFS';
 import {FSPath, Filename, Path}                                                                                                                                                             from './path';
 
 export abstract class ProxiedFS<P extends Path, IP extends Path> extends FakeFS<P> {
@@ -270,6 +270,14 @@ export abstract class ProxiedFS<P extends Path, IP extends Path> extends FakeFS<
     return this.baseFs.rmdirSync(this.mapToBase(p), opts);
   }
 
+  async rmPromise(p: P, opts?: RmOptions) {
+    return this.baseFs.rmPromise(this.mapToBase(p), opts);
+  }
+
+  rmSync(p: P, opts?: RmOptions) {
+    return this.baseFs.rmSync(this.mapToBase(p), opts);
+  }
+
   async linkPromise(existingP: P, newP: P) {
     return this.baseFs.linkPromise(this.mapToBase(existingP), this.mapToBase(newP));
   }

packages/yarnpkg-fslib/sources/index.ts

@@ -18,7 +18,7 @@ export type {CreateWriteStreamOptions}               from './FakeFS';
 export type {Dirent, DirentNoPath, Dir, SymlinkType} from './FakeFS';
 export type {MkdirOptions}                           from './FakeFS';
 export type {ReaddirOptions}                         from './FakeFS';
-export type {RmdirOptions}                           from './FakeFS';
+export type {RmdirOptions, RmOptions}                from './FakeFS';
 export type {WatchOptions}                           from './FakeFS';
 export type {WatchCallback}                          from './FakeFS';
 export type {Watcher}                                from './FakeFS';

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

@@ -32,6 +32,7 @@ const SYNC_IMPLEMENTATIONS = new Set([
   `realpathSync`,
   `renameSync`,
   `rmdirSync`,
+  `rmSync`,
   `statSync`,
   `symlinkSync`,
   `truncateSync`,
@@ -68,6 +69,7 @@ const ASYNC_IMPLEMENTATIONS = new Set([
   `readlinkPromise`,
   `renamePromise`,
   `rmdirPromise`,
+  `rmPromise`,
   `statPromise`,
   `symlinkPromise`,
   `truncatePromise`,

packages/yarnpkg-libzip/sources/ZipFS.ts

@@ -1,6 +1,6 @@
 import {Dirent, DirentNoPath, ReaddirOptions}                                                                                                        from '@yarnpkg/fslib';
 import {WatchOptions, WatchCallback, Watcher, Dir, Stats, BigIntStats, StatSyncOptions, StatOptions}                                                 from '@yarnpkg/fslib';
-import {FakeFS, MkdirOptions, RmdirOptions, WriteFileOptions, OpendirOptions}                                                                        from '@yarnpkg/fslib';
+import {FakeFS, MkdirOptions, RmdirOptions, RmOptions, WriteFileOptions, OpendirOptions}                                                             from '@yarnpkg/fslib';
 import {CreateReadStreamOptions, CreateWriteStreamOptions, BasePortableFakeFS, ExtractHintOptions, WatchFileCallback, WatchFileOptions, StatWatcher} from '@yarnpkg/fslib';
 import {NodeFS}                                                                                                                                      from '@yarnpkg/fslib';
 import {opendir}                                                                                                                                     from '@yarnpkg/fslib';
@@ -1353,6 +1353,34 @@ export class ZipFS extends BasePortableFakeFS {
 
     this.deleteEntry(p, index);
   }
+  async rmPromise(p: PortablePath, opts?: RmOptions) {
+    return this.rmSync(p, opts);
+  }
+
+  rmSync(p: PortablePath, {recursive = false}: RmOptions = {}) {
+    if (this.readOnly)
+      throw errors.EROFS(`rm '${p}'`);
+
+    if (recursive) {
+      this.removeSync(p);
+      return;
+    }
+
+    const resolvedP = this.resolveFilename(`rm '${p}'`, p);
+
+    const directoryListing = this.listings.get(resolvedP);
+    if (!directoryListing)
+      throw errors.ENOTDIR(`rm '${p}'`);
+
+    if (directoryListing.size > 0)
+      throw errors.ENOTEMPTY(`rm '${p}'`);
+
+    const index = this.entries.get(resolvedP);
+    if (typeof index === `undefined`)
+      throw errors.EINVAL(`rm '${p}'`);
+
+    this.deleteEntry(p, index);
+  }
 
   private hydrateDirectory(resolvedP: PortablePath) {
     const index = this.libzip.dir.add(this.zip, ppath.relative(PortablePath.root, resolvedP));

packages/yarnpkg-pnpify/sources/NodeModulesFS.ts

@@ -1,6 +1,6 @@
 import {BigIntStats, DirentNoPath, ReaddirOptions, Stats}                                                                          from '@yarnpkg/fslib';
 import {Dirent, Filename, MkdirOptions, ExtractHintOptions, WatchFileCallback, WatchFileOptions, StatWatcher, OpendirOptions, Dir} from '@yarnpkg/fslib';
-import {RmdirOptions}                                                                                                              from '@yarnpkg/fslib';
+import {RmdirOptions, RmOptions}                                                                                                   from '@yarnpkg/fslib';
 import {FSPath, NativePath, PortablePath, npath, ppath, opendir}                                                                   from '@yarnpkg/fslib';
 import {WatchOptions, WatchCallback, Watcher}                                                                                      from '@yarnpkg/fslib';
 import {NodeFS, FakeFS, WriteFileOptions, ProxiedFS}                                                                               from '@yarnpkg/fslib';
@@ -471,6 +471,14 @@ export class PortableNodeModulesFS extends FakeFS<PortablePath> {
     return this.baseFs.rmdirSync(this.resolveDirOrFilePath(p), opts);
   }
 
+  async rmPromise(p: PortablePath, opts?: RmOptions) {
+    return await this.baseFs.rmPromise(this.resolveDirOrFilePath(p), opts);
+  }
+
+  rmSync(p: PortablePath, opts?: RmOptions) {
+    return this.baseFs.rmSync(this.resolveDirOrFilePath(p), opts);
+  }
+
   async linkPromise(existingP: PortablePath, newP: PortablePath) {
     return await this.baseFs.linkPromise(this.resolveDirOrFilePath(existingP), this.resolveDirOrFilePath(newP));
   }