Fastify: Fast Node.js Framework

# Buat proyek baru
mkdir my-fastify-api
cd my-fastify-api
npm init -y

# Instal Fastify
npm install fastify

# Untuk TypeScript (opsional tapi direkomendasikan)
npm install -D typescript @types/node tsx

# Buat file konfigurasi TypeScript
npx tsc --init

// src/server.ts
import Fastify from 'fastify';

// Buat instance Fastify
const fastify = Fastify({
  logger: true  // Aktifkan Pino logger
});

// Definisikan route
fastify.get('/', async (request, reply) => {
  return { message: 'Halo dari Fastify!' };
});

// Jalankan server
const start = async () => {
  try {
    await fastify.listen({ port: 3000, host: '0.0.0.0' });
    console.log('Server berjalan di http://localhost:3000');
  } catch (err) {
    fastify.log.error(err);
    process.exit(1);
  }
};

start();

# Jalankan dengan tsx (TypeScript execution)
npx tsx src/server.ts

# Atau dengan npm script
# package.json:
# "scripts": {
#   "dev": "tsx watch src/server.ts",
#   "build": "tsc",
#   "start": "node dist/server.js"
# }

my-fastify-api/
├── src/
│   ├── plugins/           # Fastify plugins
│   │   ├── db.ts          # Database plugin
│   │   ├── auth.ts        # Auth plugin
│   │   └── swagger.ts     # Swagger plugin
│   ├── routes/            # Route definitions
│   │   ├── products/
│   │   │   ├── index.ts   # /products routes
│   │   │   ├── schemas.ts # JSON schemas
│   │   │   └── handlers.ts
│   │   └── users/
│   │       ├── index.ts
│   │       ├── schemas.ts
│   │       └── handlers.ts
│   ├── types/             # TypeScript types
│   │   └── fastify.d.ts   # Fastify type augmentations
│   ├── utils/             # Utility functions
│   ├── app.ts             # App setup (plugins, routes)
│   └── server.ts          # Entry point
├── tests/                 # Tests
├── .env                   # Environment variables
├── tsconfig.json
├── package.json
└── README.md

import Fastify from 'fastify';

const fastify = Fastify({ logger: true });

// === HTTP Methods ===
fastify.get('/products', async (request, reply) => {
  return { products: [] };
});

fastify.get('/products/:id', async (request, reply) => {
  const { id } = request.params as { id: string };
  return { id, name: 'Produk #' + id };
});

fastify.post('/products', async (request, reply) => {
  const body = request.body as any;
  reply.code(201); // Status 201 Created
  return { message: 'Produk dibuat', product: body };
});

fastify.put('/products/:id', async (request, reply) => {
  const { id } = request.params as { id: string };
  return { message: `Produk ${id} diupdate` };
});

fastify.delete('/products/:id', async (request, reply) => {
  const { id } = request.params as { id: string };
  reply.code(204); // No Content
  return;
});

// === Prefix Routes ===
fastify.register(async function apiRoutes(app) {
  app.get('/users', async () => ({ users: [] }));
  app.get('/users/:id', async (req) => {
    const { id } = req.params as { id: string };
    return { id, name: 'User #' + id };
  });
  app.post('/users', async (req, reply) => {
    reply.code(201);
    return { message: 'User dibuat' };
  });
}, { prefix: '/api/v1' });
// Hasil: /api/v1/users, /api/v1/users/:id

// Route dengan full options
fastify.route({
  method: 'GET',
  url: '/products',
  schema: {
    querystring: {
      type: 'object',
      properties: {
        page: { type: 'integer', default: 1 },
        limit: { type: 'integer', default: 20 },
        category: { type: 'string' }
      }
    },
    response: {
      200: {
        type: 'object',
        properties: {
          products: {
            type: 'array',
            items: {
              type: 'object',
              properties: {
                id: { type: 'integer' },
                name: { type: 'string' },
                price: { type: 'number' }
              }
            }
          },
          total: { type: 'integer' }
        }
      }
    }
  },
  handler: async (request, reply) => {
    const { page, limit, category } = request.query as any;
    // ... fetch products
    return { products: [], total: 0 };
  }
});

// Shorthand dengan schema
fastify.post('/products', {
  schema: {
    body: {
      type: 'object',
      required: ['name', 'price'],
      properties: {
        name: { type: 'string', minLength: 1 },
        price: { type: 'number', minimum: 0 },
        description: { type: 'string' }
      }
    }
  }
}, async (request, reply) => {
  // request.body sudah tervalidasi dan bertipe!
  const { name, price, description } = request.body as any;
  return { name, price, description };
});

