node-fastify 5.8.3

package/test/skip-reply-send.test.js

@@ -0,0 +1,317 @@
+'use strict'
+
+const { test, describe } = require('node:test')
+const split = require('split2')
+const net = require('node:net')
+const Fastify = require('../fastify')
+
+process.removeAllListeners('warning')
+
+const lifecycleHooks = [
+  'onRequest',
+  'preParsing',
+  'preValidation',
+  'preHandler',
+  'preSerialization',
+  'onSend',
+  'onTimeout',
+  'onResponse',
+  'onError'
+]
+
+test('skip automatic reply.send() with reply.hijack and a body', async (t) => {
+  const stream = split(JSON.parse)
+  const app = Fastify({
+    logger: {
+      stream
+    }
+  })
+
+  stream.on('data', (line) => {
+    t.assert.notStrictEqual(line.level, 40) // there are no errors
+    t.assert.notStrictEqual(line.level, 50) // there are no errors
+  })
+
+  app.get('/', (req, reply) => {
+    reply.hijack()
+    reply.raw.end('hello world')
+
+    return Promise.resolve('this will be skipped')
+  })
+
+  await app.inject({
+    method: 'GET',
+    url: '/'
+  }).then((res) => {
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.strictEqual(res.body, 'hello world')
+  })
+})
+
+test('skip automatic reply.send() with reply.hijack and no body', async (t) => {
+  const stream = split(JSON.parse)
+  const app = Fastify({
+    logger: {
+      stream
+    }
+  })
+
+  stream.on('data', (line) => {
+    t.assert.notStrictEqual(line.level, 40) // there are no error
+    t.assert.notStrictEqual(line.level, 50) // there are no error
+  })
+
+  app.get('/', (req, reply) => {
+    reply.hijack()
+    reply.raw.end('hello world')
+
+    return Promise.resolve()
+  })
+
+  await app.inject({
+    method: 'GET',
+    url: '/'
+  }).then((res) => {
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.strictEqual(res.body, 'hello world')
+  })
+})
+
+test('skip automatic reply.send() with reply.hijack and an error', async (t) => {
+  const stream = split(JSON.parse)
+  const app = Fastify({
+    logger: {
+      stream
+    }
+  })
+
+  let errorSeen = false
+
+  stream.on('data', (line) => {
+    if (line.level === 50) {
+      errorSeen = true
+      t.assert.strictEqual(line.err.message, 'kaboom')
+      t.assert.strictEqual(line.msg, 'Promise errored, but reply.sent = true was set')
+    }
+  })
+
+  app.get('/', (req, reply) => {
+    reply.hijack()
+    reply.raw.end('hello world')
+
+    return Promise.reject(new Error('kaboom'))
+  })
+
+  await app.inject({
+    method: 'GET',
+    url: '/'
+  }).then((res) => {
+    t.assert.strictEqual(errorSeen, true)
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.strictEqual(res.body, 'hello world')
+  })
+})
+
+function testHandlerOrBeforeHandlerHook (test, hookOrHandler) {
+  const idx = hookOrHandler === 'handler' ? lifecycleHooks.indexOf('preHandler') : lifecycleHooks.indexOf(hookOrHandler)
+  const previousHooks = lifecycleHooks.slice(0, idx)
+  const nextHooks = lifecycleHooks.slice(idx + 1)
+
+  describe(`Hijacking inside ${hookOrHandler} skips all the following hooks and handler execution`, () => {
+    test('Sending a response using reply.raw => onResponse hook is called', async (t) => {
+      const stream = split(JSON.parse)
+      const app = Fastify({
+        logger: {
+          stream
+        }
+      })
+
+      stream.on('data', (line) => {
+        t.assert.notStrictEqual(line.level, 40) // there are no errors
+        t.assert.notStrictEqual(line.level, 50) // there are no errors
+      })
+
+      previousHooks.forEach(h => app.addHook(h, async (req, reply) => t.assert.ok(`${h} should be called`)))
+
+      if (hookOrHandler === 'handler') {
+        app.get('/', (req, reply) => {
+          reply.hijack()
+          reply.raw.end(`hello from ${hookOrHandler}`)
+        })
+      } else {
+        app.addHook(hookOrHandler, async (req, reply) => {
+          reply.hijack()
+          reply.raw.end(`hello from ${hookOrHandler}`)
+        })
+        app.get('/', (req, reply) => t.assert.fail('Handler should not be called'))
+      }
+
+      nextHooks.forEach(h => {
+        if (h === 'onResponse') {
+          app.addHook(h, async (req, reply) => t.assert.ok(`${h} should be called`))
+        } else {
+          app.addHook(h, async (req, reply) => t.assert.fail(`${h} should not be called`))
+        }
+      })
+
+      await app.inject({
+        method: 'GET',
+        url: '/'
+      }).then((res) => {
+        t.assert.strictEqual(res.statusCode, 200)
+        t.assert.strictEqual(res.body, `hello from ${hookOrHandler}`)
+      })
+    })
+
+    test('Sending a response using req.socket => onResponse not called', (t, testDone) => {
+      const stream = split(JSON.parse)
+      const app = Fastify({
+        logger: {
+          stream
+        }
+      })
+      t.after(() => app.close())
+
+      stream.on('data', (line) => {
+        t.assert.notStrictEqual(line.level, 40) // there are no errors
+        t.assert.notStrictEqual(line.level, 50) // there are no errors
+      })
+
+      previousHooks.forEach(h => app.addHook(h, async (req, reply) => t.assert.ok(`${h} should be called`)))
+
+      if (hookOrHandler === 'handler') {
+        app.get('/', (req, reply) => {
+          reply.hijack()
+          req.socket.write('HTTP/1.1 200 OK\r\n\r\n')
+          req.socket.write(`hello from ${hookOrHandler}`)
+          req.socket.end()
+        })
+      } else {
+        app.addHook(hookOrHandler, async (req, reply) => {
+          reply.hijack()
+          req.socket.write('HTTP/1.1 200 OK\r\n\r\n')
+          req.socket.write(`hello from ${hookOrHandler}`)
+          req.socket.end()
+        })
+        app.get('/', (req, reply) => t.assert.fail('Handler should not be called'))
+      }
+
+      nextHooks.forEach(h => app.addHook(h, async (req, reply) => t.assert.fail(`${h} should not be called`)))
+
+      app.listen({ port: 0 }, err => {
+        t.assert.ifError(err)
+        const client = net.createConnection({ port: (app.server.address()).port }, () => {
+          client.write('GET / HTTP/1.1\r\nHost: fastify.test\r\n\r\n')
+
+          let chunks = ''
+          client.setEncoding('utf8')
+          client.on('data', data => {
+            chunks += data
+          })
+
+          client.on('end', function () {
+            t.assert.match(chunks, new RegExp(`hello from ${hookOrHandler}`, 'i'))
+            testDone()
+          })
+        })
+      })
+    })
+
+    test('Throwing an error does not trigger any hooks', async (t) => {
+      const stream = split(JSON.parse)
+      const app = Fastify({
+        logger: {
+          stream
+        }
+      })
+      t.after(() => app.close())
+
+      let errorSeen = false
+      stream.on('data', (line) => {
+        if (hookOrHandler === 'handler') {
+          if (line.level === 40) {
+            errorSeen = true
+            t.assert.strictEqual(line.err.code, 'FST_ERR_REP_ALREADY_SENT')
+          }
+        } else {
+          t.assert.notStrictEqual(line.level, 40) // there are no errors
+          t.assert.notStrictEqual(line.level, 50) // there are no errors
+        }
+      })
+
+      previousHooks.forEach(h => app.addHook(h, async (req, reply) => t.assert.ok(`${h} should be called`)))
+
+      if (hookOrHandler === 'handler') {
+        app.get('/', (req, reply) => {
+          reply.hijack()
+          throw new Error('This will be skipped')
+        })
+      } else {
+        app.addHook(hookOrHandler, async (req, reply) => {
+          reply.hijack()
+          throw new Error('This will be skipped')
+        })
+        app.get('/', (req, reply) => t.assert.fail('Handler should not be called'))
+      }
+
+      nextHooks.forEach(h => app.addHook(h, async (req, reply) => t.assert.fail(`${h} should not be called`)))
+
+      await Promise.race([
+        app.inject({ method: 'GET', url: '/' }),
+        new Promise((resolve, reject) => setTimeout(resolve, 1000))
+      ])
+
+      if (hookOrHandler === 'handler') {
+        t.assert.strictEqual(errorSeen, true)
+      }
+    })
+
+    test('Calling reply.send() after hijacking logs a warning', async (t) => {
+      const stream = split(JSON.parse)
+      const app = Fastify({
+        logger: {
+          stream
+        }
+      })
+
+      let errorSeen = false
+
+      stream.on('data', (line) => {
+        if (line.level === 40) {
+          errorSeen = true
+          t.assert.strictEqual(line.err.code, 'FST_ERR_REP_ALREADY_SENT')
+        }
+      })
+
+      previousHooks.forEach(h => app.addHook(h, async (req, reply) => t.assert.ok(`${h} should be called`)))
+
+      if (hookOrHandler === 'handler') {
+        app.get('/', (req, reply) => {
+          reply.hijack()
+          reply.send('hello from reply.send()')
+        })
+      } else {
+        app.addHook(hookOrHandler, async (req, reply) => {
+          reply.hijack()
+          return reply.send('hello from reply.send()')
+        })
+        app.get('/', (req, reply) => t.assert.fail('Handler should not be called'))
+      }
+
+      nextHooks.forEach(h => app.addHook(h, async (req, reply) => t.assert.fail(`${h} should not be called`)))
+
+      await Promise.race([
+        app.inject({ method: 'GET', url: '/' }),
+        new Promise((resolve, reject) => setTimeout(resolve, 1000))
+      ])
+
+      t.assert.strictEqual(errorSeen, true)
+    })
+  })
+}
+
+testHandlerOrBeforeHandlerHook(test, 'onRequest')
+testHandlerOrBeforeHandlerHook(test, 'preParsing')
+testHandlerOrBeforeHandlerHook(test, 'preValidation')
+testHandlerOrBeforeHandlerHook(test, 'preHandler')
+testHandlerOrBeforeHandlerHook(test, 'handler')

