Documentación de xTaskjs

Catálogo

Grupos de decoradores por caso de uso

Grupo de decoradores

Routing HTTP y canalizaciones

Decoradores de declaración de rutas y canalización de peticiones exportados por @xtaskjs/common. Son los bloques básicos HTTP usados por los controladores en todos los ejemplos.

13 decoradores

Grupo de decoradores

Runners y eventos del ciclo de vida

Decoradores de ciclo de vida de @xtaskjs/common usados para ejecutar lógica de arranque, tareas CLI y handlers de eventos dentro del ciclo de vida de la aplicación.

3 decoradores

Grupo de decoradores

DI y componentes de core

Decoradores de inyección de dependencias y componentes de @xtaskjs/core. Marcan providers para el descubrimiento del contenedor y seleccionan bindings con nombre para la inyección.

8 decoradores

Grupo de decoradores

Security y autorización

Decoradores de autenticación, autorización, estrategias e inyección exportados por @xtaskjs/security. Se apoyan en la metadata de rutas de @xtaskjs/common.

10 decoradores

Grupo de decoradores

Persistencia y repositorios

Decoradores de registro e inyección de TypeORM exportados por @xtaskjs/typeorm. Vinculan datasources y repositorios dentro del mismo contenedor DI.

5 decoradores

Grupo de decoradores

CQRS Buses, Handlers, And Projections

CQRS configuration, handler, projection, idempotency, and injector decorators exported by @xtaskjs/cqrs. These connect command, query, and event flows to the xtaskjs container and read or write datasource aliases.

16 decoradores

Grupo de decoradores

Event Sourcing And Stored Events

Configuration, aggregate, subscriber, and injector decorators exported by @xtaskjs/event-source. These wire aggregate metadata, event appliers, repositories, and stored-event subscribers into the xtaskjs lifecycle.

9 decoradores

Grupo de decoradores

Plantillas y entrega de mailer

Decoradores de mailer exportados por @xtaskjs/mailer. Registran transports y plantillas e inyectan servicios de entrega en clases gestionadas por DI.

5 decoradores

Grupo de decoradores

Internationalization y resolución de locale

Decoradores de configuración e inyección exportados por @xtaskjs/internationalization. Registran el comportamiento de locale y exponen servicios de traducción dentro de clases gestionadas por DI.

7 decoradores

Grupo de decoradores

Value objects y transformación de DTO

Decoradores orientados a DTO de @xtaskjs/value-objects que convierten campos crudos de la petición en envoltorios de dominio normalizados antes de que los consuman controladores y servicios.

1 decoradores

Grupo de decoradores

Cache Models And Runtime Control

Configuration, model, injector, and method decorators from @xtaskjs/cache used to register cache models, inject repositories or services, and control read/write cache behavior in DI-managed services.

9 decoradores

Grupo de decoradores

HTTP And Browser Cache Policies

HTTP response decorators from @xtaskjs/cache used to apply Cache-Control directives, validators, and Vary behavior to routes, plus injector access to HttpCacheService.

7 decoradores

Grupo de decoradores

Trabajos scheduler y ciclo de vida

Decoradores de scheduling de @xtaskjs/scheduler usados para declarar trabajos cron, interval y timeout e inyectar servicios scheduler en tiempo de ejecución.

5 decoradores

Grupo de decoradores

Throttling And Rate Limits

Rate-limiting decorators from @xtaskjs/throttler used to protect routes and inject runtime throttling services.

3 decoradores

Grupo de decoradores

Gateways realtime de Socket.IO

Decoradores de gateway, eventos e inyección exportados por @xtaskjs/socket-io. Mantienen los handlers realtime dentro de servicios xtaskjs normales y conectan namespaces de Socket.IO al contenedor DI.

8 decoradores

Grupo de decoradores

Colas y mensajería

Decoradores de consumo, publicación e inyección de colas exportados por @xtaskjs/queues. Conectan transports de broker y colas en memoria con servicios gestionados por DI.

7 decoradores

Grupo de decoradores

Routing HTTP y canalizaciones

Decoradores de declaración de rutas y canalización de peticiones exportados por @xtaskjs/common. Son los bloques básicos HTTP usados por los controladores en todos los ejemplos.

@xtaskjs/common Decorador de clase clase

Controller

Define la ruta base de un controlador HTTP y puede adjuntar middlewares, guards y pipes compartidos.

