Class Evento

Example

// Define your types
interface MyRequest { action: string; value: number; }
interface MyResponse { success: boolean; data?: unknown; }

// Create an encoder/decoder
class MyEncoder implements EventoEnDecoder<MyRequest, MyResponse> {
  async encode(args: MyRequest): Promise<Result<unknown>> {
    return Result.Ok(args);
  }
  async decode(data: unknown): Promise<Result<MyResponse>> {
    return Result.Ok(data as MyResponse);
  }
}

// Create a send implementation
class MySend implements EventoSend<MyRequest, MyRequest, MyResponse> {
  async send<IS, OS>(trigger: HandleTriggerCtx<MyRequest, MyRequest, MyResponse>, data: IS): Promise<Result<OS>> {
    // Send the response data
    console.log('Sending:', data);
    return Result.Ok(data as OS);
  }
}

// Initialize Evento
const evento = new Evento(new MyEncoder());
const send = new MySend();

// Register regular handlers (run first)
evento.push({
  hash: 'update-handler',
  validate: async (ctx) => {
    const req = ctx.enRequest as MyRequest;
    // Only handle "update" actions
    if (req.action === 'update') {
      return Result.Ok(Option.Some(req));
    }
    return Result.Ok(Option.None());
  },
  handle: async (ctx) => {
    await ctx.send.send(ctx, {
      success: true,
      data: { updated: ctx.validated.value }
    });
    return Result.Ok(EventoResult.Continue);
  }
});

// Register wildcard handler (runs if no regular handlers match)
evento.push({
  hash: 'default-handler',
  type: EventoType.WildCard,
  handle: async (ctx) => {
    await ctx.send.send(ctx, { success: false });
    return Result.Ok(EventoResult.Stop);
  }
});

// Trigger an event
await evento.trigger({
  send,
  request: { action: 'update', value: 42 }
});
Copy