// plugins/db.ts — Database plugin
import fp from 'fastify-plugin';
import { PrismaClient } from '@prisma/client';

// Deklarasi type augmentation
declare module 'fastify' {
  interface FastifyInstance {
    db: PrismaClient;
  }
}

async function dbPlugin(fastify: FastifyInstance) {
  const prisma = new PrismaClient();

  // Dekorasi instance dengan Prisma
  fastify.decorate('db', prisma);

  // Cleanup saat server ditutup
  fastify.addHook('onClose', async () => {
    await prisma.$disconnect();
    fastify.log.info('Database connection closed');
  });
}

// fp() memastikan plugin hanya di-load sekali
export default fp(dbPlugin, {
  name: 'db'
});

// === routes/products.ts — Product routes plugin ===
import { FastifyInstance } from 'fastify';

export default async function productRoutes(fastify: FastifyInstance) {
  // GET /products — Ambil semua produk
  fastify.get('/', async (request, reply) => {
    const products = await fastify.db.product.findMany({
      orderBy: { createdAt: 'desc' }
    });
    return { products };
  });

  // GET /products/:id — Ambil produk by ID
  fastify.get('/:id', async (request, reply) => {
    const { id } = request.params as { id: string };
    const product = await fastify.db.product.findUnique({
      where: { id: parseInt(id) }
    });

    if (!product) {
      reply.code(404);
      return { error: 'Produk tidak ditemukan' };
    }

    return { product };
  });

  // POST /products — Buat produk baru
  fastify.post('/', async (request, reply) => {
    const body = request.body as any;
    const product = await fastify.db.product.create({
      data: body
    });
    reply.code(201);
    return { product };
  });
}

// app.ts — App setup
import Fastify from 'fastify';
import dbPlugin from './plugins/db';
import productRoutes from './routes/products';
import userRoutes from './routes/users';

export function buildApp() {
  const fastify = Fastify({
    logger: {
      level: 'info',
      transport: {
        target: 'pino-pretty',  // Format log yang indah
        options: { colorize: true }
      }
    }
  });

  // Register plugins
  fastify.register(dbPlugin);

  // Register routes dengan prefix
  fastify.register(productRoutes, { prefix: '/api/products' });
  fastify.register(userRoutes, { prefix: '/api/users' });

  // Health check
  fastify.get('/health', async () => {
    return { status: 'ok', timestamp: new Date().toISOString() };
  });

  return fastify;
}

// server.ts — Entry point
import { buildApp } from './app';

const app = buildApp();

app.listen({ port: 3000, host: '0.0.0.0' }, (err) => {
  if (err) {
    app.log.error(err);
    process.exit(1);
  }
});

import { FastifyInstance, FastifyRequest, FastifyReply } from 'fastify';

export default async function authHooks(fastify: FastifyInstance) {

  // === onRequest: Paling awal, sebelum parsing body ===
  fastify.addHook('onRequest', async (request, reply) => {
    request.startTime = Date.now();
    request.log.info({
      method: request.method,
      url: request.url
    }, 'Incoming request');
  });

  // === preHandler: Setelah validasi, sebelum handler ===
  fastify.addHook('preHandler', async (request, reply) => {
    // Cek autentikasi untuk protected routes
    const publicRoutes = ['/api/auth/login', '/api/auth/register', '/health'];
    if (publicRoutes.includes(request.url)) return;

    try {
      const token = request.headers.authorization?.replace('Bearer ', '');
      if (!token) {
        reply.code(401).send({ error: 'Token tidak ditemukan' });
        return;
      }

      const decoded = fastify.jwt.verify(token);
      (request as any).user = decoded;
    } catch (err) {
      reply.code(401).send({ error: 'Token tidak valid' });
    }
  });

  // === onSend: Saat response akan dikirim ===
  fastify.addHook('onSend', async (request, reply, payload) => {
    // Tambahkan response time header
    const duration = Date.now() - (request.startTime || Date.now());
    reply.header('X-Response-Time', `${duration}ms`);

    return payload;
  });

  // === onResponse: Setelah response terkirim ===
  fastify.addHook('onResponse', async (request, reply) => {
    request.log.info({
      statusCode: reply.statusCode,
      duration: `${Date.now() - (request.startTime || Date.now())}ms`
    }, 'Request completed');
  });

  // === onError: Saat terjadi error ===
  fastify.addHook('onError', async (request, reply, error) => {
    request.log.error({
      err: error,
      statusCode: error.statusCode
    }, 'Request error');
  });

  // === Route-level hooks ===
  fastify.get('/admin/dashboard', {
    preHandler: [async (request, reply) => {
      const user = (request as any).user;
      if (user?.role !== 'admin') {
        reply.code(403).send({ error: 'Akses ditolak' });
      }
    }]
  }, async (request) => {
    return { message: 'Admin Dashboard' };
  });
}