package/test/stream-serializers.test.js

@@ -0,0 +1,40 @@
+'use strict'
+
+const { test } = require('node:test')
+const Fastify = require('..')
+const Reply = require('../lib/reply')
+
+test('should serialize reply when response stream is ended', (t, done) => {
+  t.plan(5)
+
+  const stream = require('node:stream')
+  const fastify = Fastify({
+    logger: {
+      serializers: {
+        res (reply) {
+          t.assert.strictEqual(reply instanceof Reply, true)
+          t.assert.ok('passed')
+          return reply
+        }
+      }
+    }
+  })
+
+  fastify.get('/error', function (req, reply) {
+    const reallyLongStream = new stream.Readable({
+      read: () => { }
+    })
+    reply.code(200).send(reallyLongStream)
+    reply.raw.end(Buffer.from('hello\n'))
+  })
+
+  t.after(() => fastify.close())
+
+  fastify.inject({
+    url: '/error',
+    method: 'GET'
+  }, (err) => {
+    t.assert.ifError(err)
+    done()
+  })
+})

package/test/stream.1.test.js

@@ -0,0 +1,94 @@
+'use strict'
+
+const { test } = require('node:test')
+const fs = require('node:fs')
+const Fastify = require('../fastify')
+
+test('should respond with a stream', async t => {
+  t.plan(4)
+  const fastify = Fastify()
+
+  fastify.get('/', function (req, reply) {
+    const stream = fs.createReadStream(__filename, 'utf8')
+    reply.code(200).send(stream)
+  })
+
+  const fastifyServer = await fastify.listen({ port: 0 })
+  t.after(() => { fastify.close() })
+
+  const response = await fetch(fastifyServer)
+  t.assert.ok(response.ok)
+  t.assert.strictEqual(response.headers.get('content-type'), null)
+  t.assert.strictEqual(response.status, 200)
+
+  const data = await response.text()
+  const expected = await fs.promises.readFile(__filename, 'utf8')
+  t.assert.strictEqual(expected.toString(), data.toString())
+})
+
+test('should respond with a stream (error)', async t => {
+  t.plan(2)
+  const fastify = Fastify()
+
+  fastify.get('/error', function (req, reply) {
+    const stream = fs.createReadStream('not-existing-file', 'utf8')
+    reply.code(200).send(stream)
+  })
+
+  const fastifyServer = await fastify.listen({ port: 0 })
+  t.after(() => fastify.close())
+
+  const response = await fetch(`${fastifyServer}/error`)
+  t.assert.ok(!response.ok)
+  t.assert.strictEqual(response.status, 500)
+})
+
+test('should trigger the onSend hook', async (t) => {
+  t.plan(3)
+  const fastify = Fastify()
+
+  fastify.get('/', (req, reply) => {
+    reply.send(fs.createReadStream(__filename, 'utf8'))
+  })
+
+  fastify.addHook('onSend', (req, reply, payload, done) => {
+    t.assert.ok(payload._readableState)
+    reply.header('Content-Type', 'application/javascript')
+    done()
+  })
+
+  const res = await fastify.inject({
+    url: '/'
+  })
+  t.assert.strictEqual(res.headers['content-type'], 'application/javascript')
+  t.assert.strictEqual(res.payload, fs.readFileSync(__filename, 'utf8'))
+  return fastify.close()
+})
+
+test('should trigger the onSend hook only twice if pumping the stream fails, first with the stream, second with the serialized error', async t => {
+  t.plan(4)
+  const fastify = Fastify()
+
+  fastify.get('/', (req, reply) => {
+    reply.send(fs.createReadStream('not-existing-file', 'utf8'))
+  })
+
+  let counter = 0
+  fastify.addHook('onSend', (req, reply, payload, done) => {
+    if (counter === 0) {
+      t.assert.ok(payload._readableState)
+    } else if (counter === 1) {
+      const error = JSON.parse(payload)
+      t.assert.strictEqual(error.statusCode, 500)
+    }
+    counter++
+    done()
+  })
+
+  const fastifyServer = await fastify.listen({ port: 0 })
+  t.after(() => { fastify.close() })
+
+  const response = await fetch(fastifyServer)
+  t.assert.ok(!response.ok)
+  t.assert.strictEqual(response.status, 500)
+})

