relay-compiler 9.0.0 → 9.1.0

package/transforms/TestOperationTransform.js.flow

@@ -0,0 +1,138 @@
+/**
+ * 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
+ * @emails oncall+relay
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+const IRTransformer = require('../core/IRTransformer');
+
+import type CompilerContext from '../core/CompilerContext';
+import type {Fragment, Root} from '../core/IR';
+import type {Schema, TypeID} from '../core/Schema';
+
+// The purpose of this directive is to add GraphQL type inform for fields in
+// the operation selection in order to use in in RelayMockPayloadGenerator
+// to generate better mock values, and expand the API of MockResolvers
+const SCHEMA_EXTENSION =
+  'directive @relay_test_operation on QUERY | MUTATION | SUBSCRIPTION';
+
+function testOperationDirective(context: CompilerContext): CompilerContext {
+  return IRTransformer.transform(context, {
+    Fragment: node => node,
+    Root: visitRoot,
+    SplitOperation: node => node,
+  });
+}
+
+type TypeDetails = {|
+  +type: string,
+  +plural: boolean,
+  +nullable: boolean,
+  +enumValues: null | $ReadOnlyArray<string>,
+|};
+
+function getTypeDetails(schema: Schema, fieldType: TypeID): TypeDetails {
+  const nullableType = schema.getNullableType(fieldType);
+  const isNullable = !schema.isNonNull(fieldType);
+  const isPlural = schema.isList(nullableType);
+  const type = schema.getRawType(nullableType);
+
+  return {
+    type: schema.getTypeString(type),
+    enumValues: schema.isEnum(type)
+      ? schema.getEnumValues(schema.assertEnumType(type))
+      : null,
+    plural: isPlural,
+    nullable: isNullable,
+  };
+}
+
+function visitRoot(node: Root) {
+  const schema: Schema = this.getContext().getSchema();
+  const testDirective = node.directives.find(
+    directive => directive.name === 'relay_test_operation',
+  );
+  if (testDirective == null) {
+    return node;
+  }
+
+  const context = this.getContext();
+  const queue = [
+    {
+      selections: node.selections,
+      path: null,
+    },
+  ];
+  const selectionsTypeInfo = {};
+  while (queue.length > 0) {
+    const {selections: currentSelections, path} = queue.pop();
+    currentSelections.forEach(selection => {
+      switch (selection.kind) {
+        case 'FragmentSpread':
+          const fragment: ?Fragment = context.get(selection.name);
+          if (fragment != null) {
+            queue.unshift({
+              selections: fragment.selections,
+              path,
+            });
+          }
+          break;
+        case 'ScalarField': {
+          const nextPath =
+            path === null ? selection.alias : `${path}.${selection.alias}`;
+          selectionsTypeInfo[nextPath] = getTypeDetails(schema, selection.type);
+          break;
+        }
+        case 'LinkedField': {
+          const nextPath =
+            path === null ? selection.alias : `${path}.${selection.alias}`;
+          selectionsTypeInfo[nextPath] = getTypeDetails(schema, selection.type);
+          queue.unshift({
+            selections: selection.selections,
+            path: nextPath,
+          });
+          break;
+        }
+        case 'Condition':
+        case 'ClientExtension':
+        case 'Defer':
+        case 'InlineDataFragmentSpread':
+        case 'InlineFragment':
+        case 'ModuleImport':
+        case 'Stream':
+          queue.unshift({
+            selections: selection.selections,
+            path,
+          });
+          break;
+        default:
+          (selection: empty);
+          break;
+      }
+    });
+  }
+  return {
+    ...node,
+    directives: node.directives.filter(
+      directive => directive !== testDirective,
+    ),
+    metadata: {
+      ...(node.metadata || {}),
+      relayTestingSelectionTypeInfo: selectionsTypeInfo,
+    },
+  };
+}
+
+module.exports = {
+  SCHEMA_EXTENSION,
+  transform: testOperationDirective,
+};

package/transforms/TransformUtils.js.flow

@@ -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.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+import type {LinkedField} from '../core/IR';
+
+function hasUnaliasedSelection(field: LinkedField, fieldName: string): boolean {
+  return field.selections.some(
+    selection =>
+      selection.kind === 'ScalarField' &&
+      selection.alias === fieldName &&
+      selection.name === fieldName,
+  );
+}
+
+module.exports = {hasUnaliasedSelection};

package/transforms/ValidateGlobalVariablesTransform.js.flow

@@ -0,0 +1,81 @@
+/**
+ * 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 inferRootArgumentDefinitions = require('../core/inferRootArgumentDefinitions');
+
+const {
+  createUserError,
+  eachWithCombinedError,
+} = require('../core/CompilerError');
+
+import type CompilerContext from '../core/CompilerContext';
+import type {ArgumentDefinition} from '../core/IR';
+
+/**
+ * Validates that all global variables used in operations are defined at the
+ * root. This isn't a real transform as it returns the original context, but
+ * has to happen before other transforms strip certain variable usages.
+ */
+function validateGlobalVariablesTransform(
+  context: CompilerContext,
+): CompilerContext {
+  const contextWithUsedArguments = inferRootArgumentDefinitions(context);
+  eachWithCombinedError(context.documents(), node => {
+    if (node.kind !== 'Root') {
+      return;
+    }
+    const nodeWithUsedArguments = contextWithUsedArguments.getRoot(node.name);
+    const definedArguments = argumentDefinitionsToMap(node.argumentDefinitions);
+    const usedArguments = argumentDefinitionsToMap(
+      nodeWithUsedArguments.argumentDefinitions,
+    );
+    // All used arguments must be defined
+    const undefinedVariables = [];
+    for (const argDef of usedArguments.values()) {
+      if (!definedArguments.has(argDef.name)) {
+        undefinedVariables.push(argDef);
+      }
+    }
+    if (undefinedVariables.length !== 0) {
+      throw createUserError(
+        `Operation '${
+          node.name
+        }' references undefined variable(s):\n${undefinedVariables
+          .map(
+            argDef =>
+              `- \$${argDef.name}: ${context
+                .getSchema()
+                .getTypeString(argDef.type)}`,
+          )
+          .join('\n')}.`,
+        undefinedVariables.map(argDef => argDef.loc),
+      );
+    }
+  });
+  return context;
+}
+
+function argumentDefinitionsToMap<T: ArgumentDefinition>(
+  argDefs: $ReadOnlyArray<T>,
+): Map<string, T> {
+  const map = new Map();
+  for (const argDef of argDefs) {
+    map.set(argDef.name, argDef);
+  }
+  return map;
+}
+
+module.exports = {
+  transform: validateGlobalVariablesTransform,
+};

