relay-compiler 0.0.0-main-f0b65f0b → 0.0.0-main-e0026a71

package/codegen/CodegenRunner.js.flow

@@ -1,424 +0,0 @@
-/**
- * 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';
-
-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';
-
-const Profiler = require('../core/GraphQLCompilerProfiler');
-const GraphQLWatchmanClient = require('../core/GraphQLWatchmanClient');
-const {create: createSchema} = require('../core/Schema');
-const CodegenDirectory = require('./CodegenDirectory');
-const CodegenWatcher = require('./CodegenWatcher');
-/* $FlowFixMe[untyped-import] - importing immutable, which is untyped (and flow
- * is sad about it) */
-const {Map: ImmutableMap} = require('immutable');
-const invariant = require('invariant');
-const path = require('path');
-
-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

@@ -1,28 +0,0 @@
-/**
- * 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

@@ -1,250 +0,0 @@
-/**
- * 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';
-
-import type {File} from './CodegenTypes';
-
-const Profiler = require('../core/GraphQLCompilerProfiler');
-const GraphQLWatchmanClient = require('../core/GraphQLWatchmanClient');
-const crypto = require('crypto');
-const fs = require('fs');
-const path = require('path');
-
-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,
-};