Apollo Server 中解析器和突变之间的共享逻辑

Question

Here is my resolver file:

import { gql } from 'apollo-server-express'
import * as db from '../database'

export const typeDefs = gql`
    extend type Query {
        getFoos(): Foo
    }

    type Foo {
        id: ID!
        missingBar: [String]
    }

    input addBarInput {
        fooId: ID!
        barId: ID!
    }

    extend type Mutation {
        addBar(input: addBarInput): Foo
        startFoo(fooId: ID!): Foo
    }
`

export const resolvers = {
    Query: {
        getFoos: async () => db.foo.findAll({include: [db.bar]}),
    },
    Foo: {
        missingBar: async (obj, args, context, info) => {
            // here starts the relevant part of code
            const someBarIds = await db.some_table.findAll({
                where: {bar_id: obj.bar_id},
            }).map(el => el.bar_id)

            const otherBarIds = await db.other_table.findAll({
                where: {id: obj.bars.map(b => b.id)},
            }).map(el => el.id)

            const missingBarIds = someBarIds.filter(x => !otherBarIds.includes(x));
            // here ends the relevant part of code

            return await db.instruments.findAll({where: {id: missingInstrumentsIds}}).map(instrument => instrument.name)
        },
    },
    Mutation: {
        addBar: async (prev, { input }) => {
            const foo = await db.foo.findByPk(input.fooId)

            const bar = await db.users.findByPk(input.userId)
            await bar.setBar(foo)

            return foo
        },
        startFoo: async (prev, { input }) => {
            const foo = await db.foo.findByPk(input.fooId)

            // here I would like to have the code from missingBar without copypasting it
            // then I need to do more logic (irrelevant for this question) using that missingBarIds array

            return foo
        },
    }
}

As a note, I don't think the precise Sequelize logic in the missingBar resolver is important to the core of the question so I simplified it. The gist of it is that I want to execute an update on the DB only if all the required elements have been added to foo , and that check is performed with the exact same logic as the one in the missingBar resolver.

Is there any way to share parts of the logic between different mutations and resolvers? Ideally, declaring a function somewhere and using it in both places?

This hypothetic function's only parameter in this case would be an instance of the foo object (which is a Sequelize model, but again I don't think that's really relevant in this case), and the return value would be that missingBarIds array.

Answer 1

At a high level, you can just write a function and use it in both resolvers. If you don't want to have it in the same module, put it in a different module and import it. There's nothing wrong with that.

That said, since you're using Sequelize, you can add both static and instance methods to your model class.

A static method would be written like this:

Foo.doSomething = function doSomething () {
  ...
}

and called using the model class:

Foo.doSomething()

An instance method would be written like this:

Foo.prototype.doSomething = function doSomething () {
  ...
}

and then called on an instance of the class :

const foo = await Foo.findOne()
foo.doSomething()

Note that when you define an instance method, as long as you don't use an arrow function, this will refer to the instance itself.