@ardatan/relay-compiler 12.0.0

package/lib/core/SchemaUtils.js

@@ -0,0 +1,98 @@
+/**
+ * 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'),
+    createCompilerError = _require.createCompilerError;
+
+var ID = 'id';
+/**
+ * @public
+ *
+ * Determine if an AST node contains a fragment/operation definition.
+ */
+
+function isExecutableDefinitionAST(ast) {
+  return ast.kind === 'FragmentDefinition' || ast.kind === 'OperationDefinition';
+}
+/**
+ * @public
+ *
+ * Determine if an AST node contains a schema definition.
+ */
+
+
+function isSchemaDefinitionAST(ast) {
+  return ast.kind === 'SchemaDefinition' || ast.kind === 'ScalarTypeDefinition' || ast.kind === 'ObjectTypeDefinition' || ast.kind === 'InterfaceTypeDefinition' || ast.kind === 'UnionTypeDefinition' || ast.kind === 'EnumTypeDefinition' || ast.kind === 'InputObjectTypeDefinition' || ast.kind === 'DirectiveDefinition' || ast.kind === 'ScalarTypeExtension' || ast.kind === 'ObjectTypeExtension' || ast.kind === 'InterfaceTypeExtension' || ast.kind === 'UnionTypeExtension' || ast.kind === 'EnumTypeExtension' || ast.kind === 'InputObjectTypeExtension';
+}
+/**
+ * Generates an id field on the given type.
+ */
+
+
+function generateIDField(schema, type) {
+  var idField = schema.getFieldByName(type, 'id');
+
+  if (idField == null) {
+    throw new createCompilerError("Expected an 'id' field on type '".concat(schema.getTypeString(type), "'."));
+  }
+
+  var idType = schema.assertScalarFieldType(schema.getFieldType(idField));
+  return {
+    kind: 'ScalarField',
+    alias: ID,
+    args: [],
+    directives: [],
+    handles: null,
+    loc: {
+      kind: 'Generated'
+    },
+    metadata: null,
+    name: ID,
+    type: idType
+  };
+}
+
+function getNullableBooleanInput(schema) {
+  return schema.assertInputType(schema.expectBooleanType());
+}
+
+function getNonNullBooleanInput(schema) {
+  return schema.assertInputType(schema.getNonNullType(schema.expectBooleanType()));
+}
+
+function getNullableStringInput(schema) {
+  return schema.assertInputType(schema.expectStringType());
+}
+
+function getNonNullStringInput(schema) {
+  return schema.assertInputType(schema.getNonNullType(schema.expectStringType()));
+}
+
+function getNullableIdInput(schema) {
+  return schema.assertInputType(schema.expectIdType());
+}
+
+function getNonNullIdInput(schema) {
+  return schema.assertInputType(schema.getNonNullType(schema.expectIdType()));
+}
+
+module.exports = {
+  generateIDField: generateIDField,
+  isExecutableDefinitionAST: isExecutableDefinitionAST,
+  isSchemaDefinitionAST: isSchemaDefinitionAST,
+  getNullableBooleanInput: getNullableBooleanInput,
+  getNonNullBooleanInput: getNonNullBooleanInput,
+  getNullableStringInput: getNullableStringInput,
+  getNonNullStringInput: getNonNullStringInput,
+  getNullableIdInput: getNullableIdInput,
+  getNonNullIdInput: getNonNullIdInput
+};

package/lib/core/filterContextForNode.js

@@ -0,0 +1,49 @@
+/**
+ * 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 CompilerContext = require('./CompilerContext');
+
+var _require = require('./IRVisitor'),
+    visit = _require.visit;
+
+/**
+ * Returns a CompilerContext containing only the documents referenced
+ * by and including the provided node.
+ */
+function filterContextForNode(node, context) {
+  var queue = [node];
+  var filteredContext = new CompilerContext(context.getSchema()).add(node);
+
+  var visitFragmentSpread = function visitFragmentSpread(fragmentSpread) {
+    var name = fragmentSpread.name;
+
+    if (!filteredContext.get(name)) {
+      var fragment = context.getFragment(name);
+      filteredContext = filteredContext.add(fragment);
+      queue.push(fragment);
+    }
+  };
+
+  var visitorConfig = {
+    FragmentSpread: function FragmentSpread(fragmentSpread) {
+      visitFragmentSpread(fragmentSpread);
+    }
+  };
+
+  while (queue.length) {
+    visit(queue.pop(), visitorConfig);
+  }
+
+  return filteredContext;
+}
+
+module.exports = filterContextForNode;

