AponiaJS vs Elysia

Elysia is not a competitor. It is the server AponiaJS runs on, and every AponiaJS application is an Elysia application underneath.

The question is whether the layer on top earns its place.

At a glance

The same endpoint, twice

Elysia:

import { Elysia, t } from "elysia";

const users = new Elysia({ prefix: "/users" })
  .decorate("repository", new UserRepository())
  .get("/:id", ({ params, repository }) => repository.find(params.id), {
    params: t.Object({ id: t.String() }),
  });

new Elysia().use(users).listen(3000);

AponiaJS:

import { Controller, Get, Injectable, Module, Param } from "@aponiajs/common";
import { AponiaFactory } from "@aponiajs/platform-elysia";

@Injectable()
class UserRepository {
  find(id: string) {
    return { id };
  }
}

@Controller("users")
class UserController {
  constructor(private readonly repository: UserRepository) {}

  @Get(":id")
  find(@Param("id") id: string) {
    return this.repository.find(id);
  }
}

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

await (await AponiaFactory.create(AppModule)).listen(3000);

At this size Elysia wins on every axis that matters: fewer lines, fewer concepts, and full type inference without a single annotation.

What changes at scale

The chained form couples three things that grow at different rates: the dependency wiring, the URL surface, and the handler bodies. Past a certain number of features, teams end up inventing a convention for splitting them. AponiaJS is that convention, made explicit.

• Dependencies are declared, not threaded. decorate puts a value on the context for everything downstream. A module declares what it provides and what it exports, so a dependency reaching the wrong file is a startup error rather than a merge conflict.
• Construction happens once. Providers are singletons built during bootstrap. See providers.
• The graph is validated. Missing providers, cycles, and unexported dependencies are reported at startup with diagnostics, not discovered at request time.

The cost is real: more files, explicit handler parameter types instead of inference through the chain, and an alpha framework between you and a stable one.

Nothing is hidden

The escape hatches are the point of the Elysia platform section:

• native access hands you the underlying application to configure or extend;
• plugin modules mount Elysia plugins through the module graph, with DI-configured variants;
• typed plugin context types a handler against the plugins it actually reads;
• low-level descriptors register routes directly on the native application when a decorator cannot express them;
• Eden Treaty exports the composed route types to a client.

Which one to pick