@ardatan/relay-compiler 12.0.0

package/lib/core/RelayCompilerScope.js

@@ -0,0 +1,149 @@
+/**
+ * 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('./CompilerError'),
+    createUserError = _require.createUserError,
+    eachWithCombinedError = _require.eachWithCombinedError;
+
+/**
+ * Creates a scope for a `Root`, with each argument mapped to a variable of the
+ * same name. Example:
+ *
+ * Query:
+ * query Foo($id: ID, $size: Int = 42) { ... }
+ *
+ * Scope:
+ * {
+ *   id: $id,
+ *   size: $size,
+ * }
+ *
+ * Note that even though a default value is defined for $size, the scope must
+ * assume that this could be overridden at runtime. The value cannot be decided
+ * statically and therefore is set to a variable.
+ */
+function getRootScope(definitions) {
+  var scope = {};
+  definitions.forEach(function (definition) {
+    scope[definition.name] = {
+      kind: 'Variable',
+      loc: definition.loc,
+      variableName: definition.name,
+      type: definition.type
+    };
+  });
+  return scope;
+}
+/**
+ * Creates a scope for a `Fragment` by translating fragment spread arguments in
+ * the context of a parent scope into a new scope and validating them against
+ * the argument definitions.
+ *
+ *
+ * Parent Scope:
+ * {
+ *   active: $parentActive
+ * }
+ *
+ * Fragment Spread:
+ * ...Bar(size: 42, enabled: $active)
+ *
+ * Fragment:
+ * fragment Bar on Foo @argumentDefinitions(
+ *   id: {type: "ID"}
+ *   size: {type: "Int"}
+ *   enabled: {type: "Boolean}
+ *   scale: {type: "Int", imports: "pixelRatio"}
+ * )
+ *
+ * Scope:
+ * {
+ *   // No argument is provided for $id, it gets the default value which in this
+ *   // case is `null`:
+ *   id: null,
+ *
+ *   // The parent passes 42 as a literal value for $size:
+ *   size: 42,
+ *
+ *   // The parent passes a variable as the value of $enabled. This variable is
+ *   // resolved in the parent scope to the value $parentActive, which becomes
+ *   // the value of $enabled:
+ *   $enabled: $parentActive,
+ *
+ *   // $scale imports pixelRatio from the root scope. Since any argument in a
+ *   // root scope maps to a variable of the same name, that means the value of
+ *   // pixelRatio in the root is $pixelRatio:
+ *   $scale: $pixelRatio,
+ * }
+ */
+
+
+function getFragmentScope(schema, definitions, args, parentScope, spread) {
+  var argMap = new Map();
+  args.forEach(function (arg) {
+    if (arg.value.kind === 'Literal') {
+      argMap.set(arg.name, arg.value);
+    } else if (arg.value.kind === 'Variable') {
+      argMap.set(arg.name, parentScope[arg.value.variableName]);
+    }
+  });
+  var fragmentScope = {};
+  eachWithCombinedError(definitions, function (definition) {
+    if (definition.kind === 'RootArgumentDefinition') {
+      if (argMap.has(definition.name)) {
+        var _argNode$loc;
+
+        var argNode = args.find(function (a) {
+          return a.name === definition.name;
+        });
+        throw createUserError("Unexpected argument '".concat(definition.name, "' supplied to fragment '").concat(spread.name, "'. @arguments may only be provided for variables defined in the fragment's @argumentDefinitions."), [(_argNode$loc = argNode === null || argNode === void 0 ? void 0 : argNode.loc) !== null && _argNode$loc !== void 0 ? _argNode$loc : spread.loc]);
+      }
+
+      fragmentScope[definition.name] = {
+        kind: 'Variable',
+        loc: definition.loc,
+        variableName: definition.name,
+        type: definition.type
+      };
+    } else {
+      var arg = argMap.get(definition.name);
+
+      if (arg == null || arg.kind === 'Literal' && arg.value == null) {
+        // No variable or literal null was passed, fall back to default
+        // value.
+        if (definition.defaultValue == null && schema.isNonNull(definition.type)) {
+          var _argNode$loc2;
+
+          var _argNode = args.find(function (a) {
+            return a.name === definition.name;
+          });
+
+          throw createUserError("No value found for required argument '".concat(definition.name, ": ").concat(schema.getTypeString(definition.type), "' on fragment '").concat(spread.name, "'."), [(_argNode$loc2 = _argNode === null || _argNode === void 0 ? void 0 : _argNode.loc) !== null && _argNode$loc2 !== void 0 ? _argNode$loc2 : spread.loc]);
+        }
+
+        fragmentScope[definition.name] = {
+          kind: 'Literal',
+          value: definition.defaultValue
+        };
+      } else {
+        // Variable or non-null literal.
+        fragmentScope[definition.name] = arg;
+      }
+    }
+  });
+  return fragmentScope;
+}
+
+module.exports = {
+  getFragmentScope: getFragmentScope,
+  getRootScope: getRootScope
+};

