fastify 4.2.0 → 4.4.0

package/test/internals/request.test.js

@@ -19,6 +19,9 @@ test('Regular request', t => {
   req.connection = req.socket
   const request = new Request('id', 'params', req, 'query', 'log')
   t.type(request, Request)
+  t.type(request.validateInput, Function)
+  t.type(request.getValidationFunction, Function)
+  t.type(request.compileValidationSchema, Function)
   t.equal(request.id, 'id')
   t.equal(request.params, 'params')
   t.equal(request.raw, req)
@@ -74,7 +77,7 @@ test('Regular request - host header has precedence over authority', t => {
 })
 
 test('Request with trust proxy', t => {
-  t.plan(15)
+  t.plan(18)
   const headers = {
     'x-forwarded-for': '2.2.2.2, 1.1.1.1',
     'x-forwarded-host': 'example.com'
@@ -103,6 +106,9 @@ test('Request with trust proxy', t => {
   t.equal(request.url, '/')
   t.equal(request.socket, req.socket)
   t.equal(request.protocol, 'http')
+  t.type(request.validateInput, Function)
+  t.type(request.getValidationFunction, Function)
+  t.type(request.compileValidationSchema, Function)
 })
 
 test('Request with trust proxy, encrypted', t => {
@@ -221,7 +227,7 @@ test('Request with trust proxy - plain', t => {
 })
 
 test('Request with undefined socket', t => {
-  t.plan(15)
+  t.plan(18)
   const headers = {
     host: 'hostname'
   }
@@ -247,6 +253,9 @@ test('Request with undefined socket', t => {
   t.equal(request.url, '/')
   t.equal(request.protocol, undefined)
   t.same(request.socket, req.socket)
+  t.type(request.validateInput, Function)
+  t.type(request.getValidationFunction, Function)
+  t.type(request.compileValidationSchema, Function)
 })
 
 test('Request with trust proxy and undefined socket', t => {

package/test/lock.test.js

@@ -0,0 +1,73 @@
+'use strict'
+
+const t = require('tap')
+const test = t.test
+const sget = require('simple-get').concat
+const fastify = require('..')()
+
+test('can be created - lock', t => {
+  t.plan(1)
+  try {
+    fastify.route({
+      method: 'LOCK',
+      url: '*',
+      handler: function (req, reply) {
+        reply
+          .code(200)
+          .send(`<?xml version="1.0" encoding="utf-8" ?>
+            <D:prop xmlns:D="DAV:">
+              <D:lockdiscovery>
+                <D:activelock>
+                  <D:locktype>
+                    <D:write/>
+                  </D:locktype>
+                  <D:lockscope>
+                    <D:exclusive/>
+                  </D:lockscope>
+                  <D:depth>infinity</D:depth>
+                  <D:owner>
+                    <D:href>http://example.org/~ejw/contact.html</D:href>
+                  </D:owner>
+                  <D:timeout>Second-604800</D:timeout>
+                  <D:locktoken>
+                    <D:href>urn:uuid:e71d4fae-5dec-22d6-fea5-00a0c91e6be4</:href>
+                  </D:locktoken>
+                  <D:lockroot>
+                    <D:href>http://example.com/workspace/webdav/proposal.oc</D:href>
+                  </D:lockroot>
+                </D:activelock>
+              </D:lockdiscovery>
+            </D:prop>`
+          )
+      }
+    })
+    t.pass()
+  } catch (e) {
+    t.fail()
+  }
+})
+
+fastify.listen({ port: 0 }, err => {
+  t.error(err)
+  t.teardown(() => { fastify.close() })
+
+  test('request - lock', t => {
+    t.plan(3)
+    sget({
+      url: `http://localhost:${fastify.server.address().port}/test/a.txt`,
+      body: `<?xml version="1.0" encoding="utf-8" ?>
+        <D:lockinfo xmlns:D='DAV:'>
+          <D:lockscope> <D:exclusive/> </D:lockscope>
+          <D:locktype> <D:write/> </D:locktype>
+          <D:owner>
+            <D:href>http://example.org/~ejw/contact.html</D:href>
+          </D:owner>
+        </D:lockinfo> `,
+      method: 'LOCK'
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 200)
+      t.equal(response.headers['content-length'], '' + body.length)
+    })
+  })
+})

package/test/mkcol.test.js

@@ -0,0 +1,38 @@
+'use strict'
+
+const t = require('tap')
+const test = t.test
+const sget = require('simple-get').concat
+const fastify = require('..')()
+
+test('can be created - mkcol', t => {
+  t.plan(1)
+  try {
+    fastify.route({
+      method: 'MKCOL',
+      url: '*',
+      handler: function (req, reply) {
+        reply.code(201).send()
+      }
+    })
+    t.pass()
+  } catch (e) {
+    t.fail()
+  }
+})
+
+fastify.listen({ port: 0 }, err => {
+  t.error(err)
+  t.teardown(() => { fastify.close() })
+
+  test('request - mkcol', t => {
+    t.plan(2)
+    sget({
+      url: `http://localhost:${fastify.server.address().port}/test/`,
+      method: 'MKCOL'
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 201)
+    })
+  })
+})

package/test/move.test.js

@@ -0,0 +1,45 @@
+'use strict'
+
+const t = require('tap')
+const test = t.test
+const sget = require('simple-get').concat
+const fastify = require('..')()
+
+test('shorthand - move', t => {
+  t.plan(1)
+  try {
+    fastify.route({
+      method: 'MOVE',
+      url: '*',
+      handler: function (req, reply) {
+        const destination = req.headers.destination
+        reply.code(201)
+          .header('location', destination)
+          .send()
+      }
+    })
+    t.pass()
+  } catch (e) {
+    t.fail()
+  }
+})
+
+fastify.listen({ port: 0 }, err => {
+  t.error(err)
+  t.teardown(() => { fastify.close() })
+
+  test('request - move', t => {
+    t.plan(3)
+    sget({
+      url: `http://localhost:${fastify.server.address().port}/test.txt`,
+      method: 'MOVE',
+      headers: {
+        Destination: '/test2.txt'
+      }
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 201)
+      t.equal(response.headers.location, '/test2.txt')
+    })
+  })
+})

package/test/propfind.test.js

@@ -0,0 +1,108 @@
+'use strict'
+
+const t = require('tap')
+const test = t.test
+const sget = require('simple-get').concat
+const fastify = require('..')()
+
+test('can be created - propfind', t => {
+  t.plan(1)
+  try {
+    fastify.route({
+      method: 'PROPFIND',
+      url: '*',
+      handler: function (req, reply) {
+        return reply.code(207)
+          .send(`<?xml version="1.0" encoding="utf-8"?>
+            <D:multistatus xmlns:D="DAV:">
+              <D:response xmlns:lp1="DAV:">
+                <D:href>/</D:href>
+                <D:propstat>
+                  <D:prop>
+                    <lp1:resourcetype>
+                      <D:collection/>
+                    </lp1:resourcetype>
+                    <lp1:creationdate>2022-04-13T12:35:30Z</lp1:creationdate>
+                    <lp1:getlastmodified>Wed, 13 Apr 2022 12:35:30 GMT</lp1:getlastmodified>
+                    <lp1:getetag>"e0-5dc8869b53ef1"</lp1:getetag>
+                    <D:supportedlock>
+                      <D:lockentry>
+                        <D:lockscope>
+                          <D:exclusive/>
+                        </D:lockscope>
+                        <D:locktype>
+                          <D:write/>
+                        </D:locktype>
+                      </D:lockentry>
+                      <D:lockentry>
+                        <D:lockscope>
+                          <D:shared/>
+                        </D:lockscope>
+                        <D:locktype>
+                          <D:write/>
+                        </D:locktype>
+                      </D:lockentry>
+                    </D:supportedlock>
+                    <D:lockdiscovery/>
+                    <D:getcontenttype>httpd/unix-directory</D:getcontenttype>
+                  </D:prop>
+                  <D:status>HTTP/1.1 200 OK</D:status>
+                </D:propstat>
+              </D:response>
+            </D:multistatus>`
+          )
+      }
+    })
+    t.pass()
+  } catch (e) {
+    t.fail()
+  }
+})
+
+fastify.listen({ port: 0 }, err => {
+  t.error(err)
+  t.teardown(() => { fastify.close() })
+
+  test('request - propfind', t => {
+    t.plan(3)
+    sget({
+      url: `http://localhost:${fastify.server.address().port}/`,
+      method: 'PROPFIND'
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 207)
+      t.equal(response.headers['content-length'], '' + body.length)
+    })
+  })
+
+  test('request with other path - propfind', t => {
+    t.plan(3)
+    sget({
+      url: `http://localhost:${fastify.server.address().port}/test`,
+      method: 'PROPFIND'
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 207)
+      t.equal(response.headers['content-length'], '' + body.length)
+    })
+  })
+
+  test('request with body - propfind', t => {
+    t.plan(3)
+    sget({
+      url: `http://localhost:${fastify.server.address().port}/test`,
+      body: `<?xml version="1.0" encoding="utf-8" ?>
+        <D:propfind xmlns:D="DAV:">
+          <D:prop xmlns:R="http://ns.example.com/boxschema/">
+            <R:bigbox/> <R:author/> <R:DingALing/> <R:Random/>
+          </D:prop>
+        </D:propfind>
+      `,
+      method: 'PROPFIND'
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 207)
+      t.equal(response.headers['content-length'], '' + body.length)
+    })
+  })
+})

package/test/proppatch.test.js

@@ -0,0 +1,78 @@
+'use strict'
+
+const t = require('tap')
+const test = t.test
+const sget = require('simple-get').concat
+const fastify = require('..')()
+
+test('shorthand - proppatch', t => {
+  t.plan(1)
+  try {
+    fastify.route({
+      method: 'PROPPATCH',
+      url: '*',
+      handler: function (req, reply) {
+        reply
+          .code(207)
+          .send(`<?xml version="1.0" encoding="utf-8" ?>
+            <D:multistatus xmlns:D="DAV:"
+              xmlns:Z="http://ns.example.com/standards/z39.50/">
+              <D:response>
+                <D:href>http://www.example.com/bar.html</D:href>
+                <D:propstat>
+                  <D:prop>
+                    <Z:Authors/>
+                  </D:prop>
+                  <D:status>HTTP/1.1 424 Failed Dependency</D:status>
+                </D:propstat>
+                <D:propstat>
+                  <D:prop>
+                    <Z:Copyright-Owner/>
+                  </D:prop>
+                  <D:status>HTTP/1.1 409 Conflict</D:status>
+                </D:propstat>
+                <D:responsedescription> Copyright Owner cannot be deleted or altered.</D:responsedescription>
+              </D:response>
+            </D:multistatus>`
+          )
+      }
+    })
+    t.pass()
+  } catch (e) {
+    t.fail()
+  }
+})
+
+fastify.listen({ port: 0 }, err => {
+  t.error(err)
+  t.teardown(() => { fastify.close() })
+
+  test('request - proppatch', t => {
+    t.plan(3)
+    sget({
+      url: `http://localhost:${fastify.server.address().port}/test/a.txt`,
+      body: `<?xml version="1.0" encoding="utf-8" ?>
+        <D:propertyupdate xmlns:D="DAV:"
+          xmlns:Z="http://ns.example.com/standards/z39.50/">
+          <D:set>
+            <D:prop>
+              <Z:Authors>
+                <Z:Author>Jim Whitehead</Z:Author>
+                <Z:Author>Roy Fielding</Z:Author>
+              </Z:Authors>
+            </D:prop>
+          </D:set>
+          <D:remove>
+            <D:prop>
+              <Z:Copyright-Owner/>
+            </D:prop>
+          </D:remove>
+        </D:propertyupdate>`,
+      method: 'PROPPATCH'
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 207)
+      t.equal(response.headers['content-length'], '' + body.length)
+    })
+  })
+})

package/test/request-error.test.js

@@ -150,7 +150,7 @@ test('default clientError handler ignores sockets in destroyed state', t => {
 })
 
 test('default clientError handler destroys sockets in writable state', t => {
-  t.plan(1)
+  t.plan(2)
 
   const fastify = Fastify({
     bodyLimit: 1,
@@ -166,6 +166,9 @@ test('default clientError handler destroys sockets in writable state', t => {
     },
     destroy () {
       t.pass('destroy should be called')
+    },
+    write (response) {
+      t.match(response, /^HTTP\/1.1 400 Bad Request/)
     }
   })
 })
@@ -186,6 +189,9 @@ test('default clientError handler destroys http sockets in non-writable state',
     },
     destroy () {
       t.pass('destroy should be called')
+    },
+    write (response) {
+      t.fail('write should not be called')
     }
   })
 })
@@ -270,3 +276,40 @@ test('encapsulated error handler binding', t => {
     t.equal(fastify.hello, undefined)
   })
 })
