ZeltJS

https://github.com/zeltjs/zelt
Admin
Portable TypeScript application framework with built-in DI that runs on Node.js, Bun, Cloudflare...
Tokens:97,699
Snippets:1,273
Trust Score:3
License:MIT
Update:4 months ago
Show doc for...
Tokens:
Raw
### Installation

Source: https://github.com/zeltjs/zelt/blob/main/website/docs/getting-started/node.mdx

Install the necessary Zelt packages for Node.js.

```bash
pnpm add @zeltjs/core@0.6.1 @zeltjs/adapter-node@0.6.1
```

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

### Installation

Source: https://github.com/zeltjs/zelt/blob/main/website/i18n/ja/docusaurus-plugin-content-docs/current/getting-started/node.md

Install the core and Node.js adapter packages using pnpm.

```bash
pnpm add @zeltjs/core @zeltjs/adapter-node
```

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

### Installation

Source: https://github.com/zeltjs/zelt/blob/main/website/docs/getting-started/bun.mdx

Install the necessary Zelt.js packages for Bun.

```bash
bun add @zeltjs/core@0.6.1 @zeltjs/adapter-bun@0.6.1
```

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

### Server Options Example

Source: https://github.com/zeltjs/zelt/blob/main/website/docs/getting-started/bun.mdx

Example demonstrating how to configure server options like port and hostname.

```typescript
// @noErrors
import { createApp, Controller, Get, pathParam } from '@zeltjs/core';
import { onBun } from '@zeltjs/adapter-bun';

@Controller('/hello')
class HelloController {
  @Get('/:name')
  greet(name = pathParam('name')) { return { message: `Hello, ${name}!` }; }
}

const app = createApp({ http: { controllers: [HelloController] } });
const bunApp = await onBun(app);
// ---cut---
const server = bunApp.serve({
  port: 8080,
  hostname: '127.0.0.1',
});
```

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

### Command Support Example

Source: https://github.com/zeltjs/zelt/blob/main/website/docs/getting-started/bun.mdx

Example showing how to integrate and execute CLI commands with Zelt on Bun.

```typescript
// @noErrors
import { createApp, Command, Arg, Controller, Get } from '@zeltjs/core';
import { onBun } from '@zeltjs/adapter-bun';

@Controller('/hello')
class HelloController {
  @Get('/') greet() { return { message: 'Hello!' }; }
}

@Command('greet')
class GreetCommand {
  constructor(private name = Arg(0)) {}
  run() { console.log(`Hello, ${this.name}!`); }
}

const app = createApp({
  http: { controllers: [HelloController] },
  commands: [GreetCommand],
});
// ---cut---
const bunApp = await onBun(app);

const result = await bunApp.execCommand(['greet', 'world']);
console.log(result.exitCode); // 0 or 1
```

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

### Hello World: Create the Controller

Source: https://github.com/zeltjs/zelt/blob/main/website/docs/getting-started/node.mdx

Create the controller file for the Hello World example.

```typescript
import { Controller, Get, pathParam } from '@zeltjs/core';
// ---cut---
@Controller('/hello')
export class HelloController {
  @Get('/:name')
  greet(name = pathParam('name')) {
    return { message: `Hello, ${name}!` };
  }
}
```

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

### Installation

Source: https://github.com/zeltjs/zelt/blob/main/website/docs/getting-started/lambda.mdx

Install the necessary Zelt packages and development dependencies for AWS Lambda.

```bash
pnpm add @zeltjs/core@0.6.1 @zeltjs/adapter-lambda@0.6.1
pnpm add -D @types/aws-lambda esbuild
```

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

### Hello World: Start the Server

Source: https://github.com/zeltjs/zelt/blob/main/website/docs/getting-started/node.mdx

Create the main file to start the Node.js server.

```typescript
import { createApp, Controller, Get, pathParam } from '@zeltjs/core';
import { onNode } from '@zeltjs/adapter-node';

@Controller('/hello')
class HelloController {
  @Get('/:name')
  greet(name = pathParam('name')) { return { message: `Hello, ${name}!` }; }
}

const app = createApp({ http: { controllers: [HelloController] } });
const nodeApp = await onNode(app);
// ---cut---
const server = await nodeApp.listen({ port: 3000 });
console.log(`Server running at http://localhost:${server.address.port}`);
```

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

### Run the Server

Source: https://github.com/zeltjs/zelt/blob/main/website/docs/getting-started/bun.mdx

Command to run the Zelt application on Bun.

```bash
bun run src/index.ts
```

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

### Warmup Option Example

Source: https://github.com/zeltjs/zelt/blob/main/website/docs/getting-started/bun.mdx

Example demonstrating how to configure the warmup option for lazy initialization.

```typescript
// @noErrors
import { createApp, Controller, Get, pathParam } from '@zeltjs/core';
import { onBun } from '@zeltjs/adapter-bun';

