relay-compiler 10.0.1 → 10.1.3

package/runner/Sources.js.flow

@@ -137,6 +137,20 @@ class Sources<T: ASTNode> {
         const newTexts = new Set();
         for (const {ast, text} of newDefs) {
           const hashedText = md5(text);
+          if (newTexts.has(hashedText)) {
+            let name = 'unknown';
+            switch (ast.kind) {
+              case 'FragmentDefinition':
+                name = ast.name.value;
+                break;
+              case 'OperationDefinition':
+                name = ast.name?.value ?? 'unnamed operation';
+                break;
+            }
+            throw new Error(
+              `Duplicate definition of \`${name}\` in \`${file.name}\``,
+            );
+          }
           newTexts.add(hashedText);
           if (hasEntry && oldEntry[hashedText] != null) {
             // Entity text did not change, so we

package/transforms/ClientExtensionsTransform.js.flow

@@ -83,9 +83,11 @@ function traverseSelections<T: Node>(
   compilerContext: CompilerContext,
   parentType: TypeID,
 ): T {
+  // $FlowFixMe[escaped-generic]
   let nodeCache = cachesByNode.get(node);
   if (nodeCache == null) {
     nodeCache = new Map();
+    // $FlowFixMe[escaped-generic]
     cachesByNode.set(node, nodeCache);
   }
   let result = nodeCache.get(parentType);
@@ -182,6 +184,7 @@ function traverseSelections<T: Node>(
       ],
     };
   }
+  // $FlowFixMe[escaped-generic]
   nodeCache.set(parentType, result);
   /* $FlowFixMe[incompatible-return] - TODO: type IRTransformer to allow
    * changing result type */

package/transforms/ConnectionTransform.js.flow

@@ -308,7 +308,6 @@ function buildConnectionArguments(
     };
   }
 
-  // T45504512: new connection model
   const dynamicKeyArg = connectionDirective.args.find(
     arg => arg.name === 'dynamicKey_UNSTABLE',
   );

package/transforms/DeclarativeConnectionMutationTransform.js.flow

@@ -18,17 +18,36 @@ const {createUserError} = require('../core/CompilerError');
 const {ConnectionInterface} = require('relay-runtime');
 
 const DELETE_RECORD = 'deleteRecord';
+const DELETE_EDGE = 'deleteEdge';
 const APPEND_EDGE = 'appendEdge';
 const PREPEND_EDGE = 'prependEdge';
-const LINKED_FIELD_DIRECTIVES = [APPEND_EDGE, PREPEND_EDGE];
+const APPEND_NODE = 'appendNode';
+const PREPEND_NODE = 'prependNode';
+const EDGE_LINKED_FIELD_DIRECTIVES = [APPEND_EDGE, PREPEND_EDGE];
+const NODE_LINKED_FIELD_DIRECTIVES = [APPEND_NODE, PREPEND_NODE];
+const LINKED_FIELD_DIRECTIVES = [
+  ...EDGE_LINKED_FIELD_DIRECTIVES,
+  ...NODE_LINKED_FIELD_DIRECTIVES,
+];
 
 const SCHEMA_EXTENSION = `
   directive @${DELETE_RECORD} on FIELD
+  directive @${DELETE_EDGE}(
+    connections: [ID!]!
+  ) on FIELD
   directive @${APPEND_EDGE}(
-    connections: [String!]!
+    connections: [ID!]!
   ) on FIELD
   directive @${PREPEND_EDGE}(
-    connections: [String!]!
+    connections: [ID!]!
+  ) on FIELD
+  directive @${APPEND_NODE}(
+    connections: [ID!]!
+    edgeTypeName: String!
+  ) on FIELD
+  directive @${PREPEND_NODE}(
+    connections: [ID!]!
+    edgeTypeName: String!
   ) on FIELD
 `;
 
@@ -58,31 +77,49 @@ function visitScalarField(field: ScalarField): ScalarField {
       [linkedFieldDirective.loc],
     );
   }