package/lib/core/RelayFindGraphQLTags.js

@@ -0,0 +1,79 @@
+/**
+ * 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 RelayCompilerCache = require('../util/RelayCompilerCache');
+
+var getModuleName = require('../util/getModuleName');
+
+var graphql = require('graphql');
+
+var path = require('path');
+
+var util = require('util');
+
+var cache = new RelayCompilerCache('RelayFindGraphQLTags', 'v1');
+
+function memoizedFind(tagFinder, text, baseDir, file) {
+  !file.exists ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayFindGraphQLTags: Called with non-existent file `%s`', file.relPath) : invariant(false) : void 0;
+  return cache.getOrCompute(file.hash, find.bind(null, tagFinder, text, path.join(baseDir, file.relPath)));
+}
+
+function find(tagFinder, text, absPath) {
+  var tags = tagFinder(text, absPath);
+  var moduleName = getModuleName(absPath);
+  tags.forEach(function (tag) {
+    return validateTemplate(tag, moduleName, absPath);
+  });
+  return tags.map(function (tag) {
+    return tag.template;
+  });
+}
+
+function validateTemplate(_ref, moduleName, filePath) {
+  var template = _ref.template,
+      keyName = _ref.keyName,
+      sourceLocationOffset = _ref.sourceLocationOffset;
+  var ast = graphql.parse(new graphql.Source(template, filePath, sourceLocationOffset));
+  ast.definitions.forEach(function (def) {
+    if (def.kind === 'OperationDefinition') {
+      !(def.name != null) ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayFindGraphQLTags: In module `%s`, an operation requires a name.', moduleName, def.kind) : invariant(false) : void 0;
+      var definitionName = def.name.value;
+      var operationNameParts = definitionName.match(/^(.*)(Mutation|Query|Subscription)$/);
+      !(operationNameParts && definitionName.startsWith(moduleName)) ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayFindGraphQLTags: Operation names in graphql tags must be prefixed ' + 'with the module name and end in "Mutation", "Query", or ' + '"Subscription". Got `%s` in module `%s`.', definitionName, moduleName) : invariant(false) : void 0;
+    } else if (def.kind === 'FragmentDefinition') {
+      var _definitionName = def.name.value;
+
+      if (keyName != null) {
+        !(_definitionName === moduleName + '_' + keyName) ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayFindGraphQLTags: Container fragment names must be ' + '`<ModuleName>_<propName>`. Got `%s`, expected `%s`.', _definitionName, moduleName + '_' + keyName) : invariant(false) : void 0;
+      } else {
+        !_definitionName.startsWith(moduleName) ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayFindGraphQLTags: Fragment names in graphql tags must be prefixed ' + 'with the module name. Got `%s` in module `%s`.', _definitionName, moduleName) : invariant(false) : void 0;
+      }
+    }
+  });
+} // TODO: Not sure why this is defined here rather than imported, is it so that it doesn’t get stripped in prod?
+
+
+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)));
+  }
+}
+
+module.exports = {
+  find: find,
+  // Exported for testing only.
+  memoizedFind: memoizedFind
+};

package/lib/core/RelayGraphQLEnumsGenerator.js

@@ -0,0 +1,50 @@
+/**
+ * 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 _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var SignedSource = require('signedsource');
+
+function writeForSchema(schema, licenseHeader, codegenDir, getModuleName) {
+  var header = '/**\n' + licenseHeader.map(function (line) {
+    return " * ".concat(line, "\n");
+  }).join('') + ' *\n' + " * ".concat(SignedSource.getSigningToken(), "\n") + ' * @flow strict\n' + ' */\n' + '\n';
+  var enumTypes = schema.getTypes().filter(function (type) {
+    return schema.isEnum(type);
+  });
+
+  var _iterator = (0, _createForOfIteratorHelper2["default"])(enumTypes),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var type = _step.value;
+      var enumType = schema.assertEnumType(type);
+      var name = schema.getTypeString(type);
+      var values = (0, _toConsumableArray2["default"])(schema.getEnumValues(enumType)).sort();
+      var enumFileContent = header + "export type ".concat(name, " =\n  | '") + values.join("'\n  | '") + "'\n  | '%future added value';\n";
+      codegenDir.writeFile("".concat(getModuleName(name), ".js"), SignedSource.signFile(enumFileContent));
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+}
+
+module.exports = {
+  writeForSchema: writeForSchema
+};

