Coming from NestJS

effx bridges enterprise frameworks and full-stack Effect. You write a familiar declarative surface (decorators or builder chains). The compiler reads it ahead of time and writes ordinary Effect that you can read, edit or keep. This page maps NestJS concepts onto that surface and says, row by row, what exists today (ADR 0012).

Pinned versions. NestJS claims cite docs.nestjs.com. As fetched on 2026-10-04 that site documents NestJS 12 (its migration guide covers "version 11 to version 12"). Effect claims cite the official clone at https://github.com/Effect-TS/effect/tree/b5a2d4c1d62c9620a68d72b7f20248c69ef7663b (commit b5a2d4c, package effect 4.0.0). effx claims cite a spec or a source path in this repository.

Read this first: what a decorator meansCopy Anchor Link

Concept mapCopy Anchor Link

HTTP surfaceCopy Anchor Link

Security and errorsCopy Anchor Link

Contracts and toolingCopy Anchor Link

InfrastructureCopy Anchor Link

Gaps todayCopy Anchor Link

effx has no declaration or generator for the items below. Where an Effect package exists, you use it directly in handlers and layers, and it coexists with generated code (ADR 0012: "Raw Effect always coexists").

• Authorization runtime. @Authorize and @Http.Access record facts. Cedar decisions and leases are deferred (ADR 0007). The compiler checks that a guard binding is present, not that the handler calls it (spec 0006). Enforcement evidence exists only in mono-web's unlanded browser and PostgreSQL journeys (STATE.md).
• Domain error to Problem conversion. The generated handler is an ordinary Effect handler. The conversion is hand-written until a runtime mapping contract exists (spec 0005).
• Persistence. Spec 0008 is proposed, not frozen. @PersistentModel records metadata only.
• Jobs, queues and scheduling. No annotation, no generator, no spec.
• Caching. No annotation and no per-route cache declaration.
• Realtime. No WebSocket or SSE annotation. Generated RPC is HTTP only.
• Configuration, logging, tracing, health checks. No annotation. Use Config, Logger, Tracer and ordinary endpoints.
• Testing harness. No module-override equivalent. Tests provide Layers directly.
• Scaffolding. No nest g equivalent. The CLI has check, build, inspect and graph.
• Global interceptors and filters. There is no app-wide declaration. Attach a marker with Http.Contract.middleware or a group's defaults.middleware, or use Effect HttpMiddleware.
• Query is a claim, not a proof. @Query does not stop a handler from writing. The analysis that would flag it is not implemented (ADR 0006).
• Distribution. The packages are not published to a registry. You run effx from the monorepo (Getting started).

Port: PATCH /users/:id/emailCopy Anchor Link

The endpoint under port:

• PATCH /users/:id/email with body { "email": "..." }.
• Only the signed-in user may change their own email (a guard).
• The email must be non-empty (validation).
• Problem-style responses: 404 when the user does not exist, 409 when the email belongs to another user.

NestJS code cites the pages named in each block. The effx tab uses the real files under examples/users/src where they match, and labelled pasted snippets where it extends them.

import { IsNotEmpty } from 'class-validator';

export class ChangeEmailDto {
  @IsNotEmpty()
  email: string;
}

app.useGlobalPipes(new ValidationPipe());

import { HttpException, HttpStatus } from '@nestjs/common';

export class UserProblem extends HttpException {
  constructor(
    readonly code: string,
    title: string,
    status: HttpStatus,
  ) {
    super(title, status);
  }
}

import { CanActivate, ExecutionContext, Injectable } from '@nestjs/common';

@Injectable()
export class OwnerGuard implements CanActivate {
  canActivate(context: ExecutionContext): boolean {
    const request = context.switchToHttp().getRequest();
    // verifyToken stands for your authentication, as validateRequest() does in the Guards chapter.
    const caller = verifyToken(request.headers.authorization);

    return caller !== undefined && caller.userId === request.params.id;
  }
}