@Controller('/hello')
class HelloController {
  @Get('/:name')
  greet(name = pathParam('name')) { return { message: `Hello, ${name}!` }; }
}

const app = createApp({ http: { controllers: [HelloController] } });
// ---cut---
const bunApp = await onBun(app, { warmup: false });
```

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

### Running the Example

Source: https://github.com/zeltjs/zelt/blob/main/website/examples/drizzle-todo.md

Instructions to install dependencies and run the Drizzle Todo example.

```bash
cd examples/drizzle-todo
pnpm install
pnpm dev
```

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

### Hello World - Step 5: Deploy

Source: https://github.com/zeltjs/zelt/blob/main/website/docs/getting-started/lambda.mdx

Deploy the application using SAM CLI.

```bash
sam build
sam deploy --guided
```

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

### Create the Application

Source: https://github.com/zeltjs/zelt/blob/main/website/docs/getting-started/bun.mdx

Create the Zelt application instance, including the HelloController.

```typescript
// @noErrors
import { createApp, Controller, Get, pathParam } from '@zeltjs/core';
@Controller('/hello')
class HelloController {
  @Get('/:name')
  greet(name = pathParam('name')) { return { message: `Hello, ${name}!` }; }
}
// ---cut---
export const app = createApp({
  http: {
    controllers: [HelloController],
  },
});
```

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

### Hello World - Step 3: Create the Lambda Handler

Source: https://github.com/zeltjs/zelt/blob/main/website/docs/getting-started/lambda.mdx

Create the Lambda handler file for the Hello World example.

```typescript
// @noErrors
import { createApp, Controller, Get, pathParam } from '@zeltjs/core';
import { onLambda } from '@zeltjs/adapter-lambda';

@Controller('/hello')
class HelloController {
  @Get('/:name')
  greet(name = pathParam('name')) { return { message: `Hello, ${name}!` }; }
}

const app = createApp({ http: { controllers: [HelloController] } });
// ---cut---
const lambdaApp = await onLambda(app);

export const handler = lambdaApp.handler;
```

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

### Hello World: Run the Application

Source: https://github.com/zeltjs/zelt/blob/main/website/docs/getting-started/node.mdx

Command to run the Node.js application using tsx.

```bash
npx tsx src/main.ts
```

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

### Create the Entry Point

Source: https://github.com/zeltjs/zelt/blob/main/website/docs/getting-started/bun.mdx

Set up the main entry point for the Bun application, integrating with the Zelt app.

```typescript
// @noErrors
import { createApp, Controller, Get, pathParam } from '@zeltjs/core';
import { onBun } from '@zeltjs/adapter-bun';

@Controller('/hello')
class HelloController {
  @Get('/:name')
  greet(name = pathParam('name')) { return { message: `Hello, ${name}!` }; }
}

const app = createApp({ http: { controllers: [HelloController] } });
// ---cut---
const bunApp = await onBun(app);

const server = bunApp.serve({ port: 3000 });
console.log(`Server running at http://${server.address.hostname}:${server.address.port}`);
```

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

### Quick Example

Source: https://github.com/zeltjs/zelt/blob/main/website/docs/index.md

A basic example of a ZeltJS controller with a GET endpoint.

```typescript
import { Controller, Get } from '@zeltjs/core';

@Controller('/hello')
class HelloController {
  @Get('/')
  greet() {
    return { message: 'Hello, World!' };
  }
}
```

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

### Eager Initialization with Warmup

Source: https://github.com/zeltjs/zelt/blob/main/website/docs/getting-started/lambda.mdx

Example demonstrating how to enable eager initialization for controllers in the Lambda adapter by setting `warmup: true`.

```typescript
// @noErrors
import { createApp, Controller, Get, pathParam } from '@zeltjs/core';
import { onLambda } from '@zeltjs/adapter-lambda';

@Controller('/hello')
class HelloController {
  @Get('/:name')
  greet(name = pathParam('name')) { return { message: `Hello, ${name}!` }; }
}

