@lafken/event 0.10.1

package/LICENCE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Aníbal Emilio Jorquera Cornejo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,288 @@
+# @lafken/event
+
+Listen and react to Amazon EventBridge events using TypeScript decorators. `@lafken/event` lets you define event rules with pattern-based filtering and automatically connects them to Lambda functions. Supports custom events, S3 notifications, and DynamoDB stream events.
+
+## Installation
+
+```bash
+npm install @lafken/event
+```
+
+## Getting Started
+
+Define an event rule class with `@EventRule`, add `@Rule` methods with event patterns, and register everything through `EventRuleResolver`:
+
+```typescript
+import { createApp, createModule } from '@lafken/main';
+import { EventRuleResolver } from '@lafken/event/resolver';
+import { EventRule, Rule, Event } from '@lafken/event/main';
+
+// 1. Define event handlers
+@EventRule()
+export class OrderEvents {
+  @Rule({
+    pattern: {
+      source: 'orders',
+      detailType: ['order.created'],
+    },
+  })
+  onOrderCreated(@Event() event: any) {
+    console.log('New order:', event);
+  }
+}
+
+// 2. Register in a module
+const orderModule = createModule({
+  name: 'order',
+  resources: [OrderEvents],
+});
+
+// 3. Add the resolver to the app
+createApp({
+  name: 'my-app',
+  resolvers: [new EventRuleResolver({ busName: 'my-event-bus' })],
+  modules: [orderModule],
+});
+```
+
+Each `@Rule` method becomes an independent Lambda function triggered by matching EventBridge events. The event payload is automatically passed through `$.detail`.
+
+## Features
+
+### Event Rule Class
+
+Use the `@EventRule` decorator to group related event handlers in a single class:
+
+```typescript
+import { EventRule, Rule, Event } from '@lafken/event/main';
+
+@EventRule()
+export class InventoryEvents {
+  @Rule({
+    pattern: {
+      source: 'inventory',
+      detailType: ['stock.updated'],
+    },
+  })
+  onStockUpdate(@Event() event: any) { }
+
+  @Rule({
+    pattern: {
+      source: 'inventory',
+      detailType: ['stock.depleted'],
+    },
+  })
+  onStockDepleted(@Event() event: any) { }
+}
+```
+
+### Custom Events
+
+Define rules that match custom events by specifying `source`, `detailType`, and `detail` filters:
+
+```typescript
+@Rule({
+  pattern: {
+    source: 'payments',
+    detailType: ['payment.completed', 'payment.refunded'],
+    detail: {
+      currency: ['USD', 'EUR'],
+    },
+  },
+})
+onPaymentEvent(@Event() event: any) {
+  // Triggered only for USD or EUR payments
+}
+```
+
+#### Pattern Fields
+
+| Field        | Type       | Description                                          |
+| ------------ | ---------- | ---------------------------------------------------- |
+| `source`     | `string`   | Event source identifier (required)                   |
+| `detailType` | `string[]` | Event type names to match                            |
+| `detail`     | `object`   | Attribute-level filtering on the event payload       |
+
+### S3 Integration
+
+Listen for S3 bucket notifications delivered through EventBridge. Set `integration: 's3'` and define a pattern matching the S3 event structure:
+
+```typescript
+@Rule({
+  integration: 's3',
+  pattern: {
+    detailType: ['Object Created'],
+    detail: {
+      bucket: {
+        name: ['uploads-bucket'],
+      },
+      object: {
+        key: [{ prefix: 'images/' }],
+      },
+    },
+  },
+})
+onImageUploaded(@Event() event: any) {
+  // Triggered when a new object is created under images/
+}
+```
+
+#### S3 Pattern Options
+
+| Field                 | Type                               | Description                                  |
+| --------------------- | ---------------------------------- | -------------------------------------------- |
+| `detailType`          | `S3DetailType[]`                   | `'Object Created'` or `'Object Deleted'`     |
+| `detail.bucket.name`  | `string[]`                         | Bucket names to match                        |
+| `detail.object.key`   | `(string \| S3ObjectKey)[]`        | Object keys or prefix/suffix patterns        |
+
+Object key filters support `prefix` and `suffix` matching:
+
+```typescript
+detail: {
+  object: {
+    key: [
+      { prefix: 'uploads/' },
+      { suffix: '.pdf' },
+      'exact-filename.txt',
+    ],
+  },
+}
+```
+
+### DynamoDB Integration
+
+Consume events from DynamoDB Streams routed through EventBridge. The target table must have streams enabled (see `@lafken/dynamo` stream configuration). Set `integration: 'dynamodb'` and use `source` to specify the table name:
+
+```typescript
+@Rule({
+  integration: 'dynamodb',
+  pattern: {
+    source: 'customers',
+    detail: {
+      eventName: ['INSERT', 'MODIFY'],
+      newImage: {
+        status: ['active'],
+      },
+    },
+  },
+})
+onCustomerChange(@Event() event: any) {
+  // Triggered on INSERT or MODIFY where status is 'active'
+}
+```
+
+#### DynamoDB Pattern Options
+
+| Field              | Type                                    | Description                                   |
+| ------------------ | --------------------------------------- | --------------------------------------------- |
+| `source`           | `string`                                | DynamoDB table name                           |
+| `detail.eventName` | `('INSERT' \| 'MODIFY' \| 'REMOVE')[]` | Stream event types to match                   |
+| `detail.keys`      | `DynamoAttributeFilters`                | Filter by primary key values                  |
+| `detail.newImage`  | `DynamoAttributeFilters`                | Filter by new item attributes (after change)  |
+| `detail.oldImage`  | `DynamoAttributeFilters`                | Filter by old item attributes (before change) |
+
+Attribute filters support EventBridge content-based filtering patterns:
+
+```typescript
+detail: {
+  keys: {
+    email: ['user@example.com'],
+    age: [{ numeric: ['>', 18] }],
+  },
+  newImage: {
+    name: [{ prefix: 'A' }],
+    role: [{ 'anything-but': 'admin' }],
+  },
+}
+```
+
+#### Available Filter Patterns
+
+| Pattern               | Example                                   | Description                        |
+| --------------------- | ----------------------------------------- | ---------------------------------- |
+| Exact match           | `'value'`                                 | Matches exact string or number     |
+| `prefix`              | `{ prefix: 'usr_' }`                     | Starts with                        |
+| `suffix`              | `{ suffix: '.com' }`                     | Ends with                          |
+| `anything-but`        | `{ 'anything-but': 'admin' }`            | Matches everything except          |
+| `numeric`             | `{ numeric: ['>', 100] }`                | Numeric comparison                 |
+| `numeric` (range)     | `{ numeric: ['>=', 0, '<', 100] }`       | Numeric range                      |
+| `exists`              | `{ exists: true }`                        | Field exists or does not exist     |
+| `equals-ignore-case`  | `{ 'equals-ignore-case': 'active' }`     | Case-insensitive string match      |
+
+### Receiving Events
+
+Use the `@Event` parameter decorator to inject the EventBridge event payload into a handler method. The payload is automatically extracted from `$.detail`:
+
+```typescript
+@Rule({
+  pattern: {
+    source: 'notifications',
+    detailType: ['notification.sent'],
+  },
+})
+onNotification(@Event() event: any) {
+  // event contains the detail object, not the full EventBridge envelope
+  console.log(event.recipientId, event.channel);
+}
+```
+
+### Event Buses
+
+Configure one or more custom event buses when initializing `EventRuleResolver`. Each `@Rule` can target a specific bus via the `bus` option. If omitted, the default EventBridge bus is used:
+
+```typescript
+import { EventRuleResolver } from '@lafken/event/resolver';
+
+createApp({
+  name: 'my-app',
+  resolvers: [
+    new EventRuleResolver(
+      {
+        busName: 'orders-bus',
+        extend: ({ eventBus, scope }) => {
+          // Apply additional CDKTN configuration
+        },
+      },
+      {
+        busName: 'notifications-bus',
+      }
+    ),
+  ],
+});
+```
+
+Reference a specific bus from a rule:
+
+```typescript
+@Rule({
+  bus: 'orders-bus',
+  pattern: {
+    source: 'checkout',
+    detailType: ['checkout.completed'],
+  },
+})
+onCheckout(@Event() event: any) { }
+```
+
+### Retry Policy
+
+Configure how EventBridge handles failed target invocations using `retryAttempts` and `maxEventAge`:
+
+```typescript
+@Rule({
+  retryAttempts: 3,
+  maxEventAge: 7200,
+  pattern: {
+    source: 'billing',
+    detailType: ['invoice.generated'],
+  },
+})
+onInvoice(@Event() event: any) {
+  // Retries up to 3 times, discards events older than 2 hours
+}
+```
+
+| Option          | Type     | Description                                                |
+| --------------- | -------- | ---------------------------------------------------------- |
+| `retryAttempts` | `number` | Maximum retry attempts if the target invocation fails      |
+| `maxEventAge`   | `number` | Maximum event age in seconds before the event is discarded |

