ElysiaJS

https://elysiajs.com/
Admin
ElysiaJS is an ergonomic and highly performant web framework for TypeScript, supercharged by Bun,...
Tokens:139,594
Snippets:1,767
Trust Score:8.5
Update:2 months ago
Show doc for...
Tokens:
Raw
### Basic WebSocket Setup

Source: https://elysiajs.com/patterns/websocket.html

This example demonstrates the fundamental setup of a WebSocket server using ElysiaJS. It establishes a '/ws' endpoint where incoming messages are echoed back to the client.

```APIDOC
## POST /ws

### Description
Establishes a WebSocket connection and echoes incoming messages back to the client.

### Method
POST

### Endpoint
/ws

### Request Body
(No specific request body defined for initial connection, message content is handled in `message` callback)

### Response
(Echoes the received message back to the client)

### Request Example
```typescript
import { Elysia } from 'elysia'

new Elysia()
    .ws('/ws', {
        message(ws, message) {
            ws.send(message)
        }
    })
    .listen(3000)
```

### Response Example
(Echoes the received message)
```

--------------------------------

### Basic Elysia Node.js Setup

Source: https://elysiajs.com/integrations/node

Initialize Elysia with the Node adapter and define a simple GET route. This is the minimal setup required to run Elysia on Node.js.

```typescript
import { Elysia } from 'elysia'
import { node } from '@elysia/node'

const app = new Elysia({ adapter: node() })
	.get('/', () => 'Hello Elysia')
	.listen(3000)

```

--------------------------------

### Main ElysiaJS Server Setup

Source: https://elysiajs.com/blog/elysia-supabase

This code initializes the ElysiaJS application and integrates the authentication module. It then starts the server and logs its address.

```typescript
import { Elysia, t } from 'elysia'

import { auth } from './modules'

const app = new Elysia()
    .use(auth) 
    .listen(3000)

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

```

--------------------------------

### Install Prisma and Prismabox

Source: https://elysiajs.com/integrations/prisma.html

Install the necessary Prisma client, Prismabox, and adapter packages using Bun. The Prisma CLI is installed as a dev dependency.

```bash
bun add @prisma/client prismabox prisma-adapter-bun-sqlite && \
bun add -d prisma
```

--------------------------------

### Install Server Timing Plugin

Source: https://elysiajs.com/plugins/server-timing

Install the Server Timing plugin using bun.

```bash
bun add @elysia/server-timing
```

--------------------------------

### Install Elysia Static Plugin

Source: https://elysiajs.com/plugins/static

Install the @elysia/static plugin using bun.

```bash
bun add @elysiajs/static
```

--------------------------------

### Install OpenAPI Plugin

Source: https://elysiajs.com/plugins/openapi.html

Install the ElysiaJS OpenAPI plugin using Bun.

```bash
bun add @elysia/openapi
```

--------------------------------

### Install JWT Plugin

Source: https://elysiajs.com/plugins/jwt.html

Install the JWT plugin using Bun.

```bash
bun add @elysiajs/jwt
```

--------------------------------

### Define a Basic GET Route

Source: https://elysiajs.com/tutorial/getting-started/your-first-route

Defines a simple GET route for the root path '/' that responds with 'Hello World!' and starts a server on port 3000.

```typescript
import { Elysia } from 'elysia'

new Elysia()
	.get('/', 'Hello World!')
	.listen(3000)
```

--------------------------------

### Install Elysia Node Adapter (Bun)

Source: https://elysiajs.com/integrations/node

Install the Elysia core library and the Node adapter using Bun package manager.

```bash
bun add elysia @elysia/node
```

--------------------------------

### Basic OpenTelemetry Setup in Elysia

Source: https://elysiajs.com/plugins/opentelemetry.html

This snippet demonstrates how to install and apply the OpenTelemetry plugin to an Elysia instance. It configures a BatchSpanProcessor with an OTLPTraceExporter.

