node-fastify 5.8.3

package/test/types/using.test-d.ts

@@ -0,0 +1,17 @@
+import { expectAssignable } from 'tsd'
+import fastify, { FastifyInstance } from '../../fastify'
+
+async function hasSymbolDisposeWithUsing () {
+  await using app = fastify()
+  expectAssignable<FastifyInstance>(app)
+  expectAssignable<FastifyInstance[typeof Symbol.asyncDispose]>(app.close)
+}
+
+async function hasSymbolDispose () {
+  const app = fastify()
+  expectAssignable<FastifyInstance>(app)
+  expectAssignable<FastifyInstance[typeof Symbol.asyncDispose]>(app.close)
+}
+
+hasSymbolDisposeWithUsing()
+hasSymbolDispose()

package/test/upgrade.test.js

@@ -0,0 +1,52 @@
+'use strict'
+
+const { describe, test } = require('node:test')
+const Fastify = require('..')
+const { connect } = require('node:net')
+const { once } = require('node:events')
+const dns = require('node:dns').promises
+
+describe('upgrade to both servers', async () => {
+  const localAddresses = await dns.lookup('localhost', { all: true })
+  const skip = localAddresses.length === 1 && 'requires both IPv4 and IPv6'
+
+  await test('upgrade IPv4 and IPv6', { skip }, async t => {
+    t.plan(2)
+
+    const fastify = Fastify()
+    fastify.server.on('upgrade', (req, socket, head) => {
+      t.assert.ok(`upgrade event ${JSON.stringify(socket.address())}`)
+      socket.end()
+    })
+
+    fastify.get('/', (req, res) => {
+      res.send()
+    })
+
+    await fastify.listen()
+    t.after(() => fastify.close())
+
+    {
+      const clientIPv4 = connect(fastify.server.address().port, '127.0.0.1')
+      clientIPv4.write('GET / HTTP/1.1\r\n')
+      clientIPv4.write('Upgrade: websocket\r\n')
+      clientIPv4.write('Connection: Upgrade\r\n')
+      clientIPv4.write('Sec-WebSocket-Key: x3JJHMbDL1EzLkh9GBhXDw==\r\n')
+      clientIPv4.write('Sec-WebSocket-Protocol: com.xxx.service.v1\r\n')
+      clientIPv4.write('Sec-WebSocket-Version: 13\r\n\r\n')
+      clientIPv4.write('\r\n\r\n')
+      await once(clientIPv4, 'close')
+    }
+
+    {
+      const clientIPv6 = connect(fastify.server.address().port, '::1')
+      clientIPv6.write('GET / HTTP/1.1\r\n')
+      clientIPv6.write('Upgrade: websocket\r\n')
+      clientIPv6.write('Connection: Upgrade\r\n')
+      clientIPv6.write('Sec-WebSocket-Key: x3JJHMbDL1EzLkh9GBhXDw==\r\n')
+      clientIPv6.write('Sec-WebSocket-Protocol: com.xxx.service.v1\r\n')
+      clientIPv6.write('Sec-WebSocket-Version: 13\r\n\r\n')
+      await once(clientIPv6, 'close')
+    }
+  })
+})

package/test/url-rewriting.test.js