const app = createApp({ http: { controllers: [HelloController] } });
// ---cut---
const lambdaApp = await onLambda(app, { warmup: true });
```

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

### Hello World: Configure TypeScript

Source: https://github.com/zeltjs/zelt/blob/main/website/docs/getting-started/node.mdx

Create the tsconfig.json file for TypeScript configuration.

```json
{
  "compilerOptions": {
    "target": "ES2022",
    "module": "NodeNext",
    "moduleResolution": "NodeNext",
    "strict": true,
    "experimentalDecorators": true,
    "esModuleInterop": true,
    "skipLibCheck": true
  },
  "include": ["src"]
}
```

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

### Create the Controller

Source: https://github.com/zeltjs/zelt/blob/main/website/docs/getting-started/bun.mdx

Define a simple controller for handling 'hello' routes.

```typescript
// @noErrors
import { Controller, Get, pathParam } from '@zeltjs/core';
// ---cut---
@Controller('/hello')
export class HelloController {
  @Get('/:name')
  greet(name = pathParam('name')) {
    return { message: `Hello, ${name}!` };
  }
}
```

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

### Configuration: Node.js-Specific Configs

Source: https://github.com/zeltjs/zelt/blob/main/website/docs/getting-started/node.mdx

Importing Node.js-specific configuration classes from @zeltjs/adapter-node.

```typescript
import { ProcessEnvConfig, DotEnvConfig } from '@zeltjs/adapter-node';
// ---cut---
// ProcessEnvConfig: Reads from process.env (default behavior)
// DotEnvConfig: Reads from .env file
void ProcessEnvConfig;
void DotEnvConfig;
```

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

### Hello World: Create the Application

Source: https://github.com/zeltjs/zelt/blob/main/website/docs/getting-started/node.mdx

Create the application file to wire up controllers for the Node.js runtime.

```typescript
import { createApp, Controller, Get, pathParam } from '@zeltjs/core';
import { onNode } from '@zeltjs/adapter-node';
@Controller('/hello')
class HelloController {
  @Get('/:name')
  greet(name = pathParam('name')) { return { message: `Hello, ${name}!` }; }
}
// ---cut---
export const app = createApp({
  http: {
    controllers: [HelloController],
  },
});

export default await onNode(app);
```

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

### Configuration: Using Environment Variables in Controller

Source: https://github.com/zeltjs/zelt/blob/main/website/docs/getting-started/node.mdx

Controller demonstrating how to use EnvService to get environment variables.

```typescript
import { Controller, Get, inject, EnvService } from '@zeltjs/core';
// ---cut---
@Controller('/config')
export class ConfigController {
  constructor(private env = inject(EnvService)) {}

  @Get('/api-host')
  getApiHost() {
    return { apiHost: this.env.getString('API_HOST', 'localhost') };
  }
}
```

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

### Adding Services: Create Service

Source: https://github.com/zeltjs/zelt/blob/main/website/docs/getting-started/node.mdx

Create the service file for managing greeting logic.

```typescript
import { Injectable } from '@zeltjs/core';
// ---cut---
@Injectable()
export class GreetingService {
  greet(name: string): string {
    return `Hello, ${name}!`;
  }
}
```

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

### Hello World - Step 4: Configure SAM Template

Source: https://github.com/zeltjs/zelt/blob/main/website/docs/getting-started/lambda.mdx

Configure the SAM template for the AWS Lambda deployment.

```yaml
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31

Globals:
  Function:
    Timeout: 30
    Runtime: nodejs20.x

Resources:
  HelloFunction:
    Type: AWS::Serverless::Function
    Properties:
      CodeUri: dist/
      Handler: handler.handler
      Events:
        Api:
          Type: HttpApi
          Properties:
            Path: /{proxy+}
            Method: ANY
    Metadata:
      BuildMethod: esbuild
      BuildProperties:
        Minify: true
        Target: es2022
        EntryPoints:
          - src/handler.ts

Outputs:
  ApiEndpoint:
    Value: !Sub "https://${ServerlessHttpApi}.execute-api.${AWS::Region}.amazonaws.com"
