编写插件 #

async function myPlugin(fastify, options) {
  fastify.decorate('hello', () => {
    return 'Hello World'
  })
}

module.exports = myPlugin

const fastify = require('fastify')()

fastify.register(require('./my-plugin'))

fastify.get('/', async (request, reply) => {
  return { message: fastify.hello() }
})

const fp = require('fastify-plugin')

async function myPlugin(fastify, options) {
  fastify.decorate('utility', () => {
    return 'Utility function'
  })
}

module.exports = fp(myPlugin, {
  name: 'my-plugin'
})

async function myPlugin(fastify, options) {
  const defaults = {
    enabled: true,
    timeout: 5000
  }
  
  const config = { ...defaults, ...options }
  
  fastify.decorate('config', config)
}

module.exports = myPlugin

const fp = require('fastify-plugin')

async function databasePlugin(fastify, options) {
  const { MongoClient } = require('mongodb')
  
  const client = new MongoClient(options.url)
  await client.connect()
  
  const db = client.db(options.database)
  
  fastify.decorate('mongo', client)
  fastify.decorate('db', db)
  
  fastify.addHook('onClose', async (instance) => {
    await client.close()
  })
}

module.exports = fp(databasePlugin, {
  name: 'database'
})

const fp = require('fastify-plugin')

async function authPlugin(fastify, options) {
  fastify.decorateRequest('user', null)
  
  fastify.addHook('onRequest', async (request, reply) => {
    const token = request.headers.authorization
    
    if (token) {
      try {
        request.user = await verifyToken(token)
      } catch (err) {
        request.log.warn('Token verification failed')
      }
    }
  })
}

module.exports = fp(authPlugin, {
  name: 'auth'
})

const fp = require('fastify-plugin')

async function responsePlugin(fastify, options) {
  fastify.decorateReply('success', function (data) {
    return this.send({
      success: true,
      data,
      timestamp: new Date().toISOString()
    })
  })
  
  fastify.decorateReply('error', function (message, code = 400) {
    return this.code(code).send({
      success: false,
      error: message,
      timestamp: new Date().toISOString()
    })
  })
}

module.exports = fp(responsePlugin, {
  name: 'response'
})

async function myPlugin(fastify, options) {
  if (fastify.hasDecorator('db')) {
    throw new Error('Database decorator already exists')
  }
  
  if (!fastify.hasRequestDecorator('user')) {
    fastify.decorateRequest('user', null)
  }
  
  if (!fastify.hasReplyDecorator('success')) {
    fastify.decorateReply('success', function (data) {
      return this.send({ success: true, data })
    })
  }
}

const fp = require('fastify-plugin')

async function loggingPlugin(fastify, options) {
  fastify.addHook('onRequest', async (request, reply) => {
    request.startTime = Date.now()
    request.log.info({ method: request.method, url: request.url }, 'Request started')
  })
  
  fastify.addHook('onResponse', async (request, reply) => {
    const duration = Date.now() - request.startTime
    request.log.info({
      method: request.method,
      url: request.url,
      statusCode: reply.statusCode,
      duration
    }, 'Request completed')
  })
}

module.exports = fp(loggingPlugin, {
  name: 'logging'
})

const fp = require('fastify-plugin')

async function authPlugin(fastify, options) {
  fastify.decorate('authenticate', async function (request, reply) {
    const token = request.headers.authorization
    
    if (!token) {
      reply.code(401).send({ error: 'No token provided' })
      return
    }
    
    try {
      const decoded = await verifyToken(token)
      request.user = decoded
    } catch (err) {
      reply.code(401).send({ error: 'Invalid token' })
    }
  })
  
  fastify.decorate('authorize', function (roles) {
    return async function (request, reply) {
      if (!request.user) {
        reply.code(401).send({ error: 'Unauthorized' })
        return
      }
      
      if (!roles.includes(request.user.role)) {
        reply.code(403).send({ error: 'Forbidden' })
      }
    }
  })
}

module.exports = fp(authPlugin, {
  name: 'auth'
})

const fp = require('fastify-plugin')

async function errorHandlerPlugin(fastify, options) {
  fastify.setErrorHandler((error, request, reply) => {
    if (error.validation) {
      reply.code(400).send({
        statusCode: 400,
        error: 'Validation Error',
        message: error.message,
        details: error.validation
      })
      return
    }
    
    if (error.statusCode) {
      reply.code(error.statusCode).send({
        statusCode: error.statusCode,
        error: error.name,
        message: error.message
      })
      return
    }
    
    fastify.log.error(error)
    reply.code(500).send({
      statusCode: 500,
      error: 'Internal Server Error',
      message: process.env.NODE_ENV === 'production' 
        ? 'Something went wrong' 
        : error.message
    })
  })
}