+
+test('default clientError replies with bad request on reused keep-alive connection', t => {
+  t.plan(2)
+
+  let response = ''
+
+  const fastify = Fastify({
+    bodyLimit: 1,
+    keepAliveTimeout: 100
+  })
+
+  fastify.get('/', (request, reply) => {
+    reply.send('OK\n')
+  })
+
+  fastify.listen({ port: 0 }, function (err) {
+    t.error(err)
+    fastify.server.unref()
+
+    const client = connect(fastify.server.address().port)
+
+    client.on('data', chunk => {
+      response += chunk.toString('utf-8')
+    })
+
+    client.on('end', () => {
+      t.match(response, /^HTTP\/1.1 200 OK.*HTTP\/1.1 400 Bad Request/s)
+    })
+
+    client.resume()
+    client.write('GET / HTTP/1.1\r\n')
+    client.write('\r\n\r\n')
+    client.write('GET /?a b HTTP/1.1\r\n')
+    client.write('Connection: close\r\n')
+    client.write('\r\n\r\n')
+  })
+})

package/test/schema-validation.test.js

@@ -4,6 +4,7 @@ const { test } = require('tap')
 const Fastify = require('..')
 
 const AJV = require('ajv')
+const Schema = require('fluent-json-schema')
 
 const customSchemaCompilers = {
   body: new AJV({
@@ -946,3 +947,73 @@ test('Custom AJV settings on different parameters - pt2', t => {
     }
   })
 })
