You are an expert in writing code in many different languages. Your goal is to perform code completion for the following code, keeping in mind the rest of the code and the file meta data.
    Metadata details:
    filename: extend_query_and_mutation_types.rs
    path of file: ./repos/grafbase/engine/crates/parser-sdl/src/rules
    
    the code of the file until where you have to start completion: use common_types::auth::Operations;
use engine::registry::{
    resolvers::{custom::CustomResolver, Resolver},
    MetaField, MetaInputValue,
};
use engine_parser::types::{ObjectType, TypeKind};

use super::{
    deprecated_directive::DeprecatedDirective,
    federation::{InaccessibleDirective, TagDirective},
    visitor::{Visitor, VisitorContext, MUTATION_TYPE, QUERY_TYPE},
};
use crate::rules::{cache_directive::CacheDirective, resolver_directive::ResolverDirective};

pub struct ExtendQueryAndMutationTypes;

enum EntryPoint {
    Query,
    Mutation,
}

fn find_entry_point(
    type_definition: &engine::Positioned<engine_parser::type
    
    fn test_parse_result_with_cache() {
        // prepare
        let schema = r#"
            extend type Query {
                foo: String! @resolver(name: "foo") @cache(maxAge: 60)
            }

            extend type Mutation {
                foo: String! @resolver(name: "foo") @cache(maxAge: 60)
            }
        "#;

        let schema = parse_schema(schema).unwrap();
        let mut ctx = VisitorContext::new_for_tests(&schema);

        // act
        visit(&mut ExtendQueryAndMutationTypes, &mut ctx, &schema);

        // assert
        assert!(ctx.errors.is_empty());

        let foo_query = ctx
            .queries
            .iter()
            .find(|query| query.name == "foo")
            .expect("Should find foo query");
        let foo_mutation = ctx
            .mutations
            .iter()
            .find(|mutation| mutation.name == "foo")
            .expect("Should find foo mutation");

        assert_eq!(
            foo_query.cache_control,
            CacheControl {
                max_age: 60,
                ..Default::default()
            }
        );

        assert_eq!(foo_mutation.cache_control, Default::default());
    }