relay-compiler 9.0.0 → 9.1.0

package/core/SchemaUtils.js.flow

@@ -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.
+ *
+ * @flow strict
+ * @format
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+import type {ScalarField} from '../core/IR';
+import type {ScalarFieldTypeID} from './Schema';
+import type {Schema, InputTypeID} from './Schema';
+import type {ASTNode} from 'graphql';
+
+const ID = 'id';
+
+/**
+ * @public
+ *
+ * Determine if an AST node contains a fragment/operation definition.
+ */
+function isExecutableDefinitionAST(ast: ASTNode): boolean %checks {
+  return (
+    ast.kind === 'FragmentDefinition' || ast.kind === 'OperationDefinition'
+  );
+}
+
+/**
+ * @public
+ *
+ * Determine if an AST node contains a schema definition.
+ */
+function isSchemaDefinitionAST(ast: ASTNode): boolean %checks {
+  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'
+  );
+}
+
+function generateIDField(idType: ScalarFieldTypeID): ScalarField {
+  return {
+    kind: 'ScalarField',
+    alias: ID,
+    args: [],
+    directives: [],
+    handles: null,
+    loc: {kind: 'Generated'},
+    metadata: null,
+    name: ID,
+    type: idType,
+  };
+}
+
+function getNullableBooleanInput(schema: Schema): InputTypeID {
+  return schema.assertInputType(schema.expectBooleanType());
+}
+
+function getNonNullBooleanInput(schema: Schema): InputTypeID {
+  return schema.assertInputType(
+    schema.getNonNullType(schema.expectBooleanType()),
+  );
+}
+
+function getNullableStringInput(schema: Schema): InputTypeID {
+  return schema.assertInputType(schema.expectStringType());
+}
+
+function getNonNullStringInput(schema: Schema): InputTypeID {
+  return schema.assertInputType(
+    schema.getNonNullType(schema.expectStringType()),
+  );
+}
+
+function getNullableIdInput(schema: Schema): InputTypeID {
+  return schema.assertInputType(schema.expectIdType());
+}
+
+function getNonNullIdInput(schema: Schema): InputTypeID {
+  return schema.assertInputType(schema.getNonNullType(schema.expectIdType()));
+}
+
+module.exports = {
+  generateIDField,
+  isExecutableDefinitionAST,
+  isSchemaDefinitionAST,
+  getNullableBooleanInput,
+  getNonNullBooleanInput,
+  getNullableStringInput,
+  getNonNullStringInput,
+  getNullableIdInput,
+  getNonNullIdInput,
+};

package/core/filterContextForNode.js.flow

@@ -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.
+ *
+ * @flow strict
+ * @format
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+const CompilerContext = require('./CompilerContext');
+
+const {visit} = require('./IRVisitor');
+
+import type {Fragment, FragmentSpread, Root} from './IR';
+
+/**
+ * Returns a CompilerContext containing only the documents referenced
+ * by and including the provided node.
+ */
+function filterContextForNode(
+  node: Fragment | Root,
+  context: CompilerContext,
+): CompilerContext {
+  const queue = [node];
+  let filteredContext = new CompilerContext(context.getSchema()).add(node);
+  const visitFragmentSpread = (fragmentSpread: FragmentSpread) => {
+    const {name} = fragmentSpread;
+    if (!filteredContext.get(name)) {
+      const fragment = context.getFragment(name);
+      filteredContext = filteredContext.add(fragment);
+      queue.push(fragment);
+    }
+  };
+  const visitorConfig = {
+    FragmentSpread: (fragmentSpread: FragmentSpread) => {
+      visitFragmentSpread(fragmentSpread);
+    },
+  };
+  while (queue.length) {
+    visit(queue.pop(), visitorConfig);
+  }
+  return filteredContext;
+}
+
+module.exports = filterContextForNode;

package/core/getFieldDefinition.js.flow

