Unify handling of plural/nullabile resolver field types

Reviewed By: voideanvalue

Differential Revision: D46163784

fbshipit-source-id: 53d45bb87db299460404f7fc4cc4a56750bbf64e

compiler/crates/relay-typegen/src/visit.rs

@@ -330,9 +330,8 @@ fn generate_resolver_type(
             if is_relay_resolver_type(typegen_context, schema_field) {
                 AST::Mixed
             } else {
-                transform_type_reference_into_ast(&schema_field.type_, |type_| {
-                    expect_scalar_type(typegen_context, encountered_enums, custom_scalars, type_)
-                })
+                let type_ = &schema_field.type_.inner();
+                expect_scalar_type(typegen_context, encountered_enums, custom_scalars, type_)
             }
         }
         ResolverOutputTypeInfo::Composite(normalization_info) => {
@@ -341,38 +340,23 @@ fn generate_resolver_type(
                 Some(normalization_info.normalization_operation.location),
             );
 
-            let type_ = AST::Nullable(Box::new(AST::RawType(
-                normalization_info.normalization_operation.item.0,
-            )));
-
-            let ast = if let Some(field_type) = normalization_info.weak_object_instance_field {
-                transform_type_reference_into_ast(
-                    &typegen_context.schema.field(field_type).type_,
-                    |type_| {
-                        expect_scalar_type(
-                            typegen_context,
-                            encountered_enums,
-                            custom_scalars,
-                            type_,
-                        )
-                    },
-                )
+            if let Some(field_type) = normalization_info.weak_object_instance_field {
+                let type_ = &typegen_context.schema.field(field_type).type_.inner();
+                expect_scalar_type(typegen_context, encountered_enums, custom_scalars, type_)
             } else {
-                type_
-            };
-
-            if normalization_info.plural {
-                AST::ReadOnlyArray(Box::new(ast))
-            } else {
-                ast
+                AST::RawType(normalization_info.normalization_operation.item.0)
             }
         }
-        ResolverOutputTypeInfo::EdgeTo => {
-            create_edge_to_return_type_ast(schema_field, typegen_context.schema, runtime_imports)
-        }
+        ResolverOutputTypeInfo::EdgeTo => create_edge_to_return_type_ast(
+            &schema_field.type_.inner(),
+            typegen_context.schema,
+            runtime_imports,
+        ),
         ResolverOutputTypeInfo::Legacy => AST::Mixed,
     };
 
