relay-compiler 10.0.1 → 10.1.0

package/codegen/NormalizationCodeGenerator.js.flow

@@ -46,7 +46,6 @@ import type {
   NormalizationLocalArgumentDefinition,
   NormalizationModuleImport,
   NormalizationOperation,
-  NormalizationScalarField,
   NormalizationSelection,
   NormalizationSplitOperation,
   NormalizationStream,
@@ -290,7 +289,6 @@ function generateLinkedField(
           kind: 'LinkedHandle',
           name: node.name,
         };
-        // T45504512: new connection model
         // NOTE: this intentionally adds a dynamic key in order to avoid
         // triggering updates to existing queries that do not use dynamic
         // keys.
@@ -392,7 +390,7 @@ function generateScalarField(node): Array<NormalizationSelection> {
             [handle.dynamicKey.loc],
           );
         }
-        return {
+        const nodeHandle = {
           alias: node.alias === node.name ? null : node.alias,
           args: generateArgs(node.args),
           filters: handle.filters,
@@ -401,9 +399,16 @@ function generateScalarField(node): Array<NormalizationSelection> {
           kind: 'ScalarHandle',
           name: node.name,
         };
+
+        if (handle.handleArgs != null) {
+          // $FlowFixMe handleArgs exists in Handle
+          nodeHandle.handleArgs = generateArgs(handle.handleArgs);
+        }
+
+        return nodeHandle;
       })) ||
     [];
