@lafken/event 0.6.0

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,162 @@
+# @lafken/event
+
+`@lafken/event` helps you create listeners for EventBridge events and trigger Lambda functions to process those events. It provides decorators that simplify configuring event listeners—whether for custom events or built-in sources like S3 and DynamoDB.
+
+## Installation
+
+```bash
+npm install @lafken/event
+```
+
+## Configuration
+
+Add the EventRuleResolver from the @lafken/event/resolver library.
+In its configuration, you can define one or more event buses. If no event bus is provided, the default EventBridge bus will be used for communication.
+
+```typescript
+import { ApiResolver } from '@lafken/event/resolver';
+
+createApp({
+  name: 'awesome-app',
+  resolvers: [
+    new EventRuleResolver({
+      busName: 'awesome-event-bus',
+      extend: ({ eventBus }) => {
+        // ... extend the event bus
+      },
+    }),
+  ],
+  ...
+});
+```
+
+This setup allows you to customize how events are routed and processed within your application.
+
+Next, you need to configure the module by importing the class resources decorated with the @EventRule decorator. These classes must contain methods decorated with @Rule, which will create the event listener and attach the corresponding Lambda function for execution.
+
+```typescript
+@EventRule({
+  minify: false,
+})
+export class GreetingEvent {
+  @Rule({
+    bus: 'awesome-event-bus',
+    pattern: {
+      source: 'simple-source',
+    },
+  })
+  simpleEvent(@Event() e: any) {
+    // ...
+  }
+}
+
+const greetingModule = createModule({
+  name: 'greeting',
+  resources: [
+    GreetingEvent
+  ]
+});
+```
+
+## Features
+
+### Receiving and Filtering Events
+The @Rule decorator allows you to define an event pattern by specifying the event source and applying filters on detail and detailType.
+
+```typescript
+@Rule({
+  pattern: {
+    source: 'simple-source',
+    detail: {
+      name: ['foo', 'bar'],
+    },
+    detailType: ['CREATE', 'UPDATE'],
+  },
+})
+// ...
+```
+
+### Receiving Events
+To access the payload sent by an event, you must use the @Event decorator. This decorator automatically maps the event’s inputPath to $.detail, allowing you to receive the event data directly as a parameter.
+
+```typescript
+@Rule(/* ... */)
+sayHelloFromEvent(@Event() event: any) {
+  console.log('simple source', event);
+}
+```
+### S3 integrations
+Event rules also support integration with Amazon S3 through EventBridge-enabled bucket notifications.
+When this integration is enabled, S3 events are delivered to EventBridge, allowing fine-grained filtering based on event metadata such as the bucket name, object key, and event type.
+
+To enable S3 integration within an event rule, set the integration property to 's3' and define a pattern that matches the desired S3 event structure.
+
+```typescript
+@Rule({
+  integration: 's3',
+  pattern: {
+    detailType: ['Object Created'],
+    detail: {
+      bucket: {
+        name: ['lafken-example-documents'],
+      },
+      object: {
+        key: [
+          {
+            prefix: 'test.json',
+          },
+        ],
+      },
+    },
+  },
+})
+s3(@Event() event: any) {
+  // Handler logic
+}
+```
+
+### Dynamo Integration
+Event rules can also consume and process events emitted by Amazon DynamoDB Streams.
+To use this integration, you must first enable DynamoDB Streams on the target table. Once enabled, DynamoDB will emit change records (INSERT, MODIFY, REMOVE), which can be routed through EventBridge and processed by your rule.
+
+After the stream is configured, you can define a rule with the integration: 'dynamodb' option and provide a pattern to filter the specific DynamoDB events you want to handle.
+
+```typescript
+@Rule({
+  integration: 'dynamodb',
+  pattern: {
+    source: 'clients',
+    detail: {
+      eventName: ['INSERT', 'MODIFY'],
+      keys: {
+        email: {
+          prefix: 'awesome',
+        },
+      },
+    },
+  },
+})
+dynamo(@Event() e: any) {
+  // ...
+}
+```
+
+### Event bus
+
+It is possible to configure multiple Event Buses when initializing the EventRuleResolver. Each event bus can then be referenced from individual rules by specifying its name in the bus property of the @Rule decorator.
+
+If no event bus is explicitly configured for a rule, the default EventBridge bus will be used automatically.
+
+
+```typescript
+//...
+new EventRuleResolver({
+  busName: 'awesome-event-bus',
+  extend: ({ eventBus }) => {
+    // ... extend the event bus
+  },
+}, {
+  busName: 'another-event-bus'
+}),
+// ...
+```

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 @@
+export declare const Event: () => (target: any, methodName: string, _number: number) => void;

