relay-compiler 8.0.0 → 10.0.1

package/runner/GraphQLASTNodeGroup.js.flow

@@ -0,0 +1,176 @@
+/**
+ * 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 GraphQLNodeMap = require('./GraphQLNodeMap');
+
+const {getName} = require('./GraphQLASTUtils');
+const {visit} = require('graphql');
+
+import type {ExecutableDefinitionNode} from 'graphql';
+
+type DependencyMap = Map<string, Array<string>>;
+
+export type NodeGroup = {|
+  +nodes: GraphQLNodeMap,
+  +baseNames: Set<string>,
+|};
+
+function buildDependencyMap(nodes: GraphQLNodeMap): DependencyMap {
+  const dependencyMap: DependencyMap = new Map();
+  for (const node of nodes.values()) {
+    const name = getName(node);
+    if (dependencyMap.has(name)) {
+      throw new Error(`Duplicated definition for ${name}`);
+    }
+    dependencyMap.set(name, findIncludedFragments(node));
+  }
+  return dependencyMap;
+}
+
+function mergeMaps<T>(maps: $ReadOnlyArray<Map<string, T>>): Map<string, T> {
+  const result = new Map();
+  for (const source of maps) {
+    for (const [key, value] of source.entries()) {
+      if (result.has(key)) {
+        throw new Error(`Duplicate entry for '${key}'.`);
+      }
+      result.set(key, value);
+    }
+  }
+  return result;
+}
+
+function forFullBuild(
+  nodes: GraphQLNodeMap,
+  baseNodes: $ReadOnlyArray<GraphQLNodeMap>,
+): NodeGroup {
+  const dependencyMap = mergeMaps(
+    [nodes, ...baseNodes].map(buildDependencyMap),
+  );
+  const includedNames = includeReachable(new Set(nodes.keys()), dependencyMap);
+  return buildResult(includedNames, nodes, mergeMaps(baseNodes));
+}
+
+function forChanges(
+  nodes: GraphQLNodeMap,
+  changedNames: Set<string>,
+  baseNodes: $ReadOnlyArray<GraphQLNodeMap> = [],
+): NodeGroup {
+  const projectDependencyMap = buildDependencyMap(nodes);
+  const baseDependencyMap = mergeMaps(baseNodes.map(buildDependencyMap));
+  const dependencyMap = mergeMaps([projectDependencyMap, baseDependencyMap]);
+  const invertedDependencyMap = inverseDependencyMap(dependencyMap);
+  const baseNameToNode: Map<string, ExecutableDefinitionNode> = mergeMaps(
+    baseNodes,
+  );
+
+  // The first step of the process is to find all ancestors of changed nodes.
+  // And we perform this search on complete dependency map (project + base)
+  const directlyChangedAndAncestors = includeReachable(
+    changedNames,
+    invertedDependencyMap,
+  );
+  // Now, we need to intersect obtained set with the project nodes
+  const directlyChangedRelatedToProject = new Set();
+  for (const node of directlyChangedAndAncestors) {
+    if (nodes.has(node)) {
+      directlyChangedRelatedToProject.add(node);
+    }
+  }
+
+  // Finally, we need to find all descendants of project-related changed nodes
+  // in the complete dependency map (project + base)
+  const allRelated = includeReachable(
+    directlyChangedRelatedToProject,
+    dependencyMap,
+  );
+
+  return buildResult(allRelated, nodes, baseNameToNode);
+}
+
+function buildResult(
+  includedNames: Set<string>,
+  nameToNode: Map<string, ExecutableDefinitionNode>,
+  baseNameToNode: Map<string, ExecutableDefinitionNode>,
+): NodeGroup {
+  const baseNames = new Set();
+  const nodes = [];
+  for (const name of includedNames) {
+    const baseNode = baseNameToNode.get(name);
+    if (baseNode != null) {
+      nodes.push(baseNode);
+      baseNames.add(name);
+    }
+
+    const node = nameToNode.get(name);
+    if (node != null) {
+      nodes.push(node);
+    }
+  }
+  return {
+    baseNames,
+    nodes: GraphQLNodeMap.from(nodes),
+  };
+}
+
+function includeReachable(
+  changed: Set<string>,
+  deps: DependencyMap,
+): Set<string> {
+  const toVisit = Array.from(changed);
+  const visited = new Set();
+  while (toVisit.length > 0) {
+    const current = toVisit.pop();
+    visited.add(current);
+    for (const dep of deps.get(current) || []) {
+      if (!visited.has(dep)) {
+        toVisit.push(dep);
+      }
+    }
+  }
+  return visited;
+}
+
+function findIncludedFragments(node: ExecutableDefinitionNode): Array<string> {
+  const result = [];
+  visit(node, {
+    FragmentSpread(spread) {
+      result.push(spread.name.value);
+    },
+  });
+  return result;
+}
+
+function inverseDependencyMap(map: DependencyMap): DependencyMap {
+  const invertedMap = new Map();
+  for (const [source, dests] of map.entries()) {
+    const inverseDest = source;
+    for (const dest of dests) {
+      const inverseSource = dest;
+
+      let inverseDests = invertedMap.get(inverseSource);
+      if (inverseDests == null) {
+        inverseDests = [];
+        invertedMap.set(inverseSource, inverseDests);
+      }
+      inverseDests.push(inverseDest);
+    }
+  }
+  return invertedMap;
+}
+
+module.exports = {
+  forChanges,
+  forFullBuild,
+};

package/runner/GraphQLASTUtils.js.flow

@@ -0,0 +1,26 @@
+/**
+ * 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
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+import type {ExecutableDefinitionNode} from 'graphql';
+
+function getName(node: ExecutableDefinitionNode): string {
+  if (node.name == null) {
+    throw new Error('All fragments and operations have to have names in Relay');
+  }
+  return node.name.value;
+}
+
+module.exports = {
+  getName,
+};

package/runner/GraphQLNodeMap.js.flow

@@ -0,0 +1,55 @@
+/**
+ * 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 {createUserError, createCompilerError} = require('../core/CompilerError');
+const {getName} = require('./GraphQLASTUtils');
+
+import type {ExecutableDefinitionNode} from 'graphql';
+import type {Sources} from 'relay-compiler';
+
+class GraphQLNodeMap extends Map<string, ExecutableDefinitionNode> {
+  static from(nodes: Iterable<ExecutableDefinitionNode>): GraphQLNodeMap {
+    const result = new GraphQLNodeMap();
+    for (const node of nodes) {
+      const name = getName(node);
+      const prevNode = result.get(name);
+      if (prevNode) {
+        throw createUserError(`Duplicate node named '${name}'`, null, [
+          node,
+          prevNode,
+        ]);
+      }
+      result.set(name, node);
+    }
+    return result;
+  }
+
+  static fromSources(
+    sources: Sources<ExecutableDefinitionNode>,
+  ): GraphQLNodeMap {
+    return GraphQLNodeMap.from(sources.nodes());
+  }
+
+  enforceGet(name: string): ExecutableDefinitionNode {
+    const node = this.get(name);
+    if (!node) {
+      throw createCompilerError(
+        `GraphQLNodeMap: expected to have a node named ${name}.`,
+      );
+    }
+    return node;
+  }
+}
+
+module.exports = GraphQLNodeMap;

package/runner/Sources.js.flow

@@ -0,0 +1,214 @@
+/**
+ * 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
+ * @emails oncall+relay
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+const invariant = require('invariant');
+const md5 = require('../util/md5');
+
+const {toASTRecord} = require('./extractAST');
+const {Source, parse} = require('graphql');
+
+import type {ASTRecord} from './extractAST';
+import type {SavedStateCollection, WatchmanFile} from './types';
+import type {ASTNode} from 'graphql';
+
+export type GraphQLExtractor<T: ASTNode> = (
+  baseDir: string,
+  file: WatchmanFile,
+) => ?{|
+  +nodes: $ReadOnlyArray<ASTRecord<T>>,
+  +sources: $ReadOnlyArray<string>,
+|};
+
+type ASTNodeWithFile<T: ASTNode> = {|
+  +file: string,
+  +ast: T,
+|};
+
+export type SourceChanges<T: ASTNode> = {|
+  +added: $ReadOnlyArray<ASTNodeWithFile<T>>,
+  +removed: $ReadOnlyArray<ASTNodeWithFile<T>>,
+|};
+
+type SourcesState = {
+  [filename: string]: {
+    nodes: {[hash: string]: ASTNode, ...},
+    sources: [string],
+    ...
+  },
+  ...,
+};
+
+class Sources<T: ASTNode> {
+  _extractFromFile: GraphQLExtractor<T>;
+  _state: SourcesState;
+
+  static fromSavedState({
+    extractFromFile,
+    savedState,
+  }: {|
+    +extractFromFile: GraphQLExtractor<T>,
+    +savedState: SavedStateCollection,
+  |}): Sources<T> {
+    const state = {};
+    for (const {file, sources: savedStateSources} of savedState) {
+      const nodes = {};
+      const sources = [];
+      for (const text of savedStateSources) {
+        const doc = parse(new Source(text, file));
+        invariant(
+          doc.definitions.length,
+          'expected not empty list of definitions',
+        );
+        const entities = doc.definitions.map(node => {
+          return toASTRecord(node);
+        });
+        entities.forEach(astRecord => {
+          nodes[md5(astRecord.text)] = astRecord.ast;
+        });
+        sources.push(text);
+      }
+      state[file] = {
+        nodes,
+        sources,
+      };
+    }
+    return new Sources({
+      extractFromFile,
+      state,
+    });
+  }
+
+  constructor({
+    extractFromFile,
+    state,
+  }: {|
+    extractFromFile: GraphQLExtractor<T>,
+    state: SourcesState,
+  |}) {
+    this._extractFromFile = extractFromFile;
+    this._state = {...state};
+  }
+
+  processChanges(
+    baseDir: string,
+    files: $ReadOnlyArray<WatchmanFile>,
+  ): {|
+    +changes: SourceChanges<T>,
+    +sources: Sources<T>,
+  |} {
+    const added = [];
+    const removed = [];
+    const state = {...this._state};
+
+    for (const file of files) {
+      let newDefs;
+      let newSources;
+      try {
+        const extracted = this._extractFromFile(baseDir, file);
+        if (extracted != null) {
+          newDefs = extracted.nodes;
+          newSources = extracted.sources;
+        }
+      } catch (error) {
+        throw new Error(
+          `RelayCompiler: Sources module failed to parse ${file.name}:\n${error.message}`,
+        );
+      }
+      const hasEntry = state.hasOwnProperty(file.name);
+      const oldEntry = state[file.name]?.nodes ?? {};
+
+      // First case, we have new changes in the file
+      // for example changed Query or Fragment
+      if (newDefs != null && newDefs.length > 0) {
+        // We need to add all entities from the changed file to added arrays
+        const newEntry = {};
+        const newTexts = new Set();
+        for (const {ast, text} of newDefs) {
+          const hashedText = md5(text);
+          newTexts.add(hashedText);
+          if (hasEntry && oldEntry[hashedText] != null) {
+            // Entity text did not change, so we
+            // don't need to change it in the state
+            newEntry[hashedText] = oldEntry[hashedText];
+          } else {
+            // Here we have completely new text.
+            // We need add it to the `added` changes
+            newEntry[hashedText] = ast;
+            added.push({file: file.name, ast});
+          }
+        }
+
+        // Also, we need to delete all old entities
+        // that are not included in the new changes
+        if (hasEntry) {
+          for (const oldHashedText of Object.keys(oldEntry)) {
+            const ast = oldEntry[oldHashedText];
+            if (!newTexts.has(oldHashedText)) {
+              removed.push({file: file.name, ast});
+            }
+          }
+        }
+
+        // Finally, update the state with the changes
+        state[file.name] = {
+          nodes: newEntry,
+          // $FlowFixMe[incompatible-type]
+          sources: newSources,
+        };
+      } else {
+        // Otherwise, file has been removed or there are no entities in the file
+        if (hasEntry) {
+          // We will put all ASTNodes from current state to removed collection
+          for (const oldHashedText of Object.keys(oldEntry)) {
+            const ast = oldEntry[oldHashedText];
+            removed.push({file: file.name, ast});
+          }
+          delete state[file.name];
+        }
+      }
+    }
+
+    return {
+      // $FlowFixMe[incompatible-return]
+      changes: {added, removed},
+      sources: new Sources({
+        extractFromFile: this._extractFromFile,
+        state,
+      }),
+    };
+  }
+
+  *nodes(): Iterable<T> {
+    for (const file in this._state) {
+      const entry = this._state[file];
+      for (const node of Object.values(entry.nodes)) {
+        yield ((node: $FlowFixMe): T);
+      }
+    }
+  }
+
+  serializeState(): SavedStateCollection {
+    const serializedState = [];
+    for (const file in this._state) {
+      serializedState.push({
+        file,
+        sources: this._state[file].sources,
+      });
+    }
+    return serializedState;
+  }
+}
+
+module.exports = Sources;

package/runner/StrictMap.js.flow

@@ -0,0 +1,96 @@
+/**
+ * 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
+ * @emails oncall+relay
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+const invariant = require('invariant');
+
+export type {StrictMap};
+
+class StrictMap<K, V> {
+  _map: Map<K, V>;
+
+  constructor(iterable: ?Iterable<[K, V]>): StrictMap<K, V> {
+    this._map = new Map<K, V>(iterable);
+    return this;
+  }
+
+  clear(): void {
+    this._map.clear();
+  }
+
+  delete(key: K): boolean {
+    return this._map.delete(key);
+  }
+
+  entries(): Iterator<[K, V]> {
+    return this._map.entries();
+  }
+
+  forEach(
+    callbackfn: (value: V, index: K, map: Map<K, V>) => mixed,
+    thisArg?: mixed,
+  ): void {
+    this._map.forEach(callbackfn, thisArg);
+  }
+
+  map<V2>(
+    f: (value: V, index: K, map: StrictMap<K, V>) => V2,
+  ): StrictMap<K, V2> {
+    const result = new StrictMap();
+    for (const [key, val] of this._map) {
+      result.set(key, f(val, key, this));
+    }
+    return result;
+  }
+
+  async asyncMap<V2>(
+    f: (value: V, index: K, map: StrictMap<K, V>) => Promise<V2>,
+  ): Promise<StrictMap<K, V2>> {
+    const entryPromises: Array<Promise<[K, V2]>> = [];
+    for (const [key, val] of this._map) {
+      entryPromises.push(f(val, key, this).then(resultVal => [key, resultVal]));
+    }
+    const entries = await Promise.all(entryPromises);
+    return new StrictMap(entries);
+  }
+
+  get(key: K): V {
+    invariant(
+      this.has(key),
+      'StrictMap: trying to read non-existent key `%s`.',
+      String(key),
+    );
+    // $FlowFixMe[incompatible-return] - we checked the key exists
+    return this._map.get(key);
+  }
+
+  has(key: K): boolean {
+    return this._map.has(key);
+  }
+
+  keys(): Iterator<K> {
+    return this._map.keys();
+  }
+
+  set(key: K, value: V): StrictMap<K, V> {
+    this._map.set(key, value);
+    return this;
+  }
+
+  values(): Iterator<V> {
+    return this._map.values();
+  }
+}
+
+module.exports = StrictMap;

package/runner/compileArtifacts.js.flow

@@ -0,0 +1,76 @@
+/**
+ * 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 ASTConvert = require('../core/ASTConvert');
+const CompilerContext = require('../core/CompilerContext');
+const RelayParser = require('../core/RelayParser');
+
+const compileRelayArtifacts = require('../codegen/compileRelayArtifacts');
+
+import type {ExecutableDefinitionNode, ValidationContext} from 'graphql';
+import type {
+  GeneratedDefinition,
+  RelayCompilerTransforms,
+  Reporter,
+  Schema,
+  TypeGenerator,
+} from 'relay-compiler';
+import type {GeneratedNode} from 'relay-runtime';
+
+export type ValidationRule = (context: ValidationContext) => $FlowFixMe;
+
+function compileArtifacts({
+  schema,
+  compilerTransforms,
+  definitions: inputDefinitions,
+  reporter,
+  typeGenerator,
+}: {|
+  schema: Schema,
+  compilerTransforms: RelayCompilerTransforms,
+  definitions: $ReadOnlyArray<ExecutableDefinitionNode>,
+  reporter: Reporter,
+  typeGenerator: TypeGenerator,
+|}): {|
+  artifacts: $ReadOnlyArray<[GeneratedDefinition, GeneratedNode]>,
+  transformedTypeContext: CompilerContext,
+|} {
+  const definitions = ASTConvert.convertASTDocuments(
+    schema,
+    [
+      {
+        kind: 'Document',
+        definitions: inputDefinitions,
+      },
+    ],
+    RelayParser.transform,
+  );
+
+  const compilerContext = new CompilerContext(schema).addAll(definitions);
+  const transformedTypeContext = compilerContext.applyTransforms(
+    typeGenerator.transforms,
+    reporter,
+  );
+
+  return {
+    transformedTypeContext,
+    artifacts: compileRelayArtifacts(
+      compilerContext,
+      compilerTransforms,
+      reporter,
+    ),
+  };
+}
+
+module.exports = compileArtifacts;