@ardatan/relay-compiler 12.0.0

package/codegen/CodegenRunner.js.flow

@@ -0,0 +1,432 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+const CodegenDirectory = require('./CodegenDirectory');
+const CodegenWatcher = require('./CodegenWatcher');
+const GraphQLWatchmanClient = require('../core/GraphQLWatchmanClient');
+const Profiler = require('../core/GraphQLCompilerProfiler');
+
+const invariant = require('invariant');
+const path = require('path');
+
+const {create: createSchema} = require('../core/Schema');
+/* $FlowFixMe[untyped-import] - importing immutable, which is untyped (and flow
+ * is sad about it) */
+const {Map: ImmutableMap} = require('immutable');
+
+import type ASTCache from '../core/ASTCache';
+import type {Schema} from '../core/Schema';
+import type {Reporter} from '../reporters/Reporter';
+import type {CompileResult, File} from './CodegenTypes';
+import type {FileFilter, WatchmanExpression} from './CodegenWatcher';
+import type {SourceControl} from './SourceControl';
+import type {DocumentNode, Source} from 'graphql';
+
+export type ParserConfig = {|
+  baseDir: string,
+  getFileFilter?: (baseDir: string) => FileFilter,
+  getParser: (baseDir: string) => ASTCache,
+  getSchemaSource: () => Source,
+  schemaExtensions: $ReadOnlyArray<string>,
+  generatedDirectoriesWatchmanExpression?: ?WatchmanExpression,
+  watchmanExpression?: ?WatchmanExpression,
+  filepaths?: ?Array<string>,
+|};
+
+type ParserConfigs = {[parser: string]: ParserConfig, ...};
+type Parsers = {[parser: string]: ASTCache, ...};
+
+export type IsGeneratedFileFn = (filePath: string) => boolean;
+export type KeepExtraFileFn = (filePath: string) => boolean;
+
+export type WriterConfig = {|
+  parser: string,
+  baseParsers?: Array<string>,
+  isGeneratedFile: IsGeneratedFileFn,
+  writeFiles: WriteFiles,
+|};
+
+type WriterConfigs = {[writer: string]: WriterConfig, ...};
+
+export type WriteFilesOptions = {|
+  onlyValidate: boolean,
+  schema: Schema,
+  documents: ImmutableMap<string, DocumentNode>,
+  baseDocuments: ImmutableMap<string, DocumentNode>,
+  sourceControl: ?SourceControl,
+  reporter: Reporter,
+  generatedDirectories?: Array<string>,
+|};
+
+export type WriteFiles = WriteFilesOptions => Promise<
+  Map<string, CodegenDirectory>,
+>;
+
+type OnCompleteCallback = (
+  codegenDirs: $ReadOnlyArray<CodegenDirectory>,
+) => void;
+
+class CodegenRunner {
+  parserConfigs: ParserConfigs;
+  writerConfigs: WriterConfigs;
+  onlyValidate: boolean;
+  parsers: Parsers;
+  onComplete: ?OnCompleteCallback;
+
+  // parser => writers that are affected by it
+  parserWriters: {[parser: string]: Set<string>, ...};
+  _reporter: Reporter;
+  _sourceControl: ?SourceControl;
+
+  constructor(options: {
+    parserConfigs: ParserConfigs,
+    writerConfigs: WriterConfigs,
+    onlyValidate: boolean,
+    reporter: Reporter,
+    sourceControl: ?SourceControl,
+    onComplete?: OnCompleteCallback,
+    ...
+  }) {
+    this.parsers = {};
+    this.parserConfigs = options.parserConfigs;
+    this.writerConfigs = options.writerConfigs;
+    this.onlyValidate = options.onlyValidate;
+    this.onComplete = options.onComplete;
+    this._reporter = options.reporter;
+    this._sourceControl = options.sourceControl;
+
+    this.parserWriters = {};
+    for (const parser in options.parserConfigs) {
+      this.parserWriters[parser] = new Set();
+    }
+
+    for (const writer in options.writerConfigs) {
+      const config = options.writerConfigs[writer];
+      config.baseParsers &&
+        config.baseParsers.forEach(parser =>
+          this.parserWriters[parser].add(writer),
+        );
+      this.parserWriters[config.parser].add(writer);
+    }
+  }
+
+  async compileAll(): Promise<CompileResult> {
+    // reset the parsers
+    this.parsers = {};
+    for (const parserName in this.parserConfigs) {
+      try {
+        await this.parseEverything(parserName);
+      } catch (e) {
+        this._reporter.reportError('CodegenRunner.compileAll', e);
+        return 'ERROR';
+      }
+    }
+
+    let hasChanges = false;
+    for (const writerName in this.writerConfigs) {
+      const result = await this.write(writerName);
+      if (result === 'ERROR') {
+        return 'ERROR';
+      }
+      if (result === 'HAS_CHANGES') {
+        hasChanges = true;
+      }
+    }
+    return hasChanges ? 'HAS_CHANGES' : 'NO_CHANGES';
+  }
+
+  async compile(writerName: string): Promise<CompileResult> {
+    const writerConfig = this.writerConfigs[writerName];
+
+    const parsers = [writerConfig.parser];
+    if (writerConfig.baseParsers) {
+      writerConfig.baseParsers.forEach(parser => parsers.push(parser));
+    }
+    // Don't bother resetting the parsers
+    await Profiler.asyncContext('CodegenRunner:parseEverything', () =>
+      Promise.all(parsers.map(parser => this.parseEverything(parser))),
+    );
+
+    return await this.write(writerName);
+  }
+
+  getDirtyWriters(filePaths: Array<string>): Promise<Set<string>> {
+    return Profiler.asyncContext('CodegenRunner:getDirtyWriters', async () => {
+      const dirtyWriters = new Set();
+
+      // Check if any files are in the output
+      for (const configName in this.writerConfigs) {
+        const config = this.writerConfigs[configName];
+        for (const filePath of filePaths) {
+          if (config.isGeneratedFile(filePath)) {
+            dirtyWriters.add(configName);
+          }
+        }
+      }
+
+      // Check for files in the input
+      await Promise.all(
+        Object.keys(this.parserConfigs).map(parserConfigName =>
+          Profiler.waitFor('Watchman:query', async () => {
+            const client = new GraphQLWatchmanClient();
+            const config = this.parserConfigs[parserConfigName];
+            const dirs = await client.watchProject(config.baseDir);
+
+            const relativeFilePaths = filePaths.map(filePath =>
+              path.relative(config.baseDir, filePath),
+            );
+
+            const query = {
+              expression: [
+                'allof',
+                config.watchmanExpression,
+                ['name', relativeFilePaths, 'wholename'],
+              ],
+              fields: ['exists'],
+              relative_root: dirs.relativePath,
+            };
+
+            const result = await client.command('query', dirs.root, query);
+            client.end();
+
+            if (result.files.length > 0) {
+              this.parserWriters[parserConfigName].forEach(writerName =>
+                dirtyWriters.add(writerName),
+              );
+            }
+          }),
+        ),
+      );
+
+      return dirtyWriters;
+    });
+  }
+
+  async parseEverything(parserName: string): Promise<void> {
+    if (this.parsers[parserName]) {
+      // no need to parse
+      return;
+    }
+
+    const parserConfig = this.parserConfigs[parserName];
+    this.parsers[parserName] = parserConfig.getParser(parserConfig.baseDir);
+    const filter = 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 CodegenWatcher.queryFiles(
+        parserConfig.baseDir,
+        parserConfig.watchmanExpression,
+        filter,
+      );
+    } else if (parserConfig.filepaths) {
+      files = await CodegenWatcher.queryFilepaths(
+        parserConfig.baseDir,
+        parserConfig.filepaths,
+        filter,
+      );
+    } else {
+      throw new Error(
+        'Either `watchmanExpression` or `filepaths` is required to query files',
+      );
+    }
+    this.parseFileChanges(parserName, files);
+  }
+
+  parseFileChanges(parserName: string, files: Set<File>): void {
+    return Profiler.run('CodegenRunner.parseFileChanges', () => {
+      const parser = this.parsers[parserName];
+      // this maybe should be await parser.parseFiles(files);
+      parser.parseFiles(files);
+    });
+  }
+
+  // We cannot do incremental writes right now.
+  // When we can, this could be writeChanges(writerName, parserName, parsedDefinitions)
+  write(writerName: string): Promise<CompileResult> {
+    return Profiler.asyncContext('CodegenRunner.write', async () => {
+      try {
+        this._reporter.reportMessage(`\nWriting ${writerName}`);
+        const {
+          writeFiles,
+          parser,
+          baseParsers,
+          isGeneratedFile,
+        } = this.writerConfigs[writerName];
+
+        let baseDocuments = ImmutableMap();
+        if (baseParsers) {
+          baseParsers.forEach(baseParserName => {
+            invariant(
+              this.parsers[baseParserName] != null,
+              'Trying to access an uncompiled base parser config: %s',
+              baseParserName,
+            );
+            baseDocuments = baseDocuments.merge(
+              this.parsers[baseParserName].documents(),
+            );
+          });
+        }
+
+        const {
+          baseDir,
+          generatedDirectoriesWatchmanExpression,
+        } = this.parserConfigs[parser];
+        let generatedDirectories = [];
+        if (generatedDirectoriesWatchmanExpression) {
+          const relativePaths = await CodegenWatcher.queryDirectories(
+            baseDir,
+            generatedDirectoriesWatchmanExpression,
+          );
+          generatedDirectories = relativePaths.map(x => path.join(baseDir, x));
+        }
+
+        // always create a new writer: we have to write everything anyways
+        const documents = this.parsers[parser].documents();
+        const schema = Profiler.run('getSchema', () =>
+          createSchema(
+            this.parserConfigs[parser].getSchemaSource(),
+            baseDocuments.toArray(),
+            this.parserConfigs[parser].schemaExtensions,
+          ),
+        );
+
+        const outputDirectories = await writeFiles({
+          onlyValidate: this.onlyValidate,
+          schema,
+          documents,
+          baseDocuments,
+          generatedDirectories,
+          sourceControl: this._sourceControl,
+          reporter: this._reporter,
+        });
+
+        for (const dir of outputDirectories.values()) {
+          const all = [
+            ...dir.changes.created,
+            ...dir.changes.updated,
+            ...dir.changes.deleted,
+            ...dir.changes.unchanged,
+          ];
+          for (const filename of all) {
+            const filePath = dir.getPath(filename);
+            invariant(
+              isGeneratedFile(filePath),
+              'CodegenRunner: %s returned false for isGeneratedFile, ' +
+                'but was in generated directory',
+              filePath,
+            );
+          }
+        }
+
+        const onCompleteCallback = this.onComplete;
+        if (onCompleteCallback != null) {
+          onCompleteCallback(Array.from(outputDirectories.values()));
+        }
+
+        const combinedChanges = CodegenDirectory.combineChanges(
+          Array.from(outputDirectories.values()),
+        );
+
+        this._reporter.reportMessage(
+          CodegenDirectory.formatChanges(combinedChanges, {
+            onlyValidate: this.onlyValidate,
+          }),
+        );
+
+        return CodegenDirectory.hasChanges(combinedChanges)
+          ? 'HAS_CHANGES'
+          : 'NO_CHANGES';
+      } catch (e) {
+        this._reporter.reportError('CodegenRunner.write', e);
+        return 'ERROR';
+      }
+    });
+  }
+
+  async watchAll(): Promise<void> {
+    // get everything set up for watching
+    await this.compileAll();
+
+    for (const parserName in this.parserConfigs) {
+      await this.watch(parserName);
+    }
+  }
+
+  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.
+    let firstChange = true;
+
+    await CodegenWatcher.watchCompile(
+      parserConfig.baseDir,
+      parserConfig.watchmanExpression,
+      parserConfig.getFileFilter
+        ? parserConfig.getFileFilter(parserConfig.baseDir)
+        : anyFileFilter,
+      async files => {
+        invariant(
+          this.parsers[parserName] != null,
+          'Trying to watch an uncompiled parser config: %s',
+          parserName,
+        );
+        if (firstChange) {
+          firstChange = false;
+          return;
+        }
+        const dependentWriters = [];
+        this.parserWriters[parserName].forEach(writer =>
+          dependentWriters.push(writer),
+        );
+
+        try {
+          if (!this.parsers[parserName]) {
+            // have to load the parser and make sure all of its dependents are set
+            await this.parseEverything(parserName);
+          } else {
+            this.parseFileChanges(parserName, files);
+          }
+          await Promise.all(dependentWriters.map(writer => this.write(writer)));
+        } catch (error) {
+          this._reporter.reportError('CodegenRunner.watch', error);
+        }
+        this._reporter.reportMessage(
+          `Watching for changes to ${parserName}...`,
+        );
+      },
+    );
+    this._reporter.reportMessage(`Watching for changes to ${parserName}...`);
+  }
+}
+
+function anyFileFilter(file: File): boolean {
+  return true;
+}
+
+module.exports = CodegenRunner;