```typescript
import { Elysia } from 'elysia'
import { opentelemetry } from '@elysia/opentelemetry'

import { BatchSpanProcessor } from '@opentelemetry/sdk-trace-node'
import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-proto'

new Elysia()
	.use(
		opentelemetry({
			spanProcessors: [
				new BatchSpanProcessor(
					new OTLPTraceExporter()
				)
			]
		})
	)

```

--------------------------------

### Install GraphQL Yoga Plugin

Source: https://elysiajs.com/plugins/graphql-yoga

Install the GraphQL Yoga plugin for Elysia using Bun.

```bash
bun add @elysia/graphql-yoga
```

--------------------------------

### Basic OpenTelemetry Setup

Source: https://elysiajs.com/patterns/opentelemetry

Install the OpenTelemetry plugin and apply it to your Elysia instance with a single line of configuration.

```typescript
import { Elysia } from 'elysia'
import { opentelemetry } from '@elysia/opentelemetry'

new Elysia()
	.use(opentelemetry())

```

--------------------------------

### Basic Elysia Static Plugin Setup

Source: https://elysiajs.com/patterns/fullstack-dev-server

Installs and uses the Elysia Static plugin to enable the Fullstack Dev Server. Requires 'await' before staticPlugin() to set up HMR hooks.

```typescript
import { Elysia } from 'elysia'
import { staticPlugin } from '@elysia/static'

new Elysia()
	.use(await staticPlugin())
	.listen(3000)
```

--------------------------------

### Clone Type Gen Example Repository

Source: https://elysiajs.com/tutorial/features/openapi

Use this command to clone and run the local example repository for testing type generation.

```bash
git clone https://github.com/SaltyAom/elysia-typegen-example && \
cd elysia-typegen-example && \
bun install && \
bun run dev
```

--------------------------------

### Install OpenAPI Plugin

Source: https://elysiajs.com/patterns/openapi.html

Install the OpenAPI plugin for ElysiaJS using Bun.

```bash
bun add @elysiajs/openapi
```

--------------------------------

### Install Bearer Plugin

Source: https://elysiajs.com/plugins/bearer

Install the @elysiajs/bearer plugin using bun.

```bash
bun add @elysiajs/bearer
```

--------------------------------

### Install Elysia HTML Plugin

Source: https://elysiajs.com/plugins/html.html

Install the Elysia HTML plugin using Bun.

```bash
bun add @elysia/html
```

--------------------------------

### Install Bun on MacOS/Linux

Source: https://elysiajs.com/quick-start

Use this command to install Bun on macOS or Linux systems.

```bash
curl -fsSL https://bun.sh/install | bash
```

--------------------------------

### Install Bun on Windows

Source: https://elysiajs.com/quick-start

Use this command to install Bun on Windows systems via PowerShell.

```powershell
powershell -c "irm bun.sh/install.ps1 | iex"
```

--------------------------------

### Install Dependencies

Source: https://elysiajs.com/blog/elysia-supabase

Install the release candidate versions of Elysia, cookie plugin, and the Supabase JavaScript client.

```bash
bun add elysia@rc @elysiajs/cookie@rc @supabase/supabase-js
```

--------------------------------

### Install OpenAPI Plugin

Source: https://elysiajs.com/tutorial/features/openapi

Install the required dependency to enable OpenAPI support in your project.

```bash
bun add @elysia/openapi
```

--------------------------------

### Configure Environment Variables

Source: https://elysiajs.com/blog/elysia-supabase

Example structure for the .env file containing Supabase credentials.

```bash
# .env
supabase_url=https://********************.supabase.co
supabase_service_role=**** **** **** ****
```

--------------------------------

### Install Elysia Node Adapter (npm)

Source: https://elysiajs.com/integrations/node

Install the Elysia core library and the Node adapter using npm package manager.

```bash
npm install elysia @elysia/node
```

--------------------------------

### Mount Hono App in Elysia with Port Listening