```

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

### Configuration: Registering EnvConfig in App

Source: https://github.com/zeltjs/zelt/blob/main/website/docs/getting-started/node.mdx

Registering EnvConfig in the application to enable environment variable access.

```typescript
import { createApp, EnvConfig, Controller, Get, inject, EnvService } from '@zeltjs/core';
@Controller('/config')
class ConfigController {
  constructor(private env = inject(EnvService)) {}
  @Get('/api-host')
  getApiHost() { return { apiHost: this.env.getString('API_HOST', 'localhost') }; }
}
// ---cut---
export const app = createApp({
  http: {
    controllers: [ConfigController],
  },
  configs: [EnvConfig],
});
```

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

### Installation

Source: https://github.com/zeltjs/zelt/blob/main/website/README.md

Installs project dependencies using Yarn.

```bash
yarn
```

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

### Application Setup with Session Middleware

Source: https://github.com/zeltjs/zelt/blob/main/website/docs/authentication/sessions.md

Example of setting up the Zelt.js application with SessionMiddleware and SessionAuthMiddleware.

```typescript
import { createApp, Config, Controller, Get, Middleware, Injectable, inject, setUser, type RequestContext, type Next } from '@zeltjs/core';
import { MemoryKVService } from '@zeltjs/kv';
import { SessionMiddleware, SessionConfig, getSession } from '@zeltjs/auth-session';

type User = { id: string; name: string; email: string; roles: string[] };

@Injectable()
class UserRepository {
  async findById(id: string): Promise<User> {
    return { id, name: '', email: '', roles: [] };
  }
}

@Config
class MySessionConfig extends SessionConfig {
  private kv = inject(MemoryKVService);
  override get store() { return this.kv.namespace('sessions'); }
}

@Middleware
class SessionAuthMiddleware {
  constructor(private userRepo = inject(UserRepository)) {}
  async use(c: RequestContext, next: Next) {
    const session = getSession() as { userId?: string } | undefined;
    if (session?.userId) {
      const user = await this.userRepo.findById(session.userId);
      setUser({ id: user.id, name: user.name, email: user.email }, user.roles);
    }
    await next();
    return undefined;
  }
}

@Controller('/users')
class UserController {
  @Get('/') findAll() { return { users: [] }; }
}
// ---cut---
const app = createApp({
  http: {
    controllers: [UserController],
    middlewares: [SessionMiddleware, SessionAuthMiddleware],
  },
  configs: [MySessionConfig],
  injectables: [MemoryKVService],
});
```

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

### Installation

Source: https://github.com/zeltjs/zelt/blob/main/website/docs/kv.md

Install the @zeltjs/kv package using pnpm.

```bash
pnpm add @zeltjs/kv
```

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

### Node.js Specific Configs

Source: https://github.com/zeltjs/zelt/blob/main/website/i18n/ja/docusaurus-plugin-content-docs/current/getting-started/node.md

Demonstrates the import of ProcessEnvConfig and DotEnvConfig from the `@zeltjs/adapter-node` package, highlighting their roles in reading environment variables or .env files.

```typescript
import { ProcessEnvConfig, DotEnvConfig } from '@zeltjs/adapter-node';
// ---
// ProcessEnvConfig: Reads from process.env (default behavior)
// DotEnvConfig: Reads from .env file
void ProcessEnvConfig;
void DotEnvConfig;
```

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

### Adding Services: Update Controller

Source: https://github.com/zeltjs/zelt/blob/main/website/docs/getting-started/node.mdx

Update the controller to inject and use the GreetingService.

```typescript
import { Controller, Get, pathParam, inject, Injectable } from '@zeltjs/core';
@Injectable()
class GreetingService {
  greet(name: string): string { return `Hello, ${name}!`; }
}
// ---cut---
@Controller('/hello')
export class HelloController {
  constructor(private greetingService = inject(GreetingService)) {}

  @Get('/:name')
  greet(name = pathParam('name')) {
    return { message: this.greetingService.greet(name) };
  }
}
```

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

### Lifecycle Integration Example

Source: https://github.com/zeltjs/zelt/blob/main/website/docs/db.md

Shows how to integrate the DatabaseService with Zelt's application lifecycle for setup and shutdown.

```typescript
// @noErrors
import { createApp } from '@zeltjs/core';

