fastify(route,method,Serialization,test,log)

summary_2018/06 fastify

1、日常工作

• fastify_server_method
• fastify_route
• fastify_log
• fastify_validate_Serialization
• fastify_test
• commit facbook_insight service update

2、技术学习

• fastify
  
  • Fastify is a web framework highly focused on providing the best developer experience with the least overhead and a powerful plugin architecture. It is inspired by Hapi and Express and as far as we know, it is one of the fastest web frameworks in town.
• fastify_server_method
• listen
  
  • Starts the server on the given port after all the plugins are loaded
  • By default, the server will listen on address 127.0.0.1 when no specific address is provided. If listening on any available interface is desired, then specifying 0.0.0.0 for the address will listen on all IPv4 address. Using :: for the address will listen on all IPv6 addresses
• use callback/return promis

fastify.listen(3000, '127.0.0.1', 511, err => {
  if (err) {
    fastify.log.error(err)
    process.exit(1)
  }
})
fastify.listen(3000)
  .then(() => console.log('Listening'))
  .catch(err => {
    console.log('Error starting server:', err)
    process.exit(1)
  })

• route(见fastify_route)
• close
  
  • fastify.close(callback): call this function to close the server instance and run the 'onClose' hook.
• rigsiter

• log(见fastify_log)

• fastify_route

  • Full declaration
  • Shorthand declaration

### Full declaration
fastify.route(options)
- method: currently it supports 'DELETE', 'GET', 'HEAD', 'PATCH', 'POST', 'PUT' and 'OPTIONS'. It could also be an array of methods.
- url: the path of the url to match this route (alias: path).
- schema: an object containing the schemas for the request and response. They need to be in JSON Schema format, check here for more info.
   - body: validates the body of the request if it is a POST or a PUT.
   - querystring: validates the querystring. This can be a complete JSON Schema object, with the property type of object and properties object of parameters, or simply the values of what would be contained in the properties object as shown below.
   - params: validates the params.
   - response: filter and generate a schema for the response, setting a schema allows us to have 10-20% more throughput.（生成请求体，加快响应速度）
- beforeHandler(request, reply, done): a function called just before the request handler, useful if you need to perform authentication at route level for example, it could also be and array of functions.（在handler前处理）
- handler(request, reply): the function that will handle this request.（处理请求的函数）
- schemaCompiler(schema): the function that build the schema for the validations. See here
- bodyLimit: prevents the default JSON body parser from parsing request bodies larger than this number of bytes. Must be an integer. You may also set this option globally when first creating the Fastify instance with fastify(options). Defaults to 1048576 (1 MiB).(请求体限制)
- logLevel: set log level for this route. See below.
- config: object used to store custom configuration.
- request is defined in Request.
- reply is defined in Reply.
### Example
fastify.route({
  method: 'GET',
  url: '/',
  //参数检查
  schema: {
    querystring: {
      name: { type: 'string' },
      excitement: { type: 'integer' }
    },
    //生成请求
    response: {
      200: {
        type: 'object',
        properties: {
          hello: { type: 'string' }
        }
      }
    }
  },
  //处理请求的函数
  handler: function (request, reply) {
    reply.send({ hello: 'world' })
  }
})
### Shorthand declaration(类似express)
//参数参考full declaration
const opts = {
  schema: {
    response: {
      200: {
        type: 'object',
        properties: {
          hello: { type: 'string' }
        }
      }
    }
  }
}
fastify.get('/', opts, (request, reply) => {
  reply.send({ hello: 'world' })
})
### Url building
Tips:Remember that static routes are always checked before parametric(参数的) and wildcard（通配符）.
// parametric
fastify.get('/example/:userId', (request, reply) => {}))
fastify.get('/example/:userId/:secretToken', (request, reply) => {}))
// wildcard（可以使用正则表达式）
fastify.get('/example/*', (request, reply) => {}))
### use Async Await
fastify.get('/', options, async function (request, reply) {
  var data = await getData()
  var processed = await processData(data)
  return processed
})
Tips:you can use return and reply.send,if you use at the same time ,the second value will be discarded
### Route Prefixing
// server.js
const fastify = require('fastify')()
fastify.register(require('./routes/v1/users'), { prefix: '/v1' })
fastify.listen(3000)
// routes/v1/users.js
module.exports = function (fastify, opts, next) {
  fastify.get('/user', handler_v1)
  next()
}
### Config
function handler (req, reply) {
  reply.send(reply.context.config.output)
}
fastify.get('/en', { config: { output: 'hello world!' } }, handler)
fastify.get('/it', { config: { output: 'ciao mondo!' } }, handler)

