[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M6CX1XP98HQ5BAVWSH2BQT3V":3,"skill-same:01M6CX1XP98HQ5BAVWSH2BQT3V":51},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":15,"categories":16,"keywords":17,"publishedAt":24,"linkOnly":25,"markdownContent":26,"markdownBody":27,"frontMatter":28,"refName":31,"commitSha":32,"skillDirectory":5,"forksCount":33,"repositoryHtmlUrl":34,"repositoryHomepageUrl":6,"ownerHtmlUrl":35,"ownerBlogUrl":6,"ownerDescription":6,"updatedAt":36,"install":37,"resources":50},"01M6CX1XP98HQ5BAVWSH2BQT3V","event-driven",null,"Event-driven architecture patterns and best practices","ffsshhttiikk\u002Fopencode-agents-skills","ffsshhttiikk","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F226346827?v=4","01M6CWD9RR3Y7VRQX3MXYC8FYH","01M6CWD9WVPYAZW0J82G1VKGHY",3,"MIT","https:\u002F\u002Fgithub.com\u002Fffsshhttiikk\u002Fopencode-agents-skills\u002Fblob\u002Fmain\u002Fevent-driven\u002FSKILL.md",[],[18,19,20,21,22,23],"event driven","architecture","best practices","architecture patterns","opencode","patterns","2026-11-10 10:12:30",false,"---\nname: event-driven\ndescription: Event-driven architecture patterns and best practices\nlicense: MIT\ncompatibility: opencode\nmetadata:\n  audience: developers\n  category: architecture\n---\n## What I do\n- Design event-driven systems\n- Implement event sourcing\n- Handle event ordering and deduplication\n- Design event schemas\n- Implement saga patterns\n- Handle eventual consistency\n- Monitor event processing\n- Handle failures and retries\n\n## When to use me\nWhen designing event-driven architectures or implementing event systems.\n\n## Event-Driven Architecture\n```\n┌─────────────────────────────────────────────────────────────────────┐\n│                         Event Producers                              │\n│  ┌─────────┐    ┌─────────┐    ┌─────────┐    ┌─────────┐          │\n│  │ Service │    │ Service │    │ Service │    │ Service │          │\n│  │    A    │───►│    B    │───►│    C    │───►│    D    │          │\n│  └─────────┘    └─────────┘    └─────────┘    └─────────┘          │\n│       │              │              │              │                │\n│       └──────────────┴──────────────┴──────────────┘                │\n│                              │                                        │\n│                    ┌────────▼────────┐                               │\n│                    │   Event Bus     │                              │\n│                    │ (Kafka\u002FRabbit)  │                              │\n│                    └────────┬────────┘                               │\n│                             │                                        │\n│         ┌───────────────────┼───────────────────┐                    │\n│         │                   │                   │                    │\n│         ▼                   ▼                   ▼                    │\n│    ┌─────────┐         ┌─────────┐         ┌─────────┐              │\n│    │Consumer │         │Consumer │         │Consumer │              │\n│    │    1    │         │    2    │         │    3    │              │\n│    └─────────┘         └─────────┘         └─────────┘              │\n│                                                                     │\n└─────────────────────────────────────────────────────────────────────┘\n```\n\n## Event Schema Design\n```python\nfrom dataclasses import dataclass, field\nfrom datetime import datetime\nfrom typing import Any, Dict\nimport json\nimport uuid\n\n\n@dataclass\nclass Event:\n    \"\"\"Base event structure.\"\"\"\n    event_id: str = field(default_factory=lambda: str(uuid.uuid4()))\n    event_type: str = \"\"\n    aggregate_id: str = \"\"\n    aggregate_type: str = \"\"\n    occurred_at: datetime = field(default_factory=datetime.utcnow)\n    payload: Dict[str, Any] = field(default_factory=dict)\n    metadata: Dict[str, Any] = field(default_factory=dict)\n    \n    def to_dict(self) -> dict:\n        return {\n            \"event_id\": self.event_id,\n            \"event_type\": self.event_type,\n            \"aggregate_id\": self.aggregate_id,\n            \"aggregate_type\": self.aggregate_type,\n            \"occurred_at\": self.occurred_at.isoformat(),\n            \"payload\": self.payload,\n            \"metadata\": self.metadata,\n        }\n    \n    @classmethod\n    def from_dict(cls, data: dict) -> 'Event':\n        data[\"occurred_at\"] = datetime.fromisoformat(data[\"occurred_at\"])\n        return cls(**data)\n    \n    def to_json(self) -> str:\n        return json.dumps(self.to_dict())\n    \n    @classmethod\n    def from_json(cls, json_str: str) -> 'Event':\n        return cls.from_dict(json.loads(json_str))\n\n\n@dataclass\nclass UserCreatedEvent(Event):\n    \"\"\"User was created.\"\"\"\n    event_type: str = \"user.created\"\n    \n    payload: Dict[str, Any] = field(default_factory=dict)\n\n\n@dataclass\nclass OrderPlacedEvent(Event):\n    \"\"\"Order was placed.\"\"\"\n    event_type: str = \"order.placed\"\n    \n    payload: Dict[str, Any] = field(default_factory=dict)\n\n\nclass EventSerializer:\n    \"\"\"Serialize and deserialize events.\"\"\"\n    \n    TYPE_MAPPING = {\n        \"user.created\": UserCreatedEvent,\n        \"order.placed\": OrderPlacedEvent,\n    }\n    \n    @classmethod\n    def deserialize(cls, data: dict) -> Event:\n        event_type = data.get(\"event_type\")\n        \n        if event_type in cls.TYPE_MAPPING:\n            event_cls = cls.TYPE_MAPPING[event_type]\n            return event_cls.from_dict(data)\n        \n        return Event.from_dict(data)\n```\n\n## Event Sourcing\n```python\nfrom abc import ABC, abstractmethod\nfrom typing import List, Optional\nfrom datetime import datetime\n\n\nclass Aggregate(ABC):\n    \"\"\"Base aggregate with event sourcing.\"\"\"\n    \n    def __init__(self, aggregate_id: str) -> None:\n        self.id = aggregate_id\n        self._events: List[Event] = []\n        self._version: int = 0\n    \n    def apply(self, event: Event) -> None:\n        \"\"\"Apply event to aggregate.\"\"\"\n        self._events.append(event)\n        self._version += 1\n        self._handle_event(event)\n    \n    @abstractmethod\n    def _handle_event(self, event: Event) -> None:\n        \"\"\"Handle event (to be implemented by subclass).\"\"\"\n        pass\n    \n    def get_pending_events(self) -> List[Event]:\n        \"\"\"Get events not yet persisted.\"\"\"\n        return self._events\n    \n    def clear_pending_events(self) -> None:\n        \"\"\"Clear pending events after persistence.\"\"\"\n        self._events = []\n    \n    @classmethod\n    def from_events(cls, aggregate_id: str, events: List[Event]) -> 'Aggregate':\n        \"\"\"Reconstruct aggregate from events.\"\"\"\n        aggregate = cls(aggregate_id)\n        \n        for event in events:\n            aggregate.apply(event)\n        \n        return aggregate\n\n\nclass UserAggregate(Aggregate):\n    \"\"\"User aggregate with event sourcing.\"\"\"\n    \n    def __init__(self, user_id: str) -> None:\n        super().__init__(user_id)\n        self.email: Optional[str] = None\n        self.name: Optional[str] = None\n        self.created_at: Optional[datetime] = None\n        self.updated_at: Optional[datetime] = None\n    \n    def create_user(self, email: str, name: str) -> None:\n        \"\"\"Create user (generates event).\"\"\"\n        event = UserCreatedEvent(\n            aggregate_id=self.id,\n            aggregate_type=\"user\",\n            payload={\n                \"email\": email,\n                \"name\": name,\n            },\n        )\n        self.apply(event)\n    \n    def _handle_event(self, event: Event) -> None:\n        \"\"\"Apply event to state.\"\"\"\n        if isinstance(event, UserCreatedEvent):\n            self.email = event.payload[\"email\"]\n            self.name = event.payload[\"name\"]\n            self.created_at = event.occurred_at\n```\n\n## Saga Pattern\n```python\nfrom dataclasses import dataclass\nfrom typing import Dict, Any, Callable\nfrom enum import Enum\nimport asyncio\n\n\nclass SagaStepStatus(Enum):\n    PENDING = \"pending\"\n    IN_PROGRESS = \"in_progress\"\n    COMPLETED = \"completed\"\n    FAILED = \"failed\"\n    COMPENSATING = \"compensating\"\n\n\n@dataclass\nclass SagaContext:\n    \"\"\"Context passed through saga steps.\"\"\"\n    data: Dict[str, Any] = None\n    status: SagaStepStatus = SagaStepStatus.PENDING\n    compensating: bool = False\n    \n    def __post_init__(self):\n        if self.data is None:\n            self.data = {}\n\n\nclass Saga:\n    \"\"\"Base saga with compensation support.\"\"\"\n    \n    def __init__(self, saga_id: str) -> None:\n        self.saga_id = saga_id\n        self.steps: List[Callable] = []\n        self.compensation_steps: List[Callable] = []\n        self.context = SagaContext()\n    \n    def add_step(\n        self,\n        forward: Callable[[SagaContext], bool],\n        backward: Callable[[SagaContext], bool]\n    ) -> None:\n        \"\"\"Add a step with compensation.\"\"\"\n        self.steps.append(forward)\n        self.compensation_steps.append(backward)\n    \n    async def execute(self) -> bool:\n        \"\"\"Execute saga with compensation if needed.\"\"\"\n        executed_steps = []\n        \n        try:\n            for step in self.steps:\n                success = step(self.context)\n                if not success:\n                    raise SagaStepFailed()\n                executed_steps.append(step)\n            \n            self.context.status = SagaStepStatus.COMPLETED\n            return True\n            \n        except SagaStepFailed:\n            # Compensate in reverse order\n            self.context.status = SagaStepStatus.COMPENSATING\n            self.context.compensating = True\n            \n            for step in reversed(executed_steps):\n                index = self.steps.index(step)\n                compensation = self.compensation_steps[index]\n                compensation(self.context)\n            \n            return False\n\n\nclass OrderPlacementSaga(Saga):\n    \"\"\"Saga for placing an order.\"\"\"\n    \n    def __init__(self, order_id: str) -> None:\n        super().__init__(order_id)\n        \n        # Add saga steps\n        self.add_step(\n            self.reserve_inventory,\n            self.release_inventory\n        )\n        self.add_step(\n            self.process_payment,\n            self.refund_payment\n        )\n        self.add_step(\n            self.create_shipment,\n            self.cancel_shipment\n        )\n    \n    def reserve_inventory(self, ctx: SagaContext) -> bool:\n        \"\"\"Reserve inventory for order.\"\"\"\n        ctx.data[\"inventory_reserved\"] = True\n        ctx.data[\"inventory_id\"] = \"INV-123\"\n        return True\n    \n    def release_inventory(self, ctx: SagaContext) -> bool:\n        \"\"\"Release reserved inventory.\"\"\"\n        if ctx.data.get(\"inventory_reserved\"):\n            # Release logic here\n            ctx.data[\"inventory_reserved\"] = False\n        return True\n    \n    def process_payment(self, ctx: SagaContext) -> bool:\n        \"\"\"Process payment.\"\"\"\n        ctx.data[\"payment_processed\"] = True\n        ctx.data[\"transaction_id\"] = \"TXN-456\"\n        return True\n    \n    def refund_payment(self, ctx: SagaContext) -> bool:\n        \"\"\"Refund payment if needed.\"\"\"\n        if ctx.data.get(\"payment_processed\"):\n            # Refund logic here\n            ctx.data[\"payment_processed\"] = False\n        return True\n```\n\n## Event Processing\n```python\nfrom abc import ABC, abstractmethod\nfrom typing import List, Optional\nimport asyncio\n\n\nclass EventConsumer(ABC):\n    \"\"\"Base event consumer.\"\"\"\n    \n    def __init__(self, consumer_group: str) -> None:\n        self.consumer_group = consumer_group\n        self.running = False\n    \n    @abstractmethod\n    async def handle_event(self, event: Event) -> bool:\n        \"\"\"Handle single event. Return True if processed successfully.\"\"\"\n        pass\n    \n    async def process_batch(self, events: List[Event]) -> int:\n        \"\"\"Process batch of events.\"\"\"\n        processed = 0\n        \n        for event in events:\n            try:\n                success = await self.handle_event(event)\n                if success:\n                    processed += 1\n            except Exception as e:\n                print(f\"Error processing event: {e}\")\n        \n        return processed\n\n\nclass DeadLetterQueue:\n    \"\"\"Handle events that fail processing.\"\"\"\n    \n    def __init__(self, max_retries: int = 3) -> None:\n        self.max_retries = max_retries\n        self.dead_letter_queue = []\n    \n    async def handle_failed_event(\n        self,\n        event: Event,\n        error: Exception\n    ) -> None:\n        \"\"\"Move failed event to DLQ.\"\"\"\n        event.metadata[\"retry_count\"] = event.metadata.get(\"retry_count\", 0) + 1\n        \n        if event.metadata[\"retry_count\"] \u003C self.max_retries:\n            # Schedule retry\n            await self.schedule_retry(event)\n        else:\n            # Move to DLQ\n            self.dead_letter_queue.append({\n                \"event\": event,\n                \"error\": str(error),\n                \"failed_at\": datetime.utcnow().isoformat(),\n            })\n    \n    async def schedule_retry(self, event: Event) -> None:\n        \"\"\"Schedule event for retry.\"\"\"\n        delay = min(2 ** event.metadata[\"retry_count\"], 300)\n        # Schedule with delay\n```\n\n## Event Ordering\n```python\n# Ordering guarantees\n\n# Per-partition ordering (Kafka)\n# - Events with same key go to same partition\n# - Consumer processes in order\n\n# Global ordering\n# - Single partition (lower throughput)\n# - Or accept eventual ordering\n\n\n# Key-based partitioning\ndef get_partition_key(event: Event) -> str:\n    \"\"\"Get partition key for event.\"\"\"\n    return f\"{event.aggregate_type}:{event.aggregate_id}\"\n```\n\n## Best Practices\n```\n1. Design events as facts\n   - Immutable, never modify\n   - Past tense naming: UserCreated, not CreateUser\n\n2. Include enough context\n   - Sufficient data for consumers\n   - Avoid frequent lookups\n\n3. Version your events\n   - Backward compatibility\n   - Schema evolution\n\n4. Handle idempotency\n   - Deduplicate events\n   - Process exactly once\n\n5. Monitor lag\n   - Track consumer lag\n   - Alert on delays\n\n6. Test thoroughly\n   - Event handlers\n   - Saga rollbacks\n\n7. Document event flow\n   - Event catalog\n   - Consumer dependencies\n```\n","## What I do\n- Design event-driven systems\n- Implement event sourcing\n- Handle event ordering and deduplication\n- Design event schemas\n- Implement saga patterns\n- Handle eventual consistency\n- Monitor event processing\n- Handle failures and retries\n\n## When to use me\nWhen designing event-driven architectures or implementing event systems.\n\n## Event-Driven Architecture\n```\n┌─────────────────────────────────────────────────────────────────────┐\n│                         Event Producers                              │\n│  ┌─────────┐    ┌─────────┐    ┌─────────┐    ┌─────────┐          │\n│  │ Service │    │ Service │    │ Service │    │ Service │          │\n│  │    A    │───►│    B    │───►│    C    │───►│    D    │          │\n│  └─────────┘    └─────────┘    └─────────┘    └─────────┘          │\n│       │              │              │              │                │\n│       └──────────────┴──────────────┴──────────────┘                │\n│                              │                                        │\n│                    ┌────────▼────────┐                               │\n│                    │   Event Bus     │                              │\n│                    │ (Kafka\u002FRabbit)  │                              │\n│                    └────────┬────────┘                               │\n│                             │                                        │\n│         ┌───────────────────┼───────────────────┐                    │\n│         │                   │                   │                    │\n│         ▼                   ▼                   ▼                    │\n│    ┌─────────┐         ┌─────────┐         ┌─────────┐              │\n│    │Consumer │         │Consumer │         │Consumer │              │\n│    │    1    │         │    2    │         │    3    │              │\n│    └─────────┘         └─────────┘         └─────────┘              │\n│                                                                     │\n└─────────────────────────────────────────────────────────────────────┘\n```\n\n## Event Schema Design\n```python\nfrom dataclasses import dataclass, field\nfrom datetime import datetime\nfrom typing import Any, Dict\nimport json\nimport uuid\n\n\n@dataclass\nclass Event:\n    \"\"\"Base event structure.\"\"\"\n    event_id: str = field(default_factory=lambda: str(uuid.uuid4()))\n    event_type: str = \"\"\n    aggregate_id: str = \"\"\n    aggregate_type: str = \"\"\n    occurred_at: datetime = field(default_factory=datetime.utcnow)\n    payload: Dict[str, Any] = field(default_factory=dict)\n    metadata: Dict[str, Any] = field(default_factory=dict)\n    \n    def to_dict(self) -> dict:\n        return {\n            \"event_id\": self.event_id,\n            \"event_type\": self.event_type,\n            \"aggregate_id\": self.aggregate_id,\n            \"aggregate_type\": self.aggregate_type,\n            \"occurred_at\": self.occurred_at.isoformat(),\n            \"payload\": self.payload,\n            \"metadata\": self.metadata,\n        }\n    \n    @classmethod\n    def from_dict(cls, data: dict) -> 'Event':\n        data[\"occurred_at\"] = datetime.fromisoformat(data[\"occurred_at\"])\n        return cls(**data)\n    \n    def to_json(self) -> str:\n        return json.dumps(self.to_dict())\n    \n    @classmethod\n    def from_json(cls, json_str: str) -> 'Event':\n        return cls.from_dict(json.loads(json_str))\n\n\n@dataclass\nclass UserCreatedEvent(Event):\n    \"\"\"User was created.\"\"\"\n    event_type: str = \"user.created\"\n    \n    payload: Dict[str, Any] = field(default_factory=dict)\n\n\n@dataclass\nclass OrderPlacedEvent(Event):\n    \"\"\"Order was placed.\"\"\"\n    event_type: str = \"order.placed\"\n    \n    payload: Dict[str, Any] = field(default_factory=dict)\n\n\nclass EventSerializer:\n    \"\"\"Serialize and deserialize events.\"\"\"\n    \n    TYPE_MAPPING = {\n        \"user.created\": UserCreatedEvent,\n        \"order.placed\": OrderPlacedEvent,\n    }\n    \n    @classmethod\n    def deserialize(cls, data: dict) -> Event:\n        event_type = data.get(\"event_type\")\n        \n        if event_type in cls.TYPE_MAPPING:\n            event_cls = cls.TYPE_MAPPING[event_type]\n            return event_cls.from_dict(data)\n        \n        return Event.from_dict(data)\n```\n\n## Event Sourcing\n```python\nfrom abc import ABC, abstractmethod\nfrom typing import List, Optional\nfrom datetime import datetime\n\n\nclass Aggregate(ABC):\n    \"\"\"Base aggregate with event sourcing.\"\"\"\n    \n    def __init__(self, aggregate_id: str) -> None:\n        self.id = aggregate_id\n        self._events: List[Event] = []\n        self._version: int = 0\n    \n    def apply(self, event: Event) -> None:\n        \"\"\"Apply event to aggregate.\"\"\"\n        self._events.append(event)\n        self._version += 1\n        self._handle_event(event)\n    \n    @abstractmethod\n    def _handle_event(self, event: Event) -> None:\n        \"\"\"Handle event (to be implemented by subclass).\"\"\"\n        pass\n    \n    def get_pending_events(self) -> List[Event]:\n        \"\"\"Get events not yet persisted.\"\"\"\n        return self._events\n    \n    def clear_pending_events(self) -> None:\n        \"\"\"Clear pending events after persistence.\"\"\"\n        self._events = []\n    \n    @classmethod\n    def from_events(cls, aggregate_id: str, events: List[Event]) -> 'Aggregate':\n        \"\"\"Reconstruct aggregate from events.\"\"\"\n        aggregate = cls(aggregate_id)\n        \n        for event in events:\n            aggregate.apply(event)\n        \n        return aggregate\n\n\nclass UserAggregate(Aggregate):\n    \"\"\"User aggregate with event sourcing.\"\"\"\n    \n    def __init__(self, user_id: str) -> None:\n        super().__init__(user_id)\n        self.email: Optional[str] = None\n        self.name: Optional[str] = None\n        self.created_at: Optional[datetime] = None\n        self.updated_at: Optional[datetime] = None\n    \n    def create_user(self, email: str, name: str) -> None:\n        \"\"\"Create user (generates event).\"\"\"\n        event = UserCreatedEvent(\n            aggregate_id=self.id,\n            aggregate_type=\"user\",\n            payload={\n                \"email\": email,\n                \"name\": name,\n            },\n        )\n        self.apply(event)\n    \n    def _handle_event(self, event: Event) -> None:\n        \"\"\"Apply event to state.\"\"\"\n        if isinstance(event, UserCreatedEvent):\n            self.email = event.payload[\"email\"]\n            self.name = event.payload[\"name\"]\n            self.created_at = event.occurred_at\n```\n\n## Saga Pattern\n```python\nfrom dataclasses import dataclass\nfrom typing import Dict, Any, Callable\nfrom enum import Enum\nimport asyncio\n\n\nclass SagaStepStatus(Enum):\n    PENDING = \"pending\"\n    IN_PROGRESS = \"in_progress\"\n    COMPLETED = \"completed\"\n    FAILED = \"failed\"\n    COMPENSATING = \"compensating\"\n\n\n@dataclass\nclass SagaContext:\n    \"\"\"Context passed through saga steps.\"\"\"\n    data: Dict[str, Any] = None\n    status: SagaStepStatus = SagaStepStatus.PENDING\n    compensating: bool = False\n    \n    def __post_init__(self):\n        if self.data is None:\n            self.data = {}\n\n\nclass Saga:\n    \"\"\"Base saga with compensation support.\"\"\"\n    \n    def __init__(self, saga_id: str) -> None:\n        self.saga_id = saga_id\n        self.steps: List[Callable] = []\n        self.compensation_steps: List[Callable] = []\n        self.context = SagaContext()\n    \n    def add_step(\n        self,\n        forward: Callable[[SagaContext], bool],\n        backward: Callable[[SagaContext], bool]\n    ) -> None:\n        \"\"\"Add a step with compensation.\"\"\"\n        self.steps.append(forward)\n        self.compensation_steps.append(backward)\n    \n    async def execute(self) -> bool:\n        \"\"\"Execute saga with compensation if needed.\"\"\"\n        executed_steps = []\n        \n        try:\n            for step in self.steps:\n                success = step(self.context)\n                if not success:\n                    raise SagaStepFailed()\n                executed_steps.append(step)\n            \n            self.context.status = SagaStepStatus.COMPLETED\n            return True\n            \n        except SagaStepFailed:\n            # Compensate in reverse order\n            self.context.status = SagaStepStatus.COMPENSATING\n            self.context.compensating = True\n            \n            for step in reversed(executed_steps):\n                index = self.steps.index(step)\n                compensation = self.compensation_steps[index]\n                compensation(self.context)\n            \n            return False\n\n\nclass OrderPlacementSaga(Saga):\n    \"\"\"Saga for placing an order.\"\"\"\n    \n    def __init__(self, order_id: str) -> None:\n        super().__init__(order_id)\n        \n        # Add saga steps\n        self.add_step(\n            self.reserve_inventory,\n            self.release_inventory\n        )\n        self.add_step(\n            self.process_payment,\n            self.refund_payment\n        )\n        self.add_step(\n            self.create_shipment,\n            self.cancel_shipment\n        )\n    \n    def reserve_inventory(self, ctx: SagaContext) -> bool:\n        \"\"\"Reserve inventory for order.\"\"\"\n        ctx.data[\"inventory_reserved\"] = True\n        ctx.data[\"inventory_id\"] = \"INV-123\"\n        return True\n    \n    def release_inventory(self, ctx: SagaContext) -> bool:\n        \"\"\"Release reserved inventory.\"\"\"\n        if ctx.data.get(\"inventory_reserved\"):\n            # Release logic here\n            ctx.data[\"inventory_reserved\"] = False\n        return True\n    \n    def process_payment(self, ctx: SagaContext) -> bool:\n        \"\"\"Process payment.\"\"\"\n        ctx.data[\"payment_processed\"] = True\n        ctx.data[\"transaction_id\"] = \"TXN-456\"\n        return True\n    \n    def refund_payment(self, ctx: SagaContext) -> bool:\n        \"\"\"Refund payment if needed.\"\"\"\n        if ctx.data.get(\"payment_processed\"):\n            # Refund logic here\n            ctx.data[\"payment_processed\"] = False\n        return True\n```\n\n## Event Processing\n```python\nfrom abc import ABC, abstractmethod\nfrom typing import List, Optional\nimport asyncio\n\n\nclass EventConsumer(ABC):\n    \"\"\"Base event consumer.\"\"\"\n    \n    def __init__(self, consumer_group: str) -> None:\n        self.consumer_group = consumer_group\n        self.running = False\n    \n    @abstractmethod\n    async def handle_event(self, event: Event) -> bool:\n        \"\"\"Handle single event. Return True if processed successfully.\"\"\"\n        pass\n    \n    async def process_batch(self, events: List[Event]) -> int:\n        \"\"\"Process batch of events.\"\"\"\n        processed = 0\n        \n        for event in events:\n            try:\n                success = await self.handle_event(event)\n                if success:\n                    processed += 1\n            except Exception as e:\n                print(f\"Error processing event: {e}\")\n        \n        return processed\n\n\nclass DeadLetterQueue:\n    \"\"\"Handle events that fail processing.\"\"\"\n    \n    def __init__(self, max_retries: int = 3) -> None:\n        self.max_retries = max_retries\n        self.dead_letter_queue = []\n    \n    async def handle_failed_event(\n        self,\n        event: Event,\n        error: Exception\n    ) -> None:\n        \"\"\"Move failed event to DLQ.\"\"\"\n        event.metadata[\"retry_count\"] = event.metadata.get(\"retry_count\", 0) + 1\n        \n        if event.metadata[\"retry_count\"] \u003C self.max_retries:\n            # Schedule retry\n            await self.schedule_retry(event)\n        else:\n            # Move to DLQ\n            self.dead_letter_queue.append({\n                \"event\": event,\n                \"error\": str(error),\n                \"failed_at\": datetime.utcnow().isoformat(),\n            })\n    \n    async def schedule_retry(self, event: Event) -> None:\n        \"\"\"Schedule event for retry.\"\"\"\n        delay = min(2 ** event.metadata[\"retry_count\"], 300)\n        # Schedule with delay\n```\n\n## Event Ordering\n```python\n# Ordering guarantees\n\n# Per-partition ordering (Kafka)\n# - Events with same key go to same partition\n# - Consumer processes in order\n\n# Global ordering\n# - Single partition (lower throughput)\n# - Or accept eventual ordering\n\n\n# Key-based partitioning\ndef get_partition_key(event: Event) -> str:\n    \"\"\"Get partition key for event.\"\"\"\n    return f\"{event.aggregate_type}:{event.aggregate_id}\"\n```\n\n## Best Practices\n```\n1. Design events as facts\n   - Immutable, never modify\n   - Past tense naming: UserCreated, not CreateUser\n\n2. Include enough context\n   - Sufficient data for consumers\n   - Avoid frequent lookups\n\n3. Version your events\n   - Backward compatibility\n   - Schema evolution\n\n4. Handle idempotency\n   - Deduplicate events\n   - Process exactly once\n\n5. Monitor lag\n   - Track consumer lag\n   - Alert on delays\n\n6. Test thoroughly\n   - Event handlers\n   - Saga rollbacks\n\n7. Document event flow\n   - Event catalog\n   - Consumer dependencies\n```\n",{"name":5,"license":14,"metadata":29,"description":7,"compatibility":22},{"audience":30,"category":19},"developers","main","5f7a3e453c98261f93d19a6a7de44ad8f7b72d41",2,"https:\u002F\u002Fgithub.com\u002Fffsshhttiikk\u002Fopencode-agents-skills","https:\u002F\u002Fgithub.com\u002Fffsshhttiikk","2026-03-01 06:55:40",{"source":8,"skillName":5,"commands":38,"prompt":48,"zipAvailable":49},[39,42,45],{"tool":40,"command":41},"npx","npx skills add ffsshhttiikk\u002Fopencode-agents-skills --skill event-driven",{"tool":43,"command":44},"bunx","bunx skills add ffsshhttiikk\u002Fopencode-agents-skills --skill event-driven",{"tool":46,"command":47},"pnpm","pnpm dlx skills add ffsshhttiikk\u002Fopencode-agents-skills --skill event-driven","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002Fffsshhttiikk\u002Fopencode-agents-skills\u002Fblob\u002Fmain\u002Fevent-driven\u002FSKILL.md",true,[],[52,63,73,82,92,101],{"skillNo":53,"name":54,"nameZh":6,"description":55,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":56,"categories":57,"keywords":58,"publishedAt":24},"01M6CXT9TXDF79BWJTMQAPB49G","xamarin","Xamarin cross-platform development","https:\u002F\u002Fgithub.com\u002Fffsshhttiikk\u002Fopencode-agents-skills\u002Fblob\u002Fmain\u002Fxamarin\u002FSKILL.md",[],[54,59,60,61,22,62],"platform","cross-platform","mobile","development",{"skillNo":64,"name":65,"nameZh":6,"description":66,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":67,"categories":68,"keywords":69,"publishedAt":24},"01M6CXT8AD04MFYDA32VW3FKAG","wrangling","Data wrangling fundamentals","https:\u002F\u002Fgithub.com\u002Fffsshhttiikk\u002Fopencode-agents-skills\u002Fblob\u002Fmain\u002Fwrangling\u002FSKILL.md",[],[65,70,22,71,72],"data wrangling","science","data",{"skillNo":74,"name":75,"nameZh":6,"description":76,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":77,"categories":78,"keywords":79,"publishedAt":24},"01M6CXT717GCN7SRRNPBDP4508","windows","Windows operating system administration and scripting","https:\u002F\u002Fgithub.com\u002Fffsshhttiikk\u002Fopencode-agents-skills\u002Fblob\u002Fmain\u002Fwindows\u002FSKILL.md",[],[75,80,22,81],"system","scripting",{"skillNo":83,"name":84,"nameZh":6,"description":85,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":86,"categories":87,"keywords":88,"publishedAt":24},"01M6CXT54K794NMEM3XAPZZDKT","wide-column","Wide-column data model","https:\u002F\u002Fgithub.com\u002Fffsshhttiikk\u002Fopencode-agents-skills\u002Fblob\u002Fmain\u002Fwide-column\u002FSKILL.md",[],[89,90,22,91,72],"wide column","databases","model",{"skillNo":93,"name":94,"nameZh":6,"description":95,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":96,"categories":97,"keywords":98,"publishedAt":24},"01M6CXT28FMT2P4V9GZE67WA8E","wide-column-stores","Wide-column database stores","https:\u002F\u002Fgithub.com\u002Fffsshhttiikk\u002Fopencode-agents-skills\u002Fblob\u002Fmain\u002Fwide-column-stores\u002FSKILL.md",[],[99,90,22,100],"wide column stores","database",{"skillNo":102,"name":103,"nameZh":6,"description":104,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":105,"categories":106,"keywords":107,"publishedAt":24},"01M6CXT0D0M0Q4T2N7C2RX7DSN","websockets","WebSocket implementation and best practices","https:\u002F\u002Fgithub.com\u002Fffsshhttiikk\u002Fopencode-agents-skills\u002Fblob\u002Fmain\u002Fwebsockets\u002FSKILL.md",[],[103,108,109,110,22,20,111],"websocket","real-time","time","implementation"]