+    let ast = transform_type_reference_into_ast(&schema_field.type_, |_| inner_ast);
+
     let return_type = if matches!(
         typegen_context.project_config.typegen_config.language,
         TypegenLanguage::TypeScript
@@ -383,10 +367,10 @@ fn generate_resolver_type(
         runtime_imports.resolver_live_state_type = true;
         AST::GenericType {
             outer: *LIVE_STATE_TYPE,
-            inner: Box::new(inner_ast),
+            inner: Box::new(ast),
         }
     } else {
-        inner_ast
+        ast
     };
 
     AST::AssertFunctionType(FunctionTypeAssertion {
@@ -2324,16 +2308,13 @@ fn has_typename_selection(selections: &[TypeSelection]) -> bool {
 }
 
 fn create_edge_to_return_type_ast(
-    schema_field: &Field,
+    inner_type: &Type,
     schema: &SDLSchema,
     runtime_imports: &mut RuntimeImports,
 ) -> AST {
     // Mark that the DataID type is used, and must be imported.
     runtime_imports.data_id_type = true;
 
-    let schema_type_reference = &schema_field.type_;
-    let inner_type = schema_type_reference.inner();
-
     let mut fields = vec![Prop::KeyValuePair(KeyValuePairProp {
         // TODO consider reading the id field from the config. This must be done
         // in conjunction with runtime changes.
@@ -2342,10 +2323,10 @@ fn create_edge_to_return_type_ast(
         read_only: true,
         optional: false,
     })];
-    if inner_type.is_abstract_type() && schema.is_extension_type(inner_type) {
+    if inner_type.is_abstract_type() && schema.is_extension_type(*inner_type) {
         // Note: there is currently no way to create a resolver that returns an abstract
         // client type, so this branch will not be hit until we enable that feature.
-        let interface_id = schema_field.type_.inner().get_interface_id().expect(
+        let interface_id = inner_type.get_interface_id().expect(
             "Only interfaces are supported here. This indicates a bug in the Relay compiler.",
         );
         let valid_typenames = schema
@@ -2368,9 +2349,7 @@ fn create_edge_to_return_type_ast(
         }))
     }
 
-    transform_type_reference_into_ast(schema_type_reference, |_| {
-        AST::ExactObject(ExactObject::new(fields))
-    })
+    AST::ExactObject(ExactObject::new(fields))
 }
 
 fn expect_scalar_type(

compiler/crates/relay-typegen/tests/generate_flow/fixtures/relay-live-resolver-no-fragment.expected

@@ -19,7 +19,7 @@ import type { LiveState } from "relay-runtime/store/experimental-live-resolvers/
 import userPopStarNameResolverType from "PopStarNameResolver";
 // Type assertion validating that `userPopStarNameResolverType` resolver is correctly implemented.
 // A type error here indicates that the type signature of the resolver module is incorrect.
-(userPopStarNameResolverType: () => LiveState<mixed>);
+(userPopStarNameResolverType: () => LiveState<?mixed>);
 export type relayResolver_Query$variables = {||};
 export type relayResolver_Query$data = {|
   +me: ?{|

compiler/crates/relay-typegen/tests/generate_flow/fixtures/relay-live-resolver-with-field-args-no-fragment.expected

@@ -28,7 +28,7 @@ import userPopStarNameResolverType from "PopStarNameResolver";
     count: ?number,
     greeting: string,
   |},
-) => LiveState<mixed>);
+) => LiveState<?mixed>);
 export type relayResolver_Query$variables = {||};
 export type relayResolver_Query$data = {|
   +me: ?{|

compiler/crates/relay-typegen/tests/generate_flow/fixtures/relay-live-resolver-with-field-args.expected

@@ -31,7 +31,7 @@ import userPopStarNameResolverType from "PopStarNameResolver";
     count: ?number,
     greeting: string,
   |},
-) => LiveState<mixed>);
+) => LiveState<?mixed>);
 export type relayResolver_Query$variables = {||};
 export type relayResolver_Query$data = {|
   +me: ?{|

compiler/crates/relay-typegen/tests/generate_flow/fixtures/relay-live-resolver.expected

@@ -27,7 +27,7 @@ import userPopStarNameResolverType from "PopStarNameResolver";
 // A type error here indicates that the type signature of the resolver module is incorrect.
 (userPopStarNameResolverType: (
   rootKey: relayResolver_PopStarNameResolverFragment_name$key,
-) => LiveState<mixed>);
+) => LiveState<?mixed>);
 export type relayResolver_Query$variables = {||};
 export type relayResolver_Query$data = {|
   +me: ?{|

compiler/crates/relay-typegen/tests/generate_flow/fixtures/relay-resolver-in-fragment.expected

@@ -36,7 +36,7 @@ import userPopStarNameResolverType from "PopStarNameResolver";
 // A type error here indicates that the type signature of the resolver module is incorrect.
 (userPopStarNameResolverType: (
   rootKey: relayResolver_PopStarNameResolverFragment_name$key,
-) => mixed);
+) => ?mixed);
 declare export opaque type relayResolver_consumer$fragmentType: FragmentType;
 export type relayResolver_consumer$data = {|
   +pop_star_name: ?$Call<<R>((...empty[]) => R) => R, typeof userPopStarNameResolverType>,

compiler/crates/relay-typegen/tests/generate_flow/fixtures/relay-resolver-inject-fragment-data.expected

@@ -21,7 +21,7 @@ import userPopStarNameResolverType from "PopStarNameResolver";
 // A type error here indicates that the type signature of the resolver module is incorrect.
 (userPopStarNameResolverType: (
   name: relayResolver_PopStarNameResolverFragment_name$data['name'],
-) => mixed);
+) => ?mixed);
 export type relayResolver_Query$variables = {||};
 export type relayResolver_Query$data = {|
   +me: ?{|

compiler/crates/relay-typegen/tests/generate_flow/fixtures/relay-resolver-multiple-consumers.expected

@@ -28,7 +28,7 @@ import userPopStarNameResolverType from "PopStarNameResolver";
 // A type error here indicates that the type signature of the resolver module is incorrect.
 (userPopStarNameResolverType: (
   rootKey: relayResolver_PopStarNameResolverFragment_name$key,
-) => mixed);
+) => ?mixed);
 export type relayResolver_Query$variables = {||};
 export type relayResolver_Query$data = {|
   +me: ?{|

compiler/crates/relay-typegen/tests/generate_flow/fixtures/relay-resolver-named-import.expected

@@ -26,7 +26,7 @@ import {pop_star_name as userPopStarNameResolverType} from "PopStarNameResolver"
 // A type error here indicates that the type signature of the resolver module is incorrect.
 (userPopStarNameResolverType: (
   rootKey: relayResolverNamedImport_PopStarNameResolverFragment_name$key,
-) => mixed);
+) => ?mixed);
 export type relayResolverNamedImport_Query$variables = {||};
 export type relayResolverNamedImport_Query$data = {|
   +me: ?{|

compiler/crates/relay-typegen/tests/generate_flow/fixtures/relay-resolver-raw-response.expected

@@ -63,7 +63,7 @@ import userPopStarNameResolverType from "PopStarNameResolver";
 // A type error here indicates that the type signature of the resolver module is incorrect.
 (userPopStarNameResolverType: (
   rootKey: relayResolver_PopStarNameResolverFragment_name$key,
-) => mixed);
+) => ?mixed);
 declare export opaque type relayResolver_user$fragmentType: FragmentType;
 export type relayResolver_user$data = {|
   +pop_star_name: ?$Call<<R>((...empty[]) => R) => R, typeof userPopStarNameResolverType>,

compiler/crates/relay-typegen/tests/generate_flow/fixtures/relay-resolver-required.expected

@@ -25,7 +25,7 @@ import userPopStarNameResolverType from "PopStarNameResolver";
 // A type error here indicates that the type signature of the resolver module is incorrect.
 (userPopStarNameResolverType: (
   rootKey: relayResolver_PopStarNameResolverFragment_name$key,
-) => mixed);
+) => ?mixed);
 export type relayResolver_Query$variables = {||};
 export type relayResolver_Query$data = {|
   +me: ?{|

compiler/crates/relay-typegen/tests/generate_flow/fixtures/relay-resolver-scalar-plural.expected

@@ -0,0 +1,50 @@
+==================================== INPUT ====================================
+fragment relayResolver_PopStarNameResolverFragment_name on User {
+  name
+}
+
+query relayResolver_Query {
+  me {
+    pop_star_name
+  }
+}
+
+# %extensions%
+
+extend type User {
+  pop_star_name: [RelayResolverValue]
+    @relay_resolver(
+      fragment_name: "relayResolver_PopStarNameResolverFragment_name"
+      import_path: "./foo/bar/baz/PopStarNameResolver.js"
+    )
+}
+==================================== OUTPUT ===================================
+import type { relayResolver_PopStarNameResolverFragment_name$key } from "relayResolver_PopStarNameResolverFragment_name.graphql";
+import userPopStarNameResolverType from "PopStarNameResolver";
+// Type assertion validating that `userPopStarNameResolverType` resolver is correctly implemented.
+// A type error here indicates that the type signature of the resolver module is incorrect.
+(userPopStarNameResolverType: (
+  rootKey: relayResolver_PopStarNameResolverFragment_name$key,
+) => ?$ReadOnlyArray<?mixed>);
+export type relayResolver_Query$variables = {||};
+export type relayResolver_Query$data = {|
+  +me: ?{|
+    +pop_star_name: ?$Call<<R>((...empty[]) => R) => R, typeof userPopStarNameResolverType>,
+  |},
+|};
+export type relayResolver_Query = {|
+  response: relayResolver_Query$data,
+  variables: relayResolver_Query$variables,
+|};
+-------------------------------------------------------------------------------
+import type { FragmentType } from "relay-runtime";
+declare export opaque type relayResolver_PopStarNameResolverFragment_name$fragmentType: FragmentType;
+export type relayResolver_PopStarNameResolverFragment_name$data = {|
+  +name: ?string,
+  +$fragmentType: relayResolver_PopStarNameResolverFragment_name$fragmentType,
+|};
+export type relayResolver_PopStarNameResolverFragment_name$key = {
+  +$data?: relayResolver_PopStarNameResolverFragment_name$data,
+  +$fragmentSpreads: relayResolver_PopStarNameResolverFragment_name$fragmentType,
+  ...
+};

compiler/crates/relay-typegen/tests/generate_flow/fixtures/relay-resolver-scalar-plural.graphql

@@ -0,0 +1,19 @@
+fragment relayResolver_PopStarNameResolverFragment_name on User {
+  name
+}
+
+query relayResolver_Query {
+  me {
+    pop_star_name
+  }
+}
+
+# %extensions%
+
+extend type User {
+  pop_star_name: [RelayResolverValue]
+    @relay_resolver(
+      fragment_name: "relayResolver_PopStarNameResolverFragment_name"
+      import_path: "./foo/bar/baz/PopStarNameResolver.js"
+    )
+}

compiler/crates/relay-typegen/tests/generate_flow/fixtures/relay-resolver-with-output-type-client-object-plural.expected

@@ -0,0 +1,80 @@
+==================================== INPUT ====================================
+fragment Foo_user on User {
+  poppy: pop_star_name {
+    __typename
+  }
+}
+
+fragment PopStarNameResolverFragment_name on User {
+  name
+  address {
+    street
+  }
+  parents {
+    lastName
+  }
+}
+
+# %extensions%
+
+type ClientUser {
+  name: String
+}
+
+extend type User {
+  pop_star_name: [ClientUser]
+    @relay_resolver(
+      fragment_name: "PopStarNameResolverFragment_name"
+      import_path: "PopStarNameResolver"
+      has_output_type: true
+    )
+}
+==================================== OUTPUT ===================================
+export type User__pop_star_name$normalization$variables = {||};
+export type User__pop_star_name$normalization$data = {|
+  +name: ?string,
+|};
+export type User__pop_star_name$normalization = {|
+  response: User__pop_star_name$normalization$data,
+  variables: User__pop_star_name$normalization$variables,
+|};
+-------------------------------------------------------------------------------
+import type { PopStarNameResolverFragment_name$key } from "PopStarNameResolverFragment_name.graphql";
+import type { User__pop_star_name$normalization } from "User__pop_star_name$normalization.graphql";
+import type { FragmentType } from "relay-runtime";
+import userPopStarNameResolverType from "PopStarNameResolver";
+// Type assertion validating that `userPopStarNameResolverType` resolver is correctly implemented.
+// A type error here indicates that the type signature of the resolver module is incorrect.
+(userPopStarNameResolverType: (
+  rootKey: PopStarNameResolverFragment_name$key,
+) => ?$ReadOnlyArray<?User__pop_star_name$normalization>);
+declare export opaque type Foo_user$fragmentType: FragmentType;
+export type Foo_user$data = {|
+  +poppy: ?$ReadOnlyArray<?{|
+    +__typename: "ClientUser",
+  |}>,
+  +$fragmentType: Foo_user$fragmentType,
+|};
+export type Foo_user$key = {
+  +$data?: Foo_user$data,
+  +$fragmentSpreads: Foo_user$fragmentType,
+  ...
+};
+-------------------------------------------------------------------------------
+import type { FragmentType } from "relay-runtime";
+declare export opaque type PopStarNameResolverFragment_name$fragmentType: FragmentType;
+export type PopStarNameResolverFragment_name$data = {|
+  +address: ?{|
+    +street: ?string,
+  |},
+  +name: ?string,
+  +parents: $ReadOnlyArray<{|
+    +lastName: ?string,
+  |}>,
+  +$fragmentType: PopStarNameResolverFragment_name$fragmentType,
+|};
+export type PopStarNameResolverFragment_name$key = {
+  +$data?: PopStarNameResolverFragment_name$data,
+  +$fragmentSpreads: PopStarNameResolverFragment_name$fragmentType,
+  ...
+};

compiler/crates/relay-typegen/tests/generate_flow/fixtures/relay-resolver-with-output-type-client-object-plural.graphql

@@ -0,0 +1,30 @@
+fragment Foo_user on User {
+  poppy: pop_star_name {
+    __typename
+  }
+}
+
+fragment PopStarNameResolverFragment_name on User {
+  name
+  address {
+    street
+  }
+  parents {
+    lastName
+  }
+}
+
+# %extensions%
+
+type ClientUser {
+  name: String
+}
+
+extend type User {
+  pop_star_name: [ClientUser]
+    @relay_resolver(
+      fragment_name: "PopStarNameResolverFragment_name"
+      import_path: "PopStarNameResolver"
+      has_output_type: true
+    )
+}