// schemas/productSchemas.ts
export const createProductSchema = {
  body: {
    type: 'object',
    required: ['name', 'price', 'categoryId'],
    properties: {
      name: {
        type: 'string',
        minLength: 2,
        maxLength: 200,
        errorMessage: {
          minLength: 'Nama produk minimal 2 karakter',
          maxLength: 'Nama produk maksimal 200 karakter'
        }
      },
      description: { type: 'string', maxLength: 2000 },
      price: {
        type: 'number',
        minimum: 0,
        exclusiveMinimum: 0,
        errorMessage: {
          minimum: 'Harga harus lebih dari 0'
        }
      },
      stock: {
        type: 'integer',
        minimum: 0,
        default: 0
      },
      categoryId: { type: 'integer' },
      tags: {
        type: 'array',
        items: { type: 'string' },
        maxItems: 10
      },
      isActive: { type: 'boolean', default: true }
    },
    additionalProperties: false
  },
  response: {
    201: {
      type: 'object',
      properties: {
        id: { type: 'integer' },
        name: { type: 'string' },
        price: { type: 'number' },
        stock: { type: 'integer' },
        isActive: { type: 'boolean' },
        createdAt: { type: 'string', format: 'date-time' }
      }
    }
  }
};

export const getProductsSchema = {
  querystring: {
    type: 'object',
    properties: {
      page: { type: 'integer', default: 1, minimum: 1 },
      limit: { type: 'integer', default: 20, minimum: 1, maximum: 100 },
      category: { type: 'string' },
      search: { type: 'string' },
      sortBy: {
        type: 'string',
        enum: ['name', 'price', 'createdAt', 'stock']
      },
      order: {
        type: 'string',
        enum: ['asc', 'desc'],
        default: 'desc'
      }
    }
  },
  response: {
    200: {
      type: 'object',
      properties: {
        products: {
          type: 'array',
          items: {
            type: 'object',
            properties: {
              id: { type: 'integer' },
              name: { type: 'string' },
              price: { type: 'number' },
              category: { type: 'string' }
            }
          }
        },
        pagination: {
          type: 'object',
          properties: {
            page: { type: 'integer' },
            limit: { type: 'integer' },
            total: { type: 'integer' },
            totalPages: { type: 'integer' }
          }
        }
      }
    }
  }
};

export const getProductByIdSchema = {
  params: {
    type: 'object',
    required: ['id'],
    properties: {
      id: { type: 'integer', minimum: 1 }
    }
  },
  response: {
    200: {
      type: 'object',
      properties: {
        id: { type: 'integer' },
        name: { type: 'string' },
        price: { type: 'number' },
        description: { type: 'string' },
        stock: { type: 'integer' },
        category: {
          type: 'object',
          properties: {
            id: { type: 'integer' },
            name: { type: 'string' }
          }
        },
        reviews: {
          type: 'array',
          items: {
            type: 'object',
            properties: {
              id: { type: 'integer' },
              rating: { type: 'integer' },
              comment: { type: 'string' },
              author: { type: 'string' }
            }
          }
        }
      }
    }
  }
};

// === routes/products.ts — Menggunakan schema ===
import { createProductSchema, getProductsSchema, getProductByIdSchema } from '../schemas/productSchemas';