package/lib/index.d.ts

@@ -0,0 +1,2 @@
+export * from './main';
+export * from './resolver';

package/lib/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./main"), exports);
+__exportStar(require("./resolver"), exports);

package/lib/main/event/event.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Parameter decorator that injects the raw EventBridge event into a
+ * handler method argument.
+ *
+ * Use it on a parameter of an `@EventHandler` method so the framework
+ * passes the incoming EventBridge event payload at runtime.
+ *
+ * @example
+ * ```ts
+ * @EventRule({})
+ * export class OrderEvents {
+ *   @EventHandler({ source: 'orders', detailType: 'order.created' })
+ *   onOrderCreated(@Event() event: any) {
+ *     // event contains the full EventBridge event payload
+ *   }
+ * }
+ * ```
+ */
+export declare const Event: () => (target: any, methodName: string, _number: number) => void;

package/lib/main/event/event.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Event = void 0;
+const common_1 = require("@lafken/common");
+/**
+ * Parameter decorator that injects the raw EventBridge event into a
+ * handler method argument.
+ *
+ * Use it on a parameter of an `@EventHandler` method so the framework
+ * passes the incoming EventBridge event payload at runtime.
+ *
+ * @example
+ * ```ts
+ * @EventRule({})
+ * export class OrderEvents {
+ *   @EventHandler({ source: 'orders', detailType: 'order.created' })
+ *   onOrderCreated(@Event() event: any) {
+ *     // event contains the full EventBridge event payload
+ *   }
+ * }
+ * ```
+ */
+const Event = () => (target, methodName, _number) => {
+    (0, common_1.reflectArgumentMethod)(target, methodName, common_1.LambdaArgumentTypes.event);
+};
+exports.Event = Event;

