eventrail
Deterministic event bus and message trace library for MoonBit
event-bus
message-routing
dead-letter
retry
replay
diagnostics
moon add violetcb/eventrail@0.3.2
Download zipAuthor
Version
0.3.2
License
MIT
Repository
Last updated
11 hours ago
Downloads
11
README#EventRail
EventRail 是一个 MoonBit 原生的确定性事件总线与消息轨迹库，用于在测试工具、示例工程、Wasm 应用、业务规则原型和本地开发工具中建立可复现的事件流。
它解决的问题是：在不引入外部服务和复杂运行时的情况下，提供一套可注册订阅、按主题路由、批量校验与发布、记录投递结果、处理重试与死信、查询事件流、生成读模型投影、输出快照与诊断报告、执行事件保留策略、并支持事件回放的基础库。所有核心逻辑均使用 MoonBit 实现。
#适用场景
- 开发工具中的进程内事件通知和插件消息分发；
- WebAssembly 示例或教学项目中的事件流建模；
- API 规则验证、任务编排、资源管线中的可复现 dispatch；
- 单元测试中需要重放事件、检查死信、验证订阅顺序的场景；
- 本地开发工具中需要批处理事件、预检订阅计划和导出调试 manifest 的场景。
- 需要在 CI 或命令行中审计事件流健康状态、保留策略和处理流水线的场景。
#安装
发布后可通过 Mooncakes 包名安装：
moon add violetcb/eventrail包名对应的 GitHub 仓库为 https://github.com/violetcb/eventrail。
#最小示例
let payload = @eventrail.record_value([
@eventrail.field("order_id", @eventrail.text_value("A-1001")),
@eventrail.field("amount", @eventrail.int_value(320)),
])
let event = @eventrail.envelope("order.created", payload, timestamp_ms=20260809)完整可运行示例：
moon run cmd/main#核心功能
- EventValue：支持 null、bool、int、text、list、record 的结构化消息载荷；
- Envelope：事件 ID、topic、headers、attempt、trace 与稳定 fingerprint；
- TopicPattern：支持 order.created、order.*、order.** 三类主题模式；
- Bus：注册订阅、按优先级和匹配精度稳定排序、发布事件；
- RetryPolicy：确定性的指数退避计划；
- DeadLetter：失败超过最大尝试次数后进入死信记录；
- EventTape：事件追加、去重压缩、按 pattern 选择、回放、manifest 导出；
- EventBatch：批量事件过滤、topic 统计、fingerprint 去重、schema 校验、规则判断、路由预览和批量发布；
- EventQuery：按 topic、header、timestamp、predicate 查询事件，并提供排序、分页和跳过原因；
- EventPredicate / RuleSet：基于 topic、header、payload path 的事件规则过滤；
- EventSchema：声明 topic 与 payload 字段合同，输出结构化校验报告；
- ProjectionSpec / EventProjection：从 batch 或 tape 构建确定性读模型；
- BusPlan：以可验证的订阅蓝图生成总线，并预览事件覆盖情况；
- EventCursor / TapeWindow：对事件 tape 做分页读取和确定性恢复；
- EventSnapshot / SnapshotDiff：汇总事件、topic、投递指标和订阅状态，并比较快照差异；
- EventPipeline：组合 schema、rules、route、projection、snapshot 等阶段，生成流水线运行报告；
- RetentionPolicy：按 topic、timestamp、全局数量、单 topic 数量和 fingerprint 压缩生成保留计划；
- DiagnosticReport：对 bus、batch、schema、rules、snapshot、pipeline、retention 输出统一健康诊断；
- DeliveryMode：支持 fanout 和 consumer-group 首选投递；
- RouteExplanation / BusAudit：输出路由诊断和订阅健康检查结果；
- DeliveryStats：按总线、发布报告、topic、subscription 汇总投递指标；
- Outbox：将 retry 投递结果转为可 drain/reschedule 的延迟事件队列；
- PublishReport / ReplayReport：可用于测试和命令行输出的执行摘要。
#支持范围
- 进程内事件路由；
- 确定性主题匹配；
- 同步 handler 结果建模；
- 重试计划与死信记录；
- 规则过滤和延迟重试 outbox；
- schema 校验、路由诊断、consumer-group 投递、投递指标统计和统一诊断报告；
- 批量事件校验、批量发布、查询分页、读模型投影、订阅计划预检；
- 快照导出、快照差异比较、保留策略预览和流水线运行报告；
- 事件回放、分页读取和统计；
- wasm 默认 target 下的构建、测试与示例运行。
#暂不支持范围
- 网络消息队列协议；
- 多线程调度；
- 持久化数据库；
- cron 或真实时间调度；
- JSON/TOML/YAML 文件解析；
- 分布式一致性协议。
#本地验收命令
moon fmt --check
moon check
moon check --deny-warn
moon build
moon test
moon test --deny-warn
moon info
moon run cmd/main
moon package当前核心库有效 MoonBit 代码已超过 4000 行参考规模，测试覆盖核心路径、错误路径和事件流扩展能力：
- topic pattern、payload path、schema、rules；
- fanout / consumer-group 路由、retry、dead letter、outbox；
- EventTape replay、manifest、cursor window；
- EventBatch validate / route preview / publish / compact / topic counts；
- EventProjection 聚合和缺失 key 诊断；
- BusPlan 配置预检和覆盖率预览；
- EventQuery 查询、排序、分页与跳过原因；
- EventSnapshot 汇总、订阅指标和差异比较；
- EventPipeline 阶段运行报告；
- RetentionPolicy 保留计划与 EventBatch/EventTape 应用；
- DiagnosticReport 统一健康诊断。
Mooncakes owner、包名和 GitHub 仓库配置均为 violetcb/eventrail。当前发布版本为 0.3.2。
#Mooncakes 包名
工程包名为：
violetcb/eventrail对应 Mooncakes 文档地址为 https://mooncakes.io/docs/violetcb/eventrail。
#开源许可证与来源说明
本项目采用 MIT License。项目为原创 MoonBit 实现，不移植第三方源码，不包含图片、音频、字体或外部测试数据。CI 中使用 MoonBit 官方安装脚本安装工具链。
#BatchDecision
pub(all) struct BatchDecision {
index : Int
event_id : String
topic : String
decision : RuleDecision
} derive(Eq, Debug)#BatchPublishReport
#BatchPublishReport::manifest
#BatchPublishReport::summary
#BatchRouteReport
pub(all) struct BatchRouteReport {
name : String
events : Int
routed_events : Int
unmatched_events : Int
deliveries_planned : Int
rows : Array[BatchRouteRow]
} derive(Eq, Debug)#BatchRouteReport::route_lines
#BatchRouteRow
#BatchRuleReport
pub(all) struct BatchRuleReport {
name : String
checked : Int
accepted : Int
rejected : Int
decisions : Array[BatchDecision]
} derive(Eq, Debug)#BatchRuleReport::decision_lines
#BatchTopicCount
#BatchValidationIssue
#BatchValidationIssue::to_wire
#BatchValidationReport
pub(all) struct BatchValidationReport {
name : String
checked : Int
valid : Int
invalid : Int
issues : Array[BatchValidationIssue]
} derive(Eq, Debug)#BatchValidationReport::issue_lines
#BatchValidationReport::summary
#Bus
pub(all) struct Bus {
subscriptions : Array[Subscription]
deliveries : Array[Delivery]
dead_letters : Array[DeadLetter]
} derive(Eq, Debug)#Bus::dead_letters_for_subscription
fn Bus::dead_letters_for_subscription(self : Bus, subscription_id : StringView) -> Array[DeadLetter]#Bus::deliveries_for_subscription
#Bus::deliveries_for_topic
#Bus::explain
fn Bus::explain(self : Bus, event : Envelope, mode? : DeliveryMode) -> Result[RouteExplanation, EventRailError]#Bus::last_delivery_for_subscription
#Bus::publish
fn Bus::publish(self : Bus, event : Envelope, handler : (Subscription, Envelope) -> HandlerResult) -> Result[(Bus, PublishReport), EventRailError]#Bus::publish_with_mode
fn Bus::publish_with_mode(self : Bus, event : Envelope, mode : DeliveryMode, handler : (Subscription, Envelope) -> HandlerResult) -> Result[(Bus, PublishReport), EventRailError]#Bus::route
#Bus::route_with_mode
fn Bus::route_with_mode(self : Bus, event : Envelope, mode : DeliveryMode) -> Result[Array[Subscription], EventRailError]#Bus::subscribe
fn Bus::subscribe(self : Bus, id : StringView, pattern : StringView, priority? : Int, group? : StringView, retry? : RetryPolicy, enabled? : Bool, guards? : ArrayView[EventPredicate]) -> Result[Bus, EventRailError]#Bus::subscription_delivery_stats
#Bus::topic_delivery_stats
#BusAudit
#BusPlan
pub(all) struct BusPlan {
name : String
subscriptions : Array[SubscriptionBlueprint]
} derive(Eq, Debug)#BusPlan::build
#BusPlan::coverage
fn BusPlan::coverage(self : BusPlan, events : ArrayView[Envelope], mode? : DeliveryMode) -> Result[PlanCoverageReport, EventRailError]#DeadLetter
#Delivery
pub(all) struct Delivery {
event_id : String
subscription_id : String
topic : String
status : DeliveryStatus
attempt : Int
delay_ms : Int
} derive(Eq, Debug)#DeliveryMode
#DeliveryStats
#DeliveryStats::record
#DeliveryStatus
#DiagnosticEntry
pub(all) struct DiagnosticEntry {
severity : DiagnosticSeverity
code : String
subject : String
message : String
} derive(Eq, Debug)#DiagnosticReport
pub(all) struct DiagnosticReport {
name : String
checked : Int
infos : Int
warnings : Int
errors : Int
entries : Array[DiagnosticEntry]
} derive(Eq, Debug)#DiagnosticReport::add
fn DiagnosticReport::add(self : DiagnosticReport, severity : DiagnosticSeverity, code : StringView, subject : StringView, message : StringView) -> DiagnosticReport#DiagnosticReport::error
fn DiagnosticReport::error(self : DiagnosticReport, code : StringView, subject : StringView, message : StringView) -> DiagnosticReport#DiagnosticReport::has_warnings
#DiagnosticReport::info
fn DiagnosticReport::info(self : DiagnosticReport, code : StringView, subject : StringView, message : StringView) -> DiagnosticReport#DiagnosticReport::manifest_lines
#DiagnosticReport::merge
#DiagnosticReport::warning
fn DiagnosticReport::warning(self : DiagnosticReport, code : StringView, subject : StringView, message : StringView) -> DiagnosticReport#DiagnosticSeverity
#DiagnosticSeverity::to_wire
#Envelope
Event envelope routed through the bus.
#Envelope::payload_path
#EventBatch
#EventBatch::append_many
#EventBatch::apply_retention
fn EventBatch::apply_retention(self : EventBatch, policy : RetentionPolicy) -> Result[(EventBatch, RetentionReport), EventRailError]#EventBatch::compact_by_fingerprint
#EventBatch::evaluate_rules
#EventBatch::filter
fn EventBatch::filter(self : EventBatch, pattern : StringView) -> Result[EventBatch, EventRailError]#EventBatch::project
fn EventBatch::project(self : EventBatch, spec : ProjectionSpec) -> Result[EventProjection, EventRailError]#EventBatch::publish
fn EventBatch::publish(self : EventBatch, bus : Bus, handler : (Subscription, Envelope) -> HandlerResult, mode? : DeliveryMode) -> Result[(Bus, BatchPublishReport), EventRailError]#EventBatch::query
#EventBatch::retention_plan
fn EventBatch::retention_plan(self : EventBatch, policy : RetentionPolicy) -> Result[RetentionReport, EventRailError]#EventBatch::route_preview
fn EventBatch::route_preview(self : EventBatch, bus : Bus, mode? : DeliveryMode) -> Result[BatchRouteReport, EventRailError]#EventBatch::snapshot
fn EventBatch::snapshot(self : EventBatch, bus : Bus, name? : StringView, timestamp_ms? : Int) -> EventSnapshot#EventBatch::sort_by_timestamp
#EventBatch::topic_counts
#EventBatch::validate
#EventBatch::with_name
#EventCursor
#EventCursor::next_from
#EventCursor::with_limit
#EventCursor::with_pattern
#EventDigest
#EventPipeline
pub(all) struct EventPipeline {
name : String
batch : EventBatch
actions : Array[PipelineAction]
} derive(Eq, Debug)#EventPipeline::add
#EventPipeline::run
#EventPredicate
pub(all) enum EventPredicate {
TopicMatches(String)
HeaderEquals(String, String)
HeaderExists(String)
PayloadExists(String)
TextEquals(String, String)
TextContains(String, String)
IntAtLeast(String, Int)
IntAtMost(String, Int)
IntBetween(String, Int, Int)
BoolEquals(String, Bool)
AllOf(Array[EventPredicate])
AnyOf(Array[EventPredicate])
Not(EventPredicate)
} derive(Eq, Debug)#EventPredicate::evaluate
#EventProjection
pub(all) struct EventProjection {
spec : ProjectionSpec
rows : Array[ProjectionRow]
skipped : Int
issues : Array[ProjectionIssue]
} derive(Eq, Debug)#EventProjection::apply
fn EventProjection::apply(self : EventProjection, event : Envelope) -> Result[EventProjection, EventRailError]#EventProjection::find
#EventProjection::issue_lines
#EventProjection::manifest_lines
#EventQuery
pub(all) struct EventQuery {
name : String
topic : TopicPattern?
headers : Array[HeaderFilter]
predicates : Array[EventPredicate]
min_timestamp_ms : Int?
max_timestamp_ms : Int?
offset : Int
limit : Int
sort : QuerySort
} derive(Eq, Debug)#EventQuery::apply
fn EventQuery::apply(self : EventQuery, events : ArrayView[Envelope]) -> Result[QueryResult, EventRailError]#EventQuery::matches
fn EventQuery::matches(self : EventQuery, event : Envelope) -> Result[(Bool, String), EventRailError]#EventQuery::with_header
#EventQuery::with_page
#EventQuery::with_predicate
#EventQuery::with_sort
#EventQuery::with_time_range
fn EventQuery::with_time_range(self : EventQuery, min_timestamp_ms? : Int, max_timestamp_ms? : Int) -> EventQuery#EventQuery::with_topic
fn EventQuery::with_topic(self : EventQuery, topic : StringView) -> Result[EventQuery, EventRailError]#EventRailError
Error values returned by EventRail builders and validators.
#EventRailError::is_configuration_error
#EventSchema
pub(all) struct EventSchema {
name : String
topic : TopicPattern?
fields : Array[FieldSpec]
} derive(Eq, Debug)#EventSchema::validate
#EventSnapshot
pub(all) struct EventSnapshot {
name : String
source : String
timestamp_ms : Int
event_count : Int
delivery_count : Int
dead_letter_count : Int
digests : Array[EventDigest]
topic_counts : Array[TopicCount]
delivery_stats : DeliveryStats
subscription_stats : Array[SnapshotDeliveryRow]
} derive(Eq, Debug)#EventSnapshot::diff
#EventSnapshot::find_event
#EventSnapshot::manifest_lines
#EventSnapshot::subscription_stats_for
fn EventSnapshot::subscription_stats_for(self : EventSnapshot, subscription_id : StringView) -> DeliveryStats?#EventSnapshot::topic_count
#EventTape
#EventTape::append_many
#EventTape::apply_retention
fn EventTape::apply_retention(self : EventTape, policy : RetentionPolicy) -> Result[(EventTape, RetentionReport), EventRailError]#EventTape::compact_by_fingerprint
#EventTape::project
fn EventTape::project(self : EventTape, spec : ProjectionSpec) -> Result[EventProjection, EventRailError]#EventTape::query
#EventTape::replay
fn EventTape::replay(self : EventTape, bus : Bus, handler : (Subscription, Envelope) -> HandlerResult) -> Result[(Bus, ReplayReport), EventRailError]#EventTape::retention_plan
fn EventTape::retention_plan(self : EventTape, policy : RetentionPolicy) -> Result[RetentionReport, EventRailError]#EventTape::select
fn EventTape::select(self : EventTape, pattern : StringView) -> Result[Array[Envelope], EventRailError]#EventTape::snapshot
fn EventTape::snapshot(self : EventTape, bus : Bus, name? : StringView, timestamp_ms? : Int) -> EventSnapshot#EventTape::to_manifest_lines
#EventTape::window
#EventValue
pub(all) enum EventValue {
VNull
VBool(Bool)
VInt(Int)
VText(String)
VList(Array[EventValue])
VRecord(Array[(String, EventValue)])
} derive(Eq, Debug)Structured event payload. Records keep declaration order so exported
snapshots stay deterministic across targets and test runs.
#EventValue::get_path
#EventValue::require_path
fn EventValue::require_path(self : EventValue, path : StringView) -> Result[EventValue, EventRailError]#FieldSpec
#HandlerResult
#HeaderFilter
#MatchReport
#Outbox
#Outbox::drop_subscription
#Outbox::from_report
fn Outbox::from_report(self : Outbox, event : Envelope, report : PublishReport, now_ms : Int) -> Outbox#OutboxDrain
#Pair
Ordered key-value pair used by record payloads and event headers.
#PipelineAction
pub(all) enum PipelineAction {
PipelineValidate(EventSchema)
PipelineRules(RuleSet)
PipelineRoute(Bus, DeliveryMode)
PipelineProject(ProjectionSpec)
PipelineSnapshot(Bus)
} derive(Eq, Debug)#PipelineRun
pub(all) struct PipelineRun {
name : String
stages : Array[PipelineStage]
passed : Int
failed : Int
warnings : Int
} derive(Eq, Debug)#PipelineRun::failed_stages
#PipelineRun::manifest_lines
#PipelineRun::warning_stages
#PipelineStage
pub(all) struct PipelineStage {
index : Int
action : PipelineAction
status : PipelineStageStatus
summary : String
lines : Array[String]
} derive(Eq, Debug)#PipelineStageStatus
#PipelineStageStatus::to_wire
#PlanBuildReport
#PlanBuildReport::issue_lines
#PlanCoverageReport
#PlanCoverageReport::coverage_lines
#PlanCoverageReport::summary
#PlanCoverageRow
#PlanIssue
pub(all) struct PlanIssue {
severity : PlanSeverity
code : String
message : String
} derive(Eq, Debug)#PlanSeverity
#ProjectionIssue
#ProjectionRow
#ProjectionRow::field
#ProjectionSpec
pub(all) struct ProjectionSpec {
name : String
topic : TopicPattern
key_path : String
include_paths : Array[String]
require_key : Bool
} derive(Eq, Debug)#ProjectionSpec::project_events
fn ProjectionSpec::project_events(self : ProjectionSpec, events : ArrayView[Envelope]) -> Result[EventProjection, EventRailError]#PublishReport
#PublishReport::delivery_stats
#QueryResult
#QueryResult::manifest_lines
#QueryRow
#QuerySkip
#QuerySort
#ReplayReport
#RetentionDecision
#RetentionPolicy
pub(all) struct RetentionPolicy {
name : String
topic : TopicPattern?
min_timestamp_ms : Int?
max_timestamp_ms : Int?
max_events : Int
max_events_per_topic : Int
compact_fingerprints : Bool
} derive(Eq, Debug)#RetentionPolicy::with_compaction
fn RetentionPolicy::with_compaction(self : RetentionPolicy, compact_fingerprints : Bool) -> RetentionPolicy#RetentionPolicy::with_limits
fn RetentionPolicy::with_limits(self : RetentionPolicy, max_events? : Int, max_events_per_topic? : Int) -> RetentionPolicy#RetentionPolicy::with_time_range
fn RetentionPolicy::with_time_range(self : RetentionPolicy, min_timestamp_ms? : Int, max_timestamp_ms? : Int) -> RetentionPolicy#RetentionPolicy::with_topic
fn RetentionPolicy::with_topic(self : RetentionPolicy, topic : StringView) -> Result[RetentionPolicy, EventRailError]#RetentionPolicy::without_topic
#RetentionReport
pub(all) struct RetentionReport {
policy : String
source : String
scanned : Int
kept : Int
dropped : Int
topic_summaries : Array[RetentionTopicSummary]
decisions : Array[RetentionDecision]
} derive(Eq, Debug)#RetentionReport::decision_lines
#RetentionReport::drop_lines
#RetentionReport::dropped_event_ids
#RetentionReport::dropped_indices
#RetentionReport::dropped_sequences
#RetentionReport::keep_lines
#RetentionReport::kept_event_ids
#RetentionReport::kept_indices
#RetentionReport::kept_sequences
#RetentionReport::manifest_lines
#RetentionReport::topic_lines
#RetentionTopicSummary
#RetentionTopicSummary::to_wire
#RetryPolicy
Policy used when a handler asks for retry or returns failure.
#RouteExplanation
pub(all) struct RouteExplanation {
event_id : String
topic : String
mode : DeliveryMode
selected : Array[String]
probes : Array[RouteProbe]
} derive(Eq, Debug)#RouteProbe
#RuleDecision
#RuleDecision::to_handler_result
#RuleResult
#RuleSet
#ScheduledEvent
#ScheduledEvent::to_manifest_line
#SchemaIssue
#SchemaReport
pub(all) struct SchemaReport {
name : String
valid : Bool
issues : Array[SchemaIssue]
} derive(Eq, Debug)#SchemaReport::to_handler_result
#SnapshotChange
pub(all) struct SnapshotChange {
kind : SnapshotChangeKind
event_id : String
before_fingerprint : String
after_fingerprint : String
} derive(Eq, Debug)#SnapshotChangeKind
#SnapshotChangeKind::to_wire
#SnapshotDeliveryRow
pub(all) struct SnapshotDeliveryRow {
subscription_id : String
stats : DeliveryStats
} derive(Eq, Debug)#SnapshotDeliveryRow::to_wire
#SnapshotDiff
pub(all) struct SnapshotDiff {
left : String
right : String
added : Int
removed : Int
changed : Int
changes : Array[SnapshotChange]
} derive(Eq, Debug)#SnapshotDiff::change_lines
#Subscription
pub(all) struct Subscription {
id : String
pattern : TopicPattern
priority : Int
group : String
order : Int
retry : RetryPolicy
enabled : Bool
guards : Array[EventPredicate]
} derive(Eq, Debug)#Subscription::first_guard_failure
#Subscription::guards_pass
#Subscription::matches
#SubscriptionBlueprint
pub(all) struct SubscriptionBlueprint {
id : String
pattern : String
priority : Int
group : String
retry : RetryPolicy
enabled : Bool
guards : Array[EventPredicate]
} derive(Eq, Debug)#SubscriptionBlueprint::to_wire
#SubscriptionDeliveryStats
pub(all) struct SubscriptionDeliveryStats {
subscription_id : String
stats : DeliveryStats
} derive(Eq, Debug)#SubscriptionDeliveryStats::to_wire
#TapeEntry
#TapeState
#TapeWindow
pub(all) struct TapeWindow {
cursor : EventCursor
entries : Array[TapeEntry]
next_cursor : EventCursor
complete : Bool
} derive(Eq, Debug)#TopicCount
#TopicDeliveryStats
#TopicDeliveryStats::to_wire
#TopicPattern
pub(all) struct TopicPattern {
raw : String
tokens : Array[TopicToken]
specificity : Int
} derive(Eq, Debug)Parsed topic pattern. Higher specificity wins when routes are sorted.
#TopicPattern::matches_topic
fn TopicPattern::matches_topic(self : TopicPattern, topic : StringView) -> Result[Bool, EventRailError]#TopicPattern::report
fn TopicPattern::report(self : TopicPattern, topic : StringView) -> Result[MatchReport, EventRailError]#TopicToken
Token in a topic pattern.
#ValueKind
#bus_plan
#compare_pattern_priority
#diagnose_batch_rules
#diagnose_batch_schema
fn diagnose_batch_schema(name : StringView, batch : EventBatch, schema : EventSchema) -> DiagnosticReport#diagnose_pipeline_run
#diagnose_retention
#diagnose_snapshot
#envelope
fn envelope(id? : StringView, topic : StringView, payload : EventValue, headers? : ArrayView[Pair], timestamp_ms? : Int, attempt? : Int, trace? : ArrayView[String]) -> Envelope#event_cursor
#event_pipeline
fn event_pipeline(name : StringView, batch : EventBatch, actions? : ArrayView[PipelineAction]) -> EventPipeline#event_query
fn event_query(name? : StringView, topic? : StringView, headers? : ArrayView[HeaderFilter], predicates? : ArrayView[EventPredicate], min_timestamp_ms? : Int, max_timestamp_ms? : Int, offset? : Int, limit? : Int, sort? : QuerySort) -> Result[EventQuery, EventRailError]#event_schema
fn event_schema(name : StringView, topic? : StringView, fields? : ArrayView[FieldSpec]) -> Result[EventSchema, EventRailError]#event_snapshot
fn event_snapshot(name : StringView, source : StringView, events : ArrayView[Envelope], bus : Bus, timestamp_ms? : Int) -> EventSnapshot#field_spec
#package_name
fn package_name() -> StringEventRail is a deterministic in-process event bus and message trace library.
The implementation is dependency-light so it can run in tests, examples,
WebAssembly demos, and command-line tooling with the same behavior.
#projection_spec
fn projection_spec(name : StringView, key_path : StringView, topic? : StringView, include_paths? : ArrayView[String], require_key? : Bool) -> Result[ProjectionSpec, EventRailError]#retention_policy
fn retention_policy(name? : StringView, topic? : StringView, min_timestamp_ms? : Int, max_timestamp_ms? : Int, max_events? : Int, max_events_per_topic? : Int, compact_fingerprints? : Bool) -> Result[RetentionPolicy, EventRailError]#retry_policy
#scheduled_event
fn scheduled_event(due_ms : Int, subscription_id : StringView, reason : StringView, event : Envelope) -> ScheduledEvent#stable_event_id
#subscription
fn subscription(id : StringView, pattern : StringView, priority? : Int, group? : StringView, order? : Int, retry? : RetryPolicy, enabled? : Bool, guards? : ArrayView[EventPredicate]) -> Result[Subscription, EventRailError]#subscription_blueprint
fn subscription_blueprint(id : StringView, pattern : StringView, priority? : Int, group? : StringView, retry? : RetryPolicy, enabled? : Bool, guards? : ArrayView[EventPredicate]) -> SubscriptionBlueprintDeterministic event bus and message trace library for MoonBit
event-busmessage-routingdead-letterretryreplaydiagnostics
0.3.2
MIT
Updated 11 hours ago
11 downloads