@@ -0,0 +1,122 @@
+'use strict'
+
+const { test } = require('node:test')
+const Fastify = require('..')
+
+test('Should rewrite url', async t => {
+  t.plan(4)
+  const fastify = Fastify({
+    rewriteUrl (req) {
+      t.assert.strictEqual(req.url, '/this-would-404-without-url-rewrite')
+      this.log.info('rewriting url')
+      return '/'
+    }
+  })
+
+  fastify.route({
+    method: 'GET',
+    url: '/',
+    handler: (req, reply) => {
+      reply.send({ hello: 'world' })
+    }
+  })
+
+  const fastifyServer = await fastify.listen({ port: 0 })
+
+  t.after(() => fastify.close())
+
+  const result = await fetch(`${fastifyServer}/this-would-404-without-url-rewrite`)
+
+  t.assert.ok(result.ok)
+  t.assert.strictEqual(result.status, 200)
+  t.assert.deepStrictEqual(await result.json(), { hello: 'world' })
+})
+
+test('Should not rewrite if the url is the same', async t => {
+  t.plan(3)
+  const fastify = Fastify({
+    rewriteUrl (req) {
+      t.assert.strictEqual(req.url, '/this-would-404-without-url-rewrite')
+      this.log.info('rewriting url')
+      return req.url
+    }
+  })
+
+  fastify.route({
+    method: 'GET',
+    url: '/',
+    handler: (req, reply) => {
+      reply.send({ hello: 'world' })
+    }
+  })
+
+  const fastifyServer = await fastify.listen({ port: 0 })
+
+  t.after(() => fastify.close())
+
+  const result = await fetch(`${fastifyServer}/this-would-404-without-url-rewrite`)
+
+  t.assert.ok(!result.ok)
+  t.assert.strictEqual(result.status, 404)
+})
+
+test('Should throw an error', async t => {
+  t.plan(2)
+  const fastify = Fastify({
+    rewriteUrl (req) {
+      t.assert.strictEqual(req.url, '/this-would-404-without-url-rewrite')
+      this.log.info('rewriting url')
+      return undefined
+    }
+  })
+
+  fastify.route({
+    method: 'GET',
+    url: '/',
+    handler: (req, reply) => {
+      reply.send({ hello: 'world' })
+    }
+  })
+
+  const fastifyServer = await fastify.listen({ port: 0 })
+
+  t.after(() => fastify.close())
+
+  try {
+    await fetch(`${fastifyServer}/this-would-404-without-url-rewrite`)
+    t.assert.fail('Expected fetch to throw an error')
+  } catch (err) {
+    t.assert.ok(err instanceof Error)
+  }
+})
+
+test('Should rewrite url but keep originalUrl unchanged', async t => {
+  t.plan(6)
+  const fastify = Fastify({
+    rewriteUrl (req) {
+      t.assert.strictEqual(req.url, '/this-would-404-without-url-rewrite')
+      t.assert.strictEqual(req.originalUrl, '/this-would-404-without-url-rewrite')
+      return '/'
+    }
+  })
+
+  fastify.route({
+    method: 'GET',
+    url: '/',
+    handler: (req, reply) => {
+      reply.send({ hello: 'world', hostname: req.hostname, port: req.port })
+      t.assert.strictEqual(req.originalUrl, '/this-would-404-without-url-rewrite')
+    }
+  })
+
+  await fastify.listen({ port: 0 })
+  const port = fastify.server.address().port
+
+  t.after(() => fastify.close())
+
+  const result = await fetch(`http://localhost:${port}/this-would-404-without-url-rewrite`)
+
+  t.assert.ok(result.ok)
+  t.assert.strictEqual(result.status, 200)
+  t.assert.deepStrictEqual(await result.json(), { hello: 'world', hostname: 'localhost', port })
+})

package/test/use-semicolon-delimiter.test.js

