BootifyJS: A Modern, Declarative Node.js Framework

BootifyJS is a powerful, modern, and developer-friendly web framework for Node.js, built on the high-performance foundations of Fastify. Inspired by the productivity and robust architecture of Spring Boot, BootifyJS brings declarative programming, a powerful Dependency Injection system, and an enterprise-grade feature set to the TypeScript ecosystem.

Our goal is to make building complex, scalable, and maintainable backend applications not just possible, but elegant and enjoyable.

Core Features

• Declarative & Decorator-Driven: Write clean, readable, and self-documenting code using a rich set of decorators for controllers, services, dependency injection, and more.
• Powerful Dependency Injection: A full-featured DI container that supports constructor and property injection, interface binding, scopes, and eager loading.
• Event-Driven Architecture: A built-in, asynchronous event bus with automatic retries and a dead-letter queue, plus high-performance buffered event processing with worker threads, priority queues, and advanced monitoring.
• Pluggable Caching: A decorator-driven caching system that works out-of-the-box with an in-memory store and can be seamlessly extended to use Redis or other backends.
• Type-Safe Configuration: A schema-driven configuration system that validates your environment at startup, catching errors early and providing fully typed config objects.
• Flexible Logging: A builder-pattern logging system with no external dependencies - bring your own logger (Pino, Winston, etc.) or use the built-in BaseLogger.
• Built on Fastify: Leverage the incredible performance and rich plugin ecosystem of one of the fastest web frameworks for Node.js.

Getting Started

Installation

To create a new BootifyJS project, you can use our upcoming CLI or set it up manually.

# (Coming Soon)
# npx bootifyjs-cli new my-project

# Manual Installation
npm install bootifyjs fastify reflect-metadata

Your First Application

Here's a simple "Hello World" application to show you how easy it is to get started.

1. Create your main server file:

// src/server.ts
import "reflect-metadata";
import { createBootify, Controller, Get } from "bootifyjs";

@Controller("/hello")
export class HelloController {
  @Get("/")
  sayHello() {
    return { message: "Hello from BootifyJS!" };
  }
}

async function main() {
  await createBootify()
    .setServiceName("my-app")
    .setPort(3000)
    .useControllers([HelloController])
    .start();
}

main();

2. Run your application:

npx ts-node src/server.ts

You can now visit http://localhost:3000/hello in your browser or with curl to see your application running!

Builder Pattern API

BootifyJS uses a fluent builder pattern for configuration:

import { createBootify } from "bootifyjs";
import { z } from "zod";

const configSchema = z.object({
  DATABASE_URL: z.string(),
  REDIS_HOST: z.string().default("localhost"),
});

async function main() {
  const { app, start, logger } = await createBootify()
    .setServiceName("my-api")
    .setPort(3000)
    .setHostname("0.0.0.0")
    .useConfig(configSchema)
    .useControllers([UserController, ProductController])
    .useMiddleware(authMiddleware)
    .useErrorHandler((error, request, reply) => {
      logger.error("Request failed", error);
      reply.status(500).send({ error: "Internal Server Error" });
    })
    .useLogger((builder) =>
      builder
        .setLevel("debug")
        .configureConsole({ colorize: true, prettyPrint: true })
    )
    .beforeStart(async (app) => {
      // Run migrations, connect to databases, etc.
    })
    .afterStart(async (app) => {
      // Post-startup tasks
    })
    .build();

  await start();
}

Available Builder Methods

Method	Description
setServiceName(name)	Set the application name (used in logs)
setPort(port)	Set the server port
setHostname(host)	Set the server hostname
setFastifyOptions(opts)	Pass custom Fastify options
useConfig(schema)	Initialize type-safe config with Zod schema
useControllers([...])	Register controller classes
usePlugin(fn)	Register a Fastify plugin
useMiddleware(fn)	Add request middleware
useMiddlewares([...])	Add multiple middlewares
useErrorHandler(fn)	Set custom error handler
useLogger(fn)	Configure the logging system
useScheduler(enabled)	Enable/disable the job scheduler
beforeStart(fn)	Hook to run before server starts
afterStart(fn)	Hook to run after server starts
build()	Build and return { app, start, logger, scheduler }
start()	Build and start the server immediately

Logging

BootifyJS provides a flexible logging system with no external dependencies:

import { createLogger, getLogger } from "bootifyjs/logging";

// Option 1: Use built-in BaseLogger
const logger = createLogger()
  .setLevel("debug")
  .setServiceName("my-api")
  .configureConsole({ colorize: true, prettyPrint: true })
  .build();

logger.info("Server started", { port: 3000 });
logger.error("Something went wrong", new Error("Oops"), { userId: 123 });

Bring Your Own Logger

Create an adapter that implements ILogger:

// adapters/pino-adapter.ts
import pino from "pino";
import { ILogger, LogContext } from "bootifyjs/logging";

export class PinoAdapter implements ILogger {
  private logger: pino.Logger;

  constructor(options: { level?: string; prettyPrint?: boolean } = {}) {
    this.logger = pino({
      level: options.level ?? "info",
      transport: options.prettyPrint
        ? { target: "pino-pretty", options: { colorize: true } }
        : undefined,
    });
  }

  info(message: string, context?: LogContext): void {
    this.logger.info(context ?? {}, message);
  }

  error(message: string, error?: Error, context?: LogContext): void {
    this.logger.error({ ...context, err: error }, message);
  }

  // ... implement other methods: trace, debug, warn, fatal, child
}

Then use it with BootifyApp:

import { createBootify } from "bootifyjs";
import { PinoAdapter } from "./adapters/pino-adapter";

createBootify()
  .useLogger((builder) =>
    builder.use(new PinoAdapter({ level: "info", prettyPrint: true }))
  )
  .start();

Philosophy

BootifyJS is built on a few core principles:

• Developer Experience First: Frameworks should reduce boilerplate and complexity, not add to it. Our primary goal is to make development fast, intuitive, and enjoyable.
• Convention Over Configuration: We provide sensible defaults and automatic wiring so you can focus on writing business logic.
• Robustness by Default: Features like startup validation, graceful shutdown, and resilient event handling are built-in, helping you write production-ready code from day one.
• Extensibility: While the framework works out-of-the-box, it's designed to be pluggable and extensible. You can easily bring your own implementations for caching, authentication, logging, and more.

Documentation

Dive deeper into the features of BootifyJS:

• Core Module: Learn about the Dependency Injection system, decorators, and component lifecycle.
• Configuration: Master the type-safe, schema-driven configuration system.
• Events Module: Master the event bus for building decoupled, event-driven services.
• Cache Module: Speed up your application with our decorator-driven caching system.
• Logging: Understand the structured, context-aware logging system.
• Scheduling: Set up cron jobs and scheduled tasks.