const app = createApp({
  http: {
    controllers: [OrderController],
  },
  configs: [DrizzleService],
});
```

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

### Installation

Source: https://github.com/zeltjs/zelt/blob/main/website/docs/bullmq.md

Install BullMQ and ioredis using pnpm.

```bash
pnpm add bullmq ioredis
```

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

### Installation

Source: https://github.com/zeltjs/zelt/blob/main/packages/adapter-lambda/README.md

Install the adapter and core packages using npm.

```bash
npm install @zeltjs/adapter-lambda @zeltjs/core
```

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

### Installation

Source: https://github.com/zeltjs/zelt/blob/main/website/i18n/ja/docusaurus-plugin-content-docs/current/testing/unit.md

Install the @zeltjs/testing package using pnpm.

```bash
pnpm add -D @zeltjs/testing
```

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

### Installation

Source: https://github.com/zeltjs/zelt/blob/main/packages/adapter-node/README.md

Install the @zeltjs/adapter-node and @zeltjs/core packages.

```bash
npm install @zeltjs/adapter-node @zeltjs/core
```

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

### Installation

Source: https://github.com/zeltjs/zelt/blob/main/packages/cli/README.md

Install the Zelt CLI using npm.

```bash
npm install -D @zeltjs/cli
```

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

### Installation

Source: https://github.com/zeltjs/zelt/blob/main/packages/kv/README.md

Install the @zeltjs/kv package along with @zeltjs/core.

```bash
npm install @zeltjs/kv @zeltjs/core
```

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

### Installation

Source: https://github.com/zeltjs/zelt/blob/main/packages/adapter-bun/README.md

Install the Bun adapter for Zelt applications.

```bash
bun add @zeltjs/adapter-bun @zeltjs/core
```

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

### Installation with bun

Source: https://github.com/zeltjs/zelt/blob/main/website/docs/validation.md

Install the Valibot validator and Valibot itself using bun.

```bash
bun add @zeltjs/validator-valibot valibot
```

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

### Installation

Source: https://github.com/zeltjs/zelt/blob/main/packages/openapi/README.md

Install the @zeltjs/openapi package using npm.

```bash
npm install @zeltjs/openapi
```

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

### Installation

Source: https://github.com/zeltjs/zelt/blob/main/packages/hono-client/README.md

Install the @zeltjs/hono-client package as a development dependency.

```bash
npm install -D @zeltjs/hono-client
```

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

### Installation

Source: https://github.com/zeltjs/zelt/blob/main/website/docs/authentication/sessions.md

Install the necessary packages for session management.

```bash
pnpm add @zeltjs/auth-session @zeltjs/kv
```

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

### Installation

Source: https://github.com/zeltjs/zelt/blob/main/website/docs/getting-started/electron.mdx

Install the necessary ZeltJS packages and Electron.

```bash
pnpm add @zeltjs/core@0.6.1 @zeltjs/adapter-electron@0.6.1
pnpm add -D electron
```

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

### Installation

Source: https://github.com/zeltjs/zelt/blob/main/website/i18n/ja/docusaurus-plugin-content-docs/current/getting-started/cloudflare-workers.md

Install the necessary Zelt.js packages and development dependencies for Cloudflare Workers.

```bash
pnpm add @zeltjs/core @zeltjs/adapter-cloudflare-workers
pnpm add -D wrangler @cloudflare/workers-types
```

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

### Installation

Source: https://github.com/zeltjs/zelt/blob/main/website/docs/hono-client.md

Install the `@zeltjs/hono-client` package using pnpm.

```bash
pnpm add @zeltjs/hono-client
```

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

### Handling Binary Responses

Source: https://github.com/zeltjs/zelt/blob/main/website/docs/getting-started/lambda.mdx

Example showing how to return binary data, such as an image, from a controller. The adapter automatically base64 encodes it.

```typescript
// @noErrors
import { Controller, Get, response } from '@zeltjs/core';
// ---cut---
@Controller('/files')
export class FileController {
  @Get('/image')
  getImage() {
    const imageBuffer = new Uint8Array([/* ... */]);
    return response()
      .header('Content-Type', 'image/png')
      .body(imageBuffer);
  }
}
```

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

### Redirect Component

Source: https://github.com/zeltjs/zelt/blob/main/website/i18n/ja/docusaurus-plugin-content-docs/current/first-steps.md

This component redirects the user to the '/getting-started/node' path.

```javascript
import {Redirect} from '@docusaurus/router';

<Redirect to="/getting-started/node" />
```

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

### API Gateway Versions - REST API (v1)

Source: https://github.com/zeltjs/zelt/blob/main/website/docs/getting-started/lambda.mdx

Example handler configuration for API Gateway REST API (v1).

```typescript
// @noErrors
import { createApp, Controller, Get, pathParam } from '@zeltjs/core';
import { onLambda } from '@zeltjs/adapter-lambda';