+
+test("The same $id in route's schema must not overwrite others", t => {
+  t.plan(4)
+  const fastify = Fastify()
+
+  const UserSchema = Schema.object()
+    .id('http://mydomain.com/user')
+    .title('User schema')
+    .description('Contains all user fields')
+    .prop('id', Schema.integer())
+    .prop('username', Schema.string().minLength(4))
+    .prop('firstName', Schema.string().minLength(1))
+    .prop('lastName', Schema.string().minLength(1))
+    .prop('fullName', Schema.string().minLength(1))
+    .prop('email', Schema.string())
+    .prop('password', Schema.string().minLength(6))
+    .prop('bio', Schema.string())
+
+  const userCreateSchema = UserSchema.only([
+    'username',
+    'firstName',
+    'lastName',
+    'email',
+    'bio',
+    'password',
+    'password_confirm'
+  ])
+    .required([
+      'username',
+      'firstName',
+      'lastName',
+      'email',
+      'bio',
+      'password'
+    ])
+
+  const userPatchSchema = UserSchema.only([
+    'firstName',
+    'lastName',
+    'bio'
+  ])
+
+  fastify
+    .patch('/user/:id', {
+      schema: { body: userPatchSchema },
+      handler: () => { return 'ok' }
+    })
+    .post('/user', {
+      schema: { body: userCreateSchema },
+      handler: () => { return 'ok' }
+    })
+
+  fastify.inject({
+    method: 'POST',
+    url: '/user',
+    body: {}
+  }, (err, res) => {
+    t.error(err)
+    t.same(res.json().message, "body must have required property 'username'")
+  })
+
+  fastify.inject({
+    url: '/user/1',
+    method: 'PATCH',
+    body: {}
+  }, (err, res) => {
+    t.error(err)
+    t.same(res.payload, 'ok')
+  })
+})

