Skip to main content Skills Marketplace Découvrez et explorez les compétences IA créées par la communauté.
Installer avec Codex ou Claude Copiez ce prompt, collez-le dans Codex, Claude ou un autre assistant, puis laissez-le vérifier la page du skill et l'installer pour vous.
Afficher les détails du prompt Une commande directe contourne le prompt de vérification. Examinez la source avant de l'exécuter.
npx skills add https://github.com/diangogav/evolution-api --skill elysiajsLa commande reste sur une seule ligne. Faites défiler horizontalement pour la vérifier avant de la copier.
Vous préférez une copie locale ? Téléchargez les fichiers actuellement disponibles dans SkillsMP.
Télécharger Zip Téléchargement... Explorateur de fichiers
53 fichiers Métiers associés SOC
Basé sur la classification professionnelle SOC
name elysiajs description Create backend with ElysiaJS, a type-safe, high-performance framework.
ElysiaJS Development Skill
Always consult elysiajs.com/llms.txt for code examples and latest API.
Overview
ElysiaJS is a TypeScript framework for building Bun-first (but not limited to Bun) type-safe, high-performance backend servers. This skill provides comprehensive guidance for developing with Elysia, including routing, validation, authentication, plugins, integrations, and deployment.
When to Use This Skill
Trigger this skill when the user asks to:
Create or modify ElysiaJS routes, handlers, or servers
Setup validation with TypeBox or other schema libraries (Zod, Valibot)
Implement authentication (JWT, session-based, macros, guards)
Add plugins (CORS, OpenAPI, Static files, JWT)
Integrate with external services (Drizzle ORM, Better Auth, Next.js, Eden Treaty)
Setup WebSocket endpoints for real-time features
Create unit tests for Elysia instances
Deploy Elysia servers to production
Quick Start
Quick scaffold:
bun create elysia app
Basic Server
import { Elysia , t, status } from 'elysia'
const app = new Elysia ()
.get ('/' , () => 'Hello World' )
.post ('/user' , ({ body } ) =>
body
Object
name
String
age
Number
get
'/id/:id'
({ params: { id } } ) =>
if
1_000_000
return
status
404
'Not Found'
return
params
Object
id
Number
minimum
1
response
200
Number
404
Literal
'Not Found'
listen
3000
Basic Usage
HTTP Methods import { Elysia } from 'elysia'
new Elysia ()
.get ('/' , 'GET' )
.post ('/' , 'POST' )
.put ('/' , 'PUT' )
.patch ('/' , 'PATCH' )
.delete ('/' , 'DELETE' )
.options ('/' , 'OPTIONS' )
.head ('/' , 'HEAD' )
Path Parameters .get ('/user/:id' , ({ params: { id } } ) => id)
.get ('/post/:id/:slug' , ({ params } ) => params)
Query Parameters .get ('/search' , ({ query } ) => query.q )
Request Body .post ('/user' , ({ body } ) => body)
Headers .get ('/' , ({ headers } ) => headers.authorization )
TypeBox Validation
Basic Types import { Elysia , t } from 'elysia'
.post ('/user' , ({ body } ) => body, {
body : t.Object ({
name : t.String (),
age : t.Number (),
email : t.String ({ format : 'email' }),
website : t.Optional (t.String ({ format : 'uri' }))
})
})
Nested Objects body : t.Object ({
user : t.Object ({
name : t.String (),
address : t.Object ({
street : t.String (),
city : t.String ()
})
})
})
Arrays body : t.Object ({
tags : t.Array (t.String ()),
users : t.Array (t.Object ({
id : t.String (),
name : t.String ()
}))
})
File Upload .post ('/upload' , ({ body } ) => body.file , {
body : t.Object ({
file : t.File ({
type : 'image' ,
maxSize : '5m'
}),
files : t.Files ({
type : ['image/png' , 'image/jpeg' ]
})
})
})
Response Validation .get ('/user/:id' , ({ params: { id } } ) => ({
id,
name : 'John' ,
email : 'john@example.com'
}), {
params : t.Object ({
id : t.Number ()
}),
response : {
200 : t.Object ({
id : t.Number (),
name : t.String (),
email : t.String ()
}),
404 : t.String ()
}
})
Standard Schema (Zod, Valibot, ArkType)
Zod import { z } from 'zod'
.post ('/user' , ({ body } ) => body, {
body : z.object ({
name : z.string (),
age : z.number ().min (0 ),
email : z.string ().email ()
})
})
Error Handling .get ('/user/:id' , ({ params: { id }, status } ) => {
const user = findUser (id)
if (!user) {
return status (404 , 'User not found' )
}
return user
})
Guards (Apply to Multiple Routes) .guard ({
params : t.Object ({
id : t.Number ()
})
}, app =>get ('/user/:id' , ({ params: { id } } ) => id)
.delete ('/user/:id' , ({ params: { id } } ) => id)
)
Macro .macro ({
hi : (word : string ({
beforeHandle (console .log (word) }
})
})
.get ('/' , () => 'hi' , { hi : 'Elysia' })
Project Structure (Recommended) Elysia takes an unopinionated approach but based on user request. But without any specific preference, we recommend a feature-based and domain driven folder structure where each feature has its own folder containing controllers, services, and models.
src/
├── index.ts # Main server entry
├── modules/
│ ├── auth/
│ │ ├── index.ts # Auth routes (Elysia instance)
│ │ ├── service.ts # Business logic
│ │ └── model.ts # TypeBox schemas/DTOs
│ └── user/
│ ├── index.ts
│ ├── service.ts
│ └── model.ts
└── plugins/
└── custom.ts
public/ # Static files (if using static plugin)
test/ # Unit tests
Each file has its own responsibility as follows:
Controller (index.ts) : Handle HTTP routing, request validation, and cookie.Service (service.ts) : Handle business logic, decoupled from Elysia controller if possible.Model (model.ts) : Define the data structure and validation for the request and response.
Best Practice Elysia is unopinionated on design pattern, but if not provided, we can relies on MVC pattern pair with feature based folder structure.
Controller:
Prefers Elysia as a controller for HTTP dependant controller
For non HTTP dependent, prefers service instead unless explicitly asked
Use onError to handle local custom errors
Register Model to Elysia instance via Elysia.models({ ...models }) and prefix model by namespace `Elysia.prefix('model', 'Namespace.')
Prefers Reference Model by name provided by Elysia instead of using an actual Model.name
Service:
Prefers class (or abstract class if possible)
Prefers interface/type derive from Model
Return status (import { status } from 'elysia') for error
Prefers return Error instead of throw Error
Models:
Always export validation model and type of validation model
Custom Error should be in contains in Model
Elysia Key Concept Elysia has a every important concepts/rules to understand before use.
Encapsulation - Isolates by Default Lifecycles (hooks, middleware) don't leak between instances unless scoped.
local (default) - current instance + descendantsscoped - parent + current + descendantsglobal - all instances .onBeforeHandle (() => {})
.onBeforeHandle ({ as : 'global' }, () => {})
Method Chaining - Required for Types Must chain . Each method returns new type reference.
const app = new Elysia ()
app.state ('build' , 1 )
app.get ('/' , ({ store } ) => store.build )
new Elysia ()
.state ('build' , 1 )
.get ('/' , ({ store } ) => store.build )
Explicit Dependencies Each instance independent. Declare what you use.
const auth = new Elysia ()
.decorate ('Auth' , Auth )
.model (Auth .models )
new Elysia ()
.get ('/' , ({ Auth } ) => Auth .getProfile ())
new Elysia ()
.use (auth)
.get ('/' , ({ Auth } ) => Auth .getProfile ())
No types added (cors, helmet)
Global lifecycle (logging, tracing)
Adds types (state, models)
Business logic (auth, db)
Deduplication Plugins re-execute unless named:
new Elysia ()
new Elysia ({ name : 'ip' })
Order Matters Events apply to routes registered after them.
.onBeforeHandle (() => console .log ('1' ))
.get ('/' , () => 'hi' )
.onBeforeHandle (() => console .log ('2' ))
Type Inference Inline functions only for accurate types.
For controllers, destructure in inline wrapper:
.post ('/' , ({ body } ) => Controller .greet (body), {
body : t.Object ({ name : t.String () })
})
type MyType = typeof MyType .static
Reference Model Model can be reference by name, especially great for documenting an API
new Elysia ()
.model ({
book : t.Object ({
name : t.String ()
})
})
.post ('/' , ({ body } ) => body.name , {
body : 'book'
})
Model can be renamed by using .prefix / .suffix
new Elysia ()
.model ({
book : t.Object ({
name : t.String ()
})
})
.prefix ('model' , 'Namespace' )
.post ('/' , ({ body } ) => body.name , {
body : 'Namespace.Book'
})
Once prefix, model name will be capitalized by default.
Technical Terms The following are technical terms that is use for Elysia:
OpenAPI Type Gen - function name fromTypes from @elysiajs/openapi for generating OpenAPI from types, see plugins/openapi.mdEden, Eden Treaty - e2e type safe RPC client for share type from backend to frontend
Resources Use the following references as needed.
It's recommended to checkout route.md for as it contains the most important foundation building blocks with examples.
plugin.md and validation.md is important as well but can be check as needed.
references/ Detailed documentation split by topic:
bun-fullstack-dev-server.md - Bun Fullstack Dev Server with HMR. React without bundler.cookie.md - Detailed documentation on cookiedeployment.md - Production deployment guide / Dockereden.md - e2e type safe RPC client for share type from backend to frontendguard.md - Setting validation/lifecycle all at oncemacro.md - Compose multiple schema/lifecycle as a reusable Elysia via key-value (recommended for complex setup, eg. authentication, authorization, Role-based Access Check)plugin.md - Decouple part of Elysia into a standalone componentroute.md - Elysia foundation building block: Routing, Handler and Contexttesting.md - Unit tests with examplesvalidation.md - Setup input/output validation and list of all custom validation ruleswebsocket.md - Real-time features
plugins/ Detailed documentation, usage and configuration reference for official Elysia plugin:
bearer.md - Add bearer capability to Elysia (@elysiajs/bearer)cors.md - Out of box configuration for CORS (@elysiajs/cors)cron.md - Run cron job with access to Elysia context (@elysiajs/cron)graphql-apollo.md - Integration GraphQL Apollo (@elysiajs/graphql-apollo)graphql-yoga.md - Integration with GraphQL Yoga (@elysiajs/graphql-yoga)html.md - HTML and JSX plugin setup and usage (@elysiajs/html)jwt.md - JWT / JWK plugin (@elysiajs/jwt)openapi.md - OpenAPI documentation and OpenAPI Type Gen / OpenAPI from types (@elysiajs/openapi)opentelemetry.md - OpenTelemetry, instrumentation, and record span utilities (@elysiajs/opentelemetry)server-timing.md - Server Timing metric for debug (@elysiajs/server-timing)static.md - Serve static files/folders for Elysia Server (@elysiajs/static)
integrations/ Guide to integrate Elysia with external library/runtime:
ai-sdk.md - Using Vercel AI SDK with Elysiaastro.md - Elysia in Astro API routebetter-auth.md - Integrate Elysia with better-authcloudflare-worker.md - Elysia on Cloudflare Worker adapterdeno.md - Elysia on Denodrizzle.md - Integrate Elysia with Drizzle ORMexpo.md - Elysia in Expo API routenextjs.md - Elysia in Nextjs API routenodejs.md - Run Elysia on Node.jsnuxt.md - Elysia on API routeprisma.md - Integrate Elysia with Prismareact-email.d - Create and Send Email with React and Elysiasveltekit.md - Run Elysia on Svelte Kit API routetanstack-start.md - Run Elysia on Tanstack Start / React Queryvercel.md - Deploy Elysia to Vercel
examples/ (optional)
basic.ts - Basic Elysia examplebody-parser.ts - Custom body parser example via .onParsecomplex.ts - Comprehensive usage of Elysia servercookie.ts - Setting cookieerror.ts - Error handlingfile.ts - Returning local file from serverguard.ts - Setting mulitple validation schema and lifecyclemap-response.ts - Custom response mapperredirect.ts - Redirect responserename.ts - Rename context's propertyschema.ts - Setup validationstate.ts - Setup global stateupload-file.ts - File upload with validationwebsocket.ts - Web Socket for realtime communication
patterns/ (optional)
patterns/mvc.md - Detail guideline for using Elysia with MVC patterns 