@Controller('/hello')
class HelloController {
  @Get('/:name')
  greet(name = pathParam('name')) { return { message: `Hello, ${name}!` }; }
}

const app = createApp({ http: { controllers: [HelloController] } });
const lambdaApp = await onLambda(app);
// ---cut---
export const handler = lambdaApp.handlerV1;
```

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

### API Gateway Versions - HTTP API (v2) — Recommended

Source: https://github.com/zeltjs/zelt/blob/main/website/docs/getting-started/lambda.mdx

Example handler configuration for API Gateway HTTP API (v2).

```typescript
// @noErrors
import { createApp, Controller, Get, pathParam } from '@zeltjs/core';
import { onLambda } from '@zeltjs/adapter-lambda';

@Controller('/hello')
class HelloController {
  @Get('/:name')
  greet(name = pathParam('name')) { return { message: `Hello, ${name}!` }; }
}

const app = createApp({ http: { controllers: [HelloController] } });
const lambdaApp = await onLambda(app);
// ---cut---
export const handler = lambdaApp.handler;
```

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

### Accessing Secrets

Source: https://github.com/zeltjs/zelt/blob/main/website/i18n/ja/docusaurus-plugin-content-docs/current/getting-started/cloudflare-workers.md

Access secrets using EnvService in your services.

```typescript
import { Injectable, EnvService, inject } from '@zeltjs/core';

@Injectable()
class DatabaseService {
  constructor(private env = inject(EnvService)) {}
// ---cut---
  get connectionUrl() {
    return this.env.getString('DATABASE_URL', '');
  }
}
```

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

### Local Development

Source: https://github.com/zeltjs/zelt/blob/main/website/README.md

Starts a local development server for live previewing changes.

```bash
yarn start
```

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

### Usage

Source: https://github.com/zeltjs/zelt/blob/main/packages/kv/README.md

Example of using the MemoryKVAdaptor to set and get key-value pairs, including setting a Time-To-Live (TTL).

```typescript
import { MemoryKVAdaptor } from '@zeltjs/kv';
import type { KVStore } from '@zeltjs/kv';

const kv: KVStore = new MemoryKVAdaptor();

await kv.set('user:1', { name: 'Alice' });
const user = await kv.get('user:1');

await kv.set('session:abc', { userId: '1' }, { ttl: 3600 });

```

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

### Request Body - Text

Source: https://github.com/zeltjs/zelt/blob/main/website/i18n/ja/docusaurus-plugin-content-docs/current/primitives.md

Example of using body('text') to get the raw text body of a request.

```typescript
import { Controller, Post, body, response } from '@zeltjs/core';

@Controller('/upload')
export class UploadController {
  @Post('/text')
  async uploadText(res = response()) {
    const text = await body('text');
    return res.json({ received: text });
  }

  @Post('/json')
  async uploadJson(res = response()) {
    const data = await body('json');
    return res.json({ received: data });
  }

  @Post('/form')
  async uploadForm(res = response()) {
    const formData = await body('form');
    return res.json({ fields: Object.fromEntries(formData) });
  }
}
```

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

### Hello World: Initialize in Main Process

Source: https://github.com/zeltjs/zelt/blob/main/website/docs/getting-started/electron.mdx

Set up the Electron main process to handle Zelt API requests.

```typescript
// @noErrors
import { app as electronApp, BrowserWindow, protocol } from 'electron';
import { createApp, Controller, Get, pathParam } from '@zeltjs/core';
import { onElectron } from '@zeltjs/adapter-electron';

@Controller('/hello')
class HelloController {
  @Get('/:name')
  greet(name = pathParam('name')) { return { message: `Hello, ${name}!` }; }
}

const app = createApp({ http: { controllers: [HelloController] } });
// ---cut---
const electronZelt = await onElectron(app);

electronApp.whenReady().then(() => {
  protocol.handle('api', async (request) => {
    return electronZelt.fetch(request);
  });

  const win = new BrowserWindow({ width: 800, height: 600 });
  win.loadFile('index.html');
});

electronApp.on('window-all-closed', async () => {
  await electronZelt.shutdown();
  electronApp.quit();
});
```

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

### Quick Overview

Source: https://github.com/zeltjs/zelt/blob/main/website/docs/dependency-injection.md

Demonstrates basic dependency injection with @Injectable and inject.

```typescript
import { Injectable, inject } from '@zeltjs/core';
// ---cut---
@Injectable()
export class DatabaseService {
  query(sql: string) {
    // ...
  }
}

