⚡ Elysia vs Hono vs NestJS vs Encore

import { Elysia, t } from 'elysia'

const app = new Elysia()
  .get('/', () => 'Hello Elysia! 💜')
  .post('/users', ({ body }) => {
    return { message: `Created user: ${body.name}`, email: body.email }
  }, {
    body: t.Object({
      name: t.String(),
      email: t.String({ format: 'email' })
    })
  })
  .listen(3000)

console.log(`🦊 Elysia running at ${app.server?.hostname}:${app.server?.port}`)

import { Hono } from 'hono'
import { cors } from 'hono/cors'
import { jwt } from 'hono/jwt'

const app = new Hono()

app.use('/*', cors())

app.get('/', (c) => c.text('Hello Hono! 🔥'))

app.get('/users/:id', (c) => {
  const id = c.req.param('id')
  return c.json({ id, name: 'John Doe' })
})

app.post('/users', async (c) => {
  const body = await c.req.json()
  return c.json({ message: `Created: ${body.name}` }, 201)
})

export default app // Deploy to any platform!

// users.controller.ts
import { Controller, Get, Post, Body, Param } from '@nestjs/common'
import { UsersService } from './users.service'
import { CreateUserDto } from './dto/create-user.dto'

@Controller('users')
export class UsersController {
  constructor(private readonly usersService: UsersService) {}

  @Get()
  findAll() {
    return this.usersService.findAll()
  }

  @Get(':id')
  findOne(@Param('id') id: string) {
    return this.usersService.findOne(+id)
  }

  @Post()
  create(@Body() createUserDto: CreateUserDto) {
    return this.usersService.create(createUserDto)
  }
}

import { api } from "encore.dev/api"
import { SQLDatabase } from "encore.dev/storage/sqldb"

// Encore tự động provision PostgreSQL!
const db = new SQLDatabase("users", { migrations: "./migrations" })

interface User {
  id: number
  name: string
  email: string
}

// API endpoint — Encore tự tạo routing, docs, tracing
export const getUser = api(
  { method: "GET", path: "/users/:id", expose: true },
  async ({ id }: { id: number }): Promise => {
    return await db.queryRow`SELECT * FROM users WHERE id = ${id}`
  }
)

export const createUser = api(
  { method: "POST", path: "/users", expose: true },
  async ({ name, email }: { name: string; email: string }): Promise => {
    return await db.queryRow`
      INSERT INTO users (name, email) VALUES (${name}, ${email})
      RETURNING *
    `
  }
)

// ═══ ELYSIA ═══
import { Elysia } from 'elysia'
new Elysia()
  .get('/hello/:name', ({ params }) => `Hello ${params.name}!`)
  .listen(3000)

// ═══ HONO ═══
import { Hono } from 'hono'
const app = new Hono()
app.get('/hello/:name', (c) => c.text(`Hello ${c.req.param('name')}!`))
export default app

// ═══ NESTJS ═══
// hello.controller.ts
@Controller('hello')
export class HelloController {
  @Get(':name')
  getHello(@Param('name') name: string) {
    return `Hello ${name}!`
  }
}
// + hello.module.ts, app.module.ts, main.ts ...

// ═══ ENCORE ═══
import { api } from "encore.dev/api"
export const hello = api(
  { method: "GET", path: "/hello/:name", expose: true },
  async ({ name }: { name: string }) => `Hello ${name}!`
)