package/test/search.test.js

@@ -0,0 +1,100 @@
+'use strict'
+
+const t = require('tap')
+const test = t.test
+const fastify = require('..')()
+
+const schema = {
+  schema: {
+    response: {
+      '2xx': {
+        type: 'object',
+        properties: {
+          hello: {
+            type: 'string'
+          }
+        }
+      }
+    }
+  }
+}
+
+const querySchema = {
+  schema: {
+    querystring: {
+      type: 'object',
+      properties: {
+        hello: {
+          type: 'integer'
+        }
+      }
+    }
+  }
+}
+
+const paramsSchema = {
+  schema: {
+    params: {
+      type: 'object',
+      properties: {
+        foo: {
+          type: 'string'
+        },
+        test: {
+          type: 'integer'
+        }
+      }
+    }
+  }
+}
+
+test('shorthand - search', t => {
+  t.plan(1)
+  try {
+    fastify.route({
+      method: 'SEARCH',
+      url: '/',
+      schema,
+      handler: function (request, reply) {
+        reply.code(200).send({ hello: 'world' })
+      }
+    })
+    t.pass()
+  } catch (e) {
+    t.fail()
+  }
+})
+
+test('shorthand - search params', t => {
+  t.plan(1)
+  try {
+    fastify.route({
+      method: 'SEARCH',
+      url: '/params/:foo/:test',
+      paramsSchema,
+      handler: function (request, reply) {
+        reply.code(200).send(request.params)
+      }
+    })
+    t.pass()
+  } catch (e) {
+    t.fail()
+  }
+})
+
+test('shorthand - get, querystring schema', t => {
+  t.plan(1)
+  try {
+    fastify.route({
+      method: 'SEARCH',
+      url: '/query',
+      querySchema,
+      handler: function (request, reply) {
+        reply.code(200).send(request.query)
+      }
+    })
+    t.pass()
+  } catch (e) {
+    t.fail()
+  }
+})

