Provide 'pre' and 'post' hooks on create and update

[GuyShane]

Is your feature request related to a problem? Please describe.
I'd like to be able to react to changes to fields before and after they've been updated, as well as be able to access the current value of the object. For example with the below type definitions, some things I might want to do could be

• Before a user updates their picture, save base64 information to an external file store and replace the field with a url
• Before application state gets updated to declined, make sure a note was added
• After application state gets updated to accepted, send an email to the user
• Before creating an application, make sure the user is verified

const typeDefs=`
type User {
    id: ID! @id
    email: String!
    verified: Boolean! @default(value: false)
    picture: String
    applications: [Application!] @relationship(type: "APPLICANT", direction: OUT)
}

type Application {
    id: ID! @id
    user: User! @relationship(type: "APPLICANT", direction: IN)
    state: String!
    note: String
}
`;

Describe the solution you'd like
I was thinking there could be directives that allow you to attach arbitrary functions to fields or objects. Something like this

const typeDefs=`
type User {
    id: ID! @id
    email: String!
    verified: Boolean! @default(value: false)
    picture: String @pre(update: savePicture)
    applications: [Application!] @relationship(type: "APPLICANT", direction: OUT)
}

type Application @pre(create: checkVerification) {
    id: ID! @id
    user: User! @relationship(type: "APPLICANT", direction: IN)
    state: String! @pre(update: checkHasNote, value: "declined") @post(update: sendEmail, value: "accepted")
    note: String
}
`;

const driver=neo4j.driver(
    'neo4j://neo4j:7687',
    neo4j.auth.basic('neo4j', 'password')
);

const ogm=new OGM({typeDefs, driver});
const Application=ogm.model('Application');

const neoSchema=new Neo4jGraphQL({
    typeDefs,
    config: {
        hooks: {
            checkVerification, savePicture, checkHasNote, sendEmail
        }
    }
});

async function sendEmail(){
    const [application]=await Application.find({selectionSet: '{user {email}}'}); //get the existing application somehow
    await email({to: application.user.email})
}

Sorry if this is possible through other means, and if it is I'd love to know, thanks!

Describe alternatives you've considered

• Extending generated resolvers
• Adding directives to type fields
• Adding directives to generated input type fields
• Apollo server middleware

[darrellwarde]

Hey @GuyShane, out of interest, have you seen Envelop? We've had our eye on it for a little while, and it looks like an interesting way of achieving what you're looking for without us implementing anything new in the library.

I hope that lifecycle hooks will make the cut eventually, but until we get around to it officially, it should be possible through projects such as Envelop.

[GuyShane]

Thanks so much for the suggestion! However from what I can see, it looks like Envelop gives pretty similar functionality to Apollo server plugins in that they let you hook in to parts of request execution. But I'm still not seeing how I can get the field level granularity that I'd like. I need to be able to before a mutation, get the current data for all the objects that are going to be modified, then perform the mutation, then compare the result to the previous data.

No worries if there's not time to look into this right now. I'll keep my eye out for solutions.

[Tenrys]

This is a feature I am really looking forward to, as the alternative (Envelop) is quite low level and does not facilitate such an implementation, and currently will require a lot of hacking.

Right now, there does not seem to be a simple way to create "computed" data that is cached on the database, aside from the @callback directive, but it does not provide enough information to be useful:

• unable to control when the callback gets called, as it does not know which type of operation triggered it (before / after creation / update?)
• the callback only knows about what data was passed to create / update a node, otherwise unaware of the identity of which node it is being called for, which is crucial to combine with OGM.

[darrellwarde]

This is going to be closed for the time being. I believe there to be a variety of options for hooking into the request lifecycle using JavaScript, however, we are still considering options for doing this using Cypher.

As can be seen in Apollo's documentation of the request lifecycle, there are a variety of events in which a plugin can interject. There are products such as Envelop and graphql-middleware which can be used for request injection.