-  const deleteDirective = field.directives.find(
+  const deleteNodeDirective = field.directives.find(
     directive => directive.name === DELETE_RECORD,
   );
-  if (deleteDirective == null) {
+  const deleteEdgeDirective = field.directives.find(
+    directive => directive.name === DELETE_EDGE,
+  );
+  if (deleteNodeDirective != null && deleteEdgeDirective != null) {
+    throw createUserError(
+      `Both @deleteNode and @deleteEdge are used on field '${field.name}'. Only one directive is supported for now.`,
+      [deleteNodeDirective.loc, deleteEdgeDirective.loc],
+    );
+  }
+  const targetDirective = deleteNodeDirective ?? deleteEdgeDirective;
+  if (targetDirective == null) {
     return field;
   }
+
   const schema = this.getContext().getSchema();
-  if (!schema.isId(field.type)) {
+
+  if (!schema.isId(schema.getRawType(field.type))) {
     throw createUserError(
-      `Invalid use of @${DELETE_RECORD} on field '${
+      `Invalid use of @${targetDirective.name} on field '${
         field.name
-      }'. Expected field type ID, got ${schema.getTypeString(field.type)}.`,
-      [deleteDirective.loc],
+      }'. Expected field to return an ID or list of ID values, got ${schema.getTypeString(
+        field.type,
+      )}.`,
+      [targetDirective.loc],
     );
   }
+  const connectionsArg = targetDirective.args.find(
+    arg => arg.name === 'connections',
+  );
   const handle: Handle = {
-    name: DELETE_RECORD,
+    name: targetDirective.name,
     key: '',
     dynamicKey: null,
     filters: null,
+    handleArgs: connectionsArg ? [connectionsArg] : undefined,
   };
   return {
     ...field,
     directives: field.directives.filter(
-      directive => directive !== deleteDirective,
+      directive => directive !== targetDirective,
     ),
     handles: field.handles ? [...field.handles, handle] : [handle],
   };
@@ -100,55 +137,110 @@ function visitLinkedField(field: LinkedField): LinkedField {
     );
   }
   const edgeDirective = transformedField.directives.find(
-    directive => LINKED_FIELD_DIRECTIVES.indexOf(directive.name) > -1,
+    directive => EDGE_LINKED_FIELD_DIRECTIVES.indexOf(directive.name) > -1,
+  );
+  const nodeDirective = transformedField.directives.find(
+    directive => NODE_LINKED_FIELD_DIRECTIVES.indexOf(directive.name) > -1,
   );
-  if (edgeDirective == null) {
+
+  if (edgeDirective == null && nodeDirective == null) {
     return transformedField;
   }
-  const connectionsArg = edgeDirective.args.find(
+  if (edgeDirective != null && nodeDirective != null) {
+    throw createUserError(
+      `Invalid use of @${edgeDirective.name} and @${nodeDirective.name} on field '${transformedField.name}' - these directives cannot be used together.`,
+      [edgeDirective.loc],
+    );
+  }
+  const targetDirective = edgeDirective ?? nodeDirective;
+  const connectionsArg = targetDirective.args.find(
     arg => arg.name === 'connections',
   );
   if (connectionsArg == null) {
     throw createUserError(
-      `Expected the 'connections' argument to be defined on @${edgeDirective.name}.`,
-      [edgeDirective.loc],
+      `Expected the 'connections' argument to be defined on @${targetDirective.name}.`,
+      [targetDirective.loc],
     );
   }
   const schema = this.getContext().getSchema();
-  const fields = schema.getFields(transformedField.type);
-  let cursorFieldID;
-  let nodeFieldID;
-  for (const fieldID of fields) {
-    const fieldName = schema.getFieldName(fieldID);
-    if (fieldName === ConnectionInterface.get().CURSOR) {
-      cursorFieldID = fieldID;
-    } else if (fieldName === ConnectionInterface.get().NODE) {
-      nodeFieldID = fieldID;
+  if (edgeDirective) {
+    const fieldType = schema.isList(transformedField.type)
+      ? transformedField.type.ofType
+      : transformedField.type;
+    const fields = schema.getFields(fieldType);
+    let cursorFieldID;
+    let nodeFieldID;
+    for (const fieldID of fields) {
+      const fieldName = schema.getFieldName(fieldID);
+      if (fieldName === ConnectionInterface.get().CURSOR) {
+        cursorFieldID = fieldID;
+      } else if (fieldName === ConnectionInterface.get().NODE) {
+        nodeFieldID = fieldID;
+      }
     }
+
+    // Edge
+    if (cursorFieldID != null && nodeFieldID != null) {
+      const handle: Handle = {
+        name: edgeDirective.name,
+        key: '',
+        dynamicKey: null,
+        filters: null,
+        handleArgs: [connectionsArg],
+      };
+      return {
+        ...transformedField,
+        directives: transformedField.directives.filter(
+          directive => directive !== edgeDirective,
+        ),
+        handles: transformedField.handles
+          ? [...transformedField.handles, handle]
+          : [handle],
+      };
+    }
+    throw createUserError(
+      `Unsupported use of @${edgeDirective.name} on field '${transformedField.name}', expected an edge field (a field with 'cursor' and 'node' selection).`,
+      [targetDirective.loc],
+    );
+  } else {
+    // Node
+    const edgeTypeNameArg = nodeDirective.args.find(
+      arg => arg.name === 'edgeTypeName',
+    );
+    if (!edgeTypeNameArg) {
+      throw createUserError(
+        `Unsupported use of @${nodeDirective.name} on field '${transformedField.name}', 'edgeTypeName' argument must be provided.`,
+        [targetDirective.loc],
+      );
+    }
+    const rawType = schema.getRawType(transformedField.type);
+    if (schema.canHaveSelections(rawType)) {
+      const handle: Handle = {
+        name: nodeDirective.name,
+        key: '',
+        dynamicKey: null,
+        filters: null,
+        handleArgs: [connectionsArg, edgeTypeNameArg],
+      };
+      return {
+        ...transformedField,
+        directives: transformedField.directives.filter(
+          directive => directive !== nodeDirective,
+        ),
+        handles: transformedField.handles
+          ? [...transformedField.handles, handle]
+          : [handle],
+      };
+    }
+    throw createUserError(
+      `Unsupported use of @${nodeDirective.name} on field '${
+        transformedField.name
+      }'. Expected an object, union or interface, but got '${schema.getTypeString(
+        transformedField.type,
+      )}'.`,
+      [nodeDirective.loc],
+    );
   }
