fn build_fragment_metadata()

in compiler/crates/relay-codegen/src/build_ast.rs [215:309]

• 92 lines of code
• 11 McCabe index (conditional complexity)

    fn build_fragment_metadata(&mut self, fragment: &FragmentDefinition) -> Primitive {
        let connection_metadata = extract_connection_metadata_from_directive(&fragment.directives);

        let mut plural = false;
        let mut unmask = false;
        if let Some(relay_directive) = RelayDirective::find(&fragment.directives) {
            plural = relay_directive.plural;
            unmask = relay_directive.unmask;
        };

        let mut metadata = vec![];
        if let Some(connection_metadata) = &connection_metadata {
            metadata.push(self.build_connection_metadata(connection_metadata))
        }
        if unmask {
            metadata.push(ObjectEntry {
                key: CODEGEN_CONSTANTS.mask,
                value: Primitive::Bool(false),
            })
        }
        if plural {
            metadata.push(ObjectEntry {
                key: CODEGEN_CONSTANTS.plural,
                value: Primitive::Bool(true),
            })
        }
        if let Some(refetch_metadata) = RefetchableMetadata::find(&fragment.directives) {
            let refetch_connection = if let Some(connection_metadata) = connection_metadata {
                let metadata = &connection_metadata[0]; // Validated in `transform_refetchable`
                let connection_object = object! {
                    forward: if let Some(first) = metadata.first {
                        Primitive::Key(self.object(object!{
                            count: Primitive::String(first),
                            cursor: Primitive::string_or_null(metadata.after),
                        }))
                    } else {
                        Primitive::Null
                    },
                    backward: if let Some(last) = metadata.last {
                        Primitive::Key(self.object(object!{
                            count: Primitive::String(last),
                            cursor: Primitive::string_or_null(metadata.before),
                        }))
                    } else {
                        Primitive::Null
                    },
                    path: Primitive::Key(
                        self.array(
                            metadata
                                .path
                                .as_ref()
                                .expect("Expected path to exist")
                                .iter()
                                .cloned()
                                .map(Primitive::String)
                                .collect(),
                        ),
                    ),
                };
                Primitive::Key(self.object(connection_object))
            } else {
                Primitive::SkippableNull
            };
            let mut refetch_object = object! {
                connection: refetch_connection,
                fragment_path_in_result: Primitive::Key(
                        self.array(
                            refetch_metadata
                                .path
                                .iter()
                                .copied()
                                .map(Primitive::String)
                                .collect(),
                        ),
                    ),
                operation: Primitive::GraphQLModuleDependency(refetch_metadata.operation_name),
            };
            if let Some(identifier_field) = refetch_metadata.identifier_field {
                refetch_object.push(ObjectEntry {
                    key: CODEGEN_CONSTANTS.identifier_field,
                    value: Primitive::String(identifier_field),
                });
            }

            metadata.push(ObjectEntry {
                key: CODEGEN_CONSTANTS.refetch,
                value: Primitive::Key(self.object(refetch_object)),
            })
        }
        if metadata.is_empty() {
            Primitive::SkippableNull
        } else {
            Primitive::Key(self.object(metadata))
        }
    }