relay-compiler 0.0.0-main-8ff54d69 → 0.0.0-main-38f1c96e

package/core/inferRootArgumentDefinitions.js.flow

@@ -1,322 +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 {
-  Argument,
-  ArgumentDefinition,
-  Condition,
-  Defer,
-  Fragment,
-  FragmentSpread,
-  LinkedField,
-  Root,
-  SplitOperation,
-  Stream,
-} from './IR';
-
-const CompilerContext = require('./CompilerContext');
-const {createCompilerError} = require('./CompilerError');
-const IRVisitor = require('./IRVisitor');
-const SchemaUtils = require('./SchemaUtils');
-
-type ArgumentMap = Map<string, ArgumentDefinition>;
-
-/**
- * Returns a transformed version of the input context where each document's
- * argument definitions are updated to accurately describe the root variables
- * used (or reachable) from that document:
- * - Fragment argument definitions are updated to include local argument
- *   definitions and any root variables that are referenced
- *   by the fragment (or any fragments it transitively spreads).
- * - Root argument definitions are updated to reflect the variables
- *   referenced locally and all root variables referenced by any
- *   fragments it (transitively) spreads.
- */
-function inferRootArgumentDefinitions(
-  context: CompilerContext,
-): CompilerContext {
-  // This transform does two main tasks:
-  // - Determine the set of root variables referenced locally in each
-  //   fragment. Note that RootArgumentDefinitions in the fragment's
-  //   argumentDefinitions can contain spurious entries for legacy
-  //   reasons. Instead of using those the fragment is traversed
-  //   to reanalyze variable usage.
-  // - Determine the set of root variables that are transitively referenced
-  //   by each fragment, ie the union of all root variables used in the
-  //   fragment and any fragments it transitively spreads.
-
-  // Cache fragments as they are transformed to avoid duplicate processing.
-  // Because @argument values don't matter (only variable names/types),
-  // each reachable fragment only has to be checked once.
-  const transformed = new Map<string, ArgumentMap>();
-  const nextContext = new CompilerContext(context.getSchema());
-  return nextContext.addAll(
-    Array.from(context.documents(), node => {
-      switch (node.kind) {
-        case 'Fragment': {
-          const argumentDefinitions = transformFragmentArguments(
-            context,
-            transformed,
-            node,
-          );
-          return ({
-            ...node,
-            argumentDefinitions: Array.from(argumentDefinitions.values()),
-          }: Fragment);
-        }
-        case 'Root': {
-          return transformRoot(context, transformed, node);
-        }
-        case 'SplitOperation': {
-          return (node: SplitOperation);
-        }
-        default: {
-          (node: empty);
-          throw createCompilerError(
-            `inferRootArgumentDefinitions: Unsupported kind '${node.kind}'.`,
-          );
-        }
-      }
-    }),
-  );
-}
-
-function transformRoot(
-  context: CompilerContext,
-  transformed: Map<string, ArgumentMap>,
-  root: Root,
-): Root {
-  // Ignore argument definitions, determine what root variables are
-  // transitively referenced
-  const argumentDefinitions = new Map();
-  const localArgumentDefinitions = new Map();
-  for (const [name, argDef] of root.argumentDefinitions.entries()) {
-    if (argDef.kind === 'LocalArgumentDefinition') {
-      localArgumentDefinitions.set(name, argDef);
-    }
-  }
-  visit(context, transformed, argumentDefinitions, root);
-  return {
-    ...root,
-    argumentDefinitions: Array.from(argumentDefinitions.values(), argDef => {
-      if (argDef.kind !== 'RootArgumentDefinition') {
-        throw createCompilerError(
-          `inferRootArgumentDefinitions: Expected inferred variable '\$${argDef.name}' to be a root variables.`,
-          [argDef.loc],
-        );
-      }
-      const localDefinition = localArgumentDefinitions.get(argDef.name);
-      const type = localDefinition?.type ?? argDef.type;
-      return {
-        defaultValue: localDefinition?.defaultValue ?? null,
-        kind: 'LocalArgumentDefinition',
-        loc: argDef.loc,
-        name: argDef.name,
-        type: type,
-      };
-    }),
-  };
-}
-
-function transformFragmentArguments(
-  context: CompilerContext,
-  transformed: Map<string, ArgumentMap>,
-  fragment: Fragment,
-): ArgumentMap {
-  const name = fragment.name;
-  const transformedArguments = transformed.get(name);
-  if (transformedArguments != null) {
-    return transformedArguments;
-  }
-  // Start with only the explicitly defined local arguments, recover the
-  // correct set of root variables excluding invalid @arguments values.
-  const argumentDefinitions: ArgumentMap = new Map();
-  fragment.argumentDefinitions.forEach(argDef => {
-    if (argDef.kind === 'LocalArgumentDefinition') {
-      argumentDefinitions.set(argDef.name, argDef);
-    }
-  });
-  // Break cycles by initially caching a version that only has local
-  // arguments. If the current fragment is reached again, it won't have
-  // any root variables to add to its parents. The traversal below will
-  // find any root variables and update the cached version of the
-  // fragment.
-  transformed.set(name, argumentDefinitions);
-  visit(context, transformed, argumentDefinitions, fragment);
-  transformed.set(name, argumentDefinitions);
-  return argumentDefinitions;
-}
-
-function visit(
-  context: CompilerContext,
-  transformed: Map<string, ArgumentMap>,
-  argumentDefinitions: ArgumentMap,
-  node: Fragment | Root,
-): void {
-  IRVisitor.visit(node, {
-    FragmentSpread(fragmentSpread: FragmentSpread) {
-      const fragment = context.getFragment(
-        fragmentSpread.name,
-        fragmentSpread.loc,
-      );
-      const referencedFragmentArguments = transformFragmentArguments(
-        context,
-        transformed,
-        fragment,
-      );
-      // Detect root variables being passed as the value of @arguments;
-      // recover the expected type from the corresponding argument definitions.
-      fragmentSpread.args.forEach(arg => {
-        const argDef = referencedFragmentArguments.get(arg.name);
-        if (
-          argDef != null &&
-          arg.value.kind === 'Variable' &&
-          !argumentDefinitions.has(arg.value.variableName)
-        ) {
-          argumentDefinitions.set(arg.value.variableName, {
-            kind: 'RootArgumentDefinition',
-            loc: {kind: 'Derived', source: arg.loc},
-            name: arg.value.variableName,
-            type: argDef.type,
-          });
-        }
-      });
-      // Merge any root variables referenced by the spread fragment
-      // into this (parent) fragment's arguments.
-      for (const argDef of referencedFragmentArguments.values()) {
-        if (argDef.kind === 'RootArgumentDefinition') {
-          argumentDefinitions.set(argDef.name, argDef);
-        }
-      }
-    },
-    Argument(argument: Argument) {
-      if (argument.value.kind === 'Literal') {
-        return false;
-      }
-      const values = [argument.value];
-      while (values.length > 0) {
-        const currentValue = values.pop();
-        if (currentValue.kind === 'Variable') {
-          const type = currentValue.type ?? argument.type;
-          if (type == null) {
-            continue;
-          }
-          if (!argumentDefinitions.has(currentValue.variableName)) {
-            // root variable
-            argumentDefinitions.set(currentValue.variableName, {
-              kind: 'RootArgumentDefinition',
-              loc: {kind: 'Derived', source: argument.loc},
-              name: currentValue.variableName,
-              type: type,
-            });
-          }
-        } else if (currentValue.kind === 'ObjectValue') {
-          currentValue.fields.forEach(fieldValue => {
-            if (fieldValue.value.kind !== 'Literal') {
-              values.push(fieldValue.value);
-            }
-          });
-        } else if (currentValue.kind === 'ListValue') {
-          currentValue.items.forEach(listValue => {
-            if (listValue.kind !== 'Literal') {
-              values.push(listValue);
-            }
-          });
-        }
-      }
-      return false;
-    },
-    Condition(condition: Condition) {
-      const variable = condition.condition;
-      if (variable.kind !== 'Variable') {
-        return;
-      }
-      const type =
-        variable.type ??
-        SchemaUtils.getNonNullBooleanInput(context.getSchema());
-      if (!argumentDefinitions.has(variable.variableName)) {
-        // root variable
-        argumentDefinitions.set(variable.variableName, {
-          kind: 'RootArgumentDefinition',
-          loc: {kind: 'Derived', source: variable.loc},
-          name: variable.variableName,
-          type: type,
-        });
-      }
-    },
-    Defer(defer: Defer) {
-      const variable = defer.if;
-      if (variable == null || variable.kind !== 'Variable') {
-        return;
-      }
-      const type =
-        variable.type ??
-        SchemaUtils.getNonNullBooleanInput(context.getSchema());
-      if (!argumentDefinitions.has(variable.variableName)) {
-        // root variable
-        argumentDefinitions.set(variable.variableName, {
-          kind: 'RootArgumentDefinition',
-          loc: {kind: 'Derived', source: variable.loc},
-          name: variable.variableName,
-          type: type,
-        });
-      }
-    },
-    Stream(stream: Stream) {
-      [stream.if, stream.initialCount].forEach(variable => {
-        if (variable == null || variable.kind !== 'Variable') {
-          return;
-        }
-
-        const type =
-          variable.type ??
-          SchemaUtils.getNonNullBooleanInput(context.getSchema());
-        if (!argumentDefinitions.has(variable.variableName)) {
-          // root variable
-          argumentDefinitions.set(variable.variableName, {
-            kind: 'RootArgumentDefinition',
-            loc: {kind: 'Derived', source: variable.loc},
-            name: variable.variableName,
-            type,
-          });
-        }
-      });
-    },
-    LinkedField(field: LinkedField) {
-      if (!field.handles) {
-        return;
-      }
-      field.handles.forEach(handle => {
-        const variable = handle.dynamicKey;
-        if (variable == null) {
-          return;
-        }
-        const type =
-          variable.type ??
-          SchemaUtils.getNullableStringInput(context.getSchema());
-        if (!argumentDefinitions.has(variable.variableName)) {
-          // root variable
-          argumentDefinitions.set(variable.variableName, {
-            kind: 'RootArgumentDefinition',
-            loc: {kind: 'Derived', source: variable.loc},
-            name: variable.variableName,
-            type: type,
-          });
-        }
-      });
-    },
-  });
-}
-
-module.exports = inferRootArgumentDefinitions;

