EventBridge

Lightweight, dependency-free fake of AWS EventBridge that speaks the real EventBridge AWS JSON 1.1 wire protocol (X-Amz-Target: AWSEvents.<Operation>, Content-Type: application/x-amz-json-1.1), so application code using @aws-sdk/client-eventbridge can run against it with zero cost and zero side effects.

Quick Start

Start the server:

import { EventbridgeServer } from "./services/eventbridge/src/server.js";

const server = new EventbridgeServer(4573);
await server.start();
// ... use it ...
await server.stop();

Connect with the real AWS SDK client:

import {
  EventBridgeClient,
  CreateEventBusCommand,
  PutRuleCommand,
  PutTargetsCommand,
  PutEventsCommand,
} from "@aws-sdk/client-eventbridge";

const eb = new EventBridgeClient({
  region: "us-east-1",
  endpoint: "http://127.0.0.1:4573",
  credentials: { accessKeyId: "parlel", secretAccessKey: "parlel" },
});

// Create a custom event bus (the "default" bus is seeded automatically)
const { EventBusArn } = await eb.send(new CreateEventBusCommand({ Name: "orders" }));

// Create a rule with an event pattern
const { RuleArn } = await eb.send(
  new PutRuleCommand({
    Name: "order-placed",
    EventBusName: "orders",
    EventPattern: JSON.stringify({ source: ["my.app"], "detail-type": ["OrderPlaced"] }),
  }),
);

// Attach a target
await eb.send(
  new PutTargetsCommand({
    Rule: "order-placed",
    EventBusName: "orders",
    Targets: [{ Id: "1", Arn: "arn:aws:lambda:us-east-1:000000000000:function:handler" }],
  }),
);

// Publish an event (matching events are routed to rules in-memory)
const res = await eb.send(
  new PutEventsCommand({
    Entries: [
      {
        Source: "my.app",
        DetailType: "OrderPlaced",
        Detail: JSON.stringify({ orderId: 123 }),
        EventBusName: "orders",
      },
    ],
  }),
);
// res.Entries[0].EventId is the generated event id

Implemented operations

All 57 operations exposed by @aws-sdk/client-eventbridge are implemented and tested.

Event buses

• CreateEventBus
• DeleteEventBus (idempotent; the default bus cannot be deleted)
• DescribeEventBus
• ListEventBuses (prefix filter + pagination)
• UpdateEventBus

Permissions (event-bus resource policy)

• PutPermission (statement form and full Policy document form)
• RemovePermission (single StatementId and RemoveAllPermissions)

Rules

• PutRule (create/upsert; validates event pattern; supports ScheduleExpression)
• DeleteRule (refuses rules with targets unless Force=true)
• DescribeRule
• EnableRule
• DisableRule
• ListRules (prefix filter + pagination)
• ListRuleNamesByTarget

Targets

• PutTargets (max 5 per request; per-entry FailedEntries reporting)
• RemoveTargets
• ListTargetsByRule

Events

• PutEvents (max 10 entries; per-entry validation; in-memory routing to matching enabled rules)
• PutPartnerEvents
• TestEventPattern (full content-filter matching engine)

Archives

• CreateArchive
• DeleteArchive
• DescribeArchive
• ListArchives (prefix / source / state filters)
• UpdateArchive

Replays

• StartReplay (completes instantly in the fake)
• CancelReplay
• DescribeReplay
• ListReplays

Connections

• CreateConnection
• DeleteConnection
• DescribeConnection (secret values redacted, like AWS)
• ListConnections
• UpdateConnection
• DeauthorizeConnection

API destinations

• CreateApiDestination
• DeleteApiDestination
• DescribeApiDestination
• ListApiDestinations
• UpdateApiDestination

Global endpoints

• CreateEndpoint
• DeleteEndpoint
• DescribeEndpoint
• ListEndpoints
• UpdateEndpoint

Partner event sources (producer side)

• CreatePartnerEventSource
• DeletePartnerEventSource
• DescribePartnerEventSource
• ListPartnerEventSources
• ListPartnerEventSourceAccounts

Event sources (consumer side)

• DescribeEventSource
• ListEventSources
• ActivateEventSource
• DeactivateEventSource

Tagging (rules, event buses, archives)

• TagResource
• UntagResource
• ListTagsForResource

Event pattern matching

PutRule, TestEventPattern and PutEvents routing all run the same content-based filtering engine. Supported matchers:

Internal / non-AWS endpoints

These are convenience endpoints for tests and tooling (not part of EventBridge):

server.reset() does the same thing in-process. Captured state useful for assertions: server.putEvents (every accepted PutEvents entry) and server.routedEvents (events that matched an enabled rule's pattern).

Surface coverage

This emulator faithfully replicates the API surface most application code and agents exercise. Anything below the supported lines is either an intentional design choice for a fast, zero-cost local emulator (✓ By design) or a candidate for a future release (⟳ Roadmap) — never a silent inaccuracy.

Legend: ✅ fully supported · ◐ accepted (stored, not strictly enforced) · ✓ by design · ⟳ on the roadmap.

Error codes & shapes

Errors are returned as non-2xx responses with Content-Type: application/x-amz-json-1.1, an x-amzn-errortype header, and a JSON body of the form:

{ "__type": "ResourceNotFoundException", "message": "Rule foo does not exist on EventBus default." }

Per-entry operations (PutEvents, PutPartnerEvents, PutTargets, RemoveTargets) return 200 with a FailedEntryCount and a list of failed entries carrying ErrorCode / ErrorMessage rather than failing the whole request.

Configuration — test.env

Copy these into your test.env (used by the bridge sidecar flow). Tokens are Parlel's seeded test credentials — any non-empty value is accepted by the emulator, so you rarely need to change them. Swap in real credentials only when pointing at the live service in prod.env.

AWS_ACCESS_KEY_ID=parlel
AWS_SECRET_ACCESS_KEY=parlel
AWS_REGION=us-east-1
AWS_ENDPOINT_URL_EVENTBRIDGE=http://parlel-bridge:4573
AWS_ENDPOINT_URL=http://parlel-bridge:4573