package/test/stream.2.test.js

@@ -0,0 +1,129 @@
+'use strict'
+
+const { test } = require('node:test')
+const proxyquire = require('proxyquire')
+const fs = require('node:fs')
+const resolve = require('node:path').resolve
+const zlib = require('node:zlib')
+const pipeline = require('node:stream').pipeline
+const Fastify = require('..')
+const { waitForCb } = require('./toolkit')
+
+test('onSend hook stream', t => {
+  t.plan(4)
+  const fastify = Fastify()
+
+  fastify.get('/', function (req, reply) {
+    reply.send({ hello: 'world' })
+  })
+
+  const { stepIn, patience } = waitForCb({ steps: 2 })
+
+  fastify.addHook('onSend', (req, reply, payload, done) => {
+    const gzStream = zlib.createGzip()
+
+    reply.header('Content-Encoding', 'gzip')
+    pipeline(
+      fs.createReadStream(resolve(__filename), 'utf8'),
+      gzStream,
+      (err) => {
+        t.assert.ifError(err)
+        stepIn()
+      }
+    )
+    done(null, gzStream)
+  })
+
+  fastify.inject({
+    url: '/',
+    method: 'GET'
+  }, (err, res) => {
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.headers['content-encoding'], 'gzip')
+    const file = fs.readFileSync(resolve(__filename), 'utf8')
+    const payload = zlib.gunzipSync(res.rawPayload)
+    t.assert.strictEqual(payload.toString('utf-8'), file)
+    fastify.close()
+    stepIn()
+  })
+
+  return patience
+})
+
+test('onSend hook stream should work even if payload is not a proper stream', (t, testDone) => {
+  t.plan(1)
+
+  const reply = proxyquire('../lib/reply', {
+    'node:stream': {
+      finished: (...args) => {
+        if (args.length === 2) { args[1](new Error('test-error')) }
+      }
+    }
+  })
+  const Fastify = proxyquire('..', {
+    './lib/reply.js': reply
+  })
+  const spyLogger = {
+    fatal: () => { },
+    error: () => { },
+    warn: (message) => {
+      t.assert.strictEqual(message, 'stream payload does not end properly')
+      fastify.close()
+      testDone()
+    },
+    info: () => { },
+    debug: () => { },
+    trace: () => { },
+    child: () => { return spyLogger }
+  }
+
+  const fastify = Fastify({ loggerInstance: spyLogger })
+  fastify.get('/', function (req, reply) {
+    reply.send({ hello: 'world' })
+  })
+  fastify.addHook('onSend', (req, reply, payload, done) => {
+    const fakeStream = { pipe: () => { } }
+    done(null, fakeStream)
+  })
+
+  fastify.inject({
+    url: '/',
+    method: 'GET'
+  })
+})
+
+test('onSend hook stream should work on payload with "close" ending function', (t, testDone) => {
+  t.plan(1)
+
+  const reply = proxyquire('../lib/reply', {
+    'node:stream': {
+      finished: (...args) => {
+        if (args.length === 2) { args[1](new Error('test-error')) }
+      }
+    }
+  })
+  const Fastify = proxyquire('..', {
+    './lib/reply.js': reply
+  })
+
+  const fastify = Fastify({ logger: false })
+  fastify.get('/', function (req, reply) {
+    reply.send({ hello: 'world' })
+  })
+  fastify.addHook('onSend', (req, reply, payload, done) => {
+    const fakeStream = {
+      pipe: () => { },
+      close: (cb) => {
+        cb()
+        t.assert.ok('close callback called')
+        testDone()
+      }
+    }
+    done(null, fakeStream)
+  })
+
+  fastify.inject({
+    url: '/',
+    method: 'GET'
+  })
+})