package/lib/main/index.d.ts

@@ -0,0 +1,2 @@
+export * from './event/event';
+export * from './rule';

package/lib/main/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./event/event"), exports);
+__exportStar(require("./rule"), exports);

package/lib/main/rule/index.d.ts

@@ -0,0 +1,2 @@
+export * from './rule';
+export * from './rule.types';

package/lib/main/rule/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./rule"), exports);
+__exportStar(require("./rule.types"), exports);

package/lib/main/rule/rule.d.ts

@@ -0,0 +1,50 @@
+import type { EventRuleProps } from './rule.types';
+export declare const RESOURCE_TYPE: "EVENT";
+/**
+ * Class decorator that registers a class as an EventBridge rule resource.
+ *
+ * The decorated class groups one or more `@Rule` handler methods that
+ * react to events published on an EventBridge bus. Each handler inside
+ * the class defines its own event pattern and integration.
+ *
+ * @param props - Optional resource configuration (e.g. a custom `name`).
+ *
+ * @example
+ * ```ts
+ * @EventRule()
+ * export class OrderEvents {
+ *   @Rule({ pattern: { source: 'orders', detailType: ['order.created'] } })
+ *   onCreated(@Event() event) { }
+ * }
+ * ```
+ */
+export declare const EventRule: (props?: import("@lafken/common").ResourceProps | undefined) => (constructor: Function) => void;
+/**
+ * Method decorator that registers a handler for a specific EventBridge
+ * rule pattern.
+ *
+ * The decorated method becomes a Lambda function that is invoked when
+ * an event matching the configured pattern is published on the
+ * EventBridge bus. Supports default custom events, S3 events, and
+ * DynamoDB stream events through the `integration` option.
+ *
+ * @param props - Rule configuration including the event pattern, optional
+ *                integration source, retry attempts, max event age, and bus name.
+ *
+ * @example
+ * ```ts
+ * // Custom event
+ * @Rule({
+ *   pattern: { source: 'payments', detailType: ['payment.completed'] },
+ * })
+ * onPayment(@Event() event) { }
+ *
+ * // S3 integration
+ * @Rule({
+ *   integration: 's3',
+ *   pattern: { detailType: ['Object Created'], detail: { bucket: { name: ['uploads'] } } },
+ * })
+ * onUpload(@Event() event) { }
+ * ```
+ */
+export declare const Rule: (props: EventRuleProps) => (target: any, methodName: string, descriptor: PropertyDescriptor) => any;

package/lib/main/rule/rule.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Rule = exports.EventRule = exports.RESOURCE_TYPE = void 0;
+const common_1 = require("@lafken/common");
+exports.RESOURCE_TYPE = 'EVENT';
+/**
+ * Class decorator that registers a class as an EventBridge rule resource.
+ *
+ * The decorated class groups one or more `@Rule` handler methods that
+ * react to events published on an EventBridge bus. Each handler inside
+ * the class defines its own event pattern and integration.
+ *
+ * @param props - Optional resource configuration (e.g. a custom `name`).
+ *
+ * @example
+ * ```ts
+ * @EventRule()
+ * export class OrderEvents {
+ *   @Rule({ pattern: { source: 'orders', detailType: ['order.created'] } })
+ *   onCreated(@Event() event) { }
+ * }
+ * ```
+ */
+exports.EventRule = (0, common_1.createResourceDecorator)({
+    type: exports.RESOURCE_TYPE,
+    callerFileIndex: 5,
+});
+/**
+ * Method decorator that registers a handler for a specific EventBridge
+ * rule pattern.
+ *
+ * The decorated method becomes a Lambda function that is invoked when
+ * an event matching the configured pattern is published on the
+ * EventBridge bus. Supports default custom events, S3 events, and
+ * DynamoDB stream events through the `integration` option.
+ *
+ * @param props - Rule configuration including the event pattern, optional
+ *                integration source, retry attempts, max event age, and bus name.
+ *
+ * @example
+ * ```ts
+ * // Custom event
+ * @Rule({
+ *   pattern: { source: 'payments', detailType: ['payment.completed'] },
+ * })
+ * onPayment(@Event() event) { }
+ *
+ * // S3 integration
+ * @Rule({
+ *   integration: 's3',
+ *   pattern: { detailType: ['Object Created'], detail: { bucket: { name: ['uploads'] } } },
+ * })
+ * onUpload(@Event() event) { }
+ * ```
+ */
+const Rule = (props) => (0, common_1.createLambdaDecorator)({
+    getLambdaMetadata: (props, methodName) => ({
+        ...props,
+        name: methodName,
+        eventType: 'rule',
+    }),
+})(props);
+exports.Rule = Rule;