Source: https://elysiajs.com/tutorial/features/mount

A concise example of mounting a Hono application's fetch handler into Elysia and starting the Elysia server on port 3000. This is suitable for testing integrated applications.

```typescript
import { Elysia, t } from 'elysia'
import { Hono } from 'hono'

const hono = new Hono()
	.get('/', (c) => c.text('Hello from Hono'))

new Elysia()
	.get('/', 'Hello from Elysia')
	.mount('/hono', hono.fetch)
	.listen(3000)
```

--------------------------------

### Install Elysia Node Adapter (yarn)

Source: https://elysiajs.com/integrations/node

Install the Elysia core library and the Node adapter using yarn package manager.

```bash
yarn add elysia @elysia/node
```

--------------------------------

### Install Development Dependencies (Bun)

Source: https://elysiajs.com/integrations/node

Install tsx, @types/node, and typescript as development dependencies using Bun.

```bash
bun add -d tsx @types/node typescript
```

--------------------------------

### Install Elysia Eden

Source: https://elysiajs.com/eden/installation.html

Install the Elysia Eden package for your frontend project using Bun.

```bash
bun add @elysia/eden
bun add -d elysia
```

--------------------------------

### Install CORS Plugin

Source: https://elysiajs.com/plugins/cors.html

Install the ElysiaJS CORS plugin using Bun.

```bash
bun add @elysiajs/cors
```

--------------------------------

### Install Elysia Node Adapter (pnpm)

Source: https://elysiajs.com/integrations/node

Install the Elysia core library and the Node adapter using pnpm package manager.

```bash
pnpm add elysia @elysia/node
```

--------------------------------

### Basic GraphQL Yoga Setup

Source: https://elysiajs.com/plugins/graphql-yoga

Set up a basic GraphQL Yoga server with Elysia, defining type definitions and resolvers.

```typescript
import { Elysia } from 'elysia'
import { yoga } from '@elysia/graphql-yoga'

const app = new Elysia()
	.use(
		yoga({
			typeDefs: /* GraphQL */ `
				type Query {
					hi: String
				}
			`,
			resolvers: {
				Query: {
					hi: () => 'Hello from Elysia'
				}
			}
		})
	)
	.listen(3000)

```

--------------------------------

### Install Netlify CLI with Bun

Source: https://elysiajs.com/integrations/netlify

Install the Netlify CLI globally using Bun to simulate Netlify Edge Functions locally. This command is used for local development and testing.

```bash
bun add -g netlify-cli
```

--------------------------------

### Initialize WebSocket Server

Source: https://elysiajs.com/patterns/websocket.html

Basic setup for a WebSocket route using Elysia.ws().

```typescript
import { Elysia } from 'elysia'

new Elysia()
    .ws('/ws', {
        message(ws, message) {
            ws.send(message)
        }
    })
    .listen(3000)
```

```typescript
import { Elysia } from 'elysia'

const app = new Elysia()
    .ws('/ws', {
        message(ws, message) {
            ws.send(message)
        }
    })
    .listen(3000)
```

--------------------------------

### Fetch API Query Example

Source: https://elysiajs.com/tutorial/patterns/standalone-schema

Example of a URL with query parameters using the Fetch API.

```typescript
fetch('https://elysiajs.com/?name=Elysia')
```

--------------------------------

### Install GraphQL Apollo Plugin

Source: https://elysiajs.com/plugins/graphql-apollo

Install the necessary packages for the Elysia GraphQL Apollo plugin using bun.

```bash
bun add graphql @elysia/apollo @apollo/server
```

--------------------------------

### Installing Production Dependencies

Source: https://elysiajs.com/patterns/deploy.html

Installs only the production dependencies listed in `package.json`. This command should be run on the production server after deployment.

```bash
bun install --production
```

--------------------------------

### Initialize Elysia with Deno.serve

Source: https://elysiajs.com/integrations/deno

Wrap the Elysia fetch handler within Deno.serve to start the application.

