feat(lambda,event-bridge): lambda event sources

.projenrc.js

@@ -109,7 +109,7 @@ const project = new CustomTypescriptProject({
     "constructs@^10.0.0",
     "esbuild",
     "typesafe-dynamodb@^0.1.5",
-    "typescript@^4.6.2",
+    "typescript@^4.7.2",
   ],
   eslintOptions: {
     lintProjenRc: true,
@@ -172,20 +172,33 @@ project.eslint.addRules({
   "@typescript-eslint/no-shadow": "off",
   "@typescript-eslint/member-ordering": "off",
   "brace-style": "off",
+  "@typescript-eslint/explicit-member-accessibility": "off",
 });
 
-/**
- * ES Lint parser needs to know about all of the tsconfig files to use.
- */
 project.eslint.addOverride({
-  files: ["*.ts", "*.tsx"],
+  files: ["*.ts", "*.mts", "*.cts", "*.tsx"],
   parserOptions: {
     project: [
       "./tsconfig.dev.json",
       "./test-app/tsconfig.json",
       "./website/tsconfig.json",
     ],
   },
+  rules: {
+    "@typescript-eslint/explicit-member-accessibility": [
+      "error",
+      {
+        accessibility: "explicit",
+        overrides: {
+          accessors: "explicit",
+          constructors: "no-public",
+          methods: "explicit",
+          properties: "off",
+          parameterProperties: "off",
+        },
+      },
+    ],
+  },
 });
 
 project.synth();

src/event-bridge/event-bus.ts

@@ -40,7 +40,12 @@ export const isEventBus = <E extends Event>(v: any): v is IEventBus<E> => {
   );
 };
 
-export interface IEventBusFilterable<E extends Event> {
+/**
+ * Returns the {@link Event} type on the {@link EventBus}.
+ */
+export type EventBusEvent<B extends IEventBus<any>> = [B] extends [IEventBus<infer E>] ? E : never;
+
+export interface IEventBusFilterable<in E extends Event> {
   /**
    * EventBus Rules can filter events using Functionless predicate functions.
    *
@@ -115,16 +120,16 @@ export interface IEventBusFilterable<E extends Event> {
   ): Rule<E, O>;
 }
 
-export interface IEventBus<E extends Event = Event>
+export interface IEventBus<in E extends Event = Event, O extends E = E>
   extends IEventBusFilterable<E>,
     Integration<
       "EventBus",
       (
-        event: EventBusPutEventInput<E>,
-        ...events: EventBusPutEventInput<E>[]
+        event: EventBusPutEventInput<O>,
+        ...events: EventBusPutEventInput<O>[]
       ) => void,
       EventBusTargetIntegration<
-        EventBusPutEventInput<E>,
+        EventBusPutEventInput<O>,
         aws_events_targets.EventBusProps | undefined
       >
     > {
@@ -134,8 +139,8 @@ export interface IEventBus<E extends Event = Event>
 
   // @ts-ignore - value does not exist, is only available at compile time
   readonly __functionBrand: (
-    event: EventBusPutEventInput<E>,
-    ...events: EventBusPutEventInput<E>[]
+    event: EventBusPutEventInput<O>,
+    ...events: EventBusPutEventInput<O>[]
   ) => void;
 
   /**
@@ -147,15 +152,10 @@ export interface IEventBus<E extends Event = Event>
    * Put one or more events on an Event Bus.
    */
   putEvents(
-    event: EventBusPutEventInput<E>,
-    ...events: EventBusPutEventInput<E>[]
+    event: EventBusPutEventInput<O>,
+    ...events: EventBusPutEventInput<O>[]
   ): void;
 
-  readonly eventBus: EventBusTargetIntegration<
-    E,
-    aws_events_targets.EventBusProps | undefined
-  >;
-
   /**
    * Creates a rule that matches all events on the bus.
    *
@@ -176,11 +176,11 @@ export interface IEventBus<E extends Event = Event>
    *  .pipe(func);
    * ```
    */
-  all(): PredicateRuleBase<E>;
-  all(scope: Construct, id: string): PredicateRuleBase<E>;
+  all(): PredicateRuleBase<O>;
+  all(scope: Construct, id: string): PredicateRuleBase<O>;
 }
 
-abstract class EventBusBase<E extends Event> implements IEventBus<E> {
+abstract class EventBusBase<in E extends Event, O extends E> implements IEventBus<E, O> {
   /**
    * This static properties identifies this class as an EventBus to the TypeScript plugin.
    */
@@ -192,7 +192,7 @@ abstract class EventBusBase<E extends Event> implements IEventBus<E> {
 
   protected static singletonDefaultNode = "__DefaultBus";
 
-  private allRule: PredicateRuleBase<E> | undefined;
+  private allRule: PredicateRuleBase<O> | undefined;
 
   public readonly putEvents: IntegrationCall<
     "EventBus.putEvents",
@@ -201,8 +201,8 @@ abstract class EventBusBase<E extends Event> implements IEventBus<E> {
 
   // @ts-ignore - value does not exist, is only available at compile time
   readonly __functionBrand: (
-    event: EventBusPutEventInput<E>,
-    ...events: EventBusPutEventInput<E>[]
+    event: EventBusPutEventInput<O>,
+    ...events: EventBusPutEventInput<O>[]
   ) => void;
 
   constructor(readonly bus: aws_events.IEventBus) {
@@ -339,7 +339,7 @@ abstract class EventBusBase<E extends Event> implements IEventBus<E> {
   }
 
   public readonly eventBus = makeEventBusIntegration<
-    E,
+    EventBusPutEventInput<O>,
     aws_events_targets.EventBusProps | undefined
   >({
     target: (props, targetInput?) => {
@@ -354,16 +354,16 @@ abstract class EventBusBase<E extends Event> implements IEventBus<E> {
   /**
    * @inheritdoc
    */
-  when<O extends E>(
+   public when<O extends E>(
     id: string,
     predicate: RulePredicateFunction<E, O>
   ): Rule<E, O>;
-  when<O extends E>(
+  public when<O extends E>(
     scope: Construct,
     id: string,
     predicate: RulePredicateFunction<E, O>
   ): Rule<E, O>;
-  when<O extends E>(
+  public when<O extends E>(
     scope: Construct | string,
     id?: string | RulePredicateFunction<E, O>,
     predicate?: RulePredicateFunction<E, O>
@@ -385,12 +385,12 @@ abstract class EventBusBase<E extends Event> implements IEventBus<E> {
     }
   }
 
-  all(): PredicateRuleBase<E>;
-  all(scope: Construct, id: string): PredicateRuleBase<E>;
-  all(scope?: Construct, id?: string): PredicateRuleBase<E> {
+  public all(): PredicateRuleBase<O>;
+  public all(scope: Construct, id: string): PredicateRuleBase<O>;
+  public all(scope?: Construct, id?: string): PredicateRuleBase<O> {
     if (!scope || !id) {
       if (!this.allRule) {
-        this.allRule = new PredicateRuleBase<E>(
+        this.allRule = new PredicateRuleBase<O>(
           this.bus,
           "all",
           this as IEventBus<any>,
@@ -400,7 +400,7 @@ abstract class EventBusBase<E extends Event> implements IEventBus<E> {
       }
       return this.allRule;
     }
-    return new PredicateRuleBase<E>(scope, id, this as IEventBus<any>, {
+    return new PredicateRuleBase<O>(scope, id, this as IEventBus<any>, {
       doc: {},
     });
   }
@@ -456,15 +456,15 @@ export type EventBusPutEventInput<E extends Event> = Partial<E> &
  *    .pipe(anotherEventBus);
  * ```
  */
-export class EventBus<E extends Event> extends EventBusBase<E> {
+export class EventBus<in E extends Event, O extends E = E> extends EventBusBase<E, O> {
   constructor(scope: Construct, id: string, props?: aws_events.EventBusProps) {
     super(new aws_events.EventBus(scope, id, props));
   }
 
   /**
    * Import an {@link aws_events.IEventBus} wrapped with Functionless abilities.
    */
-  static fromBus<E extends Event>(bus: aws_events.IEventBus): IEventBus<E> {
+  public static fromBus<E extends Event>(bus: aws_events.IEventBus): IEventBus<E> {
     return new ImportedEventBus<E>(bus);
   }
 
@@ -477,9 +477,9 @@ export class EventBus<E extends Event> extends EventBusBase<E> {
    * new functionless.EventBus.fromBus(awsBus);
    * ```
    */
-  static default<E extends Event>(stack: Stack): DefaultEventBus<E>;
-  static default<E extends Event>(scope: Construct): DefaultEventBus<E>;
-  static default<E extends Event>(
+  public static default<E extends Event>(stack: Stack): DefaultEventBus<E>;
+  public static default<E extends Event>(scope: Construct): DefaultEventBus<E>;
+  public static default<E extends Event>(
     scope: Construct | Stack
   ): DefaultEventBus<E> {
     return new DefaultEventBus<E>(scope);
@@ -501,7 +501,7 @@ export class EventBus<E extends Event> extends EventBusBase<E> {
    *    .pipe(func);
    * ```
    */
-  static schedule(
+  public static schedule(
     scope: Construct,
     id: string,
     schedule: aws_events.Schedule,
@@ -514,7 +514,7 @@ export class EventBus<E extends Event> extends EventBusBase<E> {
   }
 }
 
-export class DefaultEventBus<E extends Event> extends EventBusBase<E> {
+export class DefaultEventBus<in E extends Event> extends EventBusBase<E, E> {
   constructor(scope: Construct) {
     const stack = scope instanceof Stack ? scope : Stack.of(scope);
     const bus =
@@ -547,7 +547,7 @@ export class DefaultEventBus<E extends Event> extends EventBusBase<E> {
    *    .pipe(func);
    * ```
    */
-  schedule(
+  public schedule(
     scope: Construct,
     id: string,
     schedule: aws_events.Schedule,
@@ -565,7 +565,7 @@ export class DefaultEventBus<E extends Event> extends EventBusBase<E> {
   }
 }
 
-class ImportedEventBus<E extends Event> extends EventBusBase<E> {
+class ImportedEventBus<in E extends Event> extends EventBusBase<E, E> {
   constructor(bus: aws_events.IEventBus) {
     super(bus);
   }
@@ -589,7 +589,7 @@ class ImportedEventBus<E extends Event> extends EventBusBase<E> {
  */
 export interface EventBusTargetIntegration<
   // the payload type we expect to be transformed into before making this call.
-  P,
+  in P,
   Props extends object | undefined = undefined
 > {
   /**
@@ -599,8 +599,11 @@ export interface EventBusTargetIntegration<
    *
    * This is useful for cases like {@link IRule.pipe} and {@link IEventTransform.pipe} which need to validate that
    * an integration implements the right EventBus integration.
+   *
+   * We use a function interface in order to satisfy the covariant relationship that we expect the super-P in as opposed to
+   * returning sub-P.
    */
-  __payloadBrand: P;
+  __payloadBrand: ((p: P) => void);
 
   /**
    * Method called when an integration is passed to EventBus's `.pipe` function.

src/event-bridge/index.ts

@@ -1,3 +1,8 @@
-export { EventBus, EventBusTargetIntegration } from "./event-bus";
+export {
+  EventBus,
+  isEventBus,
+  IEventBus,
+  EventBusTargetIntegration,
+} from "./event-bus";
 export * from "./rule";
 export * from "./types";