export default async function productRoutes(fastify: FastifyInstance) {
  // Dengan schema validation
  fastify.get('/', { schema: getProductsSchema }, async (request) => {
    const { page, limit, category, search, sortBy, order } =
      request.query as any;
    // Data sudah tervalidasi dan bertipe!
    const products = await fastify.db.product.findMany({
      skip: (page - 1) * limit,
      take: limit,
      orderBy: { [sortBy]: order }
    });
    const total = await fastify.db.product.count();
    return {
      products,
      pagination: { page, limit, total, totalPages: Math.ceil(total / limit) }
    };
  });

  fastify.post('/', { schema: createProductSchema }, async (request, reply) => {
    // request.body sudah tervalidasi — aman digunakan!
    const body = request.body as any;
    const product = await fastify.db.product.create({ data: body });
    reply.code(201);
    return product;
  });

  fastify.get('/:id', { schema: getProductByIdSchema }, async (request) => {
    const { id } = request.params as any;
    // ... fetch product
  });
}

import Fastify, { FastifyError } from 'fastify';

const fastify = Fastify({ logger: true });

// === Global Error Handler ===
fastify.setErrorHandler((error: FastifyError, request, reply) => {
  // Validation error dari JSON Schema
  if (error.validation) {
    request.log.warn({ err: error }, 'Validation error');
    return reply.status(400).send({
      error: 'Validasi Gagal',
      message: error.message,
      details: error.validation
    });
  }

  // HTTP errors
  if (error.statusCode) {
    return reply.status(error.statusCode).send({
      error: error.name,
      message: error.message
    });
  }

  // Unexpected errors — jangan expose internal details
  request.log.error({ err: error }, 'Unexpected error');
  return reply.status(500).send({
    error: 'Internal Server Error',
    message: 'Terjadi kesalahan pada server'
  });
});

// === 404 Handler ===
fastify.setNotFoundHandler((request, reply) => {
  reply.status(404).send({
    error: 'Not Found',
    message: `Route ${request.method} ${request.url} tidak ditemukan`
  });
});

// === Custom Error Classes ===
class AppError extends Error {
  statusCode: number;

  constructor(message: string, statusCode: number = 500) {
    super(message);
    this.statusCode = statusCode;
    this.name = 'AppError';
  }
}

class NotFoundError extends AppError {
  constructor(resource: string) {
    super(`${resource} tidak ditemukan`, 404);
    this.name = 'NotFoundError';
  }
}

class ValidationError extends AppError {
  details: any;

  constructor(message: string, details?: any) {
    super(message, 400);
    this.name = 'ValidationError';
    this.details = details;
  }
}

// === Penggunaan di handler ===
fastify.get('/products/:id', async (request, reply) => {
  const { id } = request.params as any;
  const product = await fastify.db.product.findUnique({
    where: { id: parseInt(id) }
  });

  if (!product) {
    throw new NotFoundError('Produk');
  }

  return { product };
});

fastify.post('/products', async (request, reply) => {
  const body = request.body as any;

  if (body.price < 0) {
    throw new ValidationError('Harga tidak boleh negatif', {
      field: 'price',
      value: body.price
    });
  }

  // ... create product
});

// types/fastify.d.ts — Type augmentations
import 'fastify';

declare module 'fastify' {
  // Augment FastifyInstance (decorate)
  interface FastifyInstance {
    db: PrismaClient;
    authenticate: (request: FastifyRequest) => Promise<void>;
  }

  // Augment FastifyRequest
  interface FastifyRequest {
    user?: {
      id: number;
      email: string;
      role: string;
    };
    startTime?: number;
  }
}

// === Typed Route Handler ===
import { FastifyPluginAsyncTypebox, Type } from '@fastify/type-provider-typebox';

const productRoutes: FastifyPluginAsyncTypebox = async (fastify) => {
  fastify.get('/', {
    schema: {
      querystring: Type.Object({
        page: Type.Optional(Type.Integer({ minimum: 1, default: 1 })),
        limit: Type.Optional(Type.Integer({ minimum: 1, maximum: 100, default: 20 })),
      }),
      response: {
        200: Type.Object({
          products: Type.Array(
            Type.Object({
              id: Type.Integer(),
              name: Type.String(),
              price: Type.Number(),
            })
          ),
          total: Type.Integer(),
        }),
      },
    },
  }, async (request) => {
    // request.query sudah bertipe: { page: number, limit: number }
    const { page, limit } = request.query;
    // ... fetch products
    return { products: [], total: 0 };
  });
};

export default productRoutes;

// plugins/db-prisma.ts — Prisma Plugin
import fp from 'fastify-plugin';
import { PrismaClient } from '@prisma/client';
import { FastifyInstance } from 'fastify';

