Chegar a todos vocês como eu estou no processo de aprendizado e integração do Apollo e graphQL em um dos meus projetos. Até agora está tudo bem, mas agora estou tentando ter algumas mutações e estou lutando com o tipo de entrada e o tipo de consulta. Sinto que é muito mais complicado do que deveria e, portanto, estou procurando conselhos sobre como devo gerenciar minha situação. Os exemplos que encontrei on-line são sempre com esquemas muito básicos, mas a realidade é sempre mais complexa, pois meu esquema é bastante grande e tem a seguinte aparência (copio apenas uma parte):

type Calculation {
    _id: String!
    userId: String!
    data: CalculationData
    lastUpdated: Int
    name: String
}

type CalculationData {
    Loads: [Load]
    validated: Boolean
    x: Float
    y: Float
    z: Float
    Inputs: [Input]
    metric: Boolean

}

Então, entradas e cargas são definidas e assim por diante ...

Para isso, quero uma mutação para salvar o "Cálculo", portanto, no mesmo arquivo, tenho o seguinte:

type Mutation {
    saveCalculation(data: CalculationData!, name: String!): Calculation
}

Meu resolvedor é o seguinte:

export default resolvers = {
    Mutation: {
        saveCalculation(obj, args, context) {
            if(context.user && context.user._id){
                const calculationId = Calculations.insert({
                    userId: context.user._id,
                    data: args.data,
                    name: args.name
                })
                return Calculations.findOne({ _id: calculationId})
            }
            throw new Error('Need an account to save a calculation')
        }
    }
}

Então minha mutação é a seguinte: import gql from 'graphql-tag';

export const SAVE_CALCULATION = gql`
    mutation saveCalculation($data: CalculationData!, $name: String!){
        saveCalculation(data: $data, name: $name){
            _id
        }
    }
`

Finalmente, estou usando o componente Mutation para tentar salvar os dados:

<Mutation mutation={SAVE_CALCULATION}>
    {(saveCalculation, { data }) => (
        <div onClick={() => saveCalculation({ variables : { data: this.state, name:'name calcul' }})}>SAVE</div>
    }}
</Mutation>

Agora, recebo o seguinte erro:

[Erro do GraphQL]: Mensagem: O tipo de Mutation.saveCalculation (dados :) deve ser o Tipo de Entrada, mas obteve: CalculationData!., Local: undefined, Caminho: undefined

De minha pesquisa e algumas outras postagens de SO, entendi que eu deveria definir o tipo de entrada além do tipo de consulta, mas o tipo de entrada pode apenas avec tipos escalares, mas meu esquema depende de outros esquemas (e isso não é escalar). Posso criar tipos de entrada dependendo de outros tipos de entrada e assim por diante quando o último tiver apenas tipos escalares? Estou meio perdido porque parece muita redundância. Gostaria muito de receber algumas orientações sobre as melhores práticas. Estou convencido Apollo / graphql @ poderia me trazer uma ajuda muito boa ao longo do tempo no meu projeto, mas tenho que admitir que é mais complicado do que pensei em implementá-lo quando os esquemas são um pouco complexos. Exemplos online geralmente se ater a uma String e um Boolea