package/test/trace.test.js

@@ -0,0 +1,21 @@
+'use strict'
+
+const t = require('tap')
+const test = t.test
+const fastify = require('..')()
+
+test('shorthand - trace', t => {
+  t.plan(1)
+  try {
+    fastify.route({
+      method: 'TRACE',
+      url: '/',
+      handler: function (request, reply) {
+        reply.code(200).send('TRACE OK')
+      }
+    })
+    t.pass()
+  } catch (e) {
+    t.fail()
+  }
+})

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

@@ -194,7 +194,18 @@ expectAssignable<FastifyInstance>(fastify({ frameworkErrors: () => { } }))
 expectAssignable<FastifyInstance>(fastify({
   rewriteUrl: (req) => req.url === '/hi' ? '/hello' : req.url!
 }))
-expectAssignable<FastifyInstance>(fastify({ schemaErrorFormatter: (errors, dataVar) => new Error() }))
+expectAssignable<FastifyInstance>(fastify({
+  schemaErrorFormatter: (errors, dataVar) => {
+    console.log(
+      errors[0].keyword.toLowerCase(),
+      errors[0].message?.toLowerCase(),
+      errors[0].params,
+      errors[0].instancePath.toLowerCase(),
+      errors[0].schemaPath.toLowerCase()
+    )
+    return new Error()
+  }
+}))
 expectAssignable<FastifyInstance>(fastify({
   clientErrorHandler: (err, socket) => {
     expectType<ConnectionError>(err)

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

@@ -223,8 +223,7 @@ RawReplyDefaultExpression,
 RouteGenericInterface,
 ContextConfigDefault,
 FastifySchema,
-FastifyTypeProviderDefault,
-ResolveFastifyRequestType<FastifyTypeProviderDefault, FastifySchema, RouteGenericInterface>
+FastifyTypeProviderDefault
 > = async function (request, reply): Promise<void> {
   expectType<FastifyInstance>(this)
   expectAssignable<FastifyRequest>(request)

package/test/types/import.ts

@@ -1 +1 @@
-import { FastifyLogFn } from '../../fastify'
+import { FastifyListenOptions, FastifyLogFn } from '../../fastify'