Prefijo de ruta en un controlador

import { Controller, Get } from "@xtaskjs/common";

@Controller("/users")
export class UsersController {
  @Get("/")
  list() {
    return [];
  }
}

@xtaskjs/common Decorador de método método

Get

Registra un handler de ruta GET y opcionalmente añade middleware, guards o pipes específicos de la ruta.

Ruta GET

import { Controller, Get } from "@xtaskjs/common";

@Controller("/health")
export class HealthController {
  @Get("/")
  status() {
    return { ok: true };
  }
}

@xtaskjs/common Decorador de método método

Post

Registra un handler de ruta POST para comandos, envíos de formularios o creación de recursos.

Ruta POST

import { Controller, Post } from "@xtaskjs/common";

@Controller("/users")
export class UsersController {
  @Post("/")
  create(req: any) {
    return { email: req.body.email, created: true };
  }
}

@xtaskjs/common Decorador de método método

Patch

Registra un handler de ruta PATCH para actualizaciones parciales.

Ruta PATCH

import { Controller, Patch } from "@xtaskjs/common";

@Controller("/users")
export class UsersController {
  @Patch("/:id")
  update(req: any) {
    return { id: req.params.id, updated: true };
  }
}

@xtaskjs/common Decorador de método método

Delete

Registra un handler de ruta DELETE para eliminaciones y operaciones destructivas.

Ruta DELETE

import { Controller, Delete } from "@xtaskjs/common";

@Controller("/users")
export class UsersController {
  @Delete("/:id")
  remove(req: any) {
    return { id: req.params.id, removed: true };
  }
}

@xtaskjs/common Decorador de parámetro method parameter

Body

Binds request body data to a controller parameter and supports DTO transformation when validation pipes are enabled.

Read body payload

import { Body, Controller, Post } from "@xtaskjs/common";

class CreateUserDto {
  email!: string;
}

@Controller("/users")
export class UsersController {
  @Post("/")
  create(@Body() body: CreateUserDto) {
    return body;
  }
}

@xtaskjs/common Decorador de parámetro method parameter

Param

Extracts route parameters by name or as a full params object for typed handler input.

Read route params

import { Controller, Get, Param } from "@xtaskjs/common";

@Controller("/users")
export class UsersController {
  @Get("/:id")
  detail(@Param("id") id: string) {
    return { id };
  }
}

@xtaskjs/common Decorador de parámetro method parameter

Query

Maps query-string values to a method parameter, optionally by property name.

Read query-string filters

import { Controller, Get, Query } from "@xtaskjs/common";

@Controller("/users")
export class UsersController {
  @Get("/")
  list(@Query("role") role?: string) {
    return { role };
  }
}

@xtaskjs/common Decorador de parámetro method parameter

Req

Injects the adapter request object into a controller handler parameter.

Access request object

import { Controller, Get, Req } from "@xtaskjs/common";

@Controller("/auth")
export class AuthController {
  @Get("/me")
  me(@Req() req: any) {
    return { auth: req.auth };
  }
}

@xtaskjs/common Decorador de parámetro method parameter

Res

Injects the adapter response object into a controller handler parameter.

Access response object

import { Controller, Get, Res } from "@xtaskjs/common";

@Controller("/health")
export class HealthController {
  @Get("/")
  status(@Res() res: any) {
    return { statusCode: res.statusCode || 200 };
  }
}

@xtaskjs/common Decorador de clase y método clase o método

UseMiddlewares

Añade uno o más middlewares a un controlador o ruta para que la lógica transversal se ejecute antes del handler.

Middleware a nivel de clase

import { Controller, Get, UseMiddlewares } from "@xtaskjs/common";

const requestLogger = async (_context: any, next: () => Promise<void>) => {
  await next();
};

@Controller("/audit")
@UseMiddlewares(requestLogger)
export class AuditController {
  @Get("/")
  list() {
    return { ok: true };
  }
}

@xtaskjs/common Decorador de clase y método clase o método

UseGuards

Adjunta funciones guard a un controlador o ruta para permitir, denegar o enriquecer el contexto de la petición antes de la ejecución.

Guard a nivel de ruta

import { Controller, Get, UseGuards } from "@xtaskjs/common";

const adminGuard = (context: any) => context.request?.headers?.["x-role"] === "admin";