async function prismaPlugin(fastify: FastifyInstance) {
  const prisma = new PrismaClient({
    log: [
      { level: 'query', emit: 'event' },
      { level: 'error', emit: 'stdout' },
      { level: 'warn', emit: 'stdout' }
    ]
  });

  // Log queries di development
  if (process.env.NODE_ENV === 'development') {
    prisma.$on('query', (e) => {
      fastify.log.debug({
        query: e.query,
        duration: `${e.duration}ms`
      }, 'DB Query');
    });
  }

  await prisma.$connect();
  fastify.log.info('Database connected');

  fastify.decorate('db', prisma);

  fastify.addHook('onClose', async () => {
    await prisma.$disconnect();
  });
}

export default fp(prismaPlugin, { name: 'prisma' });

// plugins/db-postgres.ts — Raw PostgreSQL dengan fastify-postgres
import fp from 'fastify-plugin';
import fastifyPostgres from '@fastify/postgres';

export default fp(async (fastify) => {
  await fastify.register(fastifyPostgres, {
    connectionString: process.env.DATABASE_URL
  });

  // Contoh query raw
  fastify.get('/products-raw', async () => {
    const { rows } = await fastify.pg.query(
      'SELECT id, name, price FROM products ORDER BY created_at DESC LIMIT 20'
    );
    return { products: rows };
  });
});

// plugins/auth.ts
import fp from 'fastify-plugin';
import fastifyJwt from '@fastify/jwt';
import { FastifyInstance, FastifyRequest, FastifyReply } from 'fastify';

export default fp(async (fastify: FastifyInstance) => {
  // Register JWT plugin
  await fastify.register(fastifyJwt, {
    secret: process.env.JWT_SECRET || 'super-secret-key'
  });

  // Decorator: authenticate
  fastify.decorate('authenticate', async (request: FastifyRequest, reply: FastifyReply) => {
    try {
      await request.jwtVerify();
    } catch (err) {
      reply.code(401).send({
        error: 'Unauthorized',
        message: 'Token tidak valid atau sudah kedaluwarsa'
      });
    }
  });

  // Decorator: requireRole
  fastify.decorate('requireRole', (role: string) => {
    return async (request: FastifyRequest, reply: FastifyReply) => {
      const user = request.user as any;
      if (user.role !== role) {
        reply.code(403).send({
          error: 'Forbidden',
          message: 'Anda tidak memiliki akses ke resource ini'
        });
      }
    };
  });
});

// === routes/auth.ts — Login/Register ===
export default async function authRoutes(fastify: FastifyInstance) {
  // POST /auth/register
  fastify.post('/register', {
    schema: {
      body: {
        type: 'object',
        required: ['email', 'password', 'name'],
        properties: {
          email: { type: 'string', format: 'email' },
          password: { type: 'string', minLength: 8 },
          name: { type: 'string', minLength: 2 }
        }
      }
    }
  }, async (request, reply) => {
    const { email, password, name } = request.body as any;

    // Hash password
    const hashedPassword = await fastify.bcrypt.hash(password, 10);

    // Simpan user
    const user = await fastify.db.user.create({
      data: { email, password: hashedPassword, name }
    });

    // Generate JWT
    const token = fastify.jwt.sign(
      { id: user.id, email: user.email, role: user.role },
      { expiresIn: '7d' }
    );

    reply.code(201);
    return { token, user: { id: user.id, email, name } };
  });

  // POST /auth/login
  fastify.post('/login', async (request, reply) => {
    const { email, password } = request.body as any;

    const user = await fastify.db.user.findUnique({ where: { email } });
    if (!user) {
      reply.code(401);
      return { error: 'Email atau password salah' };
    }

    const isValid = await fastify.bcrypt.compare(password, user.password);
    if (!isValid) {
      reply.code(401);
      return { error: 'Email atau password salah' };
    }

    const token = fastify.jwt.sign(
      { id: user.id, email: user.email, role: user.role },
      { expiresIn: '7d' }
    );

    return { token, user: { id: user.id, email, name: user.name } };
  });
}

// === Protected routes ===
fastify.register(async function protectedRoutes(app) {
  // Semua route di plugin ini memerlukan autentikasi
  app.addHook('preHandler', app.authenticate);

  app.get('/profile', async (request) => {
    const user = request.user;
    return { user };
  });

  app.get('/admin/users', {
    preHandler: [app.requireRole('admin')]
  }, async () => {
    return { users: await fastify.db.user.findMany() };
  });
}, { prefix: '/api' });