module.exports = fp(errorHandlerPlugin, {
  name: 'error-handler'
})

const fp = require('fastify-plugin')

class UserService {
  constructor(db) {
    this.collection = db.collection('users')
  }
  
  async findAll(query = {}) {
    return this.collection.find(query).toArray()
  }
  
  async findById(id) {
    return this.collection.findOne({ _id: id })
  }
  
  async create(data) {
    const result = await this.collection.insertOne({
      ...data,
      createdAt: new Date()
    })
    return this.findById(result.insertedId)
  }
  
  async update(id, data) {
    await this.collection.updateOne(
      { _id: id },
      { $set: { ...data, updatedAt: new Date() } }
    )
    return this.findById(id)
  }
  
  async delete(id) {
    const result = await this.collection.deleteOne({ _id: id })
    return result.deletedCount > 0
  }
}

async function servicesPlugin(fastify, options) {
  fastify.decorate('services', {
    user: new UserService(fastify.db)
  })
}

module.exports = fp(servicesPlugin, {
  name: 'services',
  dependencies: ['database']
})

const fp = require('fastify-plugin')

class CacheService {
  constructor(redis) {
    this.redis = redis
  }
  
  async get(key) {
    const data = await this.redis.get(key)
    return data ? JSON.parse(data) : null
  }
  
  async set(key, value, ttl = 3600) {
    await this.redis.set(key, JSON.stringify(value), 'EX', ttl)
  }
  
  async delete(key) {
    await this.redis.del(key)
  }
  
  async getOrSet(key, fn, ttl = 3600) {
    const cached = await this.get(key)
    
    if (cached) {
      return cached
    }
    
    const data = await fn()
    await this.set(key, data, ttl)
    return data
  }
}

async function cachePlugin(fastify, options) {
  fastify.decorate('cache', new CacheService(fastify.redis))
}

module.exports = fp(cachePlugin, {
  name: 'cache',
  dependencies: ['redis']
})

const fp = require('fastify-plugin')
const nodemailer = require('nodemailer')

class EmailService {
  constructor(options) {
    this.transporter = nodemailer.createTransport(options)
    this.from = options.from
  }
  
  async send(to, subject, body) {
    await this.transporter.sendMail({
      from: this.from,
      to,
      subject,
      html: body
    })
  }
  
  async sendTemplate(to, template, data) {
    const body = await this.renderTemplate(template, data)
    await this.send(to, data.subject, body)
  }
}

async function emailPlugin(fastify, options) {
  fastify.decorate('email', new EmailService(options))
}

module.exports = fp(emailPlugin, {
  name: 'email'
})

async function myPlugin(fastify, options) {
  const required = ['apiKey', 'apiSecret']
  
  for (const key of required) {
    if (!options[key]) {
      throw new Error(`Missing required option: ${key}`)
    }
  }
  
  fastify.decorate('api', options)
}

const fp = require('fastify-plugin')
const Ajv = require('ajv')

const optionsSchema = {
  type: 'object',
  required: ['url', 'database'],
  properties: {
    url: { type: 'string', format: 'uri' },
    database: { type: 'string', minLength: 1 },
    poolSize: { type: 'integer', minimum: 1, default: 10 },
    timeout: { type: 'integer', minimum: 1000, default: 30000 }
  }
}

async function databasePlugin(fastify, options) {
  const ajv = new Ajv({ useDefaults: true })
  const validate = ajv.compile(optionsSchema)
  
  if (!validate(options)) {
    throw new Error(`Invalid options: ${ajv.errorsText(validate.errors)}`)
  }
  
  fastify.decorate('db', await connect(options))
}

module.exports = fp(databasePlugin, {
  name: 'database'
})

async function myPlugin(fastify, options) {
  const defaults = {
    enabled: true,
    timeout: 5000,
    retries: 3,
    logLevel: 'info'
  }
  
  const config = { ...defaults, ...options }
  
  fastify.decorate('config', config)
}

const fp = require('fastify-plugin')

async function myPlugin(fastify, options) {
  const db = fastify.db
  const redis = fastify.redis
  
  fastify.decorate('service', new Service(db, redis))
}

