harperdb 3.1.3 → 3.1.4

package/node_modules/fastify/test/custom-parser.test.js

@@ -388,7 +388,7 @@ test('contentTypeParser shouldn\'t support request with undefined "Content-Type"
   })
 })
 
-test('the content type should be a string or RegExp', t => {
+test('the content type should be a string', t => {
   t.plan(2)
   const fastify = Fastify()
 
@@ -397,7 +397,7 @@ test('the content type should be a string or RegExp', t => {
     t.fail()
   } catch (err) {
     t.is(err.code, 'FST_ERR_CTP_INVALID_TYPE')
-    t.is(err.message, 'The content type should be a string or a RegExp')
+    t.is(err.message, 'The content type should be a string')
   }
 })
 
@@ -1244,263 +1244,3 @@ test('should be able to use default parser for extra content type', t => {
     })
   })
 })
-
-test('contentTypeParser should add a custom parser with RegExp value', t => {
-  t.plan(3)
-
-  const fastify = Fastify()
-
-  fastify.post('/', (req, reply) => {
-    reply.send(req.body)
-  })
-
-  fastify.options('/', (req, reply) => {
-    reply.send(req.body)
-  })
-
-  fastify.addContentTypeParser(/.*\+json$/, function (req, payload, done) {
-    jsonParser(payload, function (err, body) {
-      done(err, body)
-    })
-  })
-
-  fastify.listen(0, err => {
-    t.error(err)
-
-    t.tearDown(() => fastify.close())
-
-    t.test('in POST', t => {
-      t.plan(3)
-
-      sget({
-        method: 'POST',
-        url: 'http://localhost:' + fastify.server.address().port,
-        body: '{"hello":"world"}',
-        headers: {
-          'Content-Type': 'application/vnd.test+json'
-        }
-      }, (err, response, body) => {
-        t.error(err)
-        t.strictEqual(response.statusCode, 200)
-        t.deepEqual(body.toString(), JSON.stringify({ hello: 'world' }))
-      })
-    })
-
-    t.test('in OPTIONS', t => {
-      t.plan(3)
-
-      sget({
-        method: 'OPTIONS',
-        url: 'http://localhost:' + fastify.server.address().port,
-        body: '{"hello":"world"}',
-        headers: {
-          'Content-Type': 'weird-content-type+json'
-        }
-      }, (err, response, body) => {
-        t.error(err)
-        t.strictEqual(response.statusCode, 200)
-        t.deepEqual(body.toString(), JSON.stringify({ hello: 'world' }))
-      })
-    })
-  })
-})
-
-test('contentTypeParser should add multiple custom parsers with RegExp values', t => {
-  t.plan(10)
-  const fastify = Fastify()
-
-  fastify.post('/', (req, reply) => {
-    reply.send(req.body)
-  })
-
-  fastify.addContentTypeParser(/.*\+json$/, function (req, payload, done) {
-    jsonParser(payload, function (err, body) {
-      done(err, body)
-    })
-  })
-
-  fastify.addContentTypeParser(/.*\+xml$/, function (req, payload, done) {
-    done(null, 'xml')
-  })
-
-  fastify.addContentTypeParser(/.*\+myExtension$/, function (req, payload, done) {
-    let data = ''
-    payload.on('data', chunk => { data += chunk })
-    payload.on('end', () => {
-      done(null, data + 'myExtension')
-    })
-  })
-
-  fastify.listen(0, err => {
-    t.error(err)
-
-    sget({
-      method: 'POST',
-      url: 'http://localhost:' + fastify.server.address().port,
-      body: '{"hello":"world"}',
-      headers: {
-        'Content-Type': 'application/vnd.hello+json'
-      }
-    }, (err, response, body) => {
-      t.error(err)
-      t.strictEqual(response.statusCode, 200)
-      t.deepEqual(body.toString(), JSON.stringify({ hello: 'world' }))
-    })
-
-    sget({
-      method: 'POST',
-      url: 'http://localhost:' + fastify.server.address().port,
-      body: '{"hello":"world"}',
-      headers: {
-        'Content-Type': 'application/test+xml'
-      }
-    }, (err, response, body) => {
-      t.error(err)
-      t.strictEqual(response.statusCode, 200)
-      t.deepEqual(body.toString(), 'xml')
-    })
-
-    sget({
-      method: 'POST',
-      url: 'http://localhost:' + fastify.server.address().port,
-      body: 'abcdefg',
-      headers: {
-        'Content-Type': 'application/+myExtension'
-      }
-    }, (err, response, body) => {
-      t.error(err)
-      t.strictEqual(response.statusCode, 200)
-      t.deepEqual(body.toString(), 'abcdefgmyExtension')
-      fastify.close()
-    })
-  })
-})
-
-test('catch all content type parser should not interfere with content type parser', t => {
-  t.plan(10)
-  const fastify = Fastify()
-
-  fastify.post('/', (req, reply) => {
-    reply.send(req.body)
-  })
-
-  fastify.addContentTypeParser('*', function (req, payload, done) {
-    let data = ''
-    payload.on('data', chunk => { data += chunk })
-    payload.on('end', () => {
-      done(null, data)
-    })
-  })
-
-  fastify.addContentTypeParser(/^application\/.*/, function (req, payload, done) {
-    jsonParser(payload, function (err, body) {
-      done(err, body)
-    })
-  })
-
-  fastify.addContentTypeParser('text/html', function (req, payload, done) {
-    let data = ''
-    payload.on('data', chunk => { data += chunk })
-    payload.on('end', () => {
-      done(null, data + 'html')
-    })
-  })
-
-  fastify.listen(0, err => {
-    t.error(err)
-
-    sget({
-      method: 'POST',
-      url: 'http://localhost:' + fastify.server.address().port,
-      body: '{"myKey":"myValue"}',
-      headers: {
-        'Content-Type': 'application/json'
-      }
-    }, (err, response, body) => {
-      t.error(err)
-      t.strictEqual(response.statusCode, 200)
-      t.deepEqual(body.toString(), JSON.stringify({ myKey: 'myValue' }))
-    })
-
-    sget({
-      method: 'POST',
-      url: 'http://localhost:' + fastify.server.address().port,
-      body: 'body',
-      headers: {
-        'Content-Type': 'very-weird-content-type'
-      }
-    }, (err, response, body) => {
-      t.error(err)
-      t.strictEqual(response.statusCode, 200)
-      t.deepEqual(body.toString(), 'body')
-    })
-
-    sget({
-      method: 'POST',
-      url: 'http://localhost:' + fastify.server.address().port,
-      body: 'my text',
-      headers: {
-        'Content-Type': 'text/html'
-      }
-    }, (err, response, body) => {
-      t.error(err)
-      t.strictEqual(response.statusCode, 200)
-      t.deepEqual(body.toString(), 'my texthtml')
-      fastify.close()
-    })
-  })
-})
-
-test('should prefer string content types over RegExp ones', t => {
-  t.plan(7)
-  const fastify = Fastify()
-
-  fastify.post('/', (req, reply) => {
-    reply.send(req.body)
-  })
-
-  fastify.addContentTypeParser(/^application\/.*/, function (req, payload, done) {
-    let data = ''
-    payload.on('data', chunk => { data += chunk })
-    payload.on('end', () => {
-      done(null, data)
-    })
-  })
-
-  fastify.addContentTypeParser('application/json', function (req, payload, done) {
-    jsonParser(payload, function (err, body) {
-      done(err, body)
-    })
-  })
-
-  fastify.listen(0, err => {
-    t.error(err)
-
-    sget({
-      method: 'POST',
-      url: 'http://localhost:' + fastify.server.address().port,
-      body: '{"k1":"myValue", "k2": "myValue"}',
-      headers: {
-        'Content-Type': 'application/json'
-      }
-    }, (err, response, body) => {
-      t.error(err)
-      t.strictEqual(response.statusCode, 200)
-      t.deepEqual(body.toString(), JSON.stringify({ k1: 'myValue', k2: 'myValue' }))
-    })
-
-    sget({
-      method: 'POST',
-      url: 'http://localhost:' + fastify.server.address().port,
-      body: 'javascript',
-      headers: {
-        'Content-Type': 'application/javascript'
-      }
-    }, (err, response, body) => {
-      t.error(err)
-      t.strictEqual(response.statusCode, 200)
-      t.deepEqual(body.toString(), 'javascript')
-      fastify.close()
-    })
-  })
-})