package/transforms/ValidateRequiredArgumentsTransform.js.flow

@@ -0,0 +1,127 @@
+/**
+ * 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 IRValidator = require('../core/IRValidator');
+
+const {createUserError} = require('../core/CompilerError');
+const {getFieldDefinitionStrict} = require('../core/getFieldDefinition');
+
+import type CompilerContext from '../core/CompilerContext';
+import type {
+  Directive,
+  Field,
+  Fragment,
+  Root,
+  SplitOperation,
+} from '../core/IR';
+import type {Schema, TypeID, Argument} from '../core/Schema';
+
+type State = {|
+  +rootNode: Fragment | Root | SplitOperation,
+  +parentType: TypeID,
+|};
+
+/*
+ * Validate required arguments are provided after transforms filling in arguments
+ */
+function validateRequiredArguments(context: CompilerContext): CompilerContext {
+  IRValidator.validate(
+    context,
+    {
+      Directive: visitDirective,
+      InlineFragment: visitInlineFragment,
+      LinkedField: visitField,
+      ScalarField: visitField,
+      // FragmentSpread validation is done in ApplyFragmentArgumentTransform
+    },
+    node => ({rootNode: node, parentType: node.type}),
+  );
+  return context;
+}
+
+function visitDirective(node: Directive, {rootNode}: State): void {
+  const context: CompilerContext = this.getContext();
+  const directiveDef = context.getSchema().getDirective(node.name);
+  if (directiveDef == null) {
+    return;
+  }
+  validateRequiredArgumentsOnNode(
+    context.getSchema(),
+    node,
+    directiveDef.args,
+    rootNode,
+  );
+}
+
+function visitInlineFragment(fragment, {rootNode}: State): void {
+  this.traverse(fragment, {
+    rootNode,
+    parentType: fragment.typeCondition,
+  });
+}
+
+function visitField(node: Field, {parentType, rootNode}: State): void {
+  const context: CompilerContext = this.getContext();
+  const schema = context.getSchema();
+  const definition = getFieldDefinitionStrict(schema, parentType, node.name);
+  if (definition == null) {
+    const isLegacyFatInterface = node.directives.some(
+      directive => directive.name === 'fixme_fat_interface',
+    );
+    if (!isLegacyFatInterface) {
+      throw createUserError(
+        `Unknown field '${node.name}' on type ` +
+          `'${schema.getTypeString(parentType)}'.`,
+        [node.loc],
+      );
+    }
+  } else {
+    validateRequiredArgumentsOnNode(
+      schema,
+      node,
+      schema.getFieldConfig(definition).args,
+      rootNode,
+    );
+  }
+  this.traverse(node, {
+    rootNode,
+    parentType: node.type,
+  });
+}
+
+function validateRequiredArgumentsOnNode(
+  schema: Schema,
+  node: Directive | Field,
+  definitionArgs: $ReadOnlyArray<Argument>,
+  rootNode: Fragment | Root | SplitOperation,
+): void {
+  const nodeArgsSet = new Set(node.args.map(arg => arg.name));
+  for (const arg of definitionArgs) {
+    if (
+      arg.defaultValue == null &&
+      schema.isNonNull(arg.type) &&
+      !nodeArgsSet.has(arg.name)
+    ) {
+      throw createUserError(
+        `Required argument '${arg.name}: ${schema.getTypeString(arg.type)}' ` +
+          `is missing on '${node.name}' in '${rootNode.name}'.`,
+        [node.loc, rootNode.loc],
+      );
+    }
+  }
+}
+
+module.exports = {
+  transform: validateRequiredArguments,
+};