package/lib/main/rule/rule.types.d.ts

@@ -0,0 +1,229 @@
+import type { BucketNames, DynamoTableNames, EventBusNames, LambdaMetadata, LambdaProps } from '@lafken/common';
+export interface EventRuleBaseProps {
+    /**
+     * Maximum event age.
+     *
+     * Specifies the maximum age of an event that can be sent to the rule's targets.
+     * Events older than this duration will be discarded.
+     */
+    maxEventAge?: number;
+    /**
+     * Retry attempts for failed events.
+     *
+     * Specifies the maximum number of times EventBridge will retry sending
+     * an event to the target if the initial attempt fails.
+     */
+    retryAttempts?: number;
+    /**
+     * Event bus name.
+     *
+     * Specifies the EventBridge bus where the rule will be created.
+     * If not provided, the default event bus is used.
+     */
+    bus?: EventBusNames;
+    /**
+     * Lambda configuration for the method.
+     *
+     * Specifies the properties and settings of the Lambda function
+     * associated with this API method. This allows you to customize
+     * aspects such as timeout, memory, runtime, environment variables,
+     * services, and tracing on a per-method basis.
+     *
+     * @example
+     * {
+     *   timeout: 300,
+     *   memory: 1024,
+     *   runtime: 22,
+     *   services: ['sqs'],
+     *   enableTrace: booleam
+     * }
+     */
+    lambda?: LambdaProps;
+}
+export type S3DetailType = 'Object Created' | 'Object Deleted';
+export type S3ObjectKey = {
+    prefix?: string;
+    suffix?: string;
+};
+export interface S3Detail {
+    bucket?: {
+        name: BucketNames[];
+    };
+    object?: {
+        key?: (S3ObjectKey | string)[];
+    };
+}
+export interface EventDefaultRuleProps extends EventRuleBaseProps {
+    /**
+     * Integration source for the EventBridge rule.
+     *
+     * Specifies the AWS service that will emit events for this rule.
+     * Common examples include:
+     * - `'dynamodb'` – captures events from a DynamoDB table.
+     * - `'s3'` – captures events from an S3 bucket.
+     */
+    integration?: never;
+    /**
+     * Event pattern for the EventBridge rule.
+     *
+     * Defines the filtering criteria that determine which events
+     * trigger the rule. Events are matched against the specified
+     * pattern fields.
+     * @example
+     * {
+     *   pattern: {
+     *     source: "<event_source>",
+     *     detailType: ['foo'],
+     *     detail: {
+     *       foo: 'bar'
+     *     }
+     *   }
+     * }
+     */
+    pattern: {
+        /**
+         * Event source.
+         *
+         * Specifies the AWS service or custom source that emits the events
+         * to be captured by this EventBridge rule.
+         */
+        source: string;
+        /**
+         * Event types to match.
+         *
+         * Optional array of event types (detailType) that should trigger the rule.
+         * If not specified, all event types from the source are captured.
+         */
+        detailType?: string[];
+        /**
+         * Additional filtering criteria on the event payload.
+         *
+         * Optional object specifying conditions on event attributes to further
+         * filter which events trigger the rule.
+         */
+        detail?: any;
+    };
+}
+export interface EventS3RuleProps extends EventRuleBaseProps {
+    /**
+     * Integration source for the EventBridge rule.
+     *
+     * Specifies the AWS service that will emit events for this rule.
+     * Common examples include:
+     * - `'dynamodb'` – captures events from a DynamoDB table.
+     * - `'s3'` – captures events from an S3 bucket.
+     */
+    integration: 's3';
+    /**
+     * Event pattern for the EventBridge rule.
+     *
+     * Defines the filtering criteria that determine which events
+     * trigger the rule. Events are matched against the specified
+     * pattern fields.
+     *
+     * @example
+     * {
+     *   pattern: {
+     *     detailType: ['Object Created'],
+     *     detail: {
+     *       bucket: {
+     *         name: 'bucket_name'
+     *       }
+     *     }
+     *   }
+     * }
+     */
+    pattern: {
+        /**
+         * Event types to match.
+         *
+         * Optional array of event types (detailType) that should trigger the rule.
+         * If not specified, all event types from the source are captured.
+         */
+        detailType: S3DetailType[];
+        /**
+         * Additional filtering criteria on the event payload.
+         *
+         * Optional object specifying conditions on event attributes to further
+         * filter which events trigger the rule.
+         */
+        detail: S3Detail;
+    };
+}
+type PrefixPattern = {
+    prefix: string;
+};
+type SuffixPattern = {
+    suffix: string;
+};
+type AnythingButPattern = {
+    'anything-but': string | string[];
+};
+type NumericPattern = {
+    numeric: ['=' | '>' | '>=' | '<' | '<=', number] | ['>' | '>=', number, '<' | '<=', number];
+};
+type ExistsPattern = {
+    exists: boolean;
+};
+type EqualsIgnoreCasePattern = {
+    'equals-ignore-case': string;
+};
+export type EventBridgePattern = string | number | boolean | PrefixPattern | SuffixPattern | AnythingButPattern | NumericPattern | ExistsPattern | EqualsIgnoreCasePattern;
+export type DynamoAttributeFilter = EventBridgePattern | EventBridgePattern[];
+export type DynamoAttributeFilters = Record<string, DynamoAttributeFilter>;
+interface DynamoDetail {
+    eventName?: ('INSERT' | 'MODIFY' | 'REMOVE')[];
+    keys?: DynamoAttributeFilters;
+    newImage?: DynamoAttributeFilters;
+    oldImage?: DynamoAttributeFilters;
+}
+export interface DynamoRuleProps extends EventRuleBaseProps {
+    /**
+     * Integration source for the EventBridge rule.
+     *
+     * Specifies the AWS service that will emit events for this rule.
+     * Common examples include:
+     * - `'dynamodb'` – captures events from a DynamoDB table.
+     * - `'s3'` – captures events from an S3 bucket.
+     */
+    integration: 'dynamodb';
+    /**
+     * Event pattern for the EventBridge rule.
+     *
+     * Defines the filtering criteria that determine which events
+     * trigger the rule. Events are matched against the specified
+     * pattern fields.
+     *
+     * @example
+     * {
+     *   pattern: {
+     *     source: 'dynamo_table_name',
+     *     detail: {
+     *       eventname: ['INSERT'],
+     *       keys: {
+     *         PK: ['a', 'b']
+     *       }
+     *     }
+     *   }
+     * }
+     */
+    pattern: {
+        /**
+         * Event source.
+         *
+         * Specifies the AWS service or custom source that emits the events
+         * to be captured by this EventBridge rule.
+         */
+        source: DynamoTableNames;
+        /**
+         * Additional filtering criteria on the event payload.
+         *
+         * Optional object specifying conditions on event attributes to further
+         * filter which events trigger the rule.
+         */
+        detail?: DynamoDetail;
+    };
+}
+export type EventRuleProps = EventDefaultRuleProps | EventS3RuleProps | DynamoRuleProps;
+export type EventRuleMetadata = LambdaMetadata & EventRuleProps;
+export {};