@@ -0,0 +1,156 @@
+/**
+ * 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
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+const {createCompilerError} = require('./CompilerError');
+const {SchemaMetaFieldDef, TypeMetaFieldDef} = require('graphql');
+
+import type {Schema, TypeID, FieldID} from './Schema';
+import type {FieldNode} from 'graphql';
+
+export type GetFieldDefinitionFn = (
+  schema: Schema,
+  parentType: TypeID,
+  fieldName: string,
+  fieldAST: FieldNode,
+) => ?FieldID;
+
+/**
+ * Find the definition of a field of the specified type using strict
+ * resolution rules per the GraphQL spec.
+ */
+function getFieldDefinitionStrict(
+  schema: Schema,
+  parentType: TypeID,
+  fieldName: string,
+): ?FieldID {
+  const type = schema.getRawType(parentType);
+  const queryType = schema.getQueryType();
+  const isQueryType =
+    queryType != null && schema.areEqualTypes(type, queryType);
+  const hasTypeName = schema.isAbstractType(type) || schema.isObject(type);
+
+  let 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)) {
+    const 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: Schema,
+  parentType: TypeID,
+  fieldName: string,
+  fieldAST: FieldNode,
+): ?FieldID {
+  let schemaFieldDef = getFieldDefinitionStrict(schema, parentType, fieldName);
+
+  if (!schemaFieldDef) {
+    schemaFieldDef = getFieldDefinitionLegacyImpl(
+      schema,
+      parentType,
+      fieldName,
+      fieldAST,
+    );
+  }
+  return schemaFieldDef ?? null;
+}
+
+/**
+ * @private
+ */
+function getFieldDefinitionLegacyImpl(
+  schema: Schema,
+  type: TypeID,
+  fieldName: string,
+  fieldAST: FieldNode,
+): ?FieldID {
+  const rawType = schema.getRawType(type);
+  if (
+    schema.isAbstractType(rawType) &&
+    fieldAST &&
+    fieldAST.directives &&
+    fieldAST.directives.some(
+      directive => getName(directive) === 'fixme_fat_interface',
+    )
+  ) {
+    const possibleTypes = schema.getPossibleTypes(
+      schema.assertAbstractType(rawType),
+    );
+    let schemaFieldDef;
+    for (const possibleType of possibleTypes) {
+      const 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) {
+          const argumentsAllExist = fieldAST.arguments.every(
+            argument =>
+              schema.getFieldArgByName(possibleField, getName(argument)) !=
+              null,
+          );
+          if (argumentsAllExist) {
+            break;
+          }
+        }
+      }
+    }
+    return schemaFieldDef;
+  }
+}
+
+/**
+ * @private
+ */
+function getName(ast): string {
+  const 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,
+  getFieldDefinitionStrict,
+};

package/core/getIdentifierForArgumentValue.js.flow

@@ -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.
+ *
+ * @flow strict
+ * @format
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+const invariant = require('invariant');
+
+import type {ArgumentValue} from './IR';
+
+/**
+ * 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: ArgumentValue): mixed {
+  switch (value.kind) {
+    case 'Variable':
+      return {variable: value.variableName};
+    case 'Literal':
+      return {value: value.value};
+    case 'ListValue':
+      return {
+        list: value.items.map(item => getIdentifierForArgumentValue(item)),
+      };
+    case 'ObjectValue':
+      return {
+        object: value.fields.map(field => ({
+          name: field.name,
+          value: getIdentifierForArgumentValue(field.value),
+        })),
+      };
+    default:
+      invariant(
+        false,
+        'getIdentifierForArgumentValue(): Unsupported AST kind `%s`.',
+        value.kind,
+      );
+  }
+}
+
+module.exports = getIdentifierForArgumentValue;

package/core/getIdentifierForSelection.js.flow

@@ -0,0 +1,69 @@
+/**
+ * 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 invariant = require('invariant');
+
+const {printArguments, printDirectives} = require('./IRPrinter');
+
+import type {Selection} from './IR';
+import type {Schema} from './Schema';
+
+/**
+ * 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: Schema, node: Selection): string {
+  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 {
+    invariant(
+      false,
+      'getIdentifierForSelection: Unexpected kind `%s`.',
+      (node.kind: empty),
+    );
+  }
+}
+
+module.exports = getIdentifierForSelection;

package/core/getLiteralArgumentValues.js.flow

@@ -0,0 +1,32 @@
+/**
+ * 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
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+import type {Argument} from './IR';
+
+// 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.
+type Variables = {[name: string]: mixed, ...};
+
+function getLiteralArgumentValues(args: $ReadOnlyArray<Argument>): Variables {
+  const values = {};
+  args.forEach(arg => {
+    if (arg.value.kind === 'Literal') {
+      values[arg.name] = arg.value.value;
+    }
+  });
+  return values;
+}
+
+module.exports = getLiteralArgumentValues;

package/core/getNormalizationOperationName.js.flow

@@ -0,0 +1,19 @@
+/**
+ * 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
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+function getNormalizationOperationName(name: string): string {
+  return `${name}$normalization`;
+}
+
+module.exports = getNormalizationOperationName;