package/index.js.flow

@@ -1,198 +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';
-
-const {main} = require('./bin/RelayCompilerMain');
-const CodegenDirectory = require('./codegen/CodegenDirectory');
-const CodegenRunner = require('./codegen/CodegenRunner');
-const CodegenWatcher = require('./codegen/CodegenWatcher');
-const compileRelayArtifacts = require('./codegen/compileRelayArtifacts');
-const RelayCodeGenerator = require('./codegen/RelayCodeGenerator');
-const RelayFileWriter = require('./codegen/RelayFileWriter');
-const {SourceControlMercurial} = require('./codegen/SourceControl');
-const writeRelayGeneratedFile = require('./codegen/writeRelayGeneratedFile');
-const ASTCache = require('./core/ASTCache');
-const ASTConvert = require('./core/ASTConvert');
-const CompilerContext = require('./core/CompilerContext');
-const CompilerError = require('./core/CompilerError');
-const DotGraphQLParser = require('./core/DotGraphQLParser');
-const filterContextForNode = require('./core/filterContextForNode');
-const getIdentifierForArgumentValue = require('./core/getIdentifierForArgumentValue');
-const getLiteralArgumentValues = require('./core/getLiteralArgumentValues');
-const getNormalizationOperationName = require('./core/getNormalizationOperationName');
-const GraphQLCompilerProfiler = require('./core/GraphQLCompilerProfiler');
-const {
-  getReaderSourceDefinitionName,
-} = require('./core/GraphQLDerivedFromMetadata');
-const GraphQLWatchmanClient = require('./core/GraphQLWatchmanClient');
-const IRPrinter = require('./core/IRPrinter');
-const IRTransformer = require('./core/IRTransformer');
-const IRVisitor = require('./core/IRVisitor');
-const JSModuleParser = require('./core/JSModuleParser');
-const RelayFindGraphQLTags = require('./core/RelayFindGraphQLTags');
-const RelayIRTransforms = require('./core/RelayIRTransforms');
-const RelayParser = require('./core/RelayParser');
-const RelaySchema = require('./core/Schema');
-const SchemaUtils = require('./core/SchemaUtils');
-const FindGraphQLTags = require('./language/javascript/FindGraphQLTags');
-const {
-  formatGeneratedCommonjsModule: formatGeneratedModule,
-} = require('./language/javascript/formatGeneratedModule');
-const RelayFlowGenerator = require('./language/javascript/RelayFlowGenerator');
-const ConsoleReporter = require('./reporters/ConsoleReporter');
-const MultiReporter = require('./reporters/MultiReporter');
-const Artifacts = require('./runner/Artifacts');
-const BufferedFilesystem = require('./runner/BufferedFilesystem');
-const compileArtifacts = require('./runner/compileArtifacts');
-const extractAST = require('./runner/extractAST');
-const getChangedNodeNames = require('./runner/getChangedNodeNames');
-const getSchemaInstance = require('./runner/getSchemaInstance');
-const GraphQLASTNodeGroup = require('./runner/GraphQLASTNodeGroup');
-const GraphQLASTUtils = require('./runner/GraphQLASTUtils');
-const GraphQLNodeMap = require('./runner/GraphQLNodeMap');
-const Sources = require('./runner/Sources');
-const StrictMap = require('./runner/StrictMap');
-const CodeMarker = require('./util/CodeMarker');
-const getDefinitionNodeHash = require('./util/getDefinitionNodeHash');
-const md5 = require('./util/md5');
-const Rollout = require('./util/Rollout');
-const TimeReporter = require('./util/TimeReporter');
-
-export type {Filesystem} from './codegen/CodegenDirectory';
-export type {
-  WriteFiles,
-  WriteFilesOptions,
-  ParserConfig,
-  WriterConfig,
-} from './codegen/CodegenRunner';
-export type {CompileResult, File} from './codegen/CodegenTypes';
-export type {FileFilter, WatchmanExpression} from './codegen/CodegenWatcher';
-export type {SourceControl} from './codegen/SourceControl';
-export type {RelayCompilerTransforms} from './codegen/compileRelayArtifacts';
-export type {IRTransform} from './core/CompilerContext';
-export type {
-  Argument,
-  ArgumentDefinition,
-  ArgumentValue,
-  Condition,
-  Definition,
-  Directive,
-  Field,
-  Fragment,
-  FragmentSpread,
-  GeneratedDefinition,
-  Handle,
-  InlineFragment,
-  IR,
-  LinkedField,
-  ListValue,
-  Literal,
-  LocalArgumentDefinition,
-  ModuleImport,
-  Metadata,
-  Node,
-  ObjectFieldValue,
-  ObjectValue,
-  Request,
-  Root,
-  RootArgumentDefinition,
-  ScalarField,
-  Selection,
-  SplitOperation,
-  Variable,
-} from './core/IR';
-export type {Schema, TypeID, FieldID} from './core/Schema';
-export type {
-  FormatModule,
-  TypeGenerator,
-} from './language/RelayLanguagePluginInterface';
-export type {Reporter} from './reporters/Reporter';
-export type {
-  ArtifactMap,
-  ArtifactState,
-  SerializedArtifactState,
-} from './runner/Artifacts';
-export type {NodeGroup} from './runner/GraphQLASTNodeGroup';
-export type {SourceChanges} from './runner/Sources';
-export type {StrictMap} from './runner/StrictMap';
-export type {ExtractFn} from './runner/extractAST';
-export type {SavedStateCollection, WatchmanFile} from './runner/types';
-export type {FlattenOptions} from './transforms/FlattenTransform';
-
-module.exports = {
-  relayCompiler: main,
-
-  ASTConvert,
-  CodegenDirectory,
-  CodegenRunner,
-  CodegenWatcher,
-  CodeMarker,
-  CompilerContext,
-  CompilerError,
-  ConsoleReporter,
-  DotGraphQLParser,
-  ASTCache,
-  IRTransformer,
-  IRVisitor,
-  Printer: IRPrinter,
-  Profiler: GraphQLCompilerProfiler,
-  Rollout,
-  SchemaUtils,
-  SourceControlMercurial,
-  WatchmanClient: GraphQLWatchmanClient,
-
-  filterContextForNode,
-  getIdentifierForArgumentValue,
-  getNormalizationOperationName,
-  getLiteralArgumentValues,
-
-  Parser: RelayParser,
-  Schema: RelaySchema,
-  CodeGenerator: RelayCodeGenerator,
-  FlowGenerator: RelayFlowGenerator,
-
-  FileWriter: RelayFileWriter,
-  IRTransforms: RelayIRTransforms,
-  JSModuleParser,
-  MultiReporter,
-  Runner: CodegenRunner,
-  TimeReporter,
-  compileRelayArtifacts,
-  formatGeneratedModule,
-  convertASTDocuments: ASTConvert.convertASTDocuments,
-  transformASTSchema: ASTConvert.transformASTSchema,
-
-  getReaderSourceDefinitionName,
-
-  writeRelayGeneratedFile,
-
-  Sources,
-  __internal: {
-    Artifacts,
-    BufferedFilesystem,
-    GraphQLASTNodeGroup,
-    GraphQLASTUtils,
-    GraphQLNodeMap,
-    FindGraphQLTags,
-    StrictMap,
-    RelayFindGraphQLTags,
-    compileArtifacts,
-    extractFromJS: extractAST.extractFromJS,
-    getChangedNodeNames,
-    getDefinitionNodeHash,
-    getSchemaInstance,
-    md5,
-    parseExecutableNode: extractAST.parseExecutableNode,
-    toASTRecord: extractAST.toASTRecord,
-  },
-};