```typescript
import { Elysia } from 'elysia'

const app = new Elysia()
	.get('/', () => 'Hello Elysia')
	.listen(3000) 

Deno.serve(app.fetch)
```

--------------------------------

### Install Optional Peer Dependencies

Source: https://elysiajs.com/plugins/graphql-yoga

Install optional peer dependencies for GraphQL Yoga.

```bash
bun add graphql graphql-yoga
```

--------------------------------

### Install Development Dependencies (npm)

Source: https://elysiajs.com/integrations/node

Install tsx, @types/node, and typescript as development dependencies using npm.

```bash
npm install --save-dev tsx @types/node typescript
```

--------------------------------

### Install React Email and Dependencies

Source: https://elysiajs.com/integrations/react-email.html

Install React Email and its peer dependencies using Bun. Add the email development script to your package.json.

```bash
bun add -d react-email
bun add @react-email/components react react-dom
```

```json
{
  "scripts": {
    "email": "email dev --dir src/emails"
  }
}
```

--------------------------------

### Fetch API Path Parameter Example

Source: https://elysiajs.com/tutorial/patterns/standalone-schema

Example of a URL with a path parameter using the Fetch API.

```typescript
fetch('https://elysiajs.com/id/1')
```

--------------------------------

### Install Development Dependencies (yarn)

Source: https://elysiajs.com/integrations/node

Install tsx, @types/node, and typescript as development dependencies using yarn.

```bash
yarn add -D tsx @types/node typescript
```

--------------------------------

### Install Development Dependencies (pnpm)

Source: https://elysiajs.com/integrations/node

Install tsx, @types/node, and typescript as development dependencies using pnpm.

```bash
pnpm add -D tsx @types/node typescript
```

--------------------------------

### Basic HTTP Methods

Source: https://elysiajs.com/essential/route.html

Demonstrates the basic usage of GET, POST, and LISTEN methods in Elysia.

```typescript
import { Elysia } from 'elysia'

new Elysia()
    .get('/', 'hello')
    .post('/hi', 'hi')
    .listen(3000)
```

--------------------------------

### Install Bun Type Definitions

Source: https://elysiajs.com/eden/installation.html

Install Bun type definitions if you are using Bun-specific features in your Elysia handlers and need them for client-side type inference.

```bash
bun add -d @types/bun
```

--------------------------------

### Install nuxt-elysia Plugin

Source: https://elysiajs.com/integrations/nuxt

Install the necessary packages for integrating Elysia with Nuxt. This includes Elysia, Eden Treaty, and the nuxt-elysia development dependency.

```bash
bun add elysia @elysia/eden
bun add -d nuxt-elysia
```

--------------------------------

### Install Prisma CLI

Source: https://elysiajs.com/blog/with-prisma

Add Prisma CLI as a development dependency using 'bun add -d'.

```typescript
bun add -d prisma
```

--------------------------------

### Install ElysiaJS Cron Plugin

Source: https://elysiajs.com/plugins/cron.html

Install the cron plugin using Bun. This is the first step before using cron jobs in your Elysia application.

```bash
bun add @elysia/cron
```

--------------------------------

### Initialize Prisma Project

Source: https://elysiajs.com/blog/with-prisma

Execute 'prisma init' using 'bunx' to set up your Prisma project. This command is equivalent to 'npx prisma init'.

```typescript
bunx prisma init
```

--------------------------------

### Initialize Elysia Project

Source: https://elysiajs.com/blog/elysia-supabase

Command to scaffold a new ElysiaJS project using Bun.

```bash
bun create elysia elysia-supabase
```

--------------------------------

### Elysia Limitation: Response Definition Before Server Start

Source: https://elysiajs.com/integrations/cloudflare-worker.html

This TypeScript example demonstrates an invalid pattern where a response is defined before the server starts, which will result in an error in Cloudflare Worker environments.

```typescript
import { Elysia } from 'elysia'

new Elysia()
	// This will throw error
    .get('/', 'Hello Elysia')
    .listen(3000)
```

