@lafken/event 0.8.0 → 0.9.0

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

@@ -1,4 +1,4 @@
-import type { BucketNames, DynamoTableNames, EventBusNames, LambdaMetadata } from '@lafken/common';
+import type { BucketNames, DynamoTableNames, EventBusNames, LambdaMetadata, LambdaProps } from '@lafken/common';
 export interface EventRuleBaseProps {
     /**
      * Maximum event age.
@@ -21,6 +21,24 @@ export interface EventRuleBaseProps {
      * 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 = {

package/lib/resolver/resolver.d.ts

@@ -8,4 +8,5 @@ export declare class EventRuleResolver implements ResolverType {
     constructor(...props: EventRuleResolverProps[]);
     beforeCreate(scope: AppStack): Promise<void>;
     create(module: AppModule, resource: ClassResource): void;
+    afterCreate(scope: AppStack): void;
 }

package/lib/resolver/resolver.js

@@ -7,6 +7,8 @@ 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 = {};
@@ -20,14 +22,30 @@ class EventRuleResolver {
         const defaultBus = new data_aws_cloudwatch_event_bus_1.DataAwsCloudwatchEventBus(scope, 'EventDefaultBus', {
             name: 'default',
         });
-        this.eventBuses.default = defaultBus;
+        this.eventBuses.default = {
+            eventBus: 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,
-            });
+            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) {
@@ -44,11 +62,23 @@ class EventRuleResolver {
             const id = `${handler.name}-${metadata.name}`;
             const bus = this.eventBuses[handler.bus || 'default'];
             new rule_1.Rule(module, id, {
-                bus,
+                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

@@ -1,12 +1,87 @@
 import type { CloudwatchEventBus } from '@cdktn/provider-aws/lib/cloudwatch-event-bus';
-import type { EventBusNames } from '@lafken/common';
+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';
-interface ExtendProps {
+export type BusOutputAttributes = 'arn' | 'id';
+interface ExtendProps<T> {
+    /**
+     * The CDKTN application stack scope.
+     */
     scope: AppStack;
-    eventBus: CloudwatchEventBus;
+    /**
+     * The underlying CloudWatch Event Bus construct.
+     * Use this to apply additional CDKTN configuration beyond what
+     * `EventRuleResolverProps` exposes directly.
+     */
+    eventBus: T;
 }
-export interface EventRuleResolverProps {
+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;
-    extend?: (props: ExtendProps) => void;
 }
+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/rule/rule.d.ts

@@ -5,6 +5,7 @@ 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 {

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

@@ -1,8 +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;
+    bus: CloudwatchEventBus | DataAwsCloudwatchEventBus;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lafken/event",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "private": false,
   "description": "Define EventBridge event listeners using TypeScript decorators - serverless event-driven infrastructure",
   "keywords": [
@@ -49,24 +49,24 @@
   ],
   "dependencies": {
     "reflect-metadata": "^0.2.2",
-    "@lafken/resolver": "0.8.0"
+    "@lafken/resolver": "0.9.0"
   },
   "devDependencies": {
-    "@cdktn/provider-aws": "^23.0.0",
-    "@swc/core": "^1.15.11",
-    "@swc/helpers": "^0.5.18",
-    "@vitest/runner": "^4.0.18",
-    "cdktn": "^0.22.0",
+    "@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.4.5",
+    "constructs": "^10.6.0",
     "unplugin-swc": "^1.5.9",
-    "vitest": "^4.0.18",
-    "@lafken/common": "0.8.0"
+    "vitest": "^4.1.2",
+    "@lafken/common": "0.9.0"
   },
   "peerDependencies": {
-    "@cdktn/provider-aws": "^23.0.0",
-    "@lafken/common": "^0.7.0",
-    "cdktn": "^0.22.0",
+    "@cdktn/provider-aws": ">=23.0.0",
+    "@lafken/common": ">=0.8.0",
+    "cdktn": ">=0.22.0",
     "constructs": "^10.4.5"
   },
   "engines": {