package/lib/core/getFieldDefinition.js

@@ -0,0 +1,145 @@
+/**
+ * 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 _require = require('./CompilerError'),
+    createCompilerError = _require.createCompilerError;
+
+var _require2 = require('graphql'),
+    SchemaMetaFieldDef = _require2.SchemaMetaFieldDef,
+    TypeMetaFieldDef = _require2.TypeMetaFieldDef;
+
+/**
+ * Find the definition of a field of the specified type using strict
+ * resolution rules per the GraphQL spec.
+ */
+function getFieldDefinitionStrict(schema, parentType, fieldName) {
+  var type = schema.getRawType(parentType);
+  var queryType = schema.getQueryType();
+  var isQueryType = queryType != null && schema.areEqualTypes(type, queryType);
+  var hasTypeName = schema.isAbstractType(type) || schema.isObject(type);
+  var schemaFieldDef;
+
+  if (isQueryType && fieldName === SchemaMetaFieldDef.name) {
+    schemaFieldDef = queryType != null ? schema.getFieldByName(queryType, '__schema') : null;
+  } else if (isQueryType && fieldName === TypeMetaFieldDef.name) {
+    schemaFieldDef = queryType != null ? schema.getFieldByName(queryType, '__type') : null;
+  } else if (hasTypeName && fieldName === '__typename') {
+    schemaFieldDef = schema.getFieldByName(schema.assertCompositeType(type), '__typename');
+  } else if (hasTypeName && fieldName === '__id') {
+    schemaFieldDef = schema.getFieldByName(schema.assertCompositeType(type), '__id');
+  } else if (schema.isInterface(type) || schema.isObject(type)) {
+    var compositeType = schema.assertCompositeType(type);
+
+    if (schema.hasField(compositeType, fieldName)) {
+      schemaFieldDef = schema.getFieldByName(compositeType, fieldName);
+    } else {
+      return null;
+    }
+  }
+
+  return schemaFieldDef;
+}
+/**
+ * Find the definition of a field of the specified type, first trying
+ * the standard spec-compliant resolution process and falling back
+ * to legacy mode that supports fat interfaces.
+ */
+
+
+function getFieldDefinitionLegacy(schema, parentType, fieldName, fieldAST) {
+  var _schemaFieldDef;
+
+  var schemaFieldDef = getFieldDefinitionStrict(schema, parentType, fieldName);
+
+  if (!schemaFieldDef) {
+    schemaFieldDef = getFieldDefinitionLegacyImpl(schema, parentType, fieldName, fieldAST);
+  }
+
+  return (_schemaFieldDef = schemaFieldDef) !== null && _schemaFieldDef !== void 0 ? _schemaFieldDef : null;
+}
+/**
+ * @private
+ */
+
+
+function getFieldDefinitionLegacyImpl(schema, type, fieldName, fieldAST) {
+  var rawType = schema.getRawType(type);
+
+  if (schema.isAbstractType(rawType) && fieldAST && fieldAST.directives && fieldAST.directives.some(function (directive) {
+    return getName(directive) === 'fixme_fat_interface';
+  })) {
+    var possibleTypes = schema.getPossibleTypes(schema.assertAbstractType(rawType));
+    var schemaFieldDef;
+
+    var _iterator = (0, _createForOfIteratorHelper2["default"])(possibleTypes),
+        _step;
+
+    try {
+      var _loop = function _loop() {
+        var possibleType = _step.value;
+        var possibleField = schema.getFieldByName(possibleType, fieldName);
+
+        if (possibleField) {
+          // Fat interface fields can have differing arguments. Try to return
+          // a field with matching arguments, but still return a field if the
+          // arguments do not match.
+          schemaFieldDef = possibleField;
+
+          if (fieldAST && fieldAST.arguments) {
+            var argumentsAllExist = fieldAST.arguments.every(function (argument) {
+              return schema.getFieldArgByName(possibleField, getName(argument)) != null;
+            });
+
+            if (argumentsAllExist) {
+              return "break";
+            }
+          }
+        }
+      };
+
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var _ret = _loop();
+
+        if (_ret === "break") break;
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+
+    return schemaFieldDef;
+  }
+}
+/**
+ * @private
+ */
+
+
+function getName(ast) {
+  var name = ast.name ? ast.name.value : null;
+
+  if (typeof name !== 'string') {
+    throw createCompilerError("Expected ast node to have a 'name'.", null, [ast]);
+  }
+
+  return name;
+}
+
+module.exports = {
+  getFieldDefinitionLegacy: getFieldDefinitionLegacy,
+  getFieldDefinitionStrict: getFieldDefinitionStrict
+};

package/lib/core/getIdentifierForArgumentValue.js

@@ -0,0 +1,53 @@
+/**
+ * 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 invariant = require('invariant');
+
+/**
+ * Generates an identifier for an argument value. The identifier is based on the
+ * structure/order of items and keys in the value.
+ */
+function getIdentifierForArgumentValue(value) {
+  switch (value.kind) {
+    case 'Variable':
+      return {
+        variable: value.variableName
+      };
+
+    case 'Literal':
+      return {
+        value: value.value
+      };
+
+    case 'ListValue':
+      return {
+        list: value.items.map(function (item) {
+          return getIdentifierForArgumentValue(item);
+        })
+      };
+
+    case 'ObjectValue':
+      return {
+        object: value.fields.map(function (field) {
+          return {
+            name: field.name,
+            value: getIdentifierForArgumentValue(field.value)
+          };
+        })
+      };
+
+    default:
+      !false ? process.env.NODE_ENV !== "production" ? invariant(false, 'getIdentifierForArgumentValue(): Unsupported AST kind `%s`.', value.kind) : invariant(false) : void 0;
+  }
+}
+
+module.exports = getIdentifierForArgumentValue;

package/lib/core/getIdentifierForSelection.js

@@ -0,0 +1,48 @@
+/**
+ * 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 invariant = require('invariant');
+
+var _require = require('./IRPrinter'),
+    printArguments = _require.printArguments,
+    printDirectives = _require.printDirectives;
+
+/**
+ * Generates an identifier that is unique to a given selection: the alias for
+ * fields, the type for inline fragments, and a summary of the condition
+ * variable and passing value for conditions.
+ */
+function getIdentifierForSelection(schema, node) {
+  if (node.kind === 'LinkedField' || node.kind === 'ScalarField') {
+    return 'Field: ' + node.directives.length === 0 ? node.alias : node.alias + printDirectives(schema, node.directives);
+  } else if (node.kind === 'FragmentSpread') {
+    return 'FragmentSpread:' + node.args.length === 0 ? node.name : node.name + printArguments(schema, node.args);
+  } else if (node.kind === 'ModuleImport') {
+    return 'ModuleImport:';
+  } else if (node.kind === 'Defer') {
+    return 'Defer:' + node.label;
+  } else if (node.kind === 'Stream') {
+    return 'Stream:' + node.label;
+  } else if (node.kind === 'InlineFragment') {
+    return 'InlineFragment:' + schema.getTypeString(node.typeCondition) + printDirectives(schema, node.directives);
+  } else if (node.kind === 'ClientExtension') {
+    return 'ClientExtension:';
+  } else if (node.kind === 'InlineDataFragmentSpread') {
+    return 'InlineDataFragment:' + node.name;
+  } else if (node.kind === 'Condition') {
+    return 'Condition:' + (node.condition.kind === 'Variable' ? '$' + node.condition.variableName : String(node.condition.value)) + String(node.passingValue);
+  } else {
+    !false ? process.env.NODE_ENV !== "production" ? invariant(false, 'getIdentifierForSelection: Unexpected kind `%s`.', node.kind) : invariant(false) : void 0;
+  }
+}
+
+module.exports = getIdentifierForSelection;

package/lib/core/getLiteralArgumentValues.js

@@ -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
+ */
+// flowlint ambiguous-object-type:error
+'use strict';
+
+// Copy of Variables type from '../../../react-relay/classic/tools/RelayTypes'
+// Duplicating here rather than importing it since we can't take on a dependency
+// outside of relay-compiler.
+function getLiteralArgumentValues(args) {
+  var values = {};
+  args.forEach(function (arg) {
+    if (arg.value.kind === 'Literal') {
+      values[arg.name] = arg.value.value;
+    }
+  });
+  return values;
+}
+
+module.exports = getLiteralArgumentValues;

package/lib/core/getNormalizationOperationName.js

@@ -0,0 +1,17 @@
+/**
+ * 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';
+
+function getNormalizationOperationName(name) {
+  return "".concat(name, "$normalization");
+}
+
+module.exports = getNormalizationOperationName;