@Controller("/admin")
export class AdminController {
  @Get("/")
  @UseGuards(adminGuard)
  dashboard() {
    return { secure: true };
  }
}

@xtaskjs/common Decorador de clase y método clase o método

UsePipes

Aplica funciones de transformación o validación de argumentos antes de que un handler de ruta consuma la entrada.

Limpieza del payload mediante pipes

import { Controller, Post, UsePipes } from "@xtaskjs/common";

const trimEmailPipe = (value: any) => ({ ...value, email: String(value.email || "").trim() });

@Controller("/accounts")
export class AccountController {
  @Post("/")
  @UsePipes(trimEmailPipe)
  create(req: any) {
    return req.body;
  }
}

Grupo de decoradores

Runners y eventos del ciclo de vida

Decoradores de ciclo de vida de @xtaskjs/common usados para ejecutar lógica de arranque, tareas CLI y handlers de eventos dentro del ciclo de vida de la aplicación.

@xtaskjs/common Decorador de método método

OnEvent

Registra un handler de evento del ciclo de vida para una fase dada y una prioridad de ejecución.

Listener de fase del ciclo de vida

import { OnEvent } from "@xtaskjs/common";

export class AuditListener {
  @OnEvent("AFTER_CONTROLLER_HANDLER", 10)
  afterHandler() {
    console.log("controller completed");
  }
}

@xtaskjs/common Decorador de método método

ApplicationRunner

Ejecuta un método durante el arranque de la aplicación con un orden de prioridad opcional.

Siembra de arranque

import { ApplicationRunner } from "@xtaskjs/common";
import { Service } from "@xtaskjs/core";

@Service()
export class SeedRunner {
  @ApplicationRunner(100)
  async seed() {
    console.log("seeding application data");
  }
}

@xtaskjs/common Decorador de método método

CommandLineRunner

Marca un método como runner de línea de comandos para que pueda ejecutarse en flujos orientados a CLI.

Tarea CLI

import { CommandLineRunner } from "@xtaskjs/common";
import { Service } from "@xtaskjs/core";

@Service()
export class ReportsRunner {
  @CommandLineRunner(0)
  async generate() {
    console.log("generating reports");
  }
}

Grupo de decoradores

DI y componentes de core

Decoradores de inyección de dependencias y componentes de @xtaskjs/core. Marcan providers para el descubrimiento del contenedor y seleccionan bindings con nombre para la inyección.

@xtaskjs/core Decorador de clase clase

Component

Decorador de componente de bajo nivel que almacena metadata de DI como alcance, condición, nombre y selección primaria.

Metadata personalizada de componente

import { Component } from "@xtaskjs/core";

@Component({ scope: "singleton", name: "clock" })
export class ClockService {}

@xtaskjs/core Decorador de clase clase

Service

Estereotipo de conveniencia para registrar una clase como componente de servicio gestionado por DI.

Estereotipo de servicio

import { Service } from "@xtaskjs/core";

@Service()
export class BillingService {}

@xtaskjs/core Decorador de clase clase

Controller

Registra una clase como componente controlador en el contenedor DI. Es independiente del decorador de rutas HTTP exportado por @xtaskjs/common.

Estereotipo DI de controlador

import { Controller } from "@xtaskjs/core";

@Controller({ name: "admin-controller" })
export class AdminComponent {}

@xtaskjs/core Decorador de clase clase

Repository

Estereotipo de conveniencia para providers tipo repositorio gestionados por el contenedor DI.

Estereotipo de repositorio

import { Repository } from "@xtaskjs/core";

@Repository()
export class UserLookupRepository {}

@xtaskjs/core Decorador de propiedad propiedad

AutoWired / Autowired

Inyecta una dependencia en una propiedad. El paquete también exporta Autowired como alias de AutoWired.

Inyección de propiedades

import { AutoWired } from "@xtaskjs/core";
import { UserService } from "./user.service";

export class AccountController {
  @AutoWired({ qualifier: UserService.name })
  private readonly users!: UserService;
}

@xtaskjs/core Decorador de parámetro parámetro del constructor

Qualifier

Selecciona un binding con nombre para la inyección en parámetros del constructor cuando varias implementaciones comparten el mismo tipo.

Inyección nombrada en constructor

import { Qualifier, Service } from "@xtaskjs/core";

