relay-compiler 9.0.0 → 10.1.0

package/reporters/ConsoleReporter.js.flow

@@ -0,0 +1,81 @@
+/**
+ * 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';
+
+const chalk = require('chalk');
+
+import type {Reporter} from './Reporter';
+
+function getMemoryUsageString() {
+  return chalk.blue(
+    Math.round(process.memoryUsage().heapUsed / 1024 / 1024) + 'Mb',
+  );
+}
+
+class ConsoleReporter implements Reporter {
+  _verbose: boolean;
+  _quiet: boolean;
+
+  constructor(options: {verbose: boolean, quiet: boolean, ...}) {
+    this._verbose = options.verbose;
+    this._quiet = options.quiet;
+  }
+
+  reportMessage(message: string): void {
+    if (!this._quiet) {
+      process.stdout.write(message + '\n');
+    }
+  }
+
+  reportTime(name: string, ms: number): void {
+    if (this._verbose && !this._quiet) {
+      const time =
+        ms === 0
+          ? chalk.gray(' <1ms')
+          : ms < 1000
+          ? chalk.blue(leftPad(5, ms + 'ms'))
+          : chalk.red(Math.floor(ms / 10) / 100 + 's');
+      process.stdout.write(
+        '  ' +
+          time +
+          ' ' +
+          chalk.gray(name) +
+          ' [' +
+          getMemoryUsageString() +
+          ']\n',
+      );
+    }
+  }
+
+  reportError(caughtLocation: string, error: Error): void {
+    if (!this._quiet) {
+      process.stdout.write(chalk.red('ERROR:\n' + error.message + '\n'));
+      if (this._verbose) {
+        const frames = error.stack.match(/^ {4}at .*$/gm);
+        if (frames) {
+          process.stdout.write(
+            chalk.gray(
+              'From: ' + caughtLocation + '\n' + frames.join('\n') + '\n',
+            ),
+          );
+        }
+      }
+    }
+  }
+}
+
+function leftPad(len, str) {
+  return new Array(len - str.length + 1).join(' ') + str;
+}
+
+module.exports = ConsoleReporter;

package/reporters/MultiReporter.js.flow

@@ -0,0 +1,43 @@
+/**
+ * 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';
+
+import type {Reporter} from './Reporter';
+
+class MultiReporter implements Reporter {
+  _reporters: $ReadOnlyArray<Reporter>;
+
+  constructor(...reporters: $ReadOnlyArray<Reporter>) {
+    this._reporters = reporters;
+  }
+
+  reportMessage(message: string): void {
+    this._reporters.forEach(reporter => {
+      reporter.reportMessage(message);
+    });
+  }
+
+  reportTime(name: string, ms: number): void {
+    this._reporters.forEach(reporter => {
+      reporter.reportTime(name, ms);
+    });
+  }
+
+  reportError(caughtLocation: string, error: Error): void {
+    this._reporters.forEach(reporter => {
+      reporter.reportError(caughtLocation, error);
+    });
+  }
+}
+
+module.exports = MultiReporter;

package/reporters/Reporter.js.flow

@@ -0,0 +1,19 @@
+/**
+ * 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 interface Reporter {
+  reportMessage(message: string): void;
+  reportTime(name: string, ms: number): void;
+  reportError(caughtLocation: string, error: Error): void;
+}

package/runner/Artifacts.js.flow

@@ -0,0 +1,219 @@
+/**
+ * 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.
+ *
+ * @format
+ * @flow strict-local
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+const crypto = require('crypto');
+const nullthrows = require('nullthrows');
+
+const {getName} = require('./GraphQLASTUtils');
+
+import type CodegenDirectory, {Filesystem} from '../codegen/CodegenDirectory';
+import type {SourceChanges} from './Sources';
+import type {ExecutableDefinitionNode} from 'graphql';
+
+type Filename = string;
+
+type NodeName = string;
+
+type FileSha1Hex = string;
+
+type ArtifactFiles = Set<Filename>;
+
+type ArtifactsMetadata = Map<Filename, FileSha1Hex>;
+
+export type ArtifactMap = {|
+  // Map nodeName to the set of artifacts for this node
+  +artifacts: Map<NodeName, ArtifactFiles>,
+  // Artifacts metadata (for now it's just sha1 of the file)
+  +metadata: ArtifactsMetadata,
+|};
+
+export type ArtifactState = ArtifactMap;
+
+export type SerializedArtifactState = $ReadOnlyArray<
+  [string, $ReadOnlyArray<[string, string]>],
+>;
+
+function createEmptyState(): ArtifactState {
+  return {
+    artifacts: new Map(),
+    metadata: new Map(),
+  };
+}
+
+function serializeState(state: ArtifactState): SerializedArtifactState {
+  const json = [];
+  for (const [name, artifacts] of state.artifacts) {
+    json.push([
+      name,
+      Array.from(artifacts).map(filename => {
+        return [filename, state.metadata.get(filename) ?? ''];
+      }),
+    ]);
+  }
+  return json;
+}
+
+function deserializeState(json: SerializedArtifactState): ArtifactState {
+  const metadata = new Map();
+  const artifacts = new Map();
+  json.forEach(([name, artifactArray]) => {
+    const artifactsFiles = new Set();
+    artifactArray.forEach(([filename, sha1hex]) => {
+      artifactsFiles.add(filename);
+      metadata.set(filename, sha1hex);
+    });
+    artifacts.set(name, artifactsFiles);
+  });
+  return {
+    artifacts,
+    metadata,
+  };
+}
+
+function updateState(
+  state: ArtifactState,
+  changes: SourceChanges<ExecutableDefinitionNode>,
+  generatedArtifacts: ArtifactMap,
+  filesystem: Filesystem,
+  resolveFullPath: (relativeFilePath: string) => string,
+): ArtifactState {
+  const nextState = {
+    artifacts: new Map(state.artifacts),
+    metadata: new Map(state.metadata),
+  };
+  const deletionCandidates = new Set();
+
+  const addedNames = new Set();
+  for (const {ast} of changes.added) {
+    addedNames.add(getName(ast));
+  }
+
+  // For every removed AST node, delete the generated artifacts tracked for that
+  // node, unless the AST node was also added when the file was moved or the
+  // AST changed which shows up as added and removed in changes.
+  for (const {ast} of changes.removed) {
+    const name = getName(ast);
+
+    if (addedNames.has(name)) {
+      // Update, we deal with that when iterating the added nodes.
+      continue;
+    }
+    const entry = nextState.artifacts.get(name);
+    if (entry == null) {
+      // No existing artifacts to delete
+      continue;
+    }
+    for (const outdatedFile of entry.keys()) {
+      deletionCandidates.add(outdatedFile);
+    }
+    nextState.artifacts.delete(name);
+  }
+
+  for (const [name, artifacts] of generatedArtifacts.artifacts) {
+    const oldEntry = nextState.artifacts.get(name);
+    if (oldEntry != null) {
+      for (const outdatedFile of oldEntry) {
+        if (!artifacts.has(outdatedFile)) {
+          deletionCandidates.add(outdatedFile);
+        }
+      }
+    }
+    nextState.artifacts.set(name, artifacts);
+    for (const filename of artifacts.keys()) {
+      nextState.metadata.set(
+        filename,
+        generatedArtifacts.metadata.get(filename) ?? '',
+      );
+    }
+  }
+
+  if (deletionCandidates.size === 0) {
+    return nextState;
+  }
+
+  const nextGeneratedArtifacts = new Set();
+  for (const [, artifact] of eachNameAndArtifact(nextState)) {
+    nextGeneratedArtifacts.add(artifact);
+  }
+  for (const candidate of deletionCandidates) {
+    const someoneElseArtifact = nextGeneratedArtifacts.has(candidate);
+    if (someoneElseArtifact) {
+      // Sometimes, there are artifacts that are generated by multiple files
+      // If this candidate is also generated by someone else in
+      // artifact map, we just skip it here
+      continue;
+    }
+
+    const candidatePath = resolveFullPath(candidate);
+    if (filesystem.existsSync(candidatePath)) {
+      filesystem.unlinkSync(candidatePath);
+      nextState.metadata.delete(candidate);
+    }
+  }
+
+  return nextState;
+}
+
+function producedFiles(
+  dirs: $ReadOnlyArray<{|
+    baseDir: string,
+    dir: CodegenDirectory,
+  |}>,
+  artifactsMetadata: ArtifactsMetadata,
+): ArtifactsMetadata {
+  const result = new Map();
+  dirs.forEach(({baseDir, dir}) => {
+    const {deleted, updated, created, unchanged} = dir.changes;
+    if (deleted.length > 0) {
+      throw new Error('Did not expect to see a deletion entry here.');
+    }
+    [...updated, ...created].forEach(filename => {
+      const name = dir.getPath(filename).substr(baseDir.length + 1);
+      const sha1hex = sha1(nullthrows(dir.read(filename)));
+      result.set(name, sha1hex);
+    });
+    unchanged.forEach(filename => {
+      const name = dir.getPath(filename).substr(baseDir.length + 1);
+      const sha1hex = artifactsMetadata.get(name);
+      result.set(name, sha1hex ?? sha1(nullthrows(dir.read(filename))));
+    });
+  });
+  return result;
+}
+
+function* eachNameAndArtifact(
+  artifacts: ArtifactState,
+): Iterator<[string, string]> {
+  for (const [name, artifactsForSource] of artifacts.artifacts) {
+    for (const artifactFile of artifactsForSource.keys()) {
+      yield [name, artifactFile];
+    }
+  }
+}
+
+function sha1(content: string): string {
+  return crypto
+    .createHash('sha1')
+    .update(content)
+    .digest('hex');
+}
+
+module.exports = {
+  createEmptyState,
+  serializeState,
+  deserializeState,
+  updateState,
+  producedFiles,
+  eachNameAndArtifact,
+};

package/runner/BufferedFilesystem.js.flow

@@ -0,0 +1,194 @@
+/**
+ * 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.
+ *
+ * @emails oncall+relay
+ * @flow strict
+ * @format
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+const fs = require('fs');
+const invariant = require('invariant');
+
+import type {Filesystem} from '../codegen/CodegenDirectory';
+import type {SourceControl} from '../codegen/SourceControl';
+
+/**
+ * A filesystem wrapper that buffers file reads and writes until `commit()` is
+ * called.
+ */
+class BufferedFilesystem implements Filesystem {
+  buffer: Map<string, ?string> = new Map();
+  committed: boolean = false;
+
+  _assertNotComitted() {
+    invariant(
+      !this.committed,
+      'BufferedFilesystem: no operations allowed after commit().',
+    );
+  }
+
+  async commit(sourceControl: ?SourceControl) {
+    this._assertNotComitted();
+    this.committed = true;
+
+    const removed = [];
+    const added = [];
+    for (const [path, data] of this.buffer) {
+      if (data == null) {
+        removed.push(path);
+        fs.unlinkSync(path);
+      } else {
+        const fileExisits = fs.existsSync(path);
+        const currentData = fileExisits ? fs.readFileSync(path, 'utf8') : null;
+        if (currentData !== data) {
+          added.push(path);
+          fs.writeFileSync(path, data, 'utf8');
+        }
+      }
+    }
+    if (sourceControl) {
+      await sourceControl.addRemove(added, removed);
+    }
+  }
+
+  hasChanges(): boolean {
+    this._assertNotComitted();
+    return this.buffer.size > 0;
+  }
+
+  getChangesSummary(): string {
+    this._assertNotComitted();
+    const added = [];
+    const updated = [];
+    const removed = [];
+    for (const [path, data] of this.buffer) {
+      if (data == null) {
+        removed.push(path);
+      } else {
+        if (!fs.existsSync(path)) {
+          added.push(path);
+        } else {
+          updated.push(path);
+        }
+      }
+    }
+    return [
+      added.length > 0 ? `Added:\n${added.map(formatFilepath).join('')}` : '',
+      updated.length > 0
+        ? `Updated:\n${updated.map(formatFilepath).join('')}`
+        : '',
+      removed.length > 0
+        ? `Removed:\n${removed.map(formatFilepath).join('')}`
+        : '',
+    ]
+      .filter(Boolean)
+      .join('\n');
+  }
+
+  getAddedRemovedFiles(): {|
+    +added: $ReadOnlyArray<string>,
+    +removed: $ReadOnlyArray<string>,
+  |} {
+    this._assertNotComitted();
+    const added = [];
+    const removed = [];
+    for (const [path, data] of this.buffer) {
+      if (data == null) {
+        removed.push(path);
+      } else {
+        if (!fs.existsSync(path)) {
+          added.push(path);
+        }
+      }
+    }
+    return {
+      added,
+      removed,
+    };
+  }
+
+  existsSync(path: string): boolean {
+    this._assertNotComitted();
+    return this.buffer.has(path)
+      ? Boolean(this.buffer.get(path))
+      : fs.existsSync(path);
+  }
+
+  mkdirSync(path: string): void {
+    this._assertNotComitted();
+    fs.mkdirSync(path);
+  }
+
+  readdirSync(path: string): Array<string> {
+    this._assertNotComitted();
+    throw new Error('BufferedFilesystem: readdirSync is not implemented.');
+  }
+
+  readFileSync(path: string, encoding: string): string {
+    this._assertNotComitted();
+    if (this.buffer.has(path)) {
+      const data = this.buffer.get(path);
+      invariant(
+        data != null,
+        'BufferedFilesystem: trying to read deleted file.',
+      );
+      return data;
+    }
+    return fs.readFileSync(path, encoding);
+  }
+
+  statSync(path: string): {isDirectory(): boolean, ...} {
+    this._assertNotComitted();
+    return fs.statSync(path);
+  }
+
+  unlinkSync(path: string): void {
+    this._assertNotComitted();
+    this.buffer.set(path, null);
+  }
+
+  writeFileSync(filename: string, data: string, encoding: string): void {
+    this._assertNotComitted();
+    this.buffer.set(filename, data);
+  }
+
+  changedFilesToJSON(): {|
+    +changed: $ReadOnlyArray<{|
+      +path: string,
+      +data: string,
+    |}>,
+    +removed: $ReadOnlyArray<{|
+      +path: string,
+    |}>,
+  |} {
+    this._assertNotComitted();
+    const changed = [];
+    const removed = [];
+    for (const [path, data] of this.buffer) {
+      if (data == null) {
+        removed.push({path});
+      } else {
+        changed.push({path, data});
+      }
+    }
+    return {
+      removed,
+      changed,
+    };
+  }
+}
+
+function formatFilepath(filepath: string): string {
+  const startIndex = filepath.length - 80;
+  const prefix = startIndex > 0 ? `\t - ${filepath.substr(0, 8)}...` : '\t - ';
+  return prefix + filepath.substr(startIndex, filepath.length) + '\n';
+}
+
+module.exports = BufferedFilesystem;