--------------------------------

### Basic Routing with GET Method

Source: https://elysiajs.com/essential/route.html

Defines basic routes for the root path and '/hi' using the GET method. The server listens on port 3000.

```typescript
import { Elysia } from 'elysia'

new Elysia()
    .get('/', 'hello')
    .get('/hi', 'hi')
    .listen(3000)
```

--------------------------------

### Example of Route Prefixing

Source: https://elysiajs.com/patterns/configuration.html

Illustrates how defining a prefix in the Elysia constructor results in all defined routes being appended with that prefix.

```typescript
import { Elysia, t } from 'elysia'

new Elysia({ prefix: '/v1' }).get('/name', 'elysia') // Path is /v1/name
```

--------------------------------

### Trace Listener Example

Source: https://elysiajs.com/patterns/trace

This example shows how to use a trace listener for a specific lifecycle event, in this case 'onBeforeHandle'. The listener receives a parameter object with details about the event, including its name, start time, and end time.

```typescript
import { Elysia } from 'elysia'

const app = new Elysia()
	.trace(({ onBeforeHandle }) => {
		// This is trace listener
		// hover to view the type
		onBeforeHandle((parameter) => {

		})
	})
	.get('/', () => 'Hi')
	.listen(3000)
```

--------------------------------

### Basic Better Auth Setup

Source: https://elysiajs.com/integrations/better-auth.html

Initialize Better Auth with a database connection. This is the foundational step for using Better Auth.

```typescript
import { betterAuth } from 'better-auth'
import { Pool } from 'pg'
export const auth = betterAuth({
    database: new Pool()
})
```

--------------------------------

### Define a Basic Handler

Source: https://elysiajs.com/essential/handler.html

A handler can be a function that accepts no arguments and returns a value. This example shows a simple GET route returning a string.

```typescript
import { Elysia } from 'elysia'

new Elysia()
    // the function `() => 'hello world'` is a handler
    .get('/', () => 'hello world')
    .listen(3000)
```

--------------------------------

### Create Elysia API Route

Source: https://elysiajs.com/integrations/nuxt

Define a simple Elysia API route in `api.ts`. This example creates a GET endpoint '/hello' that returns a JSON message.

```typescript
export default () => new Elysia()
  .get('/hello', () => ({ message: 'Hello world!' }))
```

--------------------------------

### Initialize Elysia Server with Auth and Post Modules

Source: https://elysiajs.com/blog/elysia-supabase

Sets up the main Elysia application, incorporating authentication and post-related modules, and starts the server. Logs the server's address to the console.

```typescript
import { Elysia, t } from 'elysia'

import { auth, post } from './modules'

const app = new Elysia()
    .use(auth)
    .use(post)
    .listen(3000)

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

--------------------------------

### Monorepo Dockerfile with Multiple Package Copies

Source: https://elysiajs.com/patterns/deploy.html

A Dockerfile for a monorepo setup using Bun. It copies package.json files from both the app and shared packages before installation to ensure correct dependency caching.

```dockerfile
FROM oven/bun:1 AS build

WORKDIR /app

# Cache packages
COPY package.json package.json
COPY bun.lock bun.lock

COPY /apps/server/package.json ./apps/server/package.json
COPY /packages/config/package.json ./packages/config/package.json

RUN bun install

COPY /apps/server ./apps/server
COPY /packages/config ./packages/config

ENV NODE_ENV=production

RUN bun build \
	--compile \
	--minify-whitespace \
	--minify-syntax \
	--outfile server \
	src/index.ts

FROM gcr.io/distroless/base

WORKDIR /app

COPY --from=build /app/server server

ENV NODE_ENV=production

CMD ["./server"]