@Injectable()
export class UserRepository {
  constructor(private db = inject(DatabaseService)) {}

  findAll() {
    return this.db.query('SELECT * FROM users');
  }
}
```

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

### Configuring Warmup Option

Source: https://github.com/zeltjs/zelt/blob/main/website/i18n/ja/docusaurus-plugin-content-docs/current/getting-started/cloudflare-workers.md

Configure the warmup option for onCloudflareWorkers to control controller initialization.

```typescript
import { createApp, Controller, Get, pathParam } from '@zeltjs/core';
import { onCloudflareWorkers } from '@zeltjs/adapter-cloudflare-workers';

@Controller('/hello')
class HelloController {
  @Get('/:name')
  greet(name = pathParam('name')) { return { message: `Hello, ${name}!` }; }
}

const app = createApp({ http: { controllers: [HelloController] } });
// ---cut---
const workers = await onCloudflareWorkers(app, { warmup: true });

export default { fetch: workers.fetch };
```

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

### Build

Source: https://github.com/zeltjs/zelt/blob/main/website/README.md

Generates static content for deployment.

```bash
yarn build
```

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

### URL & Path

Source: https://github.com/zeltjs/zelt/blob/main/website/i18n/ja/docusaurus-plugin-content-docs/current/primitives.md

Example of using url, path, and method to get request URL, path, and HTTP method.

```typescript
import { Controller, Get, url, path, method, response } from '@zeltjs/core';

@Controller('/debug')
export class DebugController {
  @Get('/request')
  requestInfo(
    fullUrl = url(),
    requestPath = path(),
    httpMethod = method(),
    res = response(),
  ) {
    return res.json({
      url: fullUrl,      // "http://localhost:3000/debug/request?foo=bar"
      path: requestPath, // "/debug/request"
      method: httpMethod // "GET"
    });
  }
}
```

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

### Basic Setup

Source: https://github.com/zeltjs/zelt/blob/main/website/i18n/ja/docusaurus-plugin-content-docs/current/bullmq.md

A Zelt.js service to manage the Redis connection and expose the BullMQ client.

```typescript
import { Injectable, inject, Config, EnvConfig, LifecycleManager, type Lifecycle } from '@zeltjs/core';
import { Redis, type RedisOptions } from 'ioredis';
import { Queue, Worker, type Job } from 'bullmq';
// ---
@Config
class BullMQConfig {
  static readonly Token = BullMQConfig;

  constructor(private env = inject(EnvConfig)) {}

  get connection(): RedisOptions {
    return {
      host: this.env.get('REDIS_HOST') ?? 'localhost',
      port: Number(this.env.get('REDIS_PORT') ?? 6379),
    };
  }
}

@Injectable()
class BullMQService implements Lifecycle {
  readonly client: Redis;

  constructor(
    private config = inject(BullMQConfig),
    lifecycle = inject(LifecycleManager),
  ) {
    this.client = new Redis(this.config.connection);
    lifecycle.register(this);
  }

  async startup(): Promise<void> {}

  async shutdown(): Promise<void> {
    await this.client.quit();
  }
}
```

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

### Installation

Source: https://github.com/zeltjs/zelt/blob/main/packages/adapter-electron/README.md

Install the Electron adapter and core Zelt package using npm.

```bash
npm install @zeltjs/adapter-electron @zeltjs/core
```

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

### Verify Token and Get Payload

Source: https://github.com/zeltjs/zelt/blob/main/website/docs/authentication/jwt.md

Example of using JwtService.verify() to validate a token and retrieve its payload. It throws an error if the token is invalid or expired.

```typescript
import { Injectable, inject } from '@zeltjs/core';
import { JwtService } from '@zeltjs/auth-jwt';