-  // Edge
-  if (cursorFieldID != null && nodeFieldID != null) {
-    const handle: Handle = {
-      name: edgeDirective.name,
-      key: '',
-      dynamicKey: null,
-      filters: null,
-      handleArgs: [connectionsArg],
-    };
-    return {
-      ...transformedField,
-      directives: transformedField.directives.filter(
-        directive => directive !== edgeDirective,
-      ),
-      handles: transformedField.handles
-        ? [...transformedField.handles, handle]
-        : [handle],
-    };
-  }
-  throw createUserError(
-    `Unsupported use of @${edgeDirective.name} on field '${transformedField.name}', expected an edge field (a field with 'cursor' and 'node' selection).`,
-    [edgeDirective.loc],
-  );
 }
 
 module.exports = {

package/transforms/FieldHandleTransform.js.flow

@@ -55,7 +55,6 @@ function visitField<F: LinkedField | ScalarField>(field: F): F {
   const args = filters
     ? nextField.args.filter(arg => filters.indexOf(arg.name) !== -1)
     : [];
-  // T45504512: new connection model
   if (handle.dynamicKey != null) {
     args.push({
       kind: 'Argument',

package/transforms/FilterCompilerDirectivesTransform.js.flow

@@ -0,0 +1,33 @@
+/**
+ * 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
+ */
+
+'use strict';
+
+const IRTransformer = require('../core/IRTransformer');
+
+import type CompilerContext from '../core/CompilerContext';
+import type {Directive} from '../core/IR';
+
+const COMPILE_TIME_DIRECTIVES = new Set(['required']);
+
+/**
+ * A transform that removes any directives that are only interpreted by the Relay compiler.
+ */
+function filterDirectivesTransform(context: CompilerContext): CompilerContext {
+  return IRTransformer.transform(context, {
+    Directive: (directive: Directive): ?Directive => {
+      return COMPILE_TIME_DIRECTIVES.has(directive.name) ? null : directive;
+    },
+  });
+}
+
+module.exports = {
+  transform: filterDirectivesTransform,
+};

package/transforms/FlattenTransform.js.flow

@@ -61,9 +61,10 @@ function flattenTransformImpl(
       Condition: visitorFn,
       Defer: visitorFn,
       Fragment: visitorFn,
-      InlineFragment: visitorFn,
       InlineDataFragmentSpread: visitorFn,
+      InlineFragment: visitorFn,
       LinkedField: visitorFn,
+      ModuleImport: visitorFn,
       Root: visitorFn,
       SplitOperation: visitorFn,
     },
@@ -71,7 +72,7 @@ function flattenTransformImpl(
   );
 }
 
-function memoizedFlattenSelection(cache) {
+function memoizedFlattenSelection(cache: Map<Node, Map<?TypeID, any>>) {
   return function flattenSelectionsFn<T: Node>(node: T, state: State): T {
     const context: CompilerContext = this.getContext();
     let nodeCache = cache.get(node);

package/transforms/MatchTransform.js.flow

@@ -188,6 +188,12 @@ function visitLinkedField(node: LinkedField, state: State): LinkedField {
     ({name}) => name === SUPPORTED_ARGUMENT_NAME,
   );
   if (supportedArgumentDefinition == null) {
+    if (moduleKey == null) {
+      throw createUserError(
+        '@match on a field without the `supported` argument is a no-op, please remove the `@match`.',
+        [node.loc],
+      );
+    }
     return transformedNode;
   }
 

package/transforms/ReactFlightComponentTransform.js.flow

@@ -0,0 +1,195 @@
+/**
+ * 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
+ */
+
+'use strict';
+
+const IRTransformer = require('../core/IRTransformer');
+
+const {createUserError, createCompilerError} = require('../core/CompilerError');
+const {RelayFeatureFlags} = require('relay-runtime');
+
+import type CompilerContext from '../core/CompilerContext';
+import type {ScalarField} from '../core/IR';
+import type {TypeID, InputTypeID, ScalarFieldTypeID} from '../core/Schema';
+
+const FLIGHT_FIELD_COMPONENT_ARGUMENT_TYPE = 'String';
+const FLIGHT_FIELD_COMPONENT_ARGUMENT_NAME = 'component';
+const FLIGHT_FIELD_PROPS_ARGUMENT_NAME = 'props';
+const FLIGHT_FIELD_PROPS_TYPE = 'ReactFlightProps';
+const FLIGHT_FIELD_RETURN_TYPE = 'ReactFlightComponent';
+
+type State = {
+  parentType: TypeID,
+  types: {
+    propsType: InputTypeID,
+    componentType: ScalarFieldTypeID,
+  },
+};
+
+/**
+ * Experimental transform for React Flight.
+ */
+function reactFlightComponentTransform(
+  context: CompilerContext,
+): CompilerContext {
+  const schema = context.getSchema();
+  let propsType = schema.getTypeFromString(FLIGHT_FIELD_PROPS_TYPE);
+  propsType = propsType ? schema.asInputType(propsType) : null;
+  let componentType = schema.getTypeFromString(FLIGHT_FIELD_RETURN_TYPE);
+  componentType = componentType
+    ? schema.asScalarFieldType(componentType)
+    : null;
+  if (
+    !RelayFeatureFlags.ENABLE_REACT_FLIGHT_COMPONENT_FIELD ||
+    propsType == null ||
+    componentType == null
+  ) {
+    return context;
+  }
+  const types = {propsType, componentType};
+  return IRTransformer.transform(
+    context,
+    {
+      ScalarField: visitScalarField,
+      LinkedField: visitLinkedField,
+      InlineFragment: visitInlineFragment,
+    },
+    node => ({
+      parentType: node.type,
+      types,
+    }),
+  );
+}
+
+function visitInlineFragment(fragment, state) {
+  return this.traverse(fragment, {
+    parentType: fragment.typeCondition ?? state.parentType,
+    types: state.types,
+  });
+}
+
+function visitLinkedField(field, state) {
+  return this.traverse(field, {parentType: field.type, types: state.types});
+}
+
+function visitScalarField(field: ScalarField, state: State): ScalarField {
+  // use the return type to quickly determine if this is a flight field
+  const schema = this.getContext().getSchema();
+  if (schema.getRawType(field.type) !== state.types.componentType) {
+    return field;
+  }
+
+  // get the name of the component that provides this field
+  const clientField = schema.getFieldByName(state.parentType, field.name);
+  if (clientField == null) {
+    throw createCompilerError(
+      `Definition not found for field '${schema.getTypeString(
+        state.parentType,
+      )}.${field.name}'`,
+      [field.loc],
+    );
+  }
+  const componentDirective = clientField.directives.find(
+    directive => directive.name === 'react_flight_component',
+  );
+  const componentNameArg = componentDirective?.args.find(
+    arg => arg.name === 'name',
+  );
+  if (
+    componentNameArg == null ||
+    componentNameArg.value.kind !== 'StringValue' ||
+    typeof componentNameArg.value.value !== 'string'
+  ) {
+    throw createUserError(
+      'Invalid Flight field, expected the schema extension to specify ' +
+        "the component's module name with the '@react_flight_component' directive",
+      [field.loc],
+    );
+  }
+  const componentName = componentNameArg.value.value;
+
+  // validate that the parent type has a `flight(component, props)` field
+  const flightField = schema.getFieldByName(state.parentType, 'flight');
+  if (flightField == null) {
+    throw createUserError(
+      `Invalid Flight field, expected the parent type '${schema.getTypeString(
+        state.parentType,
+      )}' ` +
+        "to define a 'flight(component: String, props: ReactFlightProps): ReactFlightComponent' field",
+      [field.loc],
+    );
+  }
+  const componentArg = flightField.args.get(
+    FLIGHT_FIELD_COMPONENT_ARGUMENT_NAME,
+  );
+  const propsArg = flightField.args.get(FLIGHT_FIELD_PROPS_ARGUMENT_NAME);
+  if (
+    componentArg == null ||
+    propsArg == null ||
+    schema.getRawType(componentArg.type) !==
+      schema.getTypeFromString(FLIGHT_FIELD_COMPONENT_ARGUMENT_TYPE) ||
+    schema.getRawType(propsArg.type) !== state.types.propsType ||
+    schema.getRawType(flightField.type) !== state.types.componentType
+  ) {
+    throw createUserError(
+      `Invalid Flight field, expected the parent type '${schema.getTypeString(
+        state.parentType,
+      )}' ` +
+        "to define a 'flight(component: String, props: ReactFlightProps): ReactFlightComponent' field",
+      [field.loc],
+    );
+  }
+
+  return {
+    ...field,
+    name: 'flight',
+    args: [
+      {
+        kind: 'Argument',
+        loc: field.loc,
+        name: FLIGHT_FIELD_COMPONENT_ARGUMENT_NAME,
+        type: schema.getTypeFromString(FLIGHT_FIELD_COMPONENT_ARGUMENT_TYPE),
+        value: {
+          kind: 'Literal',
+          value: componentName,
+          loc: field.loc,
+        },
+      },
+      {
+        kind: 'Argument',
+        loc: field.loc,
+        name: FLIGHT_FIELD_PROPS_ARGUMENT_NAME,
+        type: state.types.propsType,
+        value: {
+          kind: 'ObjectValue',
+          fields: field.args.map(arg => {
+            return {
+              kind: 'ObjectFieldValue',
+              loc: arg.loc,
+              name: arg.name,
+              value: arg.value,
+            };
+          }),
+          loc: field.loc,
+        },
+      },
+    ],
+    metadata: {
+      ...(field.metadata || {}),
+      flight: true,
+    },
+    type: state.types.componentType,
+  };
+}
+
+module.exports = {
+  transform: reactFlightComponentTransform,
+};