package/node_modules/fastify/test/pretty-print.test.js

@@ -93,31 +93,3 @@ test('pretty print - wildcard routes', t => {
     t.equal(tree, expected)
   })
 })
-
-test('pretty print - empty plugins', t => {
-  t.plan(2)
-
-  const fastify = Fastify()
-  fastify.ready(() => {
-    const tree = fastify.printPlugins()
-    t.is(typeof tree, 'string')
-    t.match(tree, 'bound root')
-  })
-})
-
-test('pretty print - nested plugins', t => {
-  t.plan(4)
-
-  const fastify = Fastify()
-  fastify.register(async function foo (instance) {
-    instance.register(async function bar () {})
-    instance.register(async function baz () {})
-  })
-  fastify.ready(() => {
-    const tree = fastify.printPlugins()
-    t.is(typeof tree, 'string')
-    t.match(tree, 'foo')
-    t.match(tree, 'bar')
-    t.match(tree, 'baz')
-  })
-})

package/node_modules/fastify/test/schema-special-usage.test.js

@@ -357,49 +357,3 @@ test('setSchemaController in a plugin', t => {
   }
   schemaPlugin[Symbol.for('skip-override')] = true
 })
-
-test('side effect on schema let the server crash', async t => {
-  const firstSchema = {
-    $id: 'example1',
-    type: 'object',
-    properties: {
-      name: {
-        type: 'string'
-      }
-    }
-  }
-
-  const reusedSchema = {
-    $id: 'example2',
-    type: 'object',
-    properties: {
-      name: {
-        oneOf: [
-          {
-            $ref: 'example1'
-          }
-        ]
-      }
-    }
-  }
-
-  const fastify = Fastify()
-  fastify.addSchema(firstSchema)
-
-  fastify.post('/a', {
-    handler: async () => 'OK',
-    schema: {
-      body: reusedSchema,
-      response: { 200: reusedSchema }
-    }
-  })
-  fastify.post('/b', {
-    handler: async () => 'OK',
-    schema: {
-      body: reusedSchema,
-      response: { 200: reusedSchema }
-    }
-  })
-
-  await fastify.ready()
-})