• fastify_log（uses pino as its logger）
  
  • Logging is disabled by default, and you can enable it by passing { logger: true } or { logger: { level: 'info' } } when you create the fastify instance.
  • logger option
  • level : 'fatal', 'error', 'warn', 'info', 'debug', 'trace','silent'，Default: 'info'.
  • 可以序列化自己log的格式req、res

### logger option
const fastify = require('fastify')({
  logger: {
    level: 'info',
    stream: stream
  }
})
### By default fastify adds an id to every request for easier tracking. 
//自己设置ID：genReqId
let i = 0
const fastify = require('fastify')({
  logger: {
    genReqId: function (req) { return i++ }
  }
})
### supply your own logger
//You can also supply your own logger instance. Instead of passing configuration options, simply pass the instance. The logger you supply must conform to the Pino interface; that is, it must have the following methods: info, error, debug, fatal, warn, trace, child.
const log = require('pino')({ level: 'info' })
const fastify = require('fastify')({ logger: log })
### 打印日志
//request.log.warn
//fastify.log.warn

• fastify_validate_Serialization(参数验证和生成响应体)
• validation(ajv)

### Example
const schema = {
  body: {
    type: 'object',
    required: ['someKey'],    // 必须字段
    properties: {
      someKey: { type: 'string' },
      someOtherKey: { type: 'number' }
    }
  },
  querystring: {
    name: { type: 'string' },
    excitement: { type: 'integer' }
  },
  params: {
    type: 'object',
    properties: {
      par1: { type: 'string' },
      par2: { type: 'number' }
    }
  },
}
fastify.post('/the/url', { schema }, handler)
//JSON Schema 
const querySchema = {
  schema: {
    querystring: {     // 被废弃type、properties？？
      type: 'object',
      properties: {
        name: {
          type: 'string'
        }
      },
      required: ['name']
    }
  }
}
### shared schema
//you can add multiple schemas to the Fastify instance and then reuse them in multiple parts of your application. (Note that this API is not encapsulated)
const fastify = require('fastify')()
fastify.addSchema({
  $id: 'greetings',
  type: 'object',
  properties: {
    hello: { type: 'string' }
  }
})
fastify.route({
  method: 'POST',
  url: '/',
  schema: {
    body: 'greetings#'
  },
  handler: () => {}
})
### Schema Compiler(fastify use ajv speed the validation up)
While you cannot change the configuration options of the default ajv instance, you can create your own:(创建自己的ajv instance)
const fastify = require('fastify')()
const Ajv = require('ajv')
const ajv = new Ajv({
  // the fastify defaults
  removeAdditional: true,
  useDefaults: true,
  coerceTypes: true
})
fastify.setSchemaCompiler(function (schema) {
  return ajv.compile(schema)
})
### use other validation library
const Joi = require('joi')
fastify.post('/the/url', {
  schema: {
    body: Joi.object().keys({
      hello: Joi.string().required()
    }).required()
  },
  schemaCompiler: schema => data => Joi.validate(data, schema)
}, handler)

• Serialization(生成响应，提高吞吐量100-400% )
  
  • 当返回值中有序列化中未定义的值时，会被忽略 (可以使用additionalProperties:true)

### Example
const schema = {
  response: {
    200: {
      type: 'object',
      properties: {
        value: { type: 'string' },
        otherValue: { type: 'boolean' }
      }
    }
  }
}
fastify.post('/the/url', { schema }, handler)
### the response schema is based on the status code. If you want to use the same schema for multiple status codes, you can use '2xx'
  '2xx': {
      type: 'object',
      properties: {
        value: { type: 'string' },
        otherValue: { type: 'boolean' }
      }
    }

• fastify_test
  
  • fastify.inject
  • tap
  • supertest