Full-stack-skills fastify

Provides comprehensive guidance for Fastify framework including routing, plugins, JSON schema validation, hooks, serialization, and performance optimization. Use when the user asks about Fastify, needs to create high-performance Node.js applications, implement plugins, or optimize API performance.

install

source · Clone the upstream repo

git clone https://github.com/partme-ai/full-stack-skills

Claude Code · Install into ~/.claude/skills/

T=$(mktemp -d) && git clone --depth=1 https://github.com/partme-ai/full-stack-skills "$T" && mkdir -p ~/.claude/skills && cp -r "$T/skills/nodejs-skills/fastify" ~/.claude/skills/partme-ai-full-stack-skills-fastify && rm -rf "$T"

manifest: skills/nodejs-skills/fastify/SKILL.md

When to use this skill

Use this skill whenever the user wants to:

Build high-performance Node.js HTTP services with Fastify
Use JSON Schema for request/response validation and serialization
Create and compose Fastify plugins with encapsulation
Configure logging, TypeScript, and production deployments

How to use this skill

Workflow

Create server — instantiate Fastify with options (logging, etc.)
Register plugins — add functionality via the plugin system
Define routes with schemas — validate requests and serialize responses
Test and deploy — use
```
fastify.inject()
```
for testing, deploy with process manager

Quick Start Example

const fastify = require('fastify')({ logger: true });

// Register plugins
fastify.register(require('@fastify/cors'));
fastify.register(require('@fastify/helmet'));

// Route with JSON Schema validation
fastify.post('/api/items', {
  schema: {
    body: {
      type: 'object',
      required: ['name', 'price'],
      properties: {
        name: { type: 'string', minLength: 1 },
        price: { type: 'number', minimum: 0 },
      },
    },
    response: {
      201: {
        type: 'object',
        properties: {
          id: { type: 'integer' },
          name: { type: 'string' },
          price: { type: 'number' },
        },
      },
    },
  },
  handler: async (request, reply) => {
    const item = await createItem(request.body);
    reply.code(201).send(item);
  },
});

fastify.get('/api/items/:id', async (request, reply) => {
  const item = await getItem(request.params.id);
  if (!item) {
    reply.code(404).send({ error: 'Not found' });
    return;
  }
  return item;
});

fastify.listen({ port: 3000, host: '0.0.0.0' });

Plugin Pattern

// plugins/db.js
async function dbPlugin(fastify, options) {
  const pool = createPool(options.connectionString);
  fastify.decorate('db', pool);
  fastify.addHook('onClose', async () => pool.end());
}

module.exports = require('fastify-plugin')(dbPlugin);

// app.js
fastify.register(require('./plugins/db'), {
  connectionString: process.env.DATABASE_URL,
});

Error Handling

fastify.setErrorHandler((error, request, reply) => {
  request.log.error(error);
  const statusCode = error.statusCode || 500;
  reply.code(statusCode).send({
    error: error.message,
    statusCode,
  });
});

Best Practices

Define JSON Schema for all request bodies and responses — enables fast serialization
Use
```
fastify-plugin
```
to break encapsulation when sharing decorators across scopes
Leverage built-in Pino logger; avoid
```
console.log
```
in production
Use hooks (
```
onRequest
```
,
```
preHandler
```
) for cross-cutting concerns
Test routes with
```
fastify.inject()
```
without starting a server

Reference

Official documentation: https://fastify.dev/docs/latest/

Keywords

fastify, Node.js, high performance, JSON schema, plugins, serialization, hooks, Pino logger