EXPOSE 3000
```

--------------------------------

### Create New ElysiaJS Project

Source: https://elysiajs.com/quick-start

Automatically sets up a new ElysiaJS project with all necessary configurations. Navigate into the created 'app' directory afterwards.

```bash
bun create elysia app
```

```bash
cd app
```

--------------------------------

### Basic Elysia Server in SvelteKit Route

Source: https://elysiajs.com/integrations/sveltekit

Integrate a basic Elysia server into a SvelteKit route handler. This example defines GET and POST endpoints and exports a fallback function to handle requests.

```typescript
// src/routes/[...slugs]/+server.ts
import { Elysia, t } from 'elysia';

const app = new Elysia()
    .get('/', 'hello SvelteKit')
    .post('/', ({ body }) => body, {
        body: t.Object({
            name: t.String()
        })
    })

interface WithRequest {
	request: Request
}

export const fallback = ({ request }: WithRequest) => app.handle(request) 

```

--------------------------------

### Integrate OpenTelemetry with Elysia

Source: https://elysiajs.com/blog/elysia-11

Install the `@elysiajs/opentelemetry` plugin to enable first-party support for OpenTelemetry. This setup collects span data from libraries compatible with the OpenTelemetry standard and automatically applies parent and child spans.

```typescript
import { Elysia } from 'elysia'
import { opentelemetry } from '@elysiajs/opentelemetry'

import { BatchSpanProcessor } from '@opentelemetry/sdk-trace-node'
import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-proto'

new Elysia()
	.use(
		opentelemetry({
			spanProcessors: [
				new BatchSpanProcessor(
					new OTLPTraceExporter()
				)
			]
		})
	)

```

--------------------------------

### Eden Treaty Example: Interacting with Elysia Server

Source: https://elysiajs.com/eden/overview.html

Demonstrates how to use Eden Treaty to interact with an Elysia server, including making GET and PUT requests with type safety and auto-completion. Ensure the 'App' type is correctly imported from your server file.

```typescript
import {
    treaty
} from '@elysia/eden'
import type { 
App
 } from './server'

const 
app
 =
    treaty
< 
App
>('localhost:3000')


app
.




// Call [GET] at '/'
const { data } = await 
app
.
get
()

// Call [PUT] at '/nendoroid/:id'
const { 
data
: 
nendoroid
, 
error
 } = await 
app
.

nendoroid
({ 
id
: 1895 }).
put
({
    
name
: 'Skadi',
    
from
: 'Arknights'
})
```

--------------------------------

### Basic GraphQL Apollo Setup

Source: https://elysiajs.com/plugins/graphql-apollo

Set up a basic GraphQL server with Apollo using Elysia. Define type definitions and resolvers to handle queries.

```typescript
import { Elysia } from 'elysia'
import { apollo, gql } from '@elysia/apollo'

const app = new Elysia()
	.use(
		apollo({
			typeDefs: gql`
				type Book {
					title: String
					author: String
				}

				type Query {
					books: [Book]
				}
			`,
			resolvers: {
				Query: {
					books: () => {
						return [
							{
								title: 'Elysia',
								author: 'saltyAom'
							}
						]
					}
				}
			}
		})
	)
	.listen(3000)
```

--------------------------------

### Creating and Using a Basic Plugin

Source: https://elysiajs.com/essential/plugin.html

Demonstrates how to define a simple plugin with a decoration and a route, and then use it within a main Elysia instance.

```typescript
import {
Elysia
} from 'elysia'

const plugin = new Elysia()
    .decorate('plugin', 'hi')
    .get('/plugin', ({ plugin }) => plugin)

const app = new Elysia()
    .use(plugin)
    .get('/', ({ plugin }) => plugin)
    .listen(3000)
