@atlaspack/fs 2.12.1-canary.3354

package/src/NodeFS.browser.js

@@ -0,0 +1,9 @@
+// @flow
+import type {FileSystem} from '@atlaspack/types-internal';
+
+// $FlowFixMe[prop-missing] handled by the throwing constructor
+export class NodeFS implements FileSystem {
+  constructor() {
+    throw new Error("NodeFS isn't available in the browser");
+  }
+}

package/src/NodeFS.js

@@ -0,0 +1,290 @@
+// @flow
+import type {ReadStream, Stats} from 'fs';
+import type {Writable} from 'stream';
+import type {
+  FilePath,
+  Encoding,
+  FileOptions,
+  FileSystem,
+} from '@atlaspack/types-internal';
+import type {
+  Event,
+  Options as WatcherOptions,
+  AsyncSubscription,
+} from '@parcel/watcher';
+
+import fs from 'graceful-fs';
+import nativeFS from 'fs';
+import ncp from 'ncp';
+import path from 'path';
+import {tmpdir} from 'os';
+import {promisify} from 'util';
+import {registerSerializableClass} from '@atlaspack/core';
+import {hashFile} from '@atlaspack/utils';
+import {getFeatureFlag} from '@atlaspack/feature-flags';
+import watcher from '@parcel/watcher';
+import packageJSON from '../package.json';
+
+import * as searchNative from '@atlaspack/rust';
+import * as searchJS from './find';
+
+// Most of this can go away once we only support Node 10+, which includes
+// require('fs').promises
+
+const realpath = promisify(
+  process.platform === 'win32' ? fs.realpath : fs.realpath.native,
+);
+const isPnP = process.versions.pnp != null;
+
+function getWatchmanWatcher(): typeof watcher {
+  // This is here to trick atlaspack into ignoring this require...
+  const packageName = ['@atlaspack', 'watcher-watchman-js'].join('/');
+
+  // $FlowFixMe
+  return require(packageName);
+}
+
+export class NodeFS implements FileSystem {
+  readFile: any = promisify(fs.readFile);
+  copyFile: any = promisify(fs.copyFile);
+  stat: any = promisify(fs.stat);
+  readdir: any = promisify(fs.readdir);
+  symlink: any = promisify(fs.symlink);
+  unlink: any = promisify(fs.unlink);
+  utimes: any = promisify(fs.utimes);
+  ncp: any = promisify(ncp);
+  createReadStream: (path: string, options?: any) => ReadStream =
+    fs.createReadStream;
+  cwd: () => string = () => process.cwd();
+  chdir: (directory: string) => void = directory => process.chdir(directory);
+
+  statSync: (path: string) => Stats = path => fs.statSync(path);
+  realpathSync: (path: string, cache?: any) => string =
+    process.platform === 'win32' ? fs.realpathSync : fs.realpathSync.native;
+  existsSync: (path: string) => boolean = fs.existsSync;
+  readdirSync: any = (fs.readdirSync: any);
+  findAncestorFile: any = isPnP
+    ? (...args) => searchJS.findAncestorFile(this, ...args)
+    : searchNative.findAncestorFile;
+  findNodeModule: any = isPnP
+    ? (...args) => searchJS.findNodeModule(this, ...args)
+    : searchNative.findNodeModule;
+  findFirstFile: any = isPnP
+    ? (...args) => searchJS.findFirstFile(this, ...args)
+    : searchNative.findFirstFile;
+
+  watcher(): typeof watcher {
+    return getFeatureFlag('useWatchmanWatcher')
+      ? getWatchmanWatcher()
+      : watcher;
+  }
+
+  createWriteStream(filePath: string, options: any): Writable {
+    // Make createWriteStream atomic
+    let tmpFilePath = getTempFilePath(filePath);
+    let failed = false;
+
+    const move = async () => {
+      if (!failed) {
+        try {
+          await fs.promises.rename(tmpFilePath, filePath);
+        } catch (e) {
+          // This is adapted from fs-write-stream-atomic. Apparently
+          // Windows doesn't like renaming when the target already exists.
+          if (
+            process.platform === 'win32' &&
+            e.syscall &&
+            e.syscall === 'rename' &&
+            e.code &&
+            e.code === 'EPERM'
+          ) {
+            let [hashTmp, hashTarget] = await Promise.all([
+              hashFile(this, tmpFilePath),
+              hashFile(this, filePath),
+            ]);
+
+            await this.unlink(tmpFilePath);
+
+            if (hashTmp != hashTarget) {
+              throw e;
+            }
+          }
+        }
+      }
+    };
+
+    let writeStream = fs.createWriteStream(tmpFilePath, {
+      ...options,
+      fs: {
+        ...fs,
+        close: (fd, cb) => {
+          fs.close(fd, err => {
+            if (err) {
+              cb(err);
+            } else {
+              move().then(
+                () => cb(),
+                err => cb(err),
+              );
+            }
+          });
+        },
+      },
+    });
+
+    writeStream.once('error', () => {
+      failed = true;
+      fs.unlinkSync(tmpFilePath);
+    });
+
+    return writeStream;
+  }
+
+  async writeFile(
+    filePath: FilePath,
+    contents: Buffer | string,
+    options: ?FileOptions,
+  ): Promise<void> {
+    let tmpFilePath = getTempFilePath(filePath);
+    await fs.promises.writeFile(tmpFilePath, contents, options);
+    await fs.promises.rename(tmpFilePath, filePath);
+  }
+
+  readFileSync(filePath: FilePath, encoding?: Encoding): any {
+    if (encoding != null) {
+      return fs.readFileSync(filePath, encoding);
+    }
+    return fs.readFileSync(filePath);
+  }
+
+  async realpath(originalPath: string): Promise<string> {
+    try {
+      return await realpath(originalPath, 'utf8');
+    } catch (e) {
+      // do nothing
+    }
+
+    return originalPath;
+  }
+
+  exists(filePath: FilePath): Promise<boolean> {
+    return new Promise(resolve => {
+      fs.exists(filePath, resolve);
+    });
+  }
+
+  watch(
+    dir: FilePath,
+    fn: (err: ?Error, events: Array<Event>) => mixed,
+    opts: WatcherOptions,
+  ): Promise<AsyncSubscription> {
+    return this.watcher().subscribe(dir, fn, opts);
+  }
+
+  getEventsSince(
+    dir: FilePath,
+    snapshot: FilePath,
+    opts: WatcherOptions,
+  ): Promise<Array<Event>> {
+    return this.watcher().getEventsSince(dir, snapshot, opts);
+  }
+
+  async writeSnapshot(
+    dir: FilePath,
+    snapshot: FilePath,
+    opts: WatcherOptions,
+  ): Promise<void> {
+    await this.watcher().writeSnapshot(dir, snapshot, opts);
+  }
+
+  static deserialize(): NodeFS {
+    return new NodeFS();
+  }
+
+  serialize(): null {
+    return null;
+  }
+
+  async mkdirp(filePath: FilePath): Promise<void> {
+    await nativeFS.promises.mkdir(filePath, {recursive: true});
+  }
+
+  async rimraf(filePath: FilePath): Promise<void> {
+    if (fs.promises.rm) {
+      await fs.promises.rm(filePath, {recursive: true, force: true});
+      return;
+    }
+
+    // fs.promises.rm is not supported in node 12...
+    let stat;
+    try {
+      stat = await this.stat(filePath);
+    } catch (err) {
+      return;
+    }
+
+    if (stat.isDirectory()) {
+      // $FlowFixMe
+      await nativeFS.promises.rmdir(filePath, {recursive: true});
+    } else {
+      await nativeFS.promises.unlink(filePath);
+    }
+  }
+}
+
+registerSerializableClass(`${packageJSON.version}:NodeFS`, NodeFS);
+
+let writeStreamCalls = 0;
+
+let threadId;
+try {
+  ({threadId} = require('worker_threads'));
+} catch {
+  //
+}
+
+let useOsTmpDir;
+
+function shouldUseOsTmpDir(filePath) {
+  if (useOsTmpDir != null) {
+    return useOsTmpDir;
+  }
+  try {
+    const tmpDir = tmpdir();
+    nativeFS.accessSync(
+      tmpDir,
+      nativeFS.constants.R_OK | nativeFS.constants.W_OK,
+    );
+    const tmpDirStats = nativeFS.statSync(tmpDir);
+    const filePathStats = nativeFS.statSync(filePath);
+    // Check the tmpdir is on the same partition as the target directory.
+    // This is required to ensure renaming is an atomic operation.
+    useOsTmpDir = tmpDirStats.dev === filePathStats.dev;
+  } catch (e) {
+    // We don't have read/write access to the OS tmp directory
+    useOsTmpDir = false;
+  }
+  return useOsTmpDir;
+}
+
+// Generate a temporary file path used for atomic writing of files.
+function getTempFilePath(filePath: FilePath) {
+  writeStreamCalls = writeStreamCalls % Number.MAX_SAFE_INTEGER;
+
+  let tmpFilePath = filePath;
+
+  // If possible, write the tmp file to the OS tmp directory
+  // This reduces the amount of FS events the watcher needs to process during the build
+  if (shouldUseOsTmpDir(filePath)) {
+    tmpFilePath = path.join(tmpdir(), path.basename(filePath));
+  }
+
+  return (
+    tmpFilePath +
+    '.' +
+    process.pid +
+    (threadId != null ? '.' + threadId : '') +
+    '.' +
+    (writeStreamCalls++).toString(36)
+  );
+}