package/lib/core/RelayIRTransforms.js

@@ -0,0 +1,109 @@
+/**
+ * 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 ApplyFragmentArgumentTransform = require('../transforms/ApplyFragmentArgumentTransform');
+
+var ClientExtensionsTransform = require('../transforms/ClientExtensionsTransform');
+
+var ConnectionTransform = require('../transforms/ConnectionTransform');
+
+var DeclarativeConnectionMutationTransform = require('../transforms/DeclarativeConnectionMutationTransform');
+
+var DeferStreamTransform = require('../transforms/DeferStreamTransform');
+
+var DisallowIdAsAlias = require('../transforms/DisallowIdAsAlias');
+
+var DisallowTypenameOnRoot = require('../transforms/DisallowTypenameOnRoot');
+
+var FieldHandleTransform = require('../transforms/FieldHandleTransform');
+
+var FilterCompilerDirectivesTransform = require('../transforms/FilterCompilerDirectivesTransform');
+
+var FilterDirectivesTransform = require('../transforms/FilterDirectivesTransform');
+
+var FlattenTransform = require('../transforms/FlattenTransform');
+
+var GenerateIDFieldTransform = require('../transforms/GenerateIDFieldTransform');
+
+var GenerateTypeNameTransform = require('../transforms/GenerateTypeNameTransform');
+
+var InlineDataFragmentTransform = require('../transforms/InlineDataFragmentTransform');
+
+var InlineFragmentsTransform = require('../transforms/InlineFragmentsTransform');
+
+var MaskTransform = require('../transforms/MaskTransform');
+
+var MatchTransform = require('../transforms/MatchTransform');
+
+var ReactFlightComponentTransform = require('../transforms/ReactFlightComponentTransform');
+
+var RefetchableFragmentTransform = require('../transforms/RefetchableFragmentTransform');
+
+var RelayDirectiveTransform = require('../transforms/RelayDirectiveTransform');
+
+var RelayFlowGenerator = require('../language/javascript/RelayFlowGenerator');
+
+var RequiredFieldTransform = require('../transforms/RequiredFieldTransform');
+
+var SkipClientExtensionsTransform = require('../transforms/SkipClientExtensionsTransform');
+
+var SkipHandleFieldTransform = require('../transforms/SkipHandleFieldTransform');
+
+var SkipRedundantNodesTransform = require('../transforms/SkipRedundantNodesTransform');
+
+var SkipSplitOperationTransform = require('../transforms/SkipSplitOperationTransform');
+
+var SkipUnreachableNodeTransform = require('../transforms/SkipUnreachableNodeTransform');
+
+var SkipUnusedVariablesTransform = require('../transforms/SkipUnusedVariablesTransform');
+
+var SplitModuleImportTransform = require('../transforms/SplitModuleImportTransform');
+
+var TestOperationTransform = require('../transforms/TestOperationTransform');
+
+var ValidateGlobalVariablesTransform = require('../transforms/ValidateGlobalVariablesTransform');
+
+var ValidateRequiredArgumentsTransform = require('../transforms/ValidateRequiredArgumentsTransform');
+
+var ValidateUnusedVariablesTransform = require('../transforms/ValidateUnusedVariablesTransform');
+
+// Transforms applied to the code used to process a query response.
+var relaySchemaExtensions = [ConnectionTransform.SCHEMA_EXTENSION, DeclarativeConnectionMutationTransform.SCHEMA_EXTENSION, InlineDataFragmentTransform.SCHEMA_EXTENSION, MatchTransform.SCHEMA_EXTENSION, RequiredFieldTransform.SCHEMA_EXTENSION, RefetchableFragmentTransform.SCHEMA_EXTENSION, RelayDirectiveTransform.SCHEMA_EXTENSION, RelayFlowGenerator.SCHEMA_EXTENSION, TestOperationTransform.SCHEMA_EXTENSION, ValidateUnusedVariablesTransform.SCHEMA_EXTENSION]; // Transforms applied to both operations and fragments for both reading and
+// writing from the store.
+
+var relayCommonTransforms = [DisallowIdAsAlias.transform, ConnectionTransform.transform, RelayDirectiveTransform.transform, MaskTransform.transform, MatchTransform.transform, RefetchableFragmentTransform.transform, DeferStreamTransform.transform, ReactFlightComponentTransform.transform]; // Transforms applied to fragments used for reading data from a store
+
+var relayFragmentTransforms = [ClientExtensionsTransform.transform, FieldHandleTransform.transform, InlineDataFragmentTransform.transform, FlattenTransform.transformWithOptions({
+  isForCodegen: true
+}), RequiredFieldTransform.transform, SkipRedundantNodesTransform.transform]; // Transforms applied to queries/mutations/subscriptions that are used for
+// fetching data from the server and parsing those responses.
+
+var relayQueryTransforms = [SplitModuleImportTransform.transform, DisallowTypenameOnRoot.transform, ValidateUnusedVariablesTransform.transform, ApplyFragmentArgumentTransform.transform, ValidateGlobalVariablesTransform.transform, GenerateIDFieldTransform.transform, DeclarativeConnectionMutationTransform.transform]; // Transforms applied to the code used to process a query response.
+
+var relayCodegenTransforms = [FilterCompilerDirectivesTransform.transform, SkipUnreachableNodeTransform.transform, InlineFragmentsTransform.transform, // NOTE: For the codegen context, we make sure to run ClientExtensions
+// transform after we've inlined fragment spreads (i.e. InlineFragmentsTransform)
+// This will ensure that we don't generate nested ClientExtension nodes
+ClientExtensionsTransform.transform, GenerateTypeNameTransform.transform, FlattenTransform.transformWithOptions({
+  isForCodegen: true
+}), SkipRedundantNodesTransform.transform, TestOperationTransform.transform]; // Transforms applied before printing the query sent to the server.
+
+var relayPrintTransforms = [SkipSplitOperationTransform.transform, // NOTE: Skipping client extensions might leave empty selections, which we
+// skip by running SkipUnreachableNodeTransform immediately after.
+ClientExtensionsTransform.transform, SkipClientExtensionsTransform.transform, SkipUnreachableNodeTransform.transform, GenerateTypeNameTransform.transform, FlattenTransform.transformWithOptions({}), SkipHandleFieldTransform.transform, FilterDirectivesTransform.transform, SkipUnusedVariablesTransform.transform, ValidateRequiredArgumentsTransform.transform];
+module.exports = {
+  commonTransforms: relayCommonTransforms,
+  codegenTransforms: relayCodegenTransforms,
+  fragmentTransforms: relayFragmentTransforms,
+  printTransforms: relayPrintTransforms,
+  queryTransforms: relayQueryTransforms,
+  schemaExtensions: relaySchemaExtensions
+};