```

--------------------------------

### Set up PostgreSQL Database with Docker

Source: https://elysiajs.com/blog/with-prisma

Run a PostgreSQL instance using Docker. This command maps port 5432 and sets a password for the 'postgres' user.

```bash
docker run -p 5432:5432 -e POSTGRES_PASSWORD=12345678 -d postgres
```

--------------------------------

### Install Drizzle Dependencies

Source: https://elysiajs.com/integrations/drizzle.html

Install the required Drizzle ORM and typebox integration packages.

```bash
bun add drizzle-orm drizzle-typebox
```

--------------------------------

### Install Peer Dependencies for pnpm

Source: https://elysiajs.com/integrations/astro

Manually install required peer dependencies when using pnpm.

```bash
pnpm add @sinclair/typebox openapi-types
```

--------------------------------

### Enable OpenAPI Documentation

Source: https://elysiajs.com/tutorial/features/openapi

Initialize the OpenAPI plugin to expose API documentation at the /openapi endpoint.

```typescript
import { Elysia, t } from 'elysia'
import { openapi } from '@elysia/openapi'

new Elysia()
	.use(openapi()) 
	.post(
		'/',
		({ body }) => body,
		{
			body: t.Object({
				age: t.Number()
			})
		}
	)
	.listen(3000)
```

--------------------------------

### Create Elysia Project

Source: https://elysiajs.com/blog/with-prisma

Use 'bun create' to scaffold a new Elysia project. Replace 'elysia-prisma' with your desired project name.

```bash
bun create elysia elysia-prisma
```

--------------------------------

### Setup OpenTelemetry with PgInstrumentation

Source: https://elysiajs.com/patterns/opentelemetry

This snippet demonstrates how to initialize OpenTelemetry with the PgInstrumentation. Ensure the OpenTelemetry SDK is set up before importing the target module.

```typescript
import { opentelemetry } from '@elysia/opentelemetry'
import { PgInstrumentation } from '@opentelemetry/instrumentation-pg'

export const instrumentation = opentelemetry({
	instrumentations: [new PgInstrumentation()]
})
```

--------------------------------

### Run Elysia server with Deno

Source: https://elysiajs.com/integrations/deno

Use the Deno CLI to execute the server file.

```bash
deno serve --watch src/index.ts
```

--------------------------------

### ALL Method

Source: https://elysiajs.com/essential/route.html

Explains how to use Elysia.all to handle any HTTP method for a given path.

```APIDOC
## ALL method

Elysia provides an `Elysia.all` for handling any HTTP method for a specified path using the same API like **Elysia.get** and **Elysia.post**

### Description
Handles all HTTP methods (GET, POST, DELETE, etc.) for a specific path.

### Method
ALL (any HTTP method)

### Endpoint
/

### Parameters
* **path**: Pathname
* **function**: Function to respond to the client
* **hook**: Additional metadata

### Request Example
(No example provided in source)

### Response
#### Success Response (200)
(No specific response details provided in source)

#### Response Example
(No example provided in source)
```

--------------------------------

### Define Elysia Server in TanStack Start Route

Source: https://elysiajs.com/integrations/tanstack-start.html

Set up an Elysia server instance and export its fetch handler for use in TanStack Start server routes. This allows Elysia to manage API endpoints within the TanStack Start application.

```typescript
import { Elysia } from 'elysia'

import { createFileRoute } from '@tanstack/react-router'
import { createIsomorphicFn } from '@tanstack/react-start'

const app = new Elysia({
	prefix: '/api'
}).get('/', 'Hello Elysia!')

const handle = ({ request }: { request: Request }) => app.fetch(request) 

export const Route = createFileRoute('/api/$')({
	server: {
		handlers: {
			GET: handle, 
			POST: handle 
		}
	}
})
```

--------------------------------

### Initialize Elysia Project with Wrangler

Source: https://elysiajs.com/integrations/cloudflare-worker.html

Use Wrangler to initialize a new project for deploying Elysia on Cloudflare.

```bash
wrangler init elysia-on-cloudflare
```

--------------------------------

### Install Additional Dependencies for pnpm

Source: https://elysiajs.com/integrations/node

Manually install @sinclair/typebox and openapi-types when using pnpm, as it does not auto-install peer dependencies by default.

```bash
pnpm add @sinclair/typebox openapi-types