@@ -0,0 +1,168 @@
+'use strict'
+
+const { test } = require('node:test')
+const Fastify = require('..')
+
+test('use semicolon delimiter default false', async (t) => {
+  t.plan(2)
+
+  const fastify = Fastify()
+
+  fastify.get('/1234;foo=bar', (req, reply) => {
+    reply.send(req.query)
+  })
+
+  const fastifyServer = await fastify.listen({ port: 0 })
+  t.after(() => { fastify.close() })
+
+  const result = await fetch(fastifyServer + '/1234;foo=bar', {
+    method: 'GET'
+  })
+  t.assert.strictEqual(result.status, 200)
+  const body = await result.json()
+  t.assert.deepStrictEqual(body, {})
+})
+
+test('use semicolon delimiter set to true', async (t) => {
+  t.plan(3)
+  const fastify = Fastify({
+    useSemicolonDelimiter: true
+  })
+
+  fastify.get('/1234', (req, reply) => {
+    reply.send(req.query)
+  })
+
+  const fastifyServer = await fastify.listen({ port: 0 })
+  t.after(() => { fastify.close() })
+
+  const result = await fetch(fastifyServer + '/1234;foo=bar')
+  t.assert.ok(result.ok)
+  t.assert.strictEqual(result.status, 200)
+  t.assert.deepStrictEqual(await result.json(), {
+    foo: 'bar'
+  })
+})
+
+test('use semicolon delimiter set to false', async (t) => {
+  t.plan(3)
+
+  const fastify = Fastify({
+    useSemicolonDelimiter: false
+  })
+
+  fastify.get('/1234;foo=bar', (req, reply) => {
+    reply.send(req.query)
+  })
+
+  const fastifyServer = await fastify.listen({ port: 0 })
+  t.after(() => { fastify.close() })
+
+  const result = await fetch(fastifyServer + '/1234;foo=bar')
+  t.assert.ok(result.ok)
+  t.assert.strictEqual(result.status, 200)
+  t.assert.deepStrictEqual(await result.json(), {})
+})
+
+test('use semicolon delimiter set to false return 404', async (t) => {
+  t.plan(2)
+
+  const fastify = Fastify({
+    useSemicolonDelimiter: false
+  })
+
+  fastify.get('/1234', (req, reply) => {
+    reply.send(req.query)
+  })
+
+  const fastifyServer = await fastify.listen({ port: 0 })
+  t.after(() => { fastify.close() })
+
+  const result = await fetch(fastifyServer + '/1234;foo=bar')
+  t.assert.ok(!result.ok)
+  t.assert.strictEqual(result.status, 404)
+})
+
+test('use routerOptions semicolon delimiter default false', async t => {
+  t.plan(3)
+
+  const fastify = Fastify()
+
+  fastify.get('/1234;foo=bar', (req, reply) => {
+    reply.send(req.query)
+  })
+
+  const fastifyServer = await fastify.listen({ port: 0 })
+  t.after(() => { fastify.close() })
+
+  const result = await fetch(fastifyServer + '/1234;foo=bar')
+  t.assert.ok(result.ok)
+  t.assert.strictEqual(result.status, 200)
+  t.assert.deepStrictEqual(await result.json(), {})
+})
+
+test('use routerOptions semicolon delimiter set to true', async t => {
+  t.plan(3)
+  const fastify = Fastify({
+    routerOptions: {
+      useSemicolonDelimiter: true
+    }
+  })
+
+  fastify.get('/1234', async (req, reply) => {
+    reply.send(req.query)
+  })
+
+  const fastifyServer = await fastify.listen({ port: 0 })
+  t.after(() => { fastify.close() })
+
+  const result = await fetch(fastifyServer + '/1234;foo=bar')
+  t.assert.ok(result.ok)
+  t.assert.strictEqual(result.status, 200)
+  t.assert.deepStrictEqual(await result.json(), {
+    foo: 'bar'
+  })
+})
+
+test('use routerOptions semicolon delimiter set to false', async t => {
+  t.plan(3)
+
+  const fastify = Fastify({
+    routerOptions: {
+      useSemicolonDelimiter: false
+    }
+  })
+
+  fastify.get('/1234;foo=bar', (req, reply) => {
+    reply.send(req.query)
+  })
+
+  const fastifyServer = await fastify.listen({ port: 0 })
+  t.after(() => { fastify.close() })
+
+  const result = await fetch(fastifyServer + '/1234;foo=bar')
+  t.assert.ok(result.ok)
+  t.assert.strictEqual(result.status, 200)
+  t.assert.deepStrictEqual(await result.json(), {})
+})
+
+test('use routerOptions semicolon delimiter set to false return 404', async t => {
+  t.plan(2)
+
+  const fastify = Fastify({
+    routerOptions: {
+      useSemicolonDelimiter: false
+    }
+  })
+
+  fastify.get('/1234', (req, reply) => {
+    reply.send(req.query)
+  })
+
+  const fastifyServer = await fastify.listen({ port: 0 })
+  t.after(() => { fastify.close() })
+
+  const result = await fetch(fastifyServer + '/1234;foo=bar')
+  t.assert.ok(!result.ok)
+  t.assert.strictEqual(result.status, 404)
+})