package/lib/main/rule/rule.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/resolver/index.d.ts

@@ -0,0 +1 @@
+export * from './resolver';

package/lib/resolver/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./resolver"), exports);

package/lib/resolver/resolver.d.ts

@@ -0,0 +1,12 @@
+import { type ClassResource } from '@lafken/common';
+import { type AppModule, type AppStack, type ResolverType } from '@lafken/resolver';
+import type { EventRuleResolverProps } from './resolver.types';
+export declare class EventRuleResolver implements ResolverType {
+    type: "EVENT";
+    private eventBuses;
+    private props;
+    constructor(...props: EventRuleResolverProps[]);
+    beforeCreate(scope: AppStack): Promise<void>;
+    create(module: AppModule, resource: ClassResource): void;
+    afterCreate(scope: AppStack): void;
+}

package/lib/resolver/resolver.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventRuleResolver = void 0;
+const cloudwatch_event_bus_1 = require("@cdktn/provider-aws/lib/cloudwatch-event-bus");
+const data_aws_cloudwatch_event_bus_1 = require("@cdktn/provider-aws/lib/data-aws-cloudwatch-event-bus");
+const common_1 = require("@lafken/common");
+const resolver_1 = require("@lafken/resolver");
+const main_1 = require("../main");
+const rule_1 = require("./rule/rule");
+const LafkenEventBus = resolver_1.lafkenResource.make(cloudwatch_event_bus_1.CloudwatchEventBus);
+const LafkenDataEventBus = resolver_1.lafkenResource.make(data_aws_cloudwatch_event_bus_1.DataAwsCloudwatchEventBus);
+class EventRuleResolver {
+    type = main_1.RESOURCE_TYPE;
+    eventBuses = {};
+    props = [];
+    constructor(...props) {
+        if (props) {
+            this.props = props;
+        }
+    }
+    async beforeCreate(scope) {
+        const defaultBus = new data_aws_cloudwatch_event_bus_1.DataAwsCloudwatchEventBus(scope, 'EventDefaultBus', {
+            name: 'default',
+        });
+        this.eventBuses.default = {
+            eventBus: defaultBus,
+        };
+        for (const eventBusProps of this.props) {
+            if (eventBusProps.busName === 'default') {
+                throw new Error('Event bus default already exist');
+            }
+            let eventBus;
+            if (eventBusProps.isExternal) {
+                eventBus = new LafkenDataEventBus(scope, `${eventBusProps.busName}-bus`, {
+                    name: eventBusProps.busName,
+                });
+            }
+            else {
+                eventBus = new LafkenEventBus(scope, `${eventBusProps.busName}-bus`, {
+                    name: eventBusProps.busName,
+                });
+                new resolver_1.ResourceOutput(eventBus, eventBusProps.outputs);
+            }
+            eventBus.isGlobal('event-bus', eventBusProps.busName);
+            this.eventBuses[eventBusProps.busName] = {
+                eventBus: eventBus,
+                extend: eventBusProps.extend,
+            };
+        }
+    }
+    create(module, resource) {
+        const metadata = (0, common_1.getResourceMetadata)(resource);
+        const handlers = (0, common_1.getResourceHandlerMetadata)(resource);
+        resolver_1.lambdaAssets.initializeMetadata({
+            foldername: metadata.foldername,
+            filename: metadata.filename,
+            minify: metadata.minify,
+            className: metadata.originalName,
+            methods: handlers.map((handler) => handler.name),
+        });
+        for (const handler of handlers) {
+            const id = `${handler.name}-${metadata.name}`;
+            const bus = this.eventBuses[handler.bus || 'default'];
+            new rule_1.Rule(module, id, {
+                bus: bus.eventBus,
+                handler,
+                resourceMetadata: metadata,
+            });
+        }
+    }
+    afterCreate(scope) {
+        for (const key in this.eventBuses) {
+            const { extend, eventBus } = this.eventBuses[key];
+            if (!extend) {
+                continue;
+            }
+            extend({
+                scope,
+                eventBus,
+            });
+        }
+    }
+}
+exports.EventRuleResolver = EventRuleResolver;