```

--------------------------------

### Install Peer Dependencies for pnpm

Source: https://elysiajs.com/integrations/nextjs.html

If using pnpm, manually install required peer dependencies like @sinclair/typebox and openapi-types.

```bash
pnpm add @sinclair/typebox openapi-types
```

--------------------------------

### Install Tailwind CSS Dependencies

Source: https://elysiajs.com/patterns/fullstack-dev-server

Installs Tailwind CSS version 4 and the Bun plugin for Tailwind CSS. These are development dependencies.

```bash
bun add tailwindcss@4
bun add -d bun-plugin-tailwind
```

--------------------------------

### Build Elysia Fullstack Server for Production

Source: https://elysiajs.com/patterns/fullstack-dev-server

Compiles the Elysia fullstack server into a single, self-contained executable file using Bun's build command.

```bash
bun build --compile --target bun --outfile server src/index.ts
```

--------------------------------

### Handling All HTTP Methods with Elysia.all

Source: https://elysiajs.com/essential/route.html

Demonstrates how to use Elysia.all to handle any HTTP method for a specified path, using the same API as other HTTP methods.

```typescript
import { Elysia } from 'elysia'

new Elysia()
    .all('/', 'hi')
    .listen(3000)
```

--------------------------------

### ElysiaJS WebSocket Server and Client Setup

Source: https://elysiajs.com/eden/treaty/websocket

Sets up a basic WebSocket server in ElysiaJS and demonstrates a client subscribing to messages. Requires @elysiajs/elysia and @elysiajs/eden packages.

```typescript
import { Elysia, t } from "elysia";
import { treaty } from "@elysia/eden";

const app = new Elysia()
  .ws("/chat", {
    body: t.String(),
    response: t.String(),
    message(ws, message) {
      ws.send(message);
    },
  })
  .listen(3000);

const api = treaty<typeof app>("localhost:3000");

const chat = api.chat.subscribe();

chat.subscribe((message) => {
  console.log("got", message);
});

chat.on("open", () => {
  chat.send("hello from client");
});
```

--------------------------------

### Initialize Supabase Client

Source: https://elysiajs.com/blog/elysia-supabase

Create a reusable Supabase client instance using environment variables.

```typescript
// src/libs/supabase.ts
import { createClient } from '@supabase/supabase-js'

const { supabase_url, supabase_service_role } = process.env

export const supabase = createClient(supabase_url!, supabase_service_role!)
```

--------------------------------

### Bun Configuration for Preloading

Source: https://elysiajs.com/patterns/opentelemetry

This TOML configuration tells Bun to preload the specified instrumentation setup file before running the main application script. This ensures the OpenTelemetry SDK is initialized early.

```toml
preload = ["./src/instrumentation.ts"]
```

--------------------------------

### ElysiaJS Tailored Handler Example

Source: https://elysiajs.com/internal/jit-compiler.html

An example of dynamically generated code by Elysia's JIT 'compiler' that specifically parses only the 'params' from the request.

```typescript
function tailoredHandler(request) {
	const context = {
		request,
		params: parseParams(request.url)
	}
	
	return routeHandler(context)
}
```

--------------------------------

### Basic Cron Job Setup

Source: https://elysiajs.com/plugins/cron.html

Set up a basic cron job that logs a message every 10 seconds. This demonstrates the core usage of the cron plugin.

```typescript
import { Elysia } from 'elysia'
import { cron } from '@elysia/cron'

new Elysia()
	.use(
		cron({
			name: 'heartbeat',
			pattern: '*/10 * * * * *',
			run() {
				console.log('Heartbeat')
			}
		})
	)
	.listen(3000)
```

--------------------------------

### Start Cloudflare Worker Development Server

Source: https://elysiajs.com/integrations/cloudflare-worker.html

Use `wrangler dev` to start a local development server for your Elysia Cloudflare Worker application.

```bash
wrangler dev
```
Tokens:
Raw