@ardatan/relay-compiler 12.0.0

package/lib/core/inferRootArgumentDefinitions.js

@@ -0,0 +1,351 @@
+/**
+ * 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
+ */
+// flowlint ambiguous-object-type:error
+'use strict';
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _createForOfIteratorHelper2 = _interopRequireDefault(require("@babel/runtime/helpers/createForOfIteratorHelper"));
+
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+
+var CompilerContext = require('./CompilerContext');
+
+var IRVisitor = require('./IRVisitor');
+
+var SchemaUtils = require('./SchemaUtils');
+
+var _require = require('./CompilerError'),
+    createCompilerError = _require.createCompilerError;
+
+/**
+ * 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) {
+  // 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.
+  var transformed = new Map();
+  var nextContext = new CompilerContext(context.getSchema());
+  return nextContext.addAll(Array.from(context.documents(), function (node) {
+    switch (node.kind) {
+      case 'Fragment':
+        {
+          var argumentDefinitions = transformFragmentArguments(context, transformed, node);
+          return (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, node), {}, {
+            argumentDefinitions: Array.from(argumentDefinitions.values())
+          });
+        }
+
+      case 'Root':
+        {
+          return transformRoot(context, transformed, node);
+        }
+
+      case 'SplitOperation':
+        {
+          return node;
+        }
+
+      default:
+        {
+          node;
+          throw createCompilerError("inferRootArgumentDefinitions: Unsupported kind '".concat(node.kind, "'."));
+        }
+    }
+  }));
+}
+
+function transformRoot(context, transformed, root) {
+  // Ignore argument definitions, determine what root variables are
+  // transitively referenced
+  var argumentDefinitions = new Map();
+  var localArgumentDefinitions = new Map();
+
+  var _iterator = (0, _createForOfIteratorHelper2["default"])(root.argumentDefinitions.entries()),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var _step$value = _step.value,
+          name = _step$value[0],
+          argDef = _step$value[1];
+
+      if (argDef.kind === 'LocalArgumentDefinition') {
+        localArgumentDefinitions.set(name, argDef);
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+
+  visit(context, transformed, argumentDefinitions, root);
+  return (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, root), {}, {
+    argumentDefinitions: Array.from(argumentDefinitions.values(), function (argDef) {
+      var _localDefinition$type, _localDefinition$defa;
+
+      if (argDef.kind !== 'RootArgumentDefinition') {
+        throw createCompilerError("inferRootArgumentDefinitions: Expected inferred variable '$".concat(argDef.name, "' to be a root variables."), [argDef.loc]);
+      }
+
+      var localDefinition = localArgumentDefinitions.get(argDef.name);
+      var type = (_localDefinition$type = localDefinition === null || localDefinition === void 0 ? void 0 : localDefinition.type) !== null && _localDefinition$type !== void 0 ? _localDefinition$type : argDef.type;
+      return {
+        defaultValue: (_localDefinition$defa = localDefinition === null || localDefinition === void 0 ? void 0 : localDefinition.defaultValue) !== null && _localDefinition$defa !== void 0 ? _localDefinition$defa : null,
+        kind: 'LocalArgumentDefinition',
+        loc: argDef.loc,
+        name: argDef.name,
+        type: type
+      };
+    })
+  });
+}
+
+function transformFragmentArguments(context, transformed, fragment) {
+  var name = fragment.name;
+  var 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.
+
+
+  var argumentDefinitions = new Map();
+  fragment.argumentDefinitions.forEach(function (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, transformed, argumentDefinitions, node) {
+  IRVisitor.visit(node, {
+    FragmentSpread: function FragmentSpread(fragmentSpread) {
+      var fragment = context.getFragment(fragmentSpread.name, fragmentSpread.loc);
+      var 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(function (arg) {
+        var 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.
+
+      var _iterator2 = (0, _createForOfIteratorHelper2["default"])(referencedFragmentArguments.values()),
+          _step2;
+
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var argDef = _step2.value;
+
+          if (argDef.kind === 'RootArgumentDefinition') {
+            argumentDefinitions.set(argDef.name, argDef);
+          }
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+    },
+    Argument: function Argument(argument) {
+      if (argument.value.kind === 'Literal') {
+        return false;
+      }
+
+      var values = [argument.value];
+
+      while (values.length > 0) {
+        var currentValue = values.pop();
+
+        if (currentValue.kind === 'Variable') {
+          var _currentValue$type;
+
+          var type = (_currentValue$type = currentValue.type) !== null && _currentValue$type !== void 0 ? _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(function (fieldValue) {
+            if (fieldValue.value.kind !== 'Literal') {
+              values.push(fieldValue.value);
+            }
+          });
+        } else if (currentValue.kind === 'ListValue') {
+          currentValue.items.forEach(function (listValue) {
+            if (listValue.kind !== 'Literal') {
+              values.push(listValue);
+            }
+          });
+        }
+      }
+
+      return false;
+    },
+    Condition: function Condition(condition) {
+      var _variable$type;
+
+      var variable = condition.condition;
+
+      if (variable.kind !== 'Variable') {
+        return;
+      }
+
+      var type = (_variable$type = variable.type) !== null && _variable$type !== void 0 ? _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: function Defer(defer) {
+      var _variable$type2;
+
+      var variable = defer["if"];
+
+      if (variable == null || variable.kind !== 'Variable') {
+        return;
+      }
+
+      var type = (_variable$type2 = variable.type) !== null && _variable$type2 !== void 0 ? _variable$type2 : 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: function Stream(stream) {
+      [stream["if"], stream.initialCount].forEach(function (variable) {
+        var _variable$type3;
+
+        if (variable == null || variable.kind !== 'Variable') {
+          return;
+        }
+
+        var type = (_variable$type3 = variable.type) !== null && _variable$type3 !== void 0 ? _variable$type3 : 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
+          });
+        }
+      });
+    },
+    LinkedField: function LinkedField(field) {
+      if (!field.handles) {
+        return;
+      }
+
+      field.handles.forEach(function (handle) {
+        var _variable$type4;
+
+        var variable = handle.dynamicKey;
+
+        if (variable == null) {
+          return;
+        }
+
+        var type = (_variable$type4 = variable.type) !== null && _variable$type4 !== void 0 ? _variable$type4 : 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/lib/index.js

@@ -0,0 +1,178 @@
+/**
+ * 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
+ */
+// flowlint ambiguous-object-type:error
+'use strict';
+
+var ASTCache = require('./core/ASTCache');
+
+var ASTConvert = require('./core/ASTConvert');
+
+var Artifacts = require('./runner/Artifacts');
+
+var BufferedFilesystem = require('./runner/BufferedFilesystem');
+
+var CodeMarker = require('./util/CodeMarker');
+
+var CodegenDirectory = require('./codegen/CodegenDirectory');
+
+var CodegenRunner = require('./codegen/CodegenRunner');
+
+var CodegenWatcher = require('./codegen/CodegenWatcher');
+
+var CompilerContext = require('./core/CompilerContext');
+
+var CompilerError = require('./core/CompilerError');
+
+var ConsoleReporter = require('./reporters/ConsoleReporter');
+
+var DotGraphQLParser = require('./core/DotGraphQLParser');
+
+var FindGraphQLTags = require('./language/javascript/FindGraphQLTags');
+
+var GraphQLASTNodeGroup = require('./runner/GraphQLASTNodeGroup');
+
+var GraphQLASTUtils = require('./runner/GraphQLASTUtils');
+
+var GraphQLCompilerProfiler = require('./core/GraphQLCompilerProfiler');
+
+var GraphQLNodeMap = require('./runner/GraphQLNodeMap');
+
+var GraphQLWatchmanClient = require('./core/GraphQLWatchmanClient');
+
+var IRPrinter = require('./core/IRPrinter');
+
+var IRTransformer = require('./core/IRTransformer');
+
+var IRVisitor = require('./core/IRVisitor');
+
+var JSModuleParser = require('./core/JSModuleParser');
+
+var MultiReporter = require('./reporters/MultiReporter');
+
+var RelayCodeGenerator = require('./codegen/RelayCodeGenerator');
+
+var RelayFileWriter = require('./codegen/RelayFileWriter');
+
+var RelayFindGraphQLTags = require('./core/RelayFindGraphQLTags');
+
+var RelayFlowGenerator = require('./language/javascript/RelayFlowGenerator');
+
+var RelayIRTransforms = require('./core/RelayIRTransforms');
+
+var RelayParser = require('./core/RelayParser');
+
+var RelaySchema = require('./core/Schema');
+
+var Rollout = require('./util/Rollout');
+
+var SchemaUtils = require('./core/SchemaUtils');
+
+var Sources = require('./runner/Sources');
+
+var StrictMap = require('./runner/StrictMap');
+
+var TimeReporter = require('./util/TimeReporter');
+
+var compileArtifacts = require('./runner/compileArtifacts');
+
+var compileRelayArtifacts = require('./codegen/compileRelayArtifacts');
+
+var extractAST = require('./runner/extractAST');
+
+var filterContextForNode = require('./core/filterContextForNode');
+
+var getChangedNodeNames = require('./runner/getChangedNodeNames');
+
+var getDefinitionNodeHash = require('./util/getDefinitionNodeHash');
+
+var getIdentifierForArgumentValue = require('./core/getIdentifierForArgumentValue');
+
+var getLiteralArgumentValues = require('./core/getLiteralArgumentValues');
+
+var getNormalizationOperationName = require('./core/getNormalizationOperationName');
+
+var getSchemaInstance = require('./runner/getSchemaInstance');
+
+var md5 = require('./util/md5');
+
+var writeRelayGeneratedFile = require('./codegen/writeRelayGeneratedFile');
+
+var _require = require('./bin/RelayCompilerMain'),
+    main = _require.main;
+
+var _require2 = require('./codegen/SourceControl'),
+    SourceControlMercurial = _require2.SourceControlMercurial;
+
+var _require3 = require('./core/GraphQLDerivedFromMetadata'),
+    getReaderSourceDefinitionName = _require3.getReaderSourceDefinitionName;
+
+var _require4 = require('./language/javascript/formatGeneratedModule'),
+    formatGeneratedModule = _require4.formatGeneratedCommonjsModule;
+
+module.exports = {
+  relayCompiler: main,
+  ASTConvert: ASTConvert,
+  CodegenDirectory: CodegenDirectory,
+  CodegenRunner: CodegenRunner,
+  CodegenWatcher: CodegenWatcher,
+  CodeMarker: CodeMarker,
+  CompilerContext: CompilerContext,
+  CompilerError: CompilerError,
+  ConsoleReporter: ConsoleReporter,
+  DotGraphQLParser: DotGraphQLParser,
+  ASTCache: ASTCache,
+  IRTransformer: IRTransformer,
+  IRVisitor: IRVisitor,
+  Printer: IRPrinter,
+  Profiler: GraphQLCompilerProfiler,
+  Rollout: Rollout,
+  SchemaUtils: SchemaUtils,
+  SourceControlMercurial: SourceControlMercurial,
+  WatchmanClient: GraphQLWatchmanClient,
+  filterContextForNode: filterContextForNode,
+  getIdentifierForArgumentValue: getIdentifierForArgumentValue,
+  getNormalizationOperationName: getNormalizationOperationName,
+  getLiteralArgumentValues: getLiteralArgumentValues,
+  Parser: RelayParser,
+  Schema: RelaySchema,
+  CodeGenerator: RelayCodeGenerator,
+  FlowGenerator: RelayFlowGenerator,
+  FileWriter: RelayFileWriter,
+  IRTransforms: RelayIRTransforms,
+  JSModuleParser: JSModuleParser,
+  MultiReporter: MultiReporter,
+  Runner: CodegenRunner,
+  TimeReporter: TimeReporter,
+  compileRelayArtifacts: compileRelayArtifacts,
+  formatGeneratedModule: formatGeneratedModule,
+  convertASTDocuments: ASTConvert.convertASTDocuments,
+  transformASTSchema: ASTConvert.transformASTSchema,
+  getReaderSourceDefinitionName: getReaderSourceDefinitionName,
+  writeRelayGeneratedFile: writeRelayGeneratedFile,
+  Sources: Sources,
+  __internal: {
+    Artifacts: Artifacts,
+    BufferedFilesystem: BufferedFilesystem,
+    GraphQLASTNodeGroup: GraphQLASTNodeGroup,
+    GraphQLASTUtils: GraphQLASTUtils,
+    GraphQLNodeMap: GraphQLNodeMap,
+    FindGraphQLTags: FindGraphQLTags,
+    StrictMap: StrictMap,
+    RelayFindGraphQLTags: RelayFindGraphQLTags,
+    compileArtifacts: compileArtifacts,
+    extractFromJS: extractAST.extractFromJS,
+    getChangedNodeNames: getChangedNodeNames,
+    getDefinitionNodeHash: getDefinitionNodeHash,
+    getSchemaInstance: getSchemaInstance,
+    md5: md5,
+    parseExecutableNode: extractAST.parseExecutableNode,
+    toASTRecord: extractAST.toASTRecord
+  }
+};

