AponiaJS vs Fastify

Fastify is the closest thing in Node to what AponiaJS is aiming at: an opinionated, schema-driven, performance-conscious framework with a real composition model. It is also stable, and AponiaJS is not.

At a glance

Two ways to scope a dependency

Fastify scopes by registration tree. A decorator added inside a plugin is visible to that plugin and its children, and disappears outside it:

fastify.register(async (instance) => {
  instance.decorate("repository", new UserRepository());
  instance.get("/users/:id", async (request) =>
    instance.repository.find(request.params.id),
  );
});

AponiaJS scopes by declaration. A module lists what it provides and what it exports, and importers see exactly the exported set:

@Module({
  controllers: [UserController],
  providers: [UserRepository],
  exports: [UserRepository],
})
class UserModule {}

The practical difference is when a mistake surfaces. Reaching for an undecorated property in Fastify is a runtime failure on the request that hits it. Injecting a provider a module never exported is a startup error with a diagnostic, described in visibility.

Where Fastify is clearly ahead

Hooks. onRequest, preValidation, preHandler, onSend, onResponse, and the rest give you a defined place for authentication, logging, and transformation. AponiaJS has no hook runtime of its own; that work goes through Elysia via native access.

Serialization. Fastify compiles the response schema into a fast serializer, which is both a performance and a data-leak-prevention feature. AponiaJS validates response slots but does not own a serialization or unknown-field policy — it is listed in current limitations.

OpenAPI. Route schemas feed @fastify/swagger directly. AponiaJS does not generate OpenAPI documents.

Maturity. Stable releases, a long deprecation policy, and production usage at scale.

Where AponiaJS differs meaningfully

Validator choice. Fastify's schema language is JSON Schema. AponiaJS takes any Standard Schema validator, so the types your application already uses can be the types the route validates with. See validation.

Injection instead of decoration. Constructor injection with explicit tokens rather than properties attached to a shared instance.

Typed client. Eden Treaty infers a client from the composed routes; see Eden Treaty.

Runtime. Bun and Elysia rather than Node and Fastify's HTTP layer.

Which one to pick