package/lib/resolver/resolver.types.d.ts

@@ -0,0 +1,87 @@
+import type { CloudwatchEventBus } from '@cdktn/provider-aws/lib/cloudwatch-event-bus';
+import type { DataAwsCloudwatchEventBus } from '@cdktn/provider-aws/lib/data-aws-cloudwatch-event-bus';
+import type { EventBusNames, ResourceOutputType } from '@lafken/common';
+import type { AppStack } from '@lafken/resolver';
+export type BusOutputAttributes = 'arn' | 'id';
+interface ExtendProps<T> {
+    /**
+     * The CDKTN application stack scope.
+     */
+    scope: AppStack;
+    /**
+     * The underlying CloudWatch Event Bus construct.
+     * Use this to apply additional CDKTN configuration beyond what
+     * `EventRuleResolverProps` exposes directly.
+     */
+    eventBus: T;
+}
+export interface EventBusList {
+    eventBus: CloudwatchEventBus | DataAwsCloudwatchEventBus;
+    extend?: (props: ExtendProps<CloudwatchEventBus | DataAwsCloudwatchEventBus>) => void;
+}
+export interface EventRuleResolverBaseProps {
+    /**
+     * Defines the name of the custom EventBridge event bus to create.
+     *
+     * The value must match one of the registered `EventBusNames` in your application.
+     * The reserved name `'default'` cannot be used here — the default EventBridge bus
+     * is always provisioned automatically.
+     */
+    busName: EventBusNames;
+}
+export interface InternalEventRuleResolverProps extends EventRuleResolverBaseProps {
+    isExternal?: never;
+    /**
+     * Defines which EventBridge event bus attributes should be exported.
+     *
+     * Supported attributes are based on Terraform `aws_cloudwatch_event_bus`
+     * attribute reference:
+     * - `arn`: ARN of the event bus.
+     * - `id`: Name of the event bus.
+     *
+     * Each selected attribute can be exported through SSM Parameter Store (`type: 'ssm'`)
+     * or Terraform outputs (`type: 'output'`).
+     *
+     * @example
+     * {
+     *   outputs: [
+     *     { type: 'ssm', name: '/my-app/orders-bus-arn', value: 'arn' },
+     *     { type: 'output', name: 'orders_bus_id', value: 'id' }
+     *   ]
+     * }
+     */
+    outputs?: ResourceOutputType<BusOutputAttributes>;
+    /**
+     * Allows extending the event bus with custom configurations or resources.
+     *
+     * @example
+     * {
+     *   extend: ({ eventBus, scope }) => {
+     *     // Apply additional CDKTN configuration
+     *   },
+     * }
+     */
+    extend?: (props: ExtendProps<CloudwatchEventBus>) => void;
+}
+export interface ExternalEventRuleResolverProps extends EventRuleResolverBaseProps {
+    /**
+     * Marks the EventBridge event bus as an external resource.
+     *
+     * When set to `true`, the event bus is not created by the framework.
+     * Instead, it references an existing EventBridge event bus using the provided `busName`.
+     */
+    isExternal: true;
+    /**
+     * Allows extending the event bus with custom configurations or resources.
+     *
+     * @example
+     * {
+     *   extend: ({ eventBus, scope }) => {
+     *     // Apply additional CDKTN configuration
+     *   },
+     * }
+     */
+    extend?: (props: ExtendProps<DataAwsCloudwatchEventBus>) => void;
+}
+export type EventRuleResolverProps = InternalEventRuleResolverProps | ExternalEventRuleResolverProps;
+export {};