package/codegen/CodegenTypes.js.flow

@@ -0,0 +1,28 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict
+ * @format
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+export type CompileResult = 'HAS_CHANGES' | 'NO_CHANGES' | 'ERROR';
+
+export type File =
+  | {
+      exists: false,
+      relPath: string,
+      ...
+    }
+  | {
+      exists: true,
+      relPath: string,
+      hash: string,
+      ...
+    };

package/codegen/CodegenWatcher.js.flow

@@ -0,0 +1,254 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow
+ * @format
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+const GraphQLWatchmanClient = require('../core/GraphQLWatchmanClient');
+const Profiler = require('../core/GraphQLCompilerProfiler');
+
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+
+import type {File} from './CodegenTypes';
+
+const SUBSCRIPTION_NAME = 'graphql-codegen';
+const QUERY_RETRIES = 3;
+
+export type WatchmanExpression = $ReadOnlyArray<string | WatchmanExpression>;
+
+export type FileFilter = (file: File) => boolean;
+
+type WatchmanChange = {|
+  name: string,
+  exists: boolean,
+  'content.sha1hex': ?string,
+|};
+type WatchmanChanges = {
+  files?: $ReadOnlyArray<WatchmanChange>,
+  ...
+};
+
+async function queryFiles(
+  baseDir: string,
+  expression: WatchmanExpression,
+  filter: FileFilter,
+): Promise<Set<File>> {
+  return await Profiler.waitFor('Watchman:query', async () => {
+    const client = new GraphQLWatchmanClient(QUERY_RETRIES);
+    const [watchResp, fields] = await Promise.all([
+      client.watchProject(baseDir),
+      getFields(client),
+    ]);
+    const resp = await client.command('query', watchResp.root, {
+      expression,
+      fields: fields,
+      relative_root: watchResp.relativePath,
+    });
+    client.end();
+    return updateFiles(new Set(), baseDir, filter, resp.files);
+  });
+}
+
+async function queryDirectories(
+  baseDir: string,
+  expression: WatchmanExpression,
+): Promise<$ReadOnlyArray<string>> {
+  return await Profiler.waitFor('Watchman:query', async () => {
+    const client = new GraphQLWatchmanClient();
+    const watchResp = await client.watchProject(baseDir);
+    const resp = await client.command('query', watchResp.root, {
+      expression,
+      fields: ['name'],
+      relative_root: watchResp.relativePath,
+    });
+    client.end();
+    return resp.files;
+  });
+}
+
+async function getFields(
+  client: GraphQLWatchmanClient,
+): Promise<$ReadOnlyArray<string>> {
+  const fields = ['name', 'exists'];
+  if (await client.hasCapability('field-content.sha1hex')) {
+    fields.push('content.sha1hex');
+  }
+  return fields;
+}
+
+// For use when not using Watchman.
+async function queryFilepaths(
+  baseDir: string,
+  filepaths: $ReadOnlyArray<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
+ * with watchman change events on file changes.
+ */
+async function watch(
+  baseDir: string,
+  expression: WatchmanExpression,
+  callback: (changes: WatchmanChanges) => mixed,
+): Promise<void> {
+  return await Profiler.waitFor('Watchman:subscribe', async () => {
+    const client = new GraphQLWatchmanClient();
+    const watchResp = await client.watchProject(baseDir);
+
+    await makeSubscription(
+      client,
+      watchResp.root,
+      watchResp.relativePath,
+      expression,
+      callback,
+    );
+  });
+}
+
+async function makeSubscription(
+  client: GraphQLWatchmanClient,
+  root: string,
+  relativePath: string,
+  expression: WatchmanExpression,
+  callback,
+): Promise<void> {
+  client.on('subscription', resp => {
+    if (resp.subscription === SUBSCRIPTION_NAME) {
+      callback(resp);
+    }
+  });
+  const fields = await getFields(client);
+  await client.command('subscribe', root, SUBSCRIPTION_NAME, {
+    expression,
+    fields: fields,
+    relative_root: relativePath,
+  });
+}
+
+/**
+ * Further simplifies `watch` and calls the callback on every change with a
+ * full list of files that match the conditions.
+ */
+async function watchFiles(
+  baseDir: string,
+  expression: WatchmanExpression,
+  filter: FileFilter,
+  callback: (files: Set<File>) => any,
+): Promise<void> {
+  let files = new Set();
+  await watch(baseDir, expression, changes => {
+    if (!changes.files) {
+      // Watchmen fires a change without files when a watchman state changes,
+      // for example during an hg update.
+      return;
+    }
+    files = updateFiles(files, baseDir, filter, changes.files);
+    callback(files);
+  });
+}
+
+/**
+ * Similar to watchFiles, but takes an async function. The `compile` function
+ * is awaited and not called in parallel. If multiple changes are triggered
+ * before a compile finishes, the latest version is called after the compile
+ * finished.
+ *
+ * TODO: Consider changing from a Promise to abortable, so we can abort mid
+ *       compilation.
+ */
+async function watchCompile(
+  baseDir: string,
+  expression: WatchmanExpression,
+  filter: FileFilter,
+  compile: (files: Set<File>) => Promise<any>,
+): Promise<void> {
+  let compiling = false;
+  let needsCompiling = false;
+  let latestFiles = null;
+
+  watchFiles(baseDir, expression, filter, async files => {
+    needsCompiling = true;
+    latestFiles = files;
+    if (compiling) {
+      return;
+    }
+    compiling = true;
+    while (needsCompiling) {
+      needsCompiling = false;
+      await compile(latestFiles);
+    }
+    compiling = false;
+  });
+}
+
+function updateFiles(
+  files: Set<File>,
+  baseDir: string,
+  filter: FileFilter,
+  fileChanges: $ReadOnlyArray<WatchmanChange>,
+): Set<File> {
+  const fileMap = new Map();
+  files.forEach(file => {
+    file.exists && fileMap.set(file.relPath, file);
+  });
+
+  fileChanges.forEach(({name, exists, 'content.sha1hex': hash}) => {
+    let shouldRemove = !exists;
+    if (!shouldRemove) {
+      const file = {
+        exists: true,
+        relPath: name,
+        hash: hash || hashFile(path.join(baseDir, name)),
+      };
+      if (filter(file)) {
+        fileMap.set(name, file);
+      } else {
+        shouldRemove = true;
+      }
+    }
+    shouldRemove &&
+      fileMap.set(name, {
+        exists: false,
+        relPath: name,
+      });
+  });
+  return new Set(fileMap.values());
+}
+
+function hashFile(filename: string): string {
+  const content = fs.readFileSync(filename);
+  return crypto
+    .createHash('sha1')
+    .update(content)
+    .digest('hex');
+}
+
+module.exports = {
+  queryDirectories,
+  queryFiles,
+  queryFilepaths,
+  watch,
+  watchFiles,
+  watchCompile,
+};