Having multiple calls on request again

I read documentation about async handlers and hooks and that done must not be called in case of an async function.

💬 Question here

I'm having multiple calls on this request

fastify.post('/donations', postSectionHandler)

// postSectionHandler being either
    return async (req, reply, done) => {
        console.log("*************CALLED TWICE***********")
        const { body } = req
        const { error } = validationPipeLine(req)
        if (!isEmpty(error)) {
            reply.send({ message: 'Invalid request' })
        } else {
            // Files other than images are undefined
            if (!req.file) {
                reply.send({
                    message: 'Invalid request',
                    data: body,
                    error: 'file not found'
                })
            }
            let acknowledged = await insertDocument(QInstance, req, reply, null, false)
            // done()
        }
    }

Thanks in advance !

[Eomm]

Could you try to remove the done argument from the postSectionHandler function?

You should not mix async and callback styles

As I thought the problem was not with plugins at all. I cleaned the code up in this issue. Now, Let me detail the handler please.
The problem is definitely with what the handler returns.

I narrowed this to two cases:

// this works !
let data = await insertDocument(QInstance, req, null, false)
return data

// This makes the route being called twice !!!!
let data = await insertDocument(QInstance, req, null, false)
reply.blabla([data, 'listing', section])
return reply
// same for `await reply` and if I add `return ({})` again, it works

It is to note that I also making this

reply.blabla([data, 'listing', section])
return reply

all over the app and it is working fine in other routes.

---

No problem with Fastify.blabla hook, as it is synchronous and only decides whether to send a JSON or view a template.

// cookie processing here, no issue then
if (NODE_ENV == -1) {
    this.send(context[0])
} else {
    Object.assign(context[0], { user: user })
    const userFriendlyMsg = renderer(...context)
    const route = context[1]
    this.view(`/templates/pages/${route}`, userFriendlyMsg)
}

[mcollina]

I would recommend you to write a small example to reproduce so we can help you.

If your handler is called twice, you have a hook that is calling done twice and/or being declared async while also calling done.

@mcollina Indeed, I had a hook with a callback, where in the callback, I was calling done(). I turned it to simple return (is this totally fine ?? assuming return means no further work in the callback, neither any routing logic...)

Anyway, thanks a lot @mcollina & @Eomm.

And maybe for reference, this is the hook in question (it might help anybody... it's a nice wrapper around Project Honey Pot API)

fastify.addHook('preHandler', (req, reply, done) => {
    let ip = req.headers['x-forwarded-for'] || req.socket.remoteAddress
    if (ip.substr(0, 7) === '::ffff:') {
        ip = ip.substr(7)
    }
    if (NODE_ENV < 1 || ip.split('.')[0] === '127') {
        done()
    }
    const reversedIp = ip.split('.').reverse().join('.')
    dns.resolve4([process.env.HONEYPOT_KEY, reversedIp, 'dnsbl.httpbl.org'].join('.'),
        function (err, addresses) {
            if (!addresses) {
                // no done() in a callback <<-----------------------------------
                return
            } else {
                const _response = addresses.toString().split('.').map(Number)
                // https://www.projecthoneypot.org/threat_info.php
                const test = (_response[0] === 127 && _response[2] > 50)
                if (test) {
                    reply.send({ msg: 'we hate spam to begin with!' })
                }
                // no done() in a callback <<-----------------------------------
                return
            }
        })
})

[Eomm]

In the code, there is a condition when you run done and call reply.send.

Doing this is an issue because the done let the flow going further to the hander, meanwhile the dns code runs and call reply.send in an uncertain time. So the request is processed twice and you don't know which code will call send first

I see. Thanks for clarifying.
I think my tests didn't cover that case. So that send is not being called in my flow of execution.

But yes, as a correct solution, so I would return after done, or replace done by return??

Does return alone, doesn't let the handler persue with execution?

[Eomm]

Does return alone, doesn't let the handler persue with execution?

If the done is not called the execution will stop and the request will timeout.

Not sure about your logic, but a return after the done seems correct (unless you need to run the dns logic in any case)

[QEDK]

I would recommend you to write a small example to reproduce so we can help you.

If your handler is called twice, you have a hook that is calling done twice and/or being declared async while also calling done.

I wonder if this is well-documented (sorry in advance if it is!) - I was using a synchronous function as a preHandler hook and had to change it to async when doing some DB calls, needless to say, it was very hard to figure out that a) there were multiple requests being made (we were observing DB-side mostly) b) why it was being called multiple times, got a bit lucky after figuring out that the issue was multiple requests because Fastify mostly gives an unhelpful error in this scenario (which totally makes sense): the infamous cannot set headers after reply is sent.

[anishkumar127]

Thanks same issue was their im using async prehandler and onRequest , and inside also i was using the done() that was causing the issue of handler calling 2 times. now i have removed the async only using done().

one suggestion need.
which one should best way to prefer async await or done () ? in preHandler and onRequest if their is db calls or no db calls.

[Eomm]

which one should best way to prefer async await or done () ? in preHandler and onRequest if their is db calls or no db calls.

• if there are async operations in the function => use async/await
• if there are sync operations in the function => use the callback because it is faster
• if simplicity is the key on the project => use always async/await and your team will never make a mistake

my fastify book explains it 😄