package/node_modules/fastify/test/stream.test.js

@@ -263,68 +263,6 @@ test('Destroying streams prematurely should call close method', t => {
   })
 })
 
-test('Destroying streams prematurely should call close method when destroy is not a function', t => {
-  t.plan(7)
-
-  let fastify = null
-  const logStream = split(JSON.parse)
-  try {
-    fastify = Fastify({
-      logger: {
-        stream: logStream,
-        level: 'info'
-      }
-    })
-  } catch (e) {
-    t.fail()
-  }
-  const stream = require('stream')
-  const http = require('http')
-
-  // Test that "premature close" errors are logged with level warn
-  logStream.on('data', line => {
-    if (line.res) {
-      t.equal(line.msg, 'stream closed prematurely')
-      t.equal(line.level, 30)
-    }
-  })
-
-  fastify.get('/', function (request, reply) {
-    t.pass('Received request')
-
-    let sent = false
-    const reallyLongStream = new stream.Readable({
-      read: function () {
-        if (!sent) {
-          this.push(Buffer.from('hello\n'))
-        }
-        sent = true
-      }
-    })
-    reallyLongStream.destroy = true
-    reallyLongStream.close = () => t.ok('called')
-    reply.send(reallyLongStream)
-  })
-
-  fastify.listen(0, err => {
-    t.error(err)
-    fastify.server.unref()
-
-    const port = fastify.server.address().port
-
-    http.get(`http://localhost:${port}`, function (response) {
-      t.strictEqual(response.statusCode, 200)
-      response.on('readable', function () {
-        response.destroy()
-      })
-      // Node bug? Node never emits 'close' here.
-      response.on('aborted', function () {
-        t.pass('Response closed')
-      })
-    })
-  })
-})
-
 test('Destroying streams prematurely should call abort method', t => {
   t.plan(7)
 
@@ -480,31 +418,3 @@ test('should support send module 200 and 404', t => {
     })
   })
 })
-
-test('should destroy stream when response is ended', t => {
-  t.plan(4)
-  const stream = require('stream')
-  const fastify = Fastify()
-
-  fastify.get('/error', function (req, reply) {
-    const reallyLongStream = new stream.Readable({
-      read: function () {},
-      destroy: function (err, callback) {
-        t.ok('called')
-        callback(err)
-      }
-    })
-    reply.code(200).send(reallyLongStream)
-    reply.raw.end(Buffer.from('hello\n'))
-  })
-
-  fastify.listen(0, err => {
-    t.error(err)
-    fastify.server.unref()
-
-    sget(`http://localhost:${fastify.server.address().port}/error`, function (err, response) {
-      t.error(err)
-      t.strictEqual(response.statusCode, 200)
-    })
-  })
-})

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

