relay-compiler 0.0.0-main-8ff54d69 → 0.0.0-main-4467ae84

package/runner/GraphQLASTNodeGroup.js.flow

@@ -1,174 +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.
- *
- * @format
- * @flow strict-local
- */
-
-// flowlint ambiguous-object-type:error
-
-'use strict';
-
-import type {ExecutableDefinitionNode} from 'graphql';
-
-const {getName} = require('./GraphQLASTUtils');
-const GraphQLNodeMap = require('./GraphQLNodeMap');
-const {visit} = require('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

@@ -1,26 +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.
- *
- * @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

@@ -1,55 +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.
- *
- * @format
- * @flow strict-local
- */
-
-// flowlint ambiguous-object-type:error
-
-'use strict';
-
-import type {ExecutableDefinitionNode} from 'graphql';
-import type {Sources} from 'relay-compiler';
-
-const {createCompilerError, createUserError} = require('../core/CompilerError');
-const {getName} = require('./GraphQLASTUtils');
-
-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

@@ -1,227 +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.
- *
- * @format
- * @flow strict-local
- * @emails oncall+relay
- */
-
-// flowlint ambiguous-object-type:error
-
-'use strict';
-
-import type {ASTRecord} from './extractAST';
-import type {SavedStateCollection, WatchmanFile} from './types';
-import type {ASTNode} from 'graphql';
-
-const md5 = require('../util/md5');
-const {toASTRecord} = require('./extractAST');
-const {Source, parse} = require('graphql');
-const invariant = require('invariant');
-
-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);
-          if (newTexts.has(hashedText)) {
-            let name = 'unknown';
-            switch (ast.kind) {
-              case 'FragmentDefinition':
-                name = ast.name.value;
-                break;
-              case 'OperationDefinition':
-                name = ast.name?.value ?? 'unnamed operation';
-                break;
-            }
-            throw new Error(
-              `Duplicate definition of \`${name}\` in \`${file.name}\``,
-            );
-          }
-          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

@@ -1,96 +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
- * @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

@@ -1,75 +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 {ExecutableDefinitionNode, ValidationContext} from 'graphql';
-import type {
-  GeneratedDefinition,
-  RelayCompilerTransforms,
-  Reporter,
-  Schema,
-  TypeGenerator,
-} from 'relay-compiler';
-import type {GeneratedNode} from 'relay-runtime';
-
-const compileRelayArtifacts = require('../codegen/compileRelayArtifacts');
-const ASTConvert = require('../core/ASTConvert');
-const CompilerContext = require('../core/CompilerContext');
-const RelayParser = require('../core/RelayParser');
-
-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;