Decorators

import {  Controller,  Get,  Post,  Put,  Patch,  Delete,  Body,  Param,  Query,  Headers,  Injectable,  Use,  UseGuards,  UsePipes,  ParseIntPipe,  Cron,  Interval,  Cacheable,  Transactional} from 'exisjs/decorators'

import { Server } from 'exisjs/decorators'import type { App } from 'exisjs'
@Server({  providers: [['LOGGER_TOKEN', { useValue: console }]],  plugins: []})export default class RootServer {  async onStart(app: App) {    console.log('Server started')  }
  async onClose(app: App) {    console.log('Server stopping')  }}

import { Boundary } from 'exisjs/decorators'import type { Request, Response, Next, BoundaryContext } from 'exisjs/router'import { UnauthorizedError } from 'exisjs/error'
@Boundary({  cors: { origin: 'https://admin.example.com', credentials: true },  headers: { 'X-Admin-Api-Version': '2.0' },  exclude: ['/admin/health']})export default class AdminBoundary {  // Middleware handler identified by (req, res, next) signature  requireApiKey(req: Request, res: Response, next: Next) {    if (!req.headers['x-api-key']) {      throw new UnauthorizedError('Missing admin API key')    }    next()  }
  // Request wrapper identified by handle(ctx, next) signature  async handle(ctx: BoundaryContext, next: Next) {    const start = Date.now()    const result = await next()    ctx.res.setHeader('X-Response-Time', `${Date.now() - start}ms`)    return result  }}

import { Controller, Get, Post, Put, Patch, Delete } from 'exisjs/decorators'import { UserParamsSchema, CreateUserSchema } from './schema'
@Controller('/users')export default class UsersController {  @Get('/')  async listUsers() {    return { users: [] }  }
  @Get('/:id', UserParamsSchema)  async getUser() {    return { id: 1, name: 'Alice' }  }
  @Post('/', CreateUserSchema)  async createUser() {    return { success: true }  }
  @Delete('/:id')  async deleteUser() {    return { deleted: true }  }}

import {  Controller,  Post,  Body,  Param,  Query,  Headers,  Req,  Res,  Ip,  Session,  UploadedFile} from 'exisjs/decorators'import type { Request, Response, ExisFile } from 'exisjs'
@Controller('/users')export default class UsersController {  @Post('/:id/avatar')  async uploadAvatar(    @Param('id') id: string,    @Query('quality') quality: string,    @Body() metadata: any,    @Headers('authorization') token: string,    @UploadedFile() file: ExisFile,    @Ip() clientIp: string,    @Req() req: Request,    @Res({ passthrough: true }) res: Response  ) {    return { id, quality, metadata, clientIp, file: file?.filename }  }}

import { createParamDecorator } from 'exisjs/decorators'
export const CurrentUser = createParamDecorator((data: string | undefined, ctx) => {  return data ? ctx.req.user?.[data] : ctx.req.user})

import {  Controller,  Get,  Param,  Query,  UsePipes,  ParseIntPipe,  ParseFloatPipe,  ParseBoolPipe,  ParseUUIDPipe,  ParseArrayPipe,  ValidationPipe} from 'exisjs/decorators'
@Controller('/users')@UsePipes(new ValidationPipe({ transform: true }))export default class UsersController {  @Get('/:id')  async getUser(@Param('id', ParseIntPipe) id: number) {    return { id, isNumber: typeof id === 'number' }  }
  @Get('/filter')  async filter(    @Query('page', ParseIntPipe) page: number,    @Query('active', ParseBoolPipe) active: boolean,    @Query('tags', new ParseArrayPipe({ separator: ',' })) tags: string[]  ) {    return { page, active, tags }  }
  @Get('/uuid/:uuid')  async getByUuid(@Param('uuid', new ParseUUIDPipe({ version: '4' })) uuid: string) {    return { uuid }  }}

import {  Controller,  Post,  UseGuards,  UseInterceptors,  UseFilters,  RateLimit,  Timeout,  Idempotent,  Cors,  Compress,  Dedupe,  IpFilter,  BlockProbes} from 'exisjs/decorators'import { AuthGuard } from '../../common/guards/auth.guard'import { LoggingInterceptor } from '../../common/interceptors/logging'import { HttpExceptionFilter } from '../../common/filters/http.filter'
@Controller('/checkout')@UseGuards(AuthGuard)@UseInterceptors(LoggingInterceptor)@UseFilters(HttpExceptionFilter)@Cors({ origin: 'https://pay.example.com', credentials: true })@RateLimit({ max: 20, windowMs: 60000 })@IpFilter({ allow: ['10.0.0.0/8', '127.0.0.1'] })@BlockProbes()export default class CheckoutController {  @Post('/')  @Timeout(15000)  @Idempotent({ ttlMs: 86400000 })  @Dedupe({ keyGenerator: (req) => req.user?.id ?? req.ip })  @Compress()  async processPayment() {    return { status: 'processed' }  }}

import {  Controller,  Get,  Post,  Body,  UseGuards,  Roles,  Permissions,  Public} from 'exisjs/decorators'import { AuthGuard } from '../../common/guards/auth.guard'
@Controller('/roles')@UseGuards(AuthGuard)export default class RolesController {  @Get('/public')  @Public() // Instructs AuthGuard to skip credential verification  async getPublicInfo() {    return { status: 'open' }  }
  @Get('/')  @Roles('admin', 'security_officer')  async listRoles() {    return { roles: ['admin', 'manager', 'viewer'] }  }
  @Post('/')  @Permissions('roles:create', 'roles:write')  async createRole(@Body() body: any) {    return { created: true }  }}

import { Injectable, Cron, Interval, TimeoutTask } from 'exisjs/decorators'
@Injectable()export class CleanupService {  // Executes daily at midnight UTC with overlap protection  @Cron('0 0 * * *', { name: 'nightly-purge', timezone: 'UTC', preventOverlap: true })  async purgeOldSessions() {    console.log('Purging expired sessions')  }
  // Executes every 60 seconds  @Interval(60_000, { name: 'health-heartbeat' })  async pingHeartbeat() {    console.log('Heartbeat ping')  }
  // Executes once 5 seconds after server startup  @TimeoutTask(5_000, { name: 'cache-warmup' })  async warmupCaches() {    console.log('Caches warmed up')  }}

import {  Injectable,  Cacheable,  CacheEvict,  Transactional,  Profile,  type OnInit,  type OnDestroy} from 'exisjs/decorators'
@Injectable()export class OrderService implements OnInit, OnDestroy {  async onInit() {    console.log('OrderService initialized')  }
  async onDestroy() {    console.log('OrderService destroyed')  }
  // Caches result in memory for 300 seconds  @Cacheable({ ttl: 300, key: (id: string) => `order:${id}` })  @Profile({ thresholdMs: 50, warnSlow: true })  async getOrder(id: string) {    return this.db.query('SELECT * FROM orders WHERE id = $1', [id])  }
  // Executes inside a database transaction and evicts the cached key  @Transactional()  @CacheEvict({ key: (id: string) => `order:${id}` })  async updateOrder(id: string, data: any) {    return this.db.update('orders', id, data)  }}

import {  Controller,  Post,  Get,  HttpCode,  Header,  Redirect,  Hosts,  Returns} from 'exisjs/decorators'import { ItemResponseSchema } from './schema'
@Controller('/items')@Hosts('api.example.com', 'internal.example.com')export default class ItemsController {  @Post('/')  @HttpCode(201)  @Header('X-Resource-Version', '1.0')  @Returns(ItemResponseSchema)  async create() {    return { created: true }  }
  @Get('/legacy')  @Redirect('/items', 301)  async legacyRedirect() {}}

import {  Controller,  Get,  ApiTags,  ApiOperation,  ApiResponse,  ApiBearerAuth,  ApiSecurity,  ApiExclude,  ApiProperty} from 'exisjs/decorators'
export class UserDto {  @ApiProperty({ description: 'User ID', example: 'usr_123', required: true })  id: string
  @ApiProperty({ description: 'Full name', example: 'Alice Smith' })  name: string}
@ApiTags('Users')@ApiBearerAuth()@Controller('/users')export default class UsersController {  @Get('/:id')  @ApiOperation({ summary: 'Get User By ID', description: 'Returns a user record' })  @ApiResponse({ status: 200, description: 'User retrieved successfully' })  @ApiResponse({ status: 404, description: 'User not found' })  async getUser() {    return { id: 'usr_123', name: 'Alice Smith' }  }
  @Get('/internal/health')  @ApiExclude()  async health() {    return { ok: true }  }}

import { Injectable } from 'exisjs/decorators'
@Injectable({ scope: 'singleton' }) // 'singleton' | 'transient' | 'request'export class UserService {  async findOne(id: string) {    return { id, name: 'Alice' }  }}

import { Controller, Get, Param } from 'exisjs/decorators'import { Inject, Optional } from 'exisjs/di'import { UserService } from './service'
@Controller('/users')export default class UsersController {  constructor(    @Inject(UserService) private userService: UserService,    @Inject('DATABASE_URL') private dbUrl: string,    @Optional() @Inject('ANALYTICS_SERVICE') private analytics?: any  ) {}
  @Get('/:id')  async getUser(@Param('id') id: string) {    return this.userService.findOne(id)  }}

import { Module, Global } from 'exisjs/decorators'import UsersController from './route'import { UserService } from './service'
@Global()@Module({  controllers: [UsersController],  providers: [UserService],  exports: [UserService]})export class UsersModule {}

import { Decorate, BindParam, Controller, Get, Post, Body, Param } from 'exisjs/decorators'
class UsersController {  list() {    return []  }
  create(body) {    return { created: body.name }  }}
export default Decorate(  UsersController,  [Controller('/users')],  {    list: [Get('/')],    create: [      Post('/'),      BindParam(0, Body()) // Injects @Body() into the first argument (index 0)    ]  })