don’t use watchman when not watching

Summary:
Fixes #1644

This PR will update relay-compiler to not use watchman unless watching files.
Closes #1966

Reviewed By: asiandrummer

Differential Revision: D5522984

Pulled By: leebyron

fbshipit-source-id: 5c18f9e03691a542d9c77b9c1858a734ed6b6792

gulpfile.js

@@ -30,6 +30,7 @@ const babelOptions = require('./scripts/getBabelOptions')({
     'crypto': 'crypto',
     'fb-watchman': 'fb-watchman',
     'fs': 'fs',
+    'fast-glob': 'fast-glob',
     'graphql': 'graphql',
     'immutable': 'immutable',
     'net': 'net',

package.json

@@ -40,6 +40,7 @@
     "eslint-plugin-flowtype": "2.30.4",
     "eslint-plugin-react": "5.2.2",
     "event-stream": "3.3.4",
+    "fast-glob": "^1.0.1",
     "fb-watchman": "2.0.0",
     "fbjs": "0.8.14",
     "fbjs-scripts": "0.7.1",

packages/relay-compiler/RelayCompilerPublic.js

@@ -22,6 +22,7 @@ const RelayIRTransforms = require('RelayIRTransforms');
 const RelayMultiReporter = require('RelayMultiReporter');
 
 export type {CompileResult} from 'RelayCodegenTypes';
+export type {ParserConfig, WriterConfig} from 'RelayCodegenRunner';
 
 module.exports = {
   Compiler: RelayCompiler,

packages/relay-compiler/bin/RelayCompilerBin.js

@@ -20,6 +20,7 @@ const RelayConsoleReporter = require('RelayConsoleReporter');
 const RelayFileIRParser = require('RelayFileIRParser');
 const RelayFileWriter = require('RelayFileWriter');
 const RelayIRTransforms = require('RelayIRTransforms');
+const RelayWatchmanClient = require('RelayWatchmanClient');
 
 const formatGeneratedModule = require('formatGeneratedModule');
 const fs = require('fs');
@@ -60,6 +61,27 @@ function buildWatchExpression(options: {
   ];
 }
 
+function getFilepathsFromGlob(
+  baseDir,
+  options: {
+    extensions: Array<string>,
+    include: Array<string>,
+    exclude: Array<string>,
+  },
+): Array<string> {
+  const {extensions, include, exclude} = options;
+  const patterns = include.map(inc => `${inc}/*.+(${extensions.join('|')})`);
+
+  // $FlowFixMe
+  const glob = require('fast-glob');
+  return glob.sync(patterns, {
+    cwd: baseDir,
+    bashNative: [],
+    onlyFiles: true,
+    ignore: exclude,
+  });
+}
+
 /* eslint-disable no-console-disallow */
 
 async function run(options: {
@@ -69,6 +91,7 @@ async function run(options: {
   include: Array<string>,
   exclude: Array<string>,
   verbose: boolean,
+  watchman: boolean,
   watch?: ?boolean,
 }) {
   const schemaPath = path.resolve(process.cwd(), options.schema);
@@ -79,6 +102,9 @@ async function run(options: {
   if (!fs.existsSync(srcDir)) {
     throw new Error(`--source path does not exist: ${srcDir}.`);
   }
+  if (options.watch && !options.watchman) {
+    throw new Error('Watchman is required to watch for changes.');
+  }
   if (options.watch && !hasWatchmanRootFile(srcDir)) {
     throw new Error(
       `
@@ -96,13 +122,17 @@ Ensure that one such file exists in ${srcDir} or its parents.
 
   const reporter = new RelayConsoleReporter({verbose: options.verbose});
 
+  const useWatchman =
+    options.watchman && (await RelayWatchmanClient.isAvailable());
+
   const parserConfigs = {
     default: {
       baseDir: srcDir,
       getFileFilter: RelayFileIRParser.getFileFilter,
       getParser: RelayFileIRParser.getParser,
       getSchema: () => getSchema(schemaPath),
-      watchmanExpression: buildWatchExpression(options),
+      watchmanExpression: useWatchman ? buildWatchExpression(options) : null,
+      filepaths: useWatchman ? null : getFilepathsFromGlob(srcDir, options),
     },
   };
   const writerConfigs = {
@@ -234,6 +264,11 @@ const argv = yargs
       describe: 'More verbose logging',
       type: 'boolean',
     },
+    watchman: {
+      describe: 'Use watchman when not in watch mode',
+      type: 'boolean',
+      default: true,
+    },
     watch: {
       describe: 'If specified, watches files and regenerates on changes',
       type: 'boolean',

packages/relay-compiler/generic/codegen/RelayCodegenRunner.js

@@ -36,7 +36,8 @@ export type ParserConfig = {|
   getFileFilter?: (baseDir: string) => FileFilter,
   getParser: (baseDir: string) => FileParser,
   getSchema: () => GraphQLSchema,
-  watchmanExpression: WatchmanExpression,
+  watchmanExpression?: ?WatchmanExpression,
+  filepaths?: ?Array<string>,
 |};
 
 type ParserConfigs = {
@@ -193,14 +194,34 @@ class RelayCodegenRunner {
 
     const parserConfig = this.parserConfigs[parserName];
     this.parsers[parserName] = parserConfig.getParser(parserConfig.baseDir);
+    const filter = parserConfig.getFileFilter
+      ? parserConfig.getFileFilter(parserConfig.baseDir)
+      : anyFileFilter;
 
-    const files = await RelayCodegenWatcher.queryFiles(
-      parserConfig.baseDir,
-      parserConfig.watchmanExpression,
-      parserConfig.getFileFilter
-        ? parserConfig.getFileFilter(parserConfig.baseDir)
-        : anyFileFilter,
-    );
+    if (parserConfig.filepaths && parserConfig.watchmanExpression) {
+      throw new Error(
+        'Provide either `watchmanExpression` or `filepaths` but not both.',
+      );
+    }
+
+    let files;
+    if (parserConfig.watchmanExpression) {
+      files = await RelayCodegenWatcher.queryFiles(
+        parserConfig.baseDir,
+        parserConfig.watchmanExpression,
+        filter,
+      );
+    } else if (parserConfig.filepaths) {
+      files = await RelayCodegenWatcher.queryFilepaths(
+        parserConfig.baseDir,
+        parserConfig.filepaths,
+        filter,
+      );
+    } else {
+      throw new Error(
+        'Either `watchmanExpression` or `filepaths` is required to query files',
+      );
+    }
     this.parseFileChanges(parserName, files);
   }
 
@@ -318,6 +339,10 @@ class RelayCodegenRunner {
   async watch(parserName: string): Promise<void> {
     const parserConfig = this.parserConfigs[parserName];
 
+    if (!parserConfig.watchmanExpression) {
+      throw new Error('`watchmanExpression` is required to watch files');
+    }
+
     // watchCompile starts with a full set of files as the changes
     // But as we need to set everything up due to potential parser dependencies,
     // we should prevent the first watch callback from doing anything.

packages/relay-compiler/generic/codegen/RelayCodegenWatcher.js

@@ -62,6 +62,22 @@ async function getFields(client: RelayWatchmanClient): Promise<Array<string>> {
   return fields;
 }
 
+// For use when not using Watchman.
+async function queryFilepaths(
+  baseDir: string,
+  filepaths: Array<string>,
+  filter: FileFilter,
+): Promise<Set<File>> {
+  // Construct WatchmanChange objects as an intermediate step before
+  // calling updateFiles to produce file content.
+  const files = filepaths.map(filepath => ({
+    name: filepath,
+    exists: true,
+    'content.sha1hex': null,
+  }));
+  return updateFiles(new Set(), baseDir, filter, files);
+}
+
 /**
  * Provides a simplified API to the watchman API.
  * Given some base directory and a list of subdirectories it calls the callback
@@ -192,6 +208,7 @@ function hashFile(filename: string): string {
 
 module.exports = {
   queryFiles,
+  queryFilepaths,
   watch,
   watchFiles,
   watchCompile,

packages/relay-compiler/generic/core/RelayWatchmanClient.js

@@ -17,6 +17,14 @@ const watchman = require('fb-watchman');
 class RelayWatchmanClient {
   _client: any;
 
+  static isAvailable(): Promise<boolean> {
+    return new Promise(resolve => {
+      const client = new RelayWatchmanClient();
+      client.on('error', () => resolve(false));
+      client.hasCapability('relative_root').then(resolve, () => resolve(false));
+    });
+  }
+
   constructor() {
     this._client = new watchman.Client();
   }

packages/relay-compiler/package.json

@@ -21,6 +21,7 @@
     "babel-types": "6.25.0",
     "babylon": "6.17.3",
     "chalk": "^1.1.3",
+    "fast-glob": "^1.0.1",
     "fb-watchman": "^2.0.0",
     "fbjs": "^0.8.1",
     "graphql": "^0.10.5",