@Service()
export class NotificationService {
  constructor(@Qualifier("mailer:notifications") private readonly transport: any) {}
}

@xtaskjs/core Decorador de método método

PostConstruct

Marks a method to run after dependency injection completes for the instance.

Run setup after injection

import { PostConstruct, Service } from "@xtaskjs/core";

@Service()
export class BootstrapService {
  @PostConstruct()
  init() {
    console.log("initialized");
  }
}

@xtaskjs/core Decorador de método método

PreDestroy

Marks a method to run when the container destroys managed instances during shutdown.

Release resources on shutdown

import { PreDestroy, Service } from "@xtaskjs/core";

@Service()
export class WorkerService {
  @PreDestroy()
  stop() {
    console.log("stopping");
  }
}

Grupo de decoradores

Security y autorización

Decoradores de autenticación, autorización, estrategias e inyección exportados por @xtaskjs/security. Se apoyan en la metadata de rutas de @xtaskjs/common.

@xtaskjs/security Decorador de clase y método clase o método

Authenticated

Requiere un resultado de autenticación satisfactorio antes de que se ejecute un controlador o una ruta. Puede apuntar a una estrategia concreta o a una lista de estrategias.

Proteger un controlador

import { Controller, Get } from "@xtaskjs/common";
import { Authenticated } from "@xtaskjs/security";

@Controller("/me")
@Authenticated()
export class ProfileController {
  @Get("/")
  profile(req: any) {
    return req.user;
  }
}

@xtaskjs/security Decorador de clase y método clase o método

Auth

Alias de Authenticated para proyectos que prefieren un nombre de decorador más corto.

Alias de Authenticated

import { Auth } from "@xtaskjs/security";

@Auth(["default", "encrypted"])
export class SecureAreaController {}

@xtaskjs/security Decorador de clase y método clase o método

Roles

Aplica requisitos de autorización por roles a una ruta ya autenticada.

Endpoint restringido por rol

import { Controller, Get } from "@xtaskjs/common";
import { Authenticated, Roles } from "@xtaskjs/security";

@Controller("/admin")
@Authenticated()
export class AdminController {
  @Get("/")
  @Roles("admin")
  dashboard() {
    return { secure: true };
  }
}

@xtaskjs/security Decorador de clase y método clase o método

AllowAnonymous

Marca una ruta como accesible públicamente incluso cuando el controlador circundante está autenticado por defecto.

Comprobación de salud pública

import { Controller, Get } from "@xtaskjs/common";
import { AllowAnonymous, Authenticated } from "@xtaskjs/security";

@Controller("/admin")
@Authenticated()
export class AdminController {
  @Get("/health")
  @AllowAnonymous()
  health() {
    return { ok: true };
  }
}

@xtaskjs/security Decorador de clase clase

JwtSecurityStrategy

Forma decorador de registerJwtStrategy() para registrar una definición de estrategia JWT durante la carga del módulo.

Estrategia JWT basada en decorador

import { JwtSecurityStrategy } from "@xtaskjs/security";

@JwtSecurityStrategy({
  name: "default",
  default: true,
  secretOrKey: process.env.JWT_SECRET,
})
export class DefaultJwtStrategy {}

@xtaskjs/security Decorador de clase clase

JweSecurityStrategy

Forma decorador de registerJweStrategy() para flujos de token cifrados.

Estrategia JWE basada en decorador

import { JweSecurityStrategy } from "@xtaskjs/security";

@JweSecurityStrategy({
  name: "encrypted",
  decryptionKey: process.env.JWE_SECRET || "secret",
})
export class EncryptedStrategy {}

@xtaskjs/security Decorador de parámetro y propiedad parámetro del constructor o propiedad

InjectAuthenticationService

Inyecta el SecurityAuthenticationService registrado por el gestor del ciclo de vida de security.

Inyectar servicio de autenticación

import { Service } from "@xtaskjs/core";
import { InjectAuthenticationService, SecurityAuthenticationService } from "@xtaskjs/security";

@Service()
export class SessionAuditService {
  constructor(
    @InjectAuthenticationService()
    private readonly authentication: SecurityAuthenticationService
  ) {}
}

@xtaskjs/security Decorador de parámetro y propiedad parámetro del constructor o propiedad

InjectAuthorizationService

Inyecta el SecurityAuthorizationService usado para decisiones de roles y permisos.