package/lib/resolver/resolver.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/resolver/rule/rule.d.ts

@@ -0,0 +1,19 @@
+import { CloudwatchEventRule } from '@cdktn/provider-aws/lib/cloudwatch-event-rule';
+import { type AppModule } from '@lafken/resolver';
+import type { RuleProps } from './rule.types';
+declare const Rule_base: (new (...args: any[]) => {
+    isGlobal(module: import("@lafken/common").ModuleGlobalReferenceNames | (string & {}), id: string): void;
+    isDependent(resolveDependency: () => void): void;
+    readonly node: import("constructs").Node;
+    with(...mixins: import("constructs").IMixin[]): import("constructs").IConstruct;
+    toString(): string;
+}) & typeof CloudwatchEventRule;
+export declare class Rule extends Rule_base {
+    private props;
+    constructor(scope: AppModule, id: string, props: RuleProps);
+    private addEventTarget;
+    private static getEvent;
+    private static inferDynamoDBType;
+    private static transformAttributes;
+}
+export {};

package/lib/resolver/rule/rule.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Rule = void 0;
+const cloudwatch_event_rule_1 = require("@cdktn/provider-aws/lib/cloudwatch-event-rule");
+const cloudwatch_event_target_1 = require("@cdktn/provider-aws/lib/cloudwatch-event-target");
+const resolver_1 = require("@lafken/resolver");
+const cdktn_1 = require("cdktn");
+class Rule extends resolver_1.lafkenResource.make(cloudwatch_event_rule_1.CloudwatchEventRule) {
+    props;
+    constructor(scope, id, props) {
+        const { handler, bus } = props;
+        super(scope, `${id}-rule`, {
+            name: id,
+            eventBusName: bus.name,
+            eventPattern: cdktn_1.Fn.jsonencode(Rule.getEvent(handler)),
+        });
+        this.props = props;
+        this.isGlobal(scope.id, id);
+        this.addEventTarget(id);
+    }
+    addEventTarget(id) {
+        const { resourceMetadata, handler } = this.props;
+        const lambdaHandler = new resolver_1.LambdaHandler(this, `${handler.name}-${resourceMetadata.name}`, {
+            ...handler,
+            originalName: resourceMetadata.originalName,
+            filename: resourceMetadata.filename,
+            foldername: resourceMetadata.foldername,
+            suffix: 'event',
+            principal: 'events.amazonaws.com',
+            sourceArn: this.arn,
+        });
+        new cloudwatch_event_target_1.CloudwatchEventTarget(this, `${id}-event-target`, {
+            rule: this.name,
+            arn: lambdaHandler.arn,
+            retryPolicy: {
+                maximumRetryAttempts: handler.retryAttempts,
+                maximumEventAgeInSeconds: handler.maxEventAge,
+            },
+            inputPath: '$.detail',
+        });
+    }
+    static getEvent(handler) {
+        if (!handler.integration) {
+            return {
+                source: [handler.pattern.source],
+                detail: handler.pattern.detail,
+                'detail-type': handler.pattern.detailType,
+            };
+        }
+        switch (handler.integration) {
+            case 's3': {
+                return {
+                    source: ['aws.s3'],
+                    'detail-type': handler.pattern.detailType,
+                    detail: handler.pattern.detail,
+                };
+            }
+            case 'dynamodb': {
+                const dynamoDetail = {
+                    ...(handler.pattern.detail?.keys
+                        ? {
+                            Keys: Rule.transformAttributes(handler.pattern.detail?.keys),
+                        }
+                        : {}),
+                    ...(handler.pattern.detail?.newImage
+                        ? {
+                            NewImage: Rule.transformAttributes(handler.pattern.detail?.newImage),
+                        }
+                        : {}),
+                    ...(handler.pattern.detail?.oldImage
+                        ? {
+                            OldImage: Rule.transformAttributes(handler.pattern.detail?.oldImage),
+                        }
+                        : {}),
+                };
+                return {
+                    source: [`dynamodb.${handler.pattern.source}`],
+                    'detail-type': ['db:stream'],
+                    ...(Object.keys(dynamoDetail).length > 0 || handler.pattern.detail?.eventName
+                        ? {
+                            detail: {
+                                ...(handler.pattern.detail?.eventName
+                                    ? {
+                                        eventName: handler.pattern.detail?.eventName,
+                                    }
+                                    : {}),
+                                dynamodb: dynamoDetail,
+                            },
+                        }
+                        : {}),
+                };
+            }
+            default:
+                throw new Error('Unsupported integration type');
+        }
+    }
+    static inferDynamoDBType(value) {
+        if (typeof value === 'string')
+            return 'S';
+        if (typeof value === 'number')
+            return 'N';
+        if (typeof value === 'boolean')
+            return 'BOOL';
+        if (typeof value === 'object') {
+            if ('numeric' in value)
+                return 'N';
+            if ('prefix' in value || 'suffix' in value || 'equals-ignore-case' in value)
+                return 'S';
+        }
+        return 'S';
+    }
+    static transformAttributes(attrs) {
+        if (!attrs)
+            return undefined;
+        const transformed = {};
+        for (const [key, value] of Object.entries(attrs)) {
+            const values = Array.isArray(value) ? value : [value];
+            const type = Rule.inferDynamoDBType(values[0]);
+            transformed[key] = {
+                [type]: values,
+            };
+        }
+        return transformed;
+    }
+}
+exports.Rule = Rule;