package/lib/language/RelayLanguagePluginInterface.js

@@ -0,0 +1,14 @@
+/**
+ * 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
+ */
+// flowlint ambiguous-object-type:error
+'use strict';
+
+var _require = require('relay-runtime'),
+    RelayConcreteNode = _require.RelayConcreteNode;

package/lib/language/javascript/FindGraphQLTags.js

@@ -0,0 +1,126 @@
+/**
+ * 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
+ */
+// flowlint ambiguous-object-type:error
+'use strict';
+
+var Profiler = require('../../core/GraphQLCompilerProfiler');
+
+var babylon = require('@babel/parser');
+
+var util = require('util');
+
+// Attempt to be as inclusive as possible of source text.
+var BABYLON_OPTIONS = {
+  allowImportExportEverywhere: true,
+  allowReturnOutsideFunction: true,
+  allowSuperOutsideMethod: true,
+  sourceType: 'module',
+  plugins: ['asyncGenerators', 'classProperties', ['decorators', {
+    decoratorsBeforeExport: true
+  }], 'doExpressions', 'dynamicImport', 'exportExtensions', ['flow', {
+    enums: true
+  }], 'functionBind', 'functionSent', 'jsx', 'nullishCoalescingOperator', 'objectRestSpread', 'optionalChaining', 'optionalCatchBinding'],
+  strictMode: false
+};
+
+function find(text) {
+  var result = []; // $FlowFixMe Discovered when typing babel/parser
+
+  var ast = babylon.parse(text, BABYLON_OPTIONS);
+  var visitors = {
+    TaggedTemplateExpression: function TaggedTemplateExpression(node) {
+      if (isGraphQLTag(node.tag)) {
+        result.push({
+          keyName: null,
+          template: node.quasi.quasis[0].value.raw,
+          sourceLocationOffset: getSourceLocationOffset(node.quasi)
+        });
+      }
+    }
+  };
+  visit(ast, visitors);
+  return result;
+}
+
+var IGNORED_KEYS = {
+  comments: true,
+  end: true,
+  leadingComments: true,
+  loc: true,
+  name: true,
+  start: true,
+  trailingComments: true,
+  type: true
+};
+
+function isGraphQLTag(tag) {
+  return tag.type === 'Identifier' && tag.name === 'graphql';
+}
+
+function getTemplateNode(quasi) {
+  var quasis = quasi.quasis;
+  !(quasis && quasis.length === 1) ? process.env.NODE_ENV !== "production" ? invariant(false, 'FindGraphQLTags: Substitutions are not allowed in graphql tags.') : invariant(false) : void 0;
+  return quasis[0];
+}
+
+function getSourceLocationOffset(quasi) {
+  var loc = getTemplateNode(quasi).loc.start;
+  return {
+    line: loc.line,
+    column: loc.column + 1 // babylon is 0-indexed, graphql expects 1-indexed
+
+  };
+}
+
+function invariant(condition, msg) {
+  if (!condition) {
+    for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+      args[_key - 2] = arguments[_key];
+    }
+
+    throw new Error(util.format.apply(util, [msg].concat(args)));
+  }
+}
+
+function visit(node, visitors) {
+  // $FlowFixMe Discovered when typing babel
+  var fn = visitors[node.type];
+
+  if (fn != null) {
+    fn(node);
+    return;
+  }
+
+  traverse(node, visitors);
+}
+
+function traverse(node, visitors) {
+  for (var key in node) {
+    if (IGNORED_KEYS[key]) {
+      continue;
+    }
+
+    var prop = node[key];
+
+    if (prop && typeof prop === 'object' && typeof prop.type === 'string') {
+      visit(prop, visitors);
+    } else if (Array.isArray(prop)) {
+      prop.forEach(function (item) {
+        if (item && typeof item === 'object' && typeof item.type === 'string') {
+          visit(item, visitors);
+        }
+      });
+    }
+  }
+}
+
+module.exports = {
+  find: Profiler.instrument(find, 'FindGraphQLTags.find')
+};