Inyectar servicio de autorización

import { Service } from "@xtaskjs/core";
import { InjectAuthorizationService, SecurityAuthorizationService } from "@xtaskjs/security";

@Service()
export class PolicyService {
  constructor(
    @InjectAuthorizationService()
    private readonly authorization: SecurityAuthorizationService
  ) {}
}

@xtaskjs/security Decorador de parámetro y propiedad parámetro del constructor o propiedad

InjectPassport

Inyecta la instancia de Passport configurada y gestionada por xtaskjs security.

Inyectar Passport

import { Service } from "@xtaskjs/core";
import { InjectPassport } from "@xtaskjs/security";

@Service()
export class PassportInspector {
  constructor(@InjectPassport() private readonly passport: any) {}
}

@xtaskjs/security Decorador de parámetro y propiedad parámetro del constructor o propiedad

InjectSecurityLifecycleManager

Inyecta el SecurityLifecycleManager para que los servicios avanzados puedan inspeccionar estrategias o el cableado del estado de autenticación.

Inyectar gestor del ciclo de vida

import { Service } from "@xtaskjs/core";
import { InjectSecurityLifecycleManager } from "@xtaskjs/security";

@Service()
export class SecurityDiagnosticsService {
  constructor(@InjectSecurityLifecycleManager() private readonly lifecycle: any) {}
}

Grupo de decoradores

Persistencia y repositorios

Decoradores de registro e inyección de TypeORM exportados por @xtaskjs/typeorm. Vinculan datasources y repositorios dentro del mismo contenedor DI.

@xtaskjs/typeorm Decorador de clase clase

TypeOrmDataSource

Registra una definición de datasource de TypeORM para la gestión del arranque y apagado de xtask.

Registrar un datasource

import { TypeOrmDataSource } from "@xtaskjs/typeorm";
import { UserEntity } from "./user.entity";

@TypeOrmDataSource({
  name: "default",
  type: "sqlite",
  database: "app.sqlite",
  entities: [UserEntity],
  synchronize: true,
})
export class DatabaseConfig {}

@xtaskjs/typeorm Decorador de parámetro y propiedad parámetro del constructor o propiedad

InjectDataSource

Inyecta una instancia de datasource con nombre gestionada por la integración TypeORM de xtaskjs.

Inyectar el datasource por defecto

import { Service } from "@xtaskjs/core";
import { DataSource, InjectDataSource } from "@xtaskjs/typeorm";

@Service()
export class HealthQueryService {
  constructor(@InjectDataSource() private readonly dataSource: DataSource) {}
}

@xtaskjs/typeorm Decorador de parámetro y propiedad parámetro del constructor o propiedad

InjectRepository

Inyecta un repositorio TypeORM para una entidad y nombre de datasource concretos.

Inyectar repositorio de entidad

import { Service } from "@xtaskjs/core";
import { InjectRepository, Repository } from "@xtaskjs/typeorm";
import { UserEntity } from "./user.entity";

@Service()
export class UsersService {
  constructor(
    @InjectRepository(UserEntity)
    private readonly users: Repository<UserEntity>
  ) {}
}

@xtaskjs/typeorm Decorador de clase clase

TypeOrmMigration

Registra una clase de migration en el registro de TypeORM para un datasource con nombre.

Registrar una migration

import { MigrationInterface, QueryRunner, TypeOrmMigration } from "@xtaskjs/typeorm";

@TypeOrmMigration({ dataSourceName: "default" })
export class CreateAuditEntries1700000000000 implements MigrationInterface {
  async up(queryRunner: QueryRunner): Promise<void> {
    await queryRunner.query("CREATE TABLE audit_entries (id integer primary key autoincrement, message varchar(120) not null)");
  }

  async down(queryRunner: QueryRunner): Promise<void> {
    await queryRunner.query("DROP TABLE audit_entries");
  }
}

@xtaskjs/typeorm Decorador de clase clase

TypeOrmSeeder

Registra una clase seeder ordenada que se ejecuta después de inicializar el datasource cuando los seeders están habilitados.

Registrar un seeder de arranque

import { DataSource, TypeOrmSeeder } from "@xtaskjs/typeorm";

@TypeOrmSeeder({ dataSourceName: "default", order: 1 })
export class AuditEntriesSeeder {
  async run(dataSource: DataSource): Promise<void> {
    await dataSource.query("INSERT INTO audit_entries (message) VALUES ('seeded')");
  }
}

