fn validate_edges_spec()

in compiler/crates/relay-transforms/src/validations/validate_connections.rs [162:247]

• 84 lines of code
• 8 McCabe index (conditional complexity)

    fn validate_edges_spec(
        &self,
        connection_field: &LinkedField,
        connection_schema_field: &Field,
        connection_field_type: Type,
        connection_directive: &Directive,
        edges_field: &LinkedField,
    ) -> DiagnosticsResult<()> {
        let schema = &self.program.schema;
        let connection_directive_name = connection_directive.name.item;
        let connection_type_name = schema.get_type_name(connection_field_type);
        let connection_field_name = connection_schema_field.name.item;
        let edges_selection_name = self.connection_interface.edges;

        // Validate edges selection
        let (_, edges_type) = self.validate_selection(
            connection_field_type,
            edges_selection_name,
            |_, edges_type| edges_type.is_list() && edges_type.inner().is_object_or_interface(),
            || {
                vec![
                    Diagnostic::error(
                        ValidationMessage::ExpectedConnectionToExposeValidEdgesField {
                            connection_directive_name,
                            connection_field_name,
                            connection_type_name,
                            edges_selection_name,
                        },
                        connection_field.definition.location,
                    )
                    .annotate("invalid field type", edges_field.definition.location),
                ]
            },
        )?;

        let edge_type = edges_type.inner();
        let node_selection_name = self.connection_interface.node;
        let cursor_selection_name = self.connection_interface.cursor;
        validate!(
            // Validate edges.node selection
            self.validate_selection(
                edge_type,
                node_selection_name,
                |_, node_type| {
                    !node_type.is_list()
                        && (node_type.inner().is_abstract_type() || node_type.inner().is_object())
                },
                || {
                    vec![
                        Diagnostic::error(
                            ValidationMessage::ExpectedConnectionToExposeValidNodeField {
                                connection_directive_name,
                                connection_field_name,
                                connection_type_name,
                                edges_selection_name,
                                node_selection_name,
                            },
                            connection_field.definition.location,
                        )
                        .annotate("field with invalid type", edges_field.definition.location),
                    ]
                },
            ),
            // Validate edges.cursor selection
            self.validate_selection(
                edge_type,
                cursor_selection_name,
                |_, cursor_type| !cursor_type.is_list() && cursor_type.inner().is_scalar(),
                || {
                    vec![
                        Diagnostic::error(
                            ValidationMessage::ExpectedConnectionToExposeValidCursorField {
                                connection_directive_name,
                                connection_field_name,
                                connection_type_name,
                                cursor_selection_name,
                                edges_selection_name,
                            },
                            connection_field.definition.location,
                        )
                        .annotate("field with invalid type", edges_field.definition.location),
                    ]
                },
            )
        )
    }