@Injectable()
class TokenService {
  constructor(private jwtService = inject(JwtService)) {}
// ---cut---
  async validateToken(token: string) {
    try {
      const payload = await this.jwtService.verify(token);
      console.log(payload.sub);
      return payload;
    } catch {
      return null;
    }
  }
}
```

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

### Install @zeltjs/openapi and @valibot/to-json-schema with bun

Source: https://github.com/zeltjs/zelt/blob/main/website/docs/openapi.md

Installation command for @zeltjs/openapi and @valibot/to-json-schema using bun.

```bash
bun add @zeltjs/openapi @valibot/to-json-schema
```

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

### Installation

Source: https://github.com/zeltjs/zelt/blob/main/website/docs/eventbus.md

Install the @zeltjs/eventbus package. For Redis support, also install @zeltjs/redis and ioredis.

```bash
pnpm add @zeltjs/eventbus
```

```bash
pnpm add @zeltjs/eventbus @zeltjs/redis ioredis
```

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

### Basic Setup: BullMQConfig

Source: https://github.com/zeltjs/zelt/blob/main/website/docs/bullmq.md

Configuration service for BullMQ connection settings, reading from environment variables.

```typescript
import { Injectable, inject, Config, Env, LifecycleManager, type Lifecycle } from '@zeltjs/core';
import { Redis, type RedisOptions } from 'ioredis';
import { Queue, Worker, type Job } from 'bullmq';
// ---cut---
@Config
class BullMQConfig {
  static readonly Token = BullMQConfig;

  constructor(private env = inject(Env)) {}

  get connection(): RedisOptions {
    return {
      host: this.env.getString('REDIS_HOST', 'localhost'),
      port: this.env.getNumber('REDIS_PORT', 6379),
    };
  }
}
```

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

### Install @zeltjs/openapi with bun

Source: https://github.com/zeltjs/zelt/blob/main/website/docs/openapi.md

Installation command for @zeltjs/openapi using bun.

```bash
bun add @zeltjs/openapi
```

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

### Usage

Source: https://github.com/zeltjs/zelt/blob/main/packages/adapter-electron/README.md

Example of setting up a Zelt application with the Electron adapter.

```typescript
import { createApp, Controller, Get } from '@zeltjs/core';
import { onElectron } from '@zeltjs/adapter-electron';

@Controller('/api')
class ApiController {
  @Get('/status')
  status() {
    return { status: 'ok' };
  }
}

const app = createApp({
  http: { controllers: [ApiController] },
});

const electron = await onElectron(app);
```

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

### Installation

Source: https://github.com/zeltjs/zelt/blob/main/packages/validator-valibot/README.md

Install the validator-valibot package along with its dependencies.

```bash
npm install @zeltjs/validator-valibot valibot @zeltjs/core
```

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

### Hello World: Call API from Renderer

Source: https://github.com/zeltjs/zelt/blob/main/website/docs/getting-started/electron.mdx

Example of calling the Electron-hosted Zelt API from the renderer process.

```typescript
const response = await fetch('api://localhost/hello/world');
const data = await response.json();
console.log(data.message); // "Hello, world!"
```

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

### Installation

Source: https://github.com/zeltjs/zelt/blob/main/packages/rate-limit/README.md

Install the rate-limit package along with its dependencies.

```bash
npm install @zeltjs/rate-limit @zeltjs/kv @zeltjs/core
```

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

### Node.js Entry Point

Source: https://github.com/zeltjs/zelt/blob/main/website/docs/scheduler.md

Illustrates how to integrate and start the scheduler in a Node.js application using `@zeltjs/adapter-node`.

```typescript
import { onNode } from '@zeltjs/adapter-node';
import { createApp, Scheduled, Daily } from '@zeltjs/core';

@Scheduled() class MyScheduler { @Daily({ hour: 9 }) async task() {} }
const app = createApp({ http: { controllers: [] }, schedulers: [MyScheduler] });
// ---cut---
const nodeApp = await onNode(app);
const handle = await nodeApp.listen(3000);

// Start scheduled tasks
await nodeApp.startScheduler();

process.on('SIGTERM', async () => {
  await nodeApp.stopScheduler();
  await handle.shutdown();
});
```

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

### Installation

Source: https://github.com/zeltjs/zelt/blob/main/packages/redis/README.md

Install the Redis integration for Zelt applications.

```bash
npm install @zeltjs/redis @zeltjs/core
```

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

### Hello World: Create the Application

Source: https://github.com/zeltjs/zelt/blob/main/website/docs/getting-started/electron.mdx

Define a simple Zelt application with a 'Hello' controller.

```typescript
import { createApp, Controller, Get, pathParam } from '@zeltjs/core';
// ---cut---
@Controller('/hello')
class HelloController {
  @Get('/:name')
  greet(name = pathParam('name')) {
    return { message: `Hello, ${name}!` };
  }
}

export const app = createApp({
  http: {
    controllers: [HelloController],
  },
});
```
Tokens:
Raw