-  let field: NormalizationScalarField = {
+  let field = {
     alias: node.alias === node.name ? null : node.alias,
     args: generateArgs(node.args),
     kind: 'ScalarField',
@@ -415,6 +420,9 @@ function generateScalarField(node): Array<NormalizationSelection> {
   if (storageKey != null) {
     field = {...field, storageKey};
   }
+  if (node.metadata?.flight === true) {
+    field = {...field, kind: 'FlightField'};
+  }
   return [field].concat(handles);
 }
 

package/codegen/ReaderCodeGenerator.js.flow

@@ -39,16 +39,20 @@ import type {
   InlineDataFragmentSpread,
 } from '../core/IR';
 import type {Schema, TypeID} from '../core/Schema';
+import type {RequiredDirectiveMetadata} from '../transforms/RequiredFieldTransform';
 import type {
   ReaderArgument,
   ReaderArgumentDefinition,
   ReaderField,
+  ReaderFlightField,
   ReaderFragment,
   ReaderInlineDataFragmentSpread,
   ReaderLinkedField,
   ReaderModuleImport,
+  ReaderRequiredField,
   ReaderScalarField,
   ReaderSelection,
+  RequiredFieldAction,
 } from 'relay-runtime';
 
 /**
@@ -267,7 +271,7 @@ function generateInlineDataFragmentSpread(
 function generateLinkedField(
   schema: Schema,
   node: LinkedField,
-): ReaderLinkedField {
+): ReaderLinkedField | ReaderRequiredField {
   // Note: it is important that the arguments of this field be sorted to
   // ensure stable generation of storage keys for equivalent arguments
   // which may have originally appeared in different orders across an app.
@@ -298,9 +302,26 @@ function generateLinkedField(
   if (storageKey) {
     field = {...field, storageKey};
   }
+  const requiredMetadata: ?RequiredDirectiveMetadata = (node.metadata
+    ?.required: $FlowFixMe);
+  if (requiredMetadata != null) {
+    return createRequiredField(field, requiredMetadata);
+  }
   return field;
 }
 
+function createRequiredField(
+  field: ReaderField,
+  requiredMetadata: RequiredDirectiveMetadata,
+): ReaderRequiredField {
+  return {
+    kind: 'RequiredField',
+    field,
+    action: requiredMetadata.action,
+    path: requiredMetadata.path,
+  };
+}
+
 function generateModuleImport(
   schema: Schema,
   node: ModuleImport,
@@ -335,7 +356,7 @@ function generateModuleImport(
 function generateScalarField(
   schema: Schema,
   node: ScalarField,
-): ReaderScalarField {
+): ReaderScalarField | ReaderRequiredField | ReaderFlightField {
   // Note: it is important that the arguments of this field be sorted to
   // ensure stable generation of storage keys for equivalent arguments
   // which may have originally appeared in different orders across an app.
@@ -349,7 +370,7 @@ function generateScalarField(
   //     'ReaderCodeGenerator: unexpected handles',
   //   );
 
-  let field: ReaderScalarField = {
+  let field = {
     alias: node.alias === node.name ? null : node.alias,
     args: generateArgs(node.args),
     kind: 'ScalarField',
@@ -361,6 +382,20 @@ function generateScalarField(
   if (storageKey) {
     field = {...field, storageKey};
   }
+  if (node.metadata?.flight === true) {
+    field = {...field, kind: 'FlightField'};
+  }
+  const requiredMetadata: ?RequiredDirectiveMetadata = (node.metadata
+    ?.required: $FlowFixMe);
+  if (requiredMetadata != null) {
+    if (field.kind === 'FlightField') {
+      throw new createUserError(
+        '@required cannot be used on a ReactFlightComponent.',
+        [node.loc],
+      );
+    }
+    return createRequiredField(field, requiredMetadata);
+  }
   return field;
 }
 

package/codegen/RelayFileWriter.js.flow

@@ -146,7 +146,9 @@ function writeAll({
 }: {|
   config: WriterConfig,
   onlyValidate: boolean,
+  // $FlowFixMe[value-as-type]
   baseDocuments: ImmutableMap<string, DocumentNode>,
+  // $FlowFixMe[value-as-type]
   documents: ImmutableMap<string, DocumentNode>,
   schema: Schema,
   reporter: Reporter,

package/codegen/writeRelayGeneratedFile.js.flow

@@ -68,7 +68,7 @@ function writeRelayGeneratedFile(
   ) => void,
   languagePlugin: ?PluginInterface,
 ): Promise<?GeneratedNode> {
-  let generatedNode = _generatedNode;
+  let generatedNode: GeneratedNode = _generatedNode;
   // Copy to const so Flow can refine.
   const persistQuery = _persistQuery;
   const operationName =

package/core/ASTCache.js.flow

@@ -35,6 +35,7 @@ class ASTCache {
   }
 
   // Short-term: we don't do subscriptions/delta updates, instead always use all definitions
+  // $FlowFixMe[value-as-type]
   documents(): ImmutableMap<string, DocumentNode> {
     return ImmutableMap(this._documents);
   }

package/core/CompilerContext.js.flow

@@ -34,6 +34,7 @@ export type CompilerContextDocument = Fragment | Root | SplitOperation;
  */
 class CompilerContext {
   _isMutable: boolean;
+  // $FlowFixMe[value-as-type]
   _documents: ImmutableOrderedMap<string, CompilerContextDocument>;
   _withTransform: WeakMap<IRTransform, CompilerContext>;
   +_schema: Schema;

package/core/IR.js.flow

@@ -178,7 +178,6 @@ export type InlineFragment = {|
 export type Handle = {|
   +name: string,
   +key: string,
-  // T45504512: new connection model
   +dynamicKey: Variable | null,
   +filters: ?$ReadOnlyArray<string>,
   +handleArgs?: $ReadOnlyArray<Argument>,

package/core/IRPrinter.js.flow

@@ -377,21 +377,16 @@ function printValue(
   if (value.kind === 'Variable') {
     return '$' + value.variableName;
   } else if (value.kind === 'ObjectValue') {
-    invariant(
-      type && schema.isInputObject(type),
-      'GraphQLIRPrinter: Need an InputObject type to print objects.',
-    );
-    const inputType = schema.assertInputObjectType(type);
+    const inputType = type != null ? schema.asInputObjectType(type) : null;
     const pairs = value.fields
       .map(field => {
         const fieldConfig =
-          type != null
+          inputType != null
             ? schema.hasField(inputType, field.name)
               ? schema.getFieldConfig(schema.expectField(inputType, field.name))
               : null
             : null;
-        const innerValue =
-          fieldConfig && printValue(schema, field.value, fieldConfig.type);
+        const innerValue = printValue(schema, field.value, fieldConfig?.type);
         return innerValue == null ? null : field.name + ': ' + innerValue;
       })
       .filter(Boolean);

package/core/RelayIRTransforms.js.flow

@@ -20,6 +20,7 @@ const DeferStreamTransform = require('../transforms/DeferStreamTransform');
 const DisallowIdAsAlias = require('../transforms/DisallowIdAsAlias');
 const DisallowTypenameOnRoot = require('../transforms/DisallowTypenameOnRoot');
 const FieldHandleTransform = require('../transforms/FieldHandleTransform');
+const FilterCompilerDirectivesTransform = require('../transforms/FilterCompilerDirectivesTransform');
 const FilterDirectivesTransform = require('../transforms/FilterDirectivesTransform');
 const FlattenTransform = require('../transforms/FlattenTransform');
 const GenerateIDFieldTransform = require('../transforms/GenerateIDFieldTransform');
@@ -28,9 +29,11 @@ const InlineDataFragmentTransform = require('../transforms/InlineDataFragmentTra
 const InlineFragmentsTransform = require('../transforms/InlineFragmentsTransform');
 const MaskTransform = require('../transforms/MaskTransform');
 const MatchTransform = require('../transforms/MatchTransform');
+const ReactFlightComponentTransform = require('../transforms/ReactFlightComponentTransform');
 const RefetchableFragmentTransform = require('../transforms/RefetchableFragmentTransform');
 const RelayDirectiveTransform = require('../transforms/RelayDirectiveTransform');
 const RelayFlowGenerator = require('../language/javascript/RelayFlowGenerator');
+const RequiredFieldTransform = require('../transforms/RequiredFieldTransform');
 const SkipClientExtensionsTransform = require('../transforms/SkipClientExtensionsTransform');
 const SkipHandleFieldTransform = require('../transforms/SkipHandleFieldTransform');
 const SkipRedundantNodesTransform = require('../transforms/SkipRedundantNodesTransform');
@@ -51,6 +54,7 @@ const relaySchemaExtensions: $ReadOnlyArray<string> = [
   DeclarativeConnectionMutationTransform.SCHEMA_EXTENSION,
   InlineDataFragmentTransform.SCHEMA_EXTENSION,
   MatchTransform.SCHEMA_EXTENSION,
+  RequiredFieldTransform.SCHEMA_EXTENSION,
   RefetchableFragmentTransform.SCHEMA_EXTENSION,
   RelayDirectiveTransform.SCHEMA_EXTENSION,
   RelayFlowGenerator.SCHEMA_EXTENSION,
@@ -68,6 +72,7 @@ const relayCommonTransforms: $ReadOnlyArray<IRTransform> = [
   MatchTransform.transform,
   RefetchableFragmentTransform.transform,
   DeferStreamTransform.transform,
+  ReactFlightComponentTransform.transform,
 ];
 
 // Transforms applied to fragments used for reading data from a store
@@ -76,6 +81,7 @@ const relayFragmentTransforms: $ReadOnlyArray<IRTransform> = [
   FieldHandleTransform.transform,
   InlineDataFragmentTransform.transform,
   FlattenTransform.transformWithOptions({isForCodegen: true}),
+  RequiredFieldTransform.transform,
   SkipRedundantNodesTransform.transform,
 ];
 
@@ -93,6 +99,7 @@ const relayQueryTransforms: $ReadOnlyArray<IRTransform> = [
 
 // Transforms applied to the code used to process a query response.
 const relayCodegenTransforms: $ReadOnlyArray<IRTransform> = [
+  FilterCompilerDirectivesTransform.transform,
   SkipUnreachableNodeTransform.transform,
   InlineFragmentsTransform.transform,
   // NOTE: For the codegen context, we make sure to run ClientExtensions

package/core/Schema.js.flow

@@ -133,10 +133,21 @@ type InternalArgumentStruct = $ReadOnly<{|
 
 type FieldDefinition = {|
   +arguments: $ReadOnlyArray<InternalArgumentStruct>,
+  +directives: ?$ReadOnlyArray<DirectiveInvocation>,
   +type: TypeNode,
   +isClient: boolean,
 |};
 
+type DirectiveInvocation = {|
+  +name: string,
+  +args: $ReadOnlyArray<ArgumentValue>,
+|};
+
+type ArgumentValue = {|
+  +name: string,
+  +value: ValueNode,
+|};
+
 type InternalDirectiveMap = Map<string, InternalDirectiveStruct>;
 
 type InternalDirectiveStruct = $ReadOnly<{|
@@ -251,6 +262,7 @@ class NonNull<+T> {
  */
 class Field {
   +args: $ReadOnlyMap<string, Argument>;
+  +directives: ?$ReadOnlyArray<DirectiveInvocation>;
   +belongsTo: CompositeType | InputObjectType;
   +name: string;
   +type: TypeID;
@@ -262,6 +274,7 @@ class Field {
     type: TypeID,
     belongsTo: CompositeType | InputObjectType,
     args: $ReadOnlyArray<InternalArgumentStruct>,
+    directives: ?$ReadOnlyArray<DirectiveInvocation>,
     isClient: boolean,
   ) {
     this.name = name;
@@ -269,6 +282,7 @@ class Field {
     this.belongsTo = belongsTo;
     this.isClient = isClient;
     this.args = parseInputArgumentDefinitionsMap(schema, args);
+    this.directives = directives;
   }
 }
 
@@ -528,6 +542,21 @@ class Schema {
     return type;
   }
 
+  mapListItemType(type: TypeID, mapper: (inner: TypeID) => TypeID): TypeID {
+    if (!(type instanceof List)) {
+      throw createCompilerError('Expected List type');
+    }
+    const innerType = mapper(type.ofType);
+    const cacheKey = `[${this.getTypeString(innerType)}]`;
+    let newType = this._typeWrappersMap.get(cacheKey);
+    if (newType) {
+      return newType;
+    }
+    newType = new List(innerType);
+    this._typeWrappersMap.set(cacheKey, newType);
+    return newType;
+  }
+
   areEqualTypes(typeA: TypeID, typeB: TypeID): boolean {
     if (typeA === typeB) {
       return true;
@@ -758,6 +787,13 @@ class Schema {
     return type;
   }
 
+  asInputObjectType(type: TypeID): ?InputObjectTypeID {
+    if (!isInputObject(type)) {
+      return null;
+    }
+    return type;
+  }
+
   assertInterfaceType(type: TypeID): InterfaceTypeID {
     if (!isInterface(type)) {
       throw createCompilerError(
@@ -1066,6 +1102,7 @@ class Schema {
               fieldType,
               this.assertCompositeType(type),
               fieldDefinition.arguments,
+              fieldDefinition.directives,
               fieldDefinition.isClient,
             ),
           );
@@ -1078,7 +1115,7 @@ class Schema {
           const fieldType = this.expectTypeFromAST(typeNode);
           fieldsMap.set(
             fieldName,
-            new Field(this, fieldName, fieldType, type, [], false),
+            new Field(this, fieldName, fieldType, type, [], null, false),
           );
         }
       }
@@ -1111,6 +1148,7 @@ class Schema {
           this.getNonNullType(this.expectStringType()),
           type,
           [],
+          null,
           false, // isClient === false
         );
         this._typeNameMap.set(type, typename);
@@ -1127,6 +1165,7 @@ class Schema {
           this.getNonNullType(this.expectIdType()),
           type,
           [],
+          null,
           true, // isClient === true
         );
         this._clientIdMap.set(type, clientId);
@@ -1685,6 +1724,21 @@ class TypeMap {
               };
             })
           : [],
+        directives: fieldNode.directives
+          ? fieldNode.directives.map(directive => {
+              return {
+                name: directive.name.value,
+                args: directive.arguments
+                  ? directive.arguments.map(arg => {
+                      return {
+                        name: arg.name.value,
+                        value: arg.value,
+                      };
+                    })
+                  : [],
+              };
+            })
+          : null,
         type: fieldNode.type,
         isClient: isClient,
       });

package/index.js

@@ -1,5 +1,5 @@
 /**
- * Relay v10.0.1
+ * Relay v10.1.0
  *
  * Copyright (c) Facebook, Inc. and its affiliates.
  *

package/language/javascript/FindGraphQLTags.js.flow

@@ -46,79 +46,10 @@ const BABYLON_OPTIONS = {
 
 function find(text: string): $ReadOnlyArray<GraphQLTag> {
   const result: Array<GraphQLTag> = [];
+  // $FlowFixMe Discovered when typing babel/parser
   const ast = babylon.parse(text, BABYLON_OPTIONS);
 
   const visitors = {
-    CallExpression: node => {
-      const callee = node.callee;
-      if (
-        !(
-          (callee.type === 'Identifier' &&
-            CREATE_CONTAINER_FUNCTIONS[callee.name]) ||
-          (callee.kind === 'MemberExpression' &&
-            callee.object.type === 'Identifier' &&
-            callee.object.value === 'Relay' &&
-            callee.property.type === 'Identifier' &&
-            CREATE_CONTAINER_FUNCTIONS[callee.property.name])
-        )
-      ) {
-        traverse(node, visitors);
-        return;
-      }
-      const fragments = node.arguments[1];
-      if (fragments.type === 'ObjectExpression') {
-        fragments.properties.forEach(property => {
-          invariant(
-            property.type === 'ObjectProperty' &&
-              property.key.type === 'Identifier' &&
-              property.value.type === 'TaggedTemplateExpression',
-            'FindGraphQLTags: `%s` expects fragment definitions to be ' +
-              '`key: graphql`.',
-            node.callee.name,
-          );
-          invariant(
-            isGraphQLModernOrDeprecatedTag(property.value.tag),
-            'FindGraphQLTags: `%s` expects fragment definitions to be tagged ' +
-              'with `graphql`, got `%s`.',
-            node.callee.name,
-            getSourceTextForLocation(text, property.value.tag.loc),
-          );
-          if (isGraphQLTag(property.value.tag)) {
-            result.push({
-              keyName: property.key.name,
-              template: getGraphQLText(property.value.quasi),
-              sourceLocationOffset: getSourceLocationOffset(
-                property.value.quasi,
-              ),
-            });
-          }
-        });
-      } else {
-        invariant(
-          fragments && fragments.type === 'TaggedTemplateExpression',
-          'FindGraphQLTags: `%s` expects a second argument of fragment ' +
-            'definitions.',
-          node.callee.name,
-        );
-        invariant(
-          isGraphQLModernOrDeprecatedTag(fragments.tag),
-          'FindGraphQLTags: `%s` expects fragment definitions to be tagged ' +
-            'with `graphql`, got `%s`.',
-          node.callee.name,
-          getSourceTextForLocation(text, fragments.tag.loc),
-        );
-        result.push({
-          keyName: null,
-          template: getGraphQLText(fragments.quasi),
-          sourceLocationOffset: getSourceLocationOffset(fragments.quasi),
-        });
-      }
-
-      // Visit remaining arguments
-      for (let ii = 2; ii < node.arguments.length; ii++) {
-        visit(node.arguments[ii], visitors);
-      }
-    },
     TaggedTemplateExpression: node => {
       if (isGraphQLTag(node.tag)) {
         result.push({
@@ -133,12 +64,6 @@ function find(text: string): $ReadOnlyArray<GraphQLTag> {
   return result;
 }
 
-const CREATE_CONTAINER_FUNCTIONS = Object.create(null, {
-  createFragmentContainer: {value: true},
-  createPaginationContainer: {value: true},
-  createRefetchContainer: {value: true},
-});
-
 const IGNORED_KEYS = {
   comments: true,
   end: true,
@@ -154,13 +79,6 @@ function isGraphQLTag(tag): boolean {
   return tag.type === 'Identifier' && tag.name === 'graphql';
 }
 
-function isGraphQLModernOrDeprecatedTag(tag): boolean {
-  return (
-    tag.type === 'Identifier' &&
-    (tag.name === 'graphql' || tag.name === 'graphql_DEPRECATED')
-  );
-}
-
 function getTemplateNode(quasi) {
   const quasis = quasi.quasis;
   invariant(
@@ -170,10 +88,6 @@ function getTemplateNode(quasi) {
   return quasis[0];
 }
 
-function getGraphQLText(quasi): string {
-  return getTemplateNode(quasi).value.raw;
-}
-
 function getSourceLocationOffset(quasi) {
   const loc = getTemplateNode(quasi).loc.start;
   return {
@@ -182,16 +96,6 @@ function getSourceLocationOffset(quasi) {
   };
 }
 
-function getSourceTextForLocation(text, loc) {
-  if (loc == null) {
-    return '(source unavailable)';
-  }
-  const lines = text.split('\n').slice(loc.start.line - 1, loc.end.line);
-  lines[0] = lines[0].slice(loc.start.column);
-  lines[lines.length - 1] = lines[lines.length - 1].slice(0, loc.end.column);
-  return lines.join('\n');
-}
-
 function invariant(condition, msg, ...args) {
   if (!condition) {
     throw new Error(util.format(msg, ...args));
@@ -199,6 +103,7 @@ function invariant(condition, msg, ...args) {
 }
 
 function visit(node, visitors) {
+  // $FlowFixMe Discovered when typing babel
   const fn = visitors[node.type];
   if (fn != null) {
     fn(node);

package/language/javascript/RelayFlowBabelFactories.js.flow

@@ -15,13 +15,13 @@
 const invariant = require('invariant');
 const t = require('@babel/types');
 
-type BabelAST = mixed;
+type BabelAST = BabelNode_DEPRECATED;
 
 /**
  * type NAME = any;
  */
 function anyTypeAlias(name: string): BabelAST {
-  return t.typeAlias(t.identifier(name), null, t.anyTypeAnnotation());
+  return t.typeAlias(t.identifier(name), undefined, t.anyTypeAnnotation());
 }
 
 /**
@@ -29,9 +29,7 @@ function anyTypeAlias(name: string): BabelAST {
  *   PROPS
  * |}
  */
-function exactObjectTypeAnnotation(
-  props: $ReadOnlyArray<BabelAST>,
-): $FlowFixMe {
+function exactObjectTypeAnnotation(props: Array<BabelAST>): $FlowFixMe {
   const typeAnnotation = t.objectTypeAnnotation(props);
   typeAnnotation.exact = true;
   return typeAnnotation;
@@ -43,9 +41,7 @@ function exactObjectTypeAnnotation(
  *   ...
  * }
  */
-function inexactObjectTypeAnnotation(
-  props: $ReadOnlyArray<BabelAST>,
-): $FlowFixMe {
+function inexactObjectTypeAnnotation(props: Array<BabelAST>): $FlowFixMe {
   const typeAnnotation = t.objectTypeAnnotation(props);
   typeAnnotation.inexact = true;
   return typeAnnotation;
@@ -56,9 +52,9 @@ function inexactObjectTypeAnnotation(
  */
 function exportType(name: string, type: BabelAST): $FlowFixMe {
   return t.exportNamedDeclaration(
-    t.typeAlias(t.identifier(name), null, type),
+    t.typeAlias(t.identifier(name), undefined, type),
     [],
-    null,
+    undefined,
   );
 }
 
@@ -67,12 +63,12 @@ function exportType(name: string, type: BabelAST): $FlowFixMe {
  */
 function exportTypes(names: $ReadOnlyArray<string>): $FlowFixMe {
   const res = t.exportNamedDeclaration(
-    null,
+    undefined,
     names.map(name =>
       t.exportSpecifier(t.identifier(name), t.identifier(name)),
     ),
 
-    null,
+    undefined,
   );
   res.exportKind = 'type';
   return res;
@@ -85,7 +81,7 @@ function declareExportOpaqueType(name: string, value: string): $FlowFixMe {
   return t.declareExportDeclaration(
     t.declareOpaqueType(
       t.identifier(name),
-      null,
+      undefined,
       t.genericTypeAnnotation(t.identifier(value)),
     ),
   );
@@ -113,7 +109,7 @@ function importTypes(
  *
  * TYPES[0] & TYPES[1] & ...
  */
-function intersectionTypeAnnotation(types: $ReadOnlyArray<BabelAST>): BabelAST {
+function intersectionTypeAnnotation(types: Array<BabelAST>): BabelAST {
   invariant(
     types.length > 0,
     'RelayFlowBabelFactories: cannot create an intersection of 0 types',
@@ -155,7 +151,7 @@ function stringLiteralTypeAnnotation(value: string): $FlowFixMe {
  *
  * TYPES[0] | TYPES[1] | ...
  */
-function unionTypeAnnotation(types: $ReadOnlyArray<BabelAST>): BabelAST {
+function unionTypeAnnotation(types: Array<BabelAST>): BabelAST {
   invariant(
     types.length > 0,
     'RelayFlowBabelFactories: cannot create a union of 0 types',