package/lib/main/event/event.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Event = void 0;
+const common_1 = require("@lafken/common");
+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,4 @@
+import type { EventRuleProps } from './rule.types';
+export declare const RESOURCE_TYPE: "EVENT";
+export declare const EventRule: (props?: import("@lafken/common").ResourceProps | undefined) => (constructor: Function) => void;
+export declare const Rule: (props: EventRuleProps) => (target: any, methodName: string, descriptor: PropertyDescriptor) => any;

package/lib/main/rule/rule.js

@@ -0,0 +1,17 @@
+"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';
+exports.EventRule = (0, common_1.createResourceDecorator)({
+    type: exports.RESOURCE_TYPE,
+    callerFileIndex: 5,
+});
+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,211 @@
+import type { BucketNames, DynamoTableNames, EventBusNames, LambdaMetadata } 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;
+}
+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,11 @@
+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;
+}

package/lib/resolver/resolver.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventRuleResolver = void 0;
+const cloudwatch_event_bus_1 = require("@cdktf/provider-aws/lib/cloudwatch-event-bus");
+const data_aws_cloudwatch_event_bus_1 = require("@cdktf/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");
+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 = defaultBus;
+        for (const eventBusProps of this.props) {
+            if (eventBusProps.busName === 'default') {
+                throw new Error('Event bus default already exist');
+            }
+            this.eventBuses[eventBusProps.busName] = new cloudwatch_event_bus_1.CloudwatchEventBus(scope, `${eventBusProps.busName}-bus`, {
+                name: eventBusProps.busName,
+            });
+        }
+    }
+    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,
+                handler,
+                resourceMetadata: metadata,
+            });
+        }
+    }
+}
+exports.EventRuleResolver = EventRuleResolver;

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

@@ -0,0 +1,12 @@
+import type { CloudwatchEventBus } from '@cdktf/provider-aws/lib/cloudwatch-event-bus';
+import type { EventBusNames } from '@lafken/common';
+import type { AppStack } from '@lafken/resolver';
+interface ExtendProps {
+    scope: AppStack;
+    eventBus: CloudwatchEventBus;
+}
+export interface EventRuleResolverProps {
+    busName: EventBusNames;
+    extend?: (props: ExtendProps) => void;
+}
+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,18 @@
+import { CloudwatchEventRule } from '@cdktf/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;
+    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,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Rule = void 0;
+const cloudwatch_event_rule_1 = require("@cdktf/provider-aws/lib/cloudwatch-event-rule");
+const cloudwatch_event_target_1 = require("@cdktf/provider-aws/lib/cloudwatch-event-target");
+const resolver_1 = require("@lafken/resolver");
+const cdktf_1 = require("cdktf");
+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: cdktf_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',
+        });
+        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,8 @@
+import type { CloudwatchEventBus } from '@cdktf/provider-aws/lib/cloudwatch-event-bus';
+import type { ResourceMetadata } from '@lafken/common';
+import type { EventRuleMetadata } from '../../main';
+export interface RuleProps {
+    resourceMetadata: ResourceMetadata;
+    handler: EventRuleMetadata;
+    bus: CloudwatchEventBus;
+}

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,56 @@
+{
+  "name": "@lafken/event",
+  "version": "0.6.0",
+  "private": false,
+  "license": "MIT",
+  "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": {
+    "@cdktf/provider-aws": "21.22.0",
+    "cdktf": "0.21.0",
+    "constructs": "10.4.4",
+    "reflect-metadata": "0.2.2",
+    "@lafken/common": "0.6.0",
+    "@lafken/resolver": "0.6.0"
+  },
+  "devDependencies": {
+    "@jest/types": "^30.2.0",
+    "@types/jest": "30.0.0",
+    "jest": "30.2.0",
+    "ts-jest": "29.4.6",
+    "ts-node": "10.9.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "pnpm clean && tsc -p ./tsconfig.build.json",
+    "clean": "rm -rf ./lib",
+    "dev": "tsc -w",
+    "test": "jest",
+    "test:coverage": "jest --coverage"
+  }
+}