What is effx

// DTO validated by class-validator (ValidationPipe is registered with app.useGlobalPipes)
export class ChangeEmailDto {
  @IsEmail()
  email: string;
}

// Guard: canActivate returns a boolean (a false result becomes a ForbiddenException)
@Injectable()
export class ChangeEmailGuard implements CanActivate {
  canActivate(context: ExecutionContext): boolean {
    const request = context.switchToHttp().getRequest();
    return request.user?.id === request.params.id;
  }
}

@Controller("users")
export class UsersController {
  constructor(private readonly users: UsersService) {}

  @Patch(":id/email")
  @UseGuards(ChangeEmailGuard)
  async changeEmail(@Param("id") id: string, @Body() dto: ChangeEmailDto) {
    const user = await this.users.setEmail(id, dto.email);

    if (user === undefined) throw new NotFoundException(`User ${id} not found`);

    return user;
  }
}

import { Authorize, Cli, Command, Errors, Http, Query, Requirements, Rpc } from "@effx/runtime";
import { Effect } from "effect";
import { ChangeEmail, Read } from "./capabilities.ts";
import { ChangeEmailInput, EmailTaken, GetUserInput, UserNotFound } from "./schemas.ts";
import { Users } from "./services.ts";
import { User } from "./user.ts";

export class UserOperations {
  @Query({ name: "User.Get", input: GetUserInput, success: User.Public })
  @Http.Get("/users/:id")
  @Rpc("User.Get")
  @Cli("users get")
  @Authorize(Read)
  static get(input: typeof GetUserInput.Type) {
    return Effect.gen(function* () {
      const users = yield* Users;
      const user = yield* users.find(input.id);

      return { id: user.id, displayName: user.displayName };
    });
  }

  @Command({ name: "User.ChangeEmail", input: ChangeEmailInput, success: User.Self })
  @Http.Patch("/users/:id/email")
  @Rpc("User.ChangeEmail")
  @Cli("users change-email")
  @Authorize(ChangeEmail)
  @Errors(UserNotFound, EmailTaken)
  @Requirements(Users)
  static changeEmail(input: typeof ChangeEmailInput.Type) {
    return Effect.gen(function* () {
      const users = yield* Users;

      return yield* users.setEmail(input.id, input.email);
    });
  }
}

export class HttpOperations extends HttpApiGroup.make("operations").add(
  HttpApiEndpoint.patch("User.ChangeEmail", "/users/:id/email", {
  params: { id: Schema.String },
  payload: ChangeEmailInput,
  success: User.Self,
  error: Schema.Union([EmailTaken, UserNotFound]),
}),
  // HttpApiEndpoint.get("User.Get", ...) omitted
) {}

export class Api extends HttpApi.make("effx").add(HttpOperations) {}

export const ApiHandlers = HttpApiBuilder.group(
  Api,
  "operations",
  Effect.fn(function* (handlers) {
    return handlers.handleAll({
      "User.ChangeEmail": ({ params, payload }) => UserOperations.changeEmail({ ...params, ...payload }),
      // "User.Get" omitted
    });
  }),
);

// Generated by effx. Do not edit.
// Source: ../../src/operations.client-foldkit#ClientFoldkitProfileOperations.read, ../../src/operations.client-foldkit#ClientFoldkitProfileOperations.update
// IR: operation:Profile.Read, operation:Profile.Update

import { Effect } from "effect";
import { HttpServerRequest } from "effect/http";
import { ClientFoldkitProfileOperations } from "../../src/operations.client-foldkit.ts";

type GuardEffect<Callback> = Callback extends () => Effect.Effect<infer Principal, infer Problem, infer Requirements>
  ? Effect.Effect<Principal, Problem, Requirements> : never;

export type ProfileGuards = {
  readonly "read": (request: HttpServerRequest.HttpServerRequest) => GuardEffect<Parameters<typeof ClientFoldkitProfileOperations.read>[1]>;
  readonly "update": (request: HttpServerRequest.HttpServerRequest) => GuardEffect<Parameters<typeof ClientFoldkitProfileOperations.update>[1]>;
};

export type AppGuards = {
  readonly "effx/profile": ProfileGuards;
};

 source        decorators  @Query @Http.Get ...      packages/runtime  (syntax only)
 (.ts)         builder     Operation.query(...)...
   │
   │  frontend: TypeScript compiler API              packages/frontend-ts
   ▼
 Collected     declarations + annotations (same shape from both syntaxes)
   │
   │  interpret: Extension.interpreters              packages/compiler
   ▼
 IR            ApplicationIR = nodes + edges         packages/ir
   │            (normalized, Schema-defined)
   │  analyses: Analysis(ir, index) → Diagnostic[]   errors stop generation
   ▼
 generators    Generator(ir, index, ctx) → GeneratedFile[]
   │
   ▼
 .effx/generated/*.ts   ordinary Effect
 .effx/ir.json          canonical IR
 .effx/manifest.json    hash, locations, diagnostics