import { ArgumentsHost, Catch, ExceptionFilter, HttpException } from '@nestjs/common';
import { Request, Response } from 'express';
import { UserProblem } from './user-problem.exception';

@Catch(HttpException)
export class ProblemFilter implements ExceptionFilter {
  catch(exception: HttpException, host: ArgumentsHost) {
    const ctx = host.switchToHttp();
    const response = ctx.getResponse<Response>();
    const request = ctx.getRequest<Request>();
    const status = exception.getStatus();

    response.status(status).json({
      code: exception instanceof UserProblem ? exception.code : undefined,
      title: exception.message,
      status,
      instance: request.url,
    });
  }
}

import { Body, Controller, Param, Patch, UseFilters, UseGuards } from '@nestjs/common';

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

  @Patch(':id/email')
  @UseGuards(OwnerGuard)
  changeEmail(@Param('id') id: string, @Body() dto: ChangeEmailDto) {
    return this.users.setEmail(id, dto.email);
  }
}

@Injectable()
export class UsersService {
  private readonly users = new Map<string, { id: string; email: string; displayName: string }>([
    ['1', { id: '1', email: 'alice@example.com', displayName: 'Alice' }],
    ['2', { id: '2', email: 'bob@example.com', displayName: 'Bob' }],
  ]);

  setEmail(id: string, email: string) {
    const user = this.users.get(id);

    if (user === undefined) {
      throw new UserProblem('user.not-found', 'User not found', HttpStatus.NOT_FOUND);
    }

    for (const [otherId, other] of this.users) {
      if (otherId !== id && other.email === email) {
        throw new UserProblem('user.email-taken', 'Email already in use', HttpStatus.CONFLICT);
      }
    }

    const updated = { ...user, email };
    this.users.set(id, updated);

    return updated;
  }
}

What the port preservesCopy Anchor Link

What it does not preserveCopy Anchor Link

• effx declares an access contract. It does not evaluate it. Http.Access is data (credentials, principal kinds, capability, requirements, scope resolver, decision time). Your guard record decides, and your handler chooses when to call authorize(). A typed binding is not proof that the handler called it (spec 0006). The ownership check above is application code.
• Order differs. In Nest a guard runs before pipes (Guards), so a non-owner with an invalid body gets 403. In effx the request is decoded before the handler runs (HttpApiBuilder.ts:866-883) and authorize() runs inside the handler, so the same request gets the decode failure first. Credential rejection by the UserSecurity marker's Layer is a separate step, and its order relative to decoding was not examined.
• Validation errors are not problem-style by default. Nest's ValidationPipe returns 400 with messages (Validation), and the filter above reshapes it. A decode failure in Effect HttpApi is an HttpApiSchemaError, which responds as an empty 400 (packages/effect/src/http-api/HttpApiError.ts:470-471). You can map it with HttpApiMiddleware.layerSchemaErrorTransform (HttpApiMiddleware.ts:489). effx generates no such mapping.
• No catch-all filter. The NestJS filter shapes every HttpException. In effx, only errors declared on an operation have a response schema. An error outside E is a defect.
• The problem body is whatever your registry returns. Here it is the encoded UserNotFound or EmailTaken (a _tag and its fields), not a Problem Details document. A registry can return { code, title } schemas instead (ai-docs/src/04_problems-and-access/fixtures/settings.ts), but then converting the domain error to that body is hand-written (spec 0005).
• The service is Effect, not a provider. Users is a Context.Service with an in-memory Layer (examples/users/src/services.ts), not a persistence layer. UsersService in the NestJS tab is in-memory too, so the comparison covers the endpoint, not storage (spec 0008 is proposed).
• The authorize thunk is a handler parameter. In NestJS the guard never appears in the handler's signature. In effx it does, which is how the requirement stays visible in types.
• Generated code stays readable. The two generated excerpts above are real compiler output, ordinary HttpApi code. See Generated code.

Where to go nextCopy Anchor Link