package/lib/resolver/rule/rule.types.d.ts

@@ -0,0 +1,9 @@
+import type { CloudwatchEventBus } from '@cdktn/provider-aws/lib/cloudwatch-event-bus';
+import type { DataAwsCloudwatchEventBus } from '@cdktn/provider-aws/lib/data-aws-cloudwatch-event-bus';
+import type { ResourceMetadata } from '@lafken/common';
+import type { EventRuleMetadata } from '../../main';
+export interface RuleProps {
+    resourceMetadata: ResourceMetadata;
+    handler: EventRuleMetadata;
+    bus: CloudwatchEventBus | DataAwsCloudwatchEventBus;
+}

package/lib/resolver/rule/rule.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,86 @@
+{
+  "name": "@lafken/event",
+  "version": "0.10.1",
+  "private": false,
+  "description": "Define EventBridge event listeners using TypeScript decorators - serverless event-driven infrastructure",
+  "keywords": [
+    "aws",
+    "eventbridge",
+    "event",
+    "event-driven",
+    "serverless",
+    "typescript",
+    "decorators",
+    "lafken"
+  ],
+  "homepage": "https://github.com/Hero64/lafken#readme",
+  "bugs": "https://github.com/Hero64/lafken/issues",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Hero64/lafken",
+    "directory": "packages/event"
+  },
+  "license": "MIT",
+  "author": "Aníbal Jorquera",
+  "exports": {
+    "./main": {
+      "import": "./lib/main/index.js",
+      "types": "./lib/main/index.d.ts",
+      "require": "./lib/main/index.js"
+    },
+    "./resolver": {
+      "import": "./lib/resolver/index.js",
+      "types": "./lib/resolver/index.d.ts",
+      "require": "./lib/resolver/index.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "main": [
+        "./lib/main/index.d.ts"
+      ],
+      "resolver": [
+        "./lib/resolver/index.d.ts"
+      ]
+    }
+  },
+  "files": [
+    "lib"
+  ],
+  "dependencies": {
+    "reflect-metadata": "^0.2.2",
+    "@lafken/resolver": "0.10.1"
+  },
+  "devDependencies": {
+    "@cdktn/provider-aws": "^23.5.0",
+    "@swc/core": "^1.15.21",
+    "@swc/helpers": "^0.5.20",
+    "@vitest/runner": "^4.1.2",
+    "cdktn": "^0.22.1",
+    "cdktn-vitest": "^1.0.0",
+    "constructs": "^10.6.0",
+    "typescript": "6.0.2",
+    "unplugin-swc": "^1.5.9",
+    "vitest": "^4.1.2",
+    "@lafken/common": "0.10.1"
+  },
+  "peerDependencies": {
+    "@cdktn/provider-aws": ">=23.0.0",
+    "cdktn": ">=0.22.0",
+    "constructs": "^10.4.5",
+    "@lafken/common": "0.10.1"
+  },
+  "engines": {
+    "node": ">=20.19"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "pnpm clean && tsc -p ./tsconfig.build.json",
+    "check-types": "tsc --noEmit -p ./tsconfig.build.json",
+    "clean": "rm -rf ./lib",
+    "dev": "tsc -w",
+    "test": "vitest"
+  }
+}