@@ -15,8 +15,6 @@ expectAssignable<FastifyInstance>(server.addSchema({
 
 expectType<Record<string, unknown>>(server.getSchemas())
 expectType<unknown>(server.getSchema('SchemaId'))
-expectType<string>(server.printRoutes())
-expectType<string>(server.printPlugins())
 
 expectAssignable<FastifyInstance>(
   server.setErrorHandler(function (error, request, reply) {

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

@@ -5,16 +5,11 @@ import * as pino from 'pino'
 
 expectType<FastifyLoggerInstance>(fastify().log)
 
-class Foo {}
-
-['trace', 'debug', 'info', 'warn', 'error', 'fatal'].forEach(logLevel => {
+;['trace', 'debug', 'info', 'warn', 'error', 'fatal'].forEach(logLevel => {
   expectType<FastifyLogFn>(fastify<Server, IncomingMessage, ServerResponse, FastifyLoggerInstance>().log[logLevel as LogLevel])
   expectType<void>(fastify<Server, IncomingMessage, ServerResponse, FastifyLoggerInstance>().log[logLevel as LogLevel](''))
   expectType<void>(fastify<Server, IncomingMessage, ServerResponse, FastifyLoggerInstance>().log[logLevel as LogLevel]({}))
-  expectType<void>(fastify<Server, IncomingMessage, ServerResponse, FastifyLoggerInstance>().log[logLevel as LogLevel]({ foo: 'bar' }))
-  expectType<void>(fastify<Server, IncomingMessage, ServerResponse, FastifyLoggerInstance>().log[logLevel as LogLevel](new Error()))
-  expectType<void>(fastify<Server, IncomingMessage, ServerResponse, FastifyLoggerInstance>().log[logLevel as LogLevel](new Foo()))
-  expectType<void>(fastify<Server, IncomingMessage, ServerResponse, FastifyLoggerInstance>().log[logLevel as LogLevel](0))
+  expectError(fastify<Server, IncomingMessage, ServerResponse, FastifyLoggerInstance>().log[logLevel as LogLevel](0))
 })
 
 interface CustomLogger extends FastifyLoggerInstance {
@@ -25,7 +20,7 @@ class CustomLoggerImpl implements CustomLogger {
   customMethod (msg: string, ...args: unknown[]) { console.log(msg, args) }
 
   // Implementation signature must be compatible with all overloads of FastifyLogFn
-  info (arg1: unknown, arg2?: unknown, ...args: unknown[]): void {
+  info (arg1: string | Record<string, unknown>, arg2?: string | unknown, ...args: unknown[]): void {
     console.log(arg1, arg2, ...args)
   }
 

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

@@ -1,8 +1,5 @@
 import { expectAssignable, expectError } from 'tsd'
-import fastify, { FastifyInstance, FastifyRequest, FastifySchema } from '../../fastify'
-import { RouteGenericInterface } from '../../types/route'
-import { ContextConfigDefault } from '../../types/utils'
-import { FastifyReply } from '../../types/reply'
+import fastify, { FastifyInstance } from '../../fastify'
 import Ajv = require('ajv')
 
 const server = fastify()
@@ -35,33 +32,6 @@ expectAssignable<FastifyInstance>(server.get(
   () => { }
 ))
 
-expectAssignable<FastifyInstance>(server.get<RouteGenericInterface, ContextConfigDefault, { validate:(data: any) => any }>(
-  '/no-schema',
-{
-  schema: {},
-  validatorCompiler: ({ schema }) => {
-    // Error: Property 'validate' does not exist on type 'FastifySchema'.
-    return (data: any) => schema.validate(data)
-  }
-},
-() => { }
-))
-
-expectAssignable<FastifyInstance>(
-  server.route<RouteGenericInterface, ContextConfigDefault, { validate:(data: any) => any }>(
-    {
-      schema: {},
-      validatorCompiler: ({ schema }) => {
-        // Error: Property 'validate' does not exist on type 'FastifySchema'.
-        return (data: any) => schema.validate(data)
-      },
-      method: 'POST',
-      url: '/',
-      handler: async (_request: FastifyRequest, _reply: FastifyReply) => {}
-    }
-  )
-)
-
 expectAssignable<FastifyInstance>(server.setValidatorCompiler(({ schema }) => {
   return new Ajv().compile(schema)
 }))
@@ -81,16 +51,6 @@ expectAssignable<FastifyInstance>(server.post('/test', {
   }
 }, async req => req.body))
 
-expectAssignable<FastifyInstance>(server.setValidatorCompiler<FastifySchema & { validate: Record<string, unknown> }>(
-  function ({ schema }) {
-    return new Ajv().compile(schema.validate)
-  }
-))
-
-expectAssignable<FastifyInstance>(server.setSerializerCompiler<FastifySchema & { validate: string }>(
-  () => data => JSON.stringify(data)
-))
-
 expectError(server.get(
   '/unknown-schema-prop',
   {