module.exports = fp(myPlugin, {
  name: 'my-plugin',
  dependencies: ['database', 'redis']
})

async function myPlugin(fastify, options) {
  const cache = fastify.hasDecorator('redis') 
    ? new RedisCache(fastify.redis)
    : new MemoryCache()
  
  fastify.decorate('cache', cache)
}

const fp = require('fastify-plugin')

async function databasePlugin(fastify, options) {
  let connection = null
  
  const connect = async () => {
    connection = await createConnection(options)
    fastify.decorate('db', connection)
    fastify.log.info('Database connected')
  }
  
  const disconnect = async () => {
    if (connection) {
      await connection.close()
      fastify.log.info('Database disconnected')
    }
  }
  
  await connect()
  
  fastify.addHook('onClose', async () => {
    await disconnect()
  })
  
  fastify.addHook('onReady', async () => {
    if (!connection) {
      await connect()
    }
  })
}

module.exports = fp(databasePlugin, {
  name: 'database'
})

const fp = require('fastify-plugin')

class ConnectionPool {
  constructor(options) {
    this.options = options
    this.pool = []
    this.maxSize = options.maxSize || 10
  }
  
  async acquire() {
    if (this.pool.length > 0) {
      return this.pool.pop()
    }
    return this.create()
  }
  
  async release(connection) {
    if (this.pool.length < this.maxSize) {
      this.pool.push(connection)
    } else {
      await connection.close()
    }
  }
  
  async create() {
    return createConnection(this.options)
  }
  
  async closeAll() {
    for (const conn of this.pool) {
      await conn.close()
    }
    this.pool = []
  }
}

async function poolPlugin(fastify, options) {
  const pool = new ConnectionPool(options)
  
  fastify.decorate('pool', pool)
  
  fastify.addHook('onClose', async () => {
    await pool.closeAll()
  })
}

module.exports = fp(poolPlugin, {
  name: 'pool'
})

const { test } = require('node:test')
const assert = require('node:assert')
const Fastify = require('fastify')
const myPlugin = require('./my-plugin')

test('plugin registers correctly', async (t) => {
  const fastify = Fastify()
  
  await fastify.register(myPlugin, { option: 'value' })
  await fastify.ready()
  
  assert.ok(fastify.hasDecorator('utility'))
  assert.strictEqual(fastify.utility(), 'Hello World')
  
  await fastify.close()
})

test('plugin hooks work correctly', async (t) => {
  const fastify = Fastify()
  
  await fastify.register(myPlugin)
  
  fastify.get('/test', async (request, reply) => {
    return { user: request.user }
  })
  
  await fastify.ready()
  
  const response = await fastify.inject({
    method: 'GET',
    url: '/test',
    headers: { authorization: 'valid-token' }
  })
  
  assert.strictEqual(response.statusCode, 200)
  
  await fastify.close()
})

test('plugin throws on missing required option', async (t) => {
  const fastify = Fastify()
  
  await assert.rejects(
    async () => {
      await fastify.register(myPlugin, {})
      await fastify.ready()
    },
    { message: /Missing required option/ }
  )
  
  await fastify.close()
})

{
  "name": "fastify-my-plugin",
  "version": "1.0.0",
  "description": "A Fastify plugin for...",
  "main": "index.js",
  "scripts": {
    "test": "node --test",
    "lint": "eslint ."
  },
  "keywords": [
    "fastify",
    "plugin"
  ],
  "peerDependencies": {
    "fastify": "4.x"
  },
  "dependencies": {
    "fastify-plugin": "^4.0.0"
  },
  "devDependencies": {
    "fastify": "^4.0.0"
  }
}

# fastify-my-plugin

A Fastify plugin for...

## Installation

```bash
npm install fastify-my-plugin

const fastify = require('fastify')()

fastify.register(require('fastify-my-plugin'), {
  option: 'value'
})

## 十、最佳实践

### 10.1 插件命名

```javascript
module.exports = fp(myPlugin, {
  name: '@myorg/fastify-mysql'
})

async function myPlugin(fastify, options) {
  try {
    const resource = await createResource(options)
    fastify.decorate('resource', resource)
  } catch (err) {
    fastify.log.error('Failed to initialize plugin:', err)
    throw err
  }
}

async function myPlugin(fastify, options) {
  fastify.log.info('Initializing plugin...')
  
  const resource = await createResource(options)
  fastify.decorate('resource', resource)
  
  fastify.log.info('Plugin initialized successfully')
}