package/transforms/ValidateServerOnlyDirectivesTransform.js.flow

@@ -0,0 +1,112 @@
+/**
+ * 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 IRValidator = require('../core/IRValidator');
+
+const {createUserError} = require('../core/CompilerError');
+
+import type CompilerContext from '../core/CompilerContext';
+import type {
+  ClientExtension,
+  Defer,
+  LinkedField,
+  Selection,
+  Stream,
+} from '../core/IR';
+
+type State = {rootClientSelection: ?Selection, ...};
+
+const NODEKIND_DIRECTIVE_MAP = {
+  Defer: 'defer',
+  Stream: 'stream',
+};
+
+/*
+ * Validate that server-only directives are not used inside client fields
+ */
+function validateServerOnlyDirectives(
+  context: CompilerContext,
+): CompilerContext {
+  IRValidator.validate(
+    context,
+    {
+      ClientExtension: visitClientExtension,
+      Defer: visitTransformedDirective,
+      Stream: visitTransformedDirective,
+      LinkedField: visitLinkedField,
+      ScalarField: stopVisit,
+    },
+    () => ({
+      rootClientSelection: null,
+    }),
+  );
+  return context;
+}
+
+// If an empty visitor is defined, we no longer automatically visit child nodes
+// such as arguments.
+function stopVisit() {}
+
+// Only visits selections as an optimization to not look at arguments
+function visitLinkedField(node: LinkedField, state: State): void {
+  for (const selection of node.selections) {
+    this.visit(selection, state);
+  }
+}
+
+function visitClientExtension(node: ClientExtension, state: State): void {
+  for (const selection of node.selections) {
+    this.visit(selection, {
+      rootClientSelection: selection,
+    });
+  }
+}
+
+function visitTransformedDirective(node: Defer | Stream, state: State): void {
+  if (state.rootClientSelection) {
+    throwError(
+      `@${NODEKIND_DIRECTIVE_MAP[node.kind]}`,
+      node.loc,
+      state.rootClientSelection.loc,
+    );
+  }
+  // directive used only on client fields
+  if (node.selections.every(sel => sel.kind === 'ClientExtension')) {
+    const clientExtension = node.selections[0];
+    throwError(
+      `@${NODEKIND_DIRECTIVE_MAP[node.kind]}`,
+      node.loc,
+      clientExtension && clientExtension.kind === 'ClientExtension'
+        ? clientExtension.selections[0]?.loc
+        : null,
+    );
+  }
+  this.traverse(node, state);
+}
+
+function throwError(directiveName, directiveLoc, clientExtensionLoc) {
+  throw createUserError(
+    `Unexpected directive: ${directiveName}. ` +
+      'This directive can only be used on fields/fragments that are ' +
+      'fetched from the server schema, but it is used ' +
+      'inside a client-only selection.',
+    clientExtensionLoc == null || directiveLoc === clientExtensionLoc
+      ? [directiveLoc]
+      : [directiveLoc, clientExtensionLoc],
+  );
+}
+
+module.exports = {
+  transform: validateServerOnlyDirectives,
+};