Grupo de decoradores

CQRS Buses, Handlers, And Projections

CQRS configuration, handler, projection, idempotency, and injector decorators exported by @xtaskjs/cqrs. These connect command, query, and event flows to the xtaskjs container and read or write datasource aliases.

@xtaskjs/cqrs Decorador de clase clase

Cqrs

Decorator form of configureCqrs() for binding the read and write datasource aliases and optional idempotency store during module loading.

Bind read and write datasource aliases

import { Cqrs } from "@xtaskjs/cqrs";

@Cqrs({ writeDataSourceName: "write-db", readDataSourceName: "read-db" })
export class CqrsConfiguration {}

@xtaskjs/cqrs Decorador de clase clase

CommandHandler

Registers a DI-managed class as the single handler for a command message type.

Command handler

import { Service } from "@xtaskjs/core";
import { CommandHandler, ICommandHandler } from "@xtaskjs/cqrs";

class CreateUserCommand {
  constructor(public readonly name: string) {}
}

@Service()
@CommandHandler(CreateUserCommand)
export class CreateUserHandler implements ICommandHandler<CreateUserCommand, string> {
  execute(command: CreateUserCommand) {
    return command.name;
  }
}

@xtaskjs/cqrs Decorador de clase clase

QueryHandler

Registers a DI-managed class as the handler for a query message type.

Query handler

import { Service } from "@xtaskjs/core";
import { IQueryHandler, QueryHandler } from "@xtaskjs/cqrs";

class ListUsersQuery {}

@Service()
@QueryHandler(ListUsersQuery)
export class ListUsersHandler implements IQueryHandler<ListUsersQuery, string[]> {
  execute() {
    return ["Ada"];
  }
}

@xtaskjs/cqrs Decorador de clase clase

EventHandler

Registers one or more event handlers that react after a message publishes an event on the CQRS event bus.

Event handler

import { Service } from "@xtaskjs/core";
import { EventHandler, IEventHandler } from "@xtaskjs/cqrs";

class UserCreatedEvent {
  constructor(public readonly id: string) {}
}

@Service()
@EventHandler(UserCreatedEvent)
export class UserProjectionHandler implements IEventHandler<UserCreatedEvent> {
  async handle(event: UserCreatedEvent) {
    console.log(event.id);
  }
}

@xtaskjs/cqrs Decorador de clase clase

ProcessManager / Saga

Registers an orchestration component that reacts to events with access to command, query, and event buses. Saga is an alias of ProcessManager.

Event-driven orchestration

import { Service } from "@xtaskjs/core";
import { IProcessManager, ProcessManager, ProcessManagerContext } from "@xtaskjs/cqrs";

class UserCreatedEvent {
  constructor(public readonly id: string) {}
}

@Service()
@ProcessManager(UserCreatedEvent)
export class WelcomeProcessManager implements IProcessManager<UserCreatedEvent> {
  async handle(event: UserCreatedEvent, context: ProcessManagerContext) {
    await context.commandBus.execute({ userId: event.id });
  }
}

@xtaskjs/cqrs Decorador de clase clase

ProjectionRebuilder

Registers a named projection rebuilder so operators or diagnostics flows can rebuild a read model from write-side state.

Named projection rebuilder

import { Service } from "@xtaskjs/core";
import { IProjectionRebuilder, ProjectionRebuilder } from "@xtaskjs/cqrs";

@Service()
@ProjectionRebuilder("users")
export class UserProjectionRebuilder implements IProjectionRebuilder {
  async rebuild() {
    console.log("rebuild read model");
  }
}

@xtaskjs/cqrs Decorador de clase clase

IdempotentCommand

Adds idempotency metadata to a command handler so repeated executions can reuse a cached result instead of running the write-side action again.

Idempotent command handler

import { CommandHandler, IdempotentCommand } from "@xtaskjs/cqrs";

class CreateUserCommand {
  constructor(public readonly name: string, public readonly idempotencyKey: string) {}
}

@IdempotentCommand<CreateUserCommand>({ key: (command) => command.idempotencyKey })
@CommandHandler(CreateUserCommand)
export class CreateUserHandler {
  execute(command: CreateUserCommand) {
    return `${command.name}:${command.idempotencyKey}`;
  }
}