Quickstart - abxbus

Install abxbus, define one typed event, register a handler, and emit the event. Rust and Go support is currently alpha while cross-runtime parity coverage continues to expand. Repository example files:

Install

Python
TypeScript
Rust
Go

pip install abxbus

npm install abxbus

cargo test --manifest-path abxbus-rust/Cargo.toml

go get github.com/ArchiveBox/abxbus/abxbus-go

First event

Python
TypeScript
Rust
Go

import asyncio
from abxbus import BaseEvent, EventBus

class CreateUserEvent(BaseEvent[dict]):
    email: str

async def on_create_user(event: CreateUserEvent) -> dict:
    user = await your_create_user_logic(event.email)
    return {'user_id': user['id']}

async def main() -> None:
    bus = EventBus('MyAuthEventBus')
    bus.on(CreateUserEvent, on_create_user)

    event = await bus.emit(CreateUserEvent(email='someuser@example.com')).now()
    result = await event.event_result()
    print(result)
    # {'user_id': 'some-user-uuid'}

asyncio.run(main())

import { BaseEvent, EventBus } from 'abxbus'
import { z } from 'zod'

const CreateUserEvent = BaseEvent.extend('CreateUserEvent', {
  email: z.string(),
  event_result_type: z.object({ user_id: z.string() }),
})

const bus = new EventBus('MyAuthEventBus')

bus.on(CreateUserEvent, async (event) => {
  const user = await yourCreateUserLogic(event.email)
  return { user_id: user.id }
})

const event = bus.emit(CreateUserEvent({ email: 'someuser@example.com' }))
await event.now()
console.log(await event.eventResult()) // { user_id: 'some-user-uuid' }

use abxbus::{event, event_bus::EventBus};
use futures::executor::block_on;
use serde_json::json;

event! {
    struct CreateUserEvent {
        email: String,
        event_result_type: serde_json::Value,
    }
}

let bus = EventBus::new(Some("MyAuthEventBus".to_string()));
bus.on(CreateUserEvent, |event: CreateUserEvent| async move {
    let email = event.email.clone();
    Ok(json!({"user_id": format!("created:{email}")}))
});

let event = bus.emit(CreateUserEvent {
    email: "someuser@example.com".to_string(),
    ..Default::default()
});
block_on(async {
    let completed = event.now().await?;
    let result = completed.event_result().await?;
    println!("{result:?}");
    Ok::<(), String>(())
})?;

type CreateUserEvent struct {
	Email string `json:"email"`
}

type CreateUserResult struct {
	UserID string `json:"user_id"`
}

bus := abxbus.NewEventBus("MyAuthEventBus", nil)
bus.On(func(event CreateUserEvent) (CreateUserResult, error) {
	return CreateUserResult{UserID: "some-user-uuid"}, nil
})

event := bus.Emit(CreateUserEvent{Email: "someuser@example.com"})
result, err := event.EventResult()
if err != nil {
	panic(err)
}
fmt.Println(result)

Next steps

Browse the Features section for behavior patterns.
Use API Reference for signatures and options.
See Integrations for bridges and middleware.