package/transforms/ValidateUnusedVariablesTransform.js.flow

@@ -0,0 +1,89 @@
+/**
+ * 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 inferRootArgumentDefinitions = require('../core/inferRootArgumentDefinitions');
+
+const {
+  createUserError,
+  eachWithCombinedError,
+} = require('../core/CompilerError');
+
+import type CompilerContext from '../core/CompilerContext';
+import type {ArgumentDefinition} from '../core/IR';
+
+const SCHEMA_EXTENSION =
+  'directive @DEPRECATED__relay_ignore_unused_variables_error on QUERY | MUTATION | SUBSCRIPTION';
+
+/**
+ * Validates that there are no unused variables in the operation.
+ * former `graphql-js`` NoUnusedVariablesRule
+ */
+function validateUnusedVariablesTransform(
+  context: CompilerContext,
+): CompilerContext {
+  const contextWithUsedArguments = inferRootArgumentDefinitions(context);
+  eachWithCombinedError(context.documents(), node => {
+    if (node.kind !== 'Root') {
+      return;
+    }
+    const rootArgumentLocations = new Map(
+      node.argumentDefinitions.map(arg => [arg.name, arg.loc]),
+    );
+    const nodeWithUsedArguments = contextWithUsedArguments.getRoot(node.name);
+    const usedArguments = argumentDefinitionsToMap(
+      nodeWithUsedArguments.argumentDefinitions,
+    );
+    for (const usedArgumentName of usedArguments.keys()) {
+      rootArgumentLocations.delete(usedArgumentName);
+    }
+
+    const ignoreErrorDirective = node.directives.find(
+      ({name}) => name === 'DEPRECATED__relay_ignore_unused_variables_error',
+    );
+    if (rootArgumentLocations.size > 0 && !ignoreErrorDirective) {
+      const isPlural = rootArgumentLocations.size > 1;
+      throw createUserError(
+        `Variable${isPlural ? 's' : ''} '$${Array.from(
+          rootArgumentLocations.keys(),
+        ).join("', '$")}' ${isPlural ? 'are' : 'is'} never used in operation '${
+          node.name
+        }'.`,
+        Array.from(rootArgumentLocations.values()),
+      );
+    }
+    if (rootArgumentLocations.size === 0 && ignoreErrorDirective) {
+      throw createUserError(
+        "Invalid usage of '@DEPRECATED__relay_ignore_unused_variables_error.'" +
+          `No unused variables found in the query '${node.name}'`,
+        [ignoreErrorDirective.loc],
+      );
+    }
+  });
+  return context;
+}
+
+function argumentDefinitionsToMap<T: ArgumentDefinition>(
+  argDefs: $ReadOnlyArray<T>,
+): Map<string, T> {
+  const map = new Map();
+  for (const argDef of argDefs) {
+    map.set(argDef.name, argDef);
+  }
+  return map;
+}
+
+module.exports = {
+  transform: validateUnusedVariablesTransform,
+  SCHEMA_EXTENSION,
+};