@alanszp/eventbridge-client 12.0.2 → 12.0.3

package/src/basicEventbridgeClient.ts

@@ -1,160 +0,0 @@
-import { ILogger } from "@alanszp/logger";
-import { SharedContext } from "@alanszp/shared-context";
-import { chain, omit, partition } from "lodash";
-import {
-  getEventbridgeClient,
-  PutEventEntryRequest,
-  PutEventEntryResponse,
-} from "./aws";
-import { mapLaraEventToAWSEvent } from "./helpers/mapLaraEventToAWSEvent";
-
-/**
- * Represents an event that is sent in the Lara ecosystem.
- *
- * @property topic: The topic of the event. E.g.: if an employee was created, topid would be employee.created.
- * @property body: The body of the event. This will be used to match in the rules, along with the topic and maybe the id. If it has a property id it
- *                  will be overwritten by the id sent to this method in the parameters.
- */
-export type LaraEvent = {
-  topic: string;
-  body: Record<string, unknown>;
-};
-
-export type PutEventFailedEntryResponse = PutEventEntryResponse & {
-  event: PutEventEntryRequest;
-};
-
-export interface EventDispatchResult {
-  successful: PutEventEntryResponse[];
-  failed: PutEventFailedEntryResponse[];
-  failedCount: number | undefined;
-}
-
-/**
- * Max batch size for the putEvents request defined by AWS.
- */
-const MAX_BATCH_SIZE = 10;
-
-/**
- * Basic client for Eventbridge.
- * Usage will be done by extending this class and implementing methods that internally call the protected sendEvents method.
- */
-export class BasicEventbridgeClient {
-  private appName: string;
-  private env: string;
-  private bus: string;
-  private client;
-
-  protected getLogger: () => ILogger;
-  protected context: SharedContext;
-
-  constructor(
-    appName: string,
-    env: string,
-    getLogger: () => ILogger,
-    context: SharedContext,
-    bus: string,
-    customEndpoint?: string,
-    customRegion?: string
-  ) {
-    this.appName = appName;
-    this.env = env;
-    this.bus = bus;
-    this.getLogger = getLogger;
-    this.context = context;
-    this.client = getEventbridgeClient(customEndpoint, customRegion);
-  }
-
-  protected async sendEvents(
-    events: LaraEvent[]
-  ): Promise<EventDispatchResult> {
-    const logger = this.getLogger();
-
-    const eventsToSend = chain(events)
-      .map((event) =>
-        mapLaraEventToAWSEvent(
-          event,
-          this.env,
-          this.appName,
-          this.bus,
-          logger,
-          this.context
-        )
-      )
-      .compact()
-      .map((event) => ({
-        Entries: [event],
-      }))
-      .value();
-
-    /**
-     * Eventbridge in US-EAST-1 has a limit of 10.000 events/second.
-     * We should be fine without a limiter here.
-     */
-    const results = await Promise.all(
-      eventsToSend.map((singleEventArray) =>
-        this.client
-          .putEvents(singleEventArray)
-          .promise()
-          .then(({ Entries, FailedEntryCount }) => ({
-            FailedEntryCount,
-            Entries: [
-              {
-                ...(Entries || [])[0],
-                event: singleEventArray.Entries[0],
-              },
-            ],
-          }))
-          .catch((error) => ({
-            FailedEntryCount: 1,
-            Entries: [
-              {
-                EventId: undefined,
-                ErrorMessage: JSON.stringify(error),
-                event: singleEventArray.Entries[0],
-              },
-            ],
-          }))
-      )
-    );
-
-    const aggregatedResult = results.reduce(
-      (prev, act) => {
-        const { Entries: NewEntries, FailedEntryCount: newFailedCount } = act;
-        const { eventsDispatched, failedCount } = prev;
-
-        return {
-          eventsDispatched: [
-            ...(eventsDispatched || []),
-            ...(NewEntries || []),
-          ],
-          failedCount: (failedCount || 0) + (newFailedCount || 0),
-        };
-      },
-      {
-        eventsDispatched: [],
-        failedCount: 0,
-      }
-    );
-
-    const { eventsDispatched, failedCount } = aggregatedResult;
-
-    const [successful, failed] = partition(
-      eventsDispatched,
-      (entry) => entry.EventId
-    );
-
-    logger.info("eventbridge.client.sendEvents.end", {
-      successful,
-      failed,
-    });
-
-    return {
-      successful: successful.map((eventDispatched) =>
-        omit(eventDispatched, "event")
-      ),
-      failed,
-      failedCount,
-    };
-  }
-}

package/src/helpers/mapLaraEventToAWSEvent.ts

@@ -1,37 +0,0 @@
-import { LaraEvent } from "../basicEventbridgeClient";
-import { PutEventsRequestEntry } from "aws-sdk/clients/eventbridge";
-import type { ILogger } from "@alanszp/logger";
-import type { SharedContext } from "@alanszp/shared-context";
-import { compact } from "lodash";
-import { createId } from "@paralleldrive/cuid2";
-
-export function mapLaraEventToAWSEvent(
-  { topic, body }: LaraEvent,
-  env: string,
-  appName: string,
-  bus: string,
-  logger: ILogger,
-  context: SharedContext
-): PutEventsRequestEntry | undefined {
-  const lid = context.getLifecycleId() || createId();
-  const oldlLch = context.getLifecycleChain();
-  const lch = compact([oldlLch, "aws.eb"]).join(",");
-  try {
-    return {
-      DetailType: topic,
-      Detail: JSON.stringify({ ...body, lch, lid }), // lid is included here since the TraceHeader is not sent to the targets by aws
-      Source: `${env}.lara.${appName}`,
-      EventBusName: bus,
-      Time: new Date(),
-      TraceHeader: lid,
-    };
-  } catch {
-    const org = body.organizationReference as string;
-    logger.error("eventbridge.client.map_lara_to_aws_event.parse_error", {
-      topic,
-      org,
-      lid,
-    });
-    return undefined;
-  }
-}

package/src/index.ts

@@ -1,3 +0,0 @@
-export * from "./basicEventbridgeClient";
-export * from "./aws/awsTypes";
-export * from "./types";

package/src/mockEventbridgeClient.ts

@@ -1,11 +0,0 @@
-import {
-  BasicEventbridgeClient,
-  EventDispatchResult,
-  LaraEvent,
-} from "./basicEventbridgeClient";
-
-export class MockEventbridgeClient extends BasicEventbridgeClient {
-  public mockSendEvents(events: LaraEvent[]): Promise<EventDispatchResult> {
-    return this.sendEvents(events);
-  }
-}

package/src/mocks/fixtures/eventbridgeFixture.ts

@@ -1,41 +0,0 @@
-export const topics = ["topic1", "topic2"];
-
-export const events = [{ property: "1" }, { property: "2" }];
-
-export const twoEventsToSend = [
-  { topic: topics[0], body: events[0] },
-  { topic: topics[1], body: events[1] },
-];
-
-export const twoSuccessfulResponses = [
-  {
-    Entries: [{ EventId: 1 }],
-    FailedEntryCount: 0,
-  },
-  {
-    Entries: [{ EventId: 2 }],
-    FailedEntryCount: 0,
-  },
-];
-
-export const twoUnsuccessfulResponses = [
-  {
-    Entries: [{ EventId: undefined }],
-    FailedEntryCount: 1,
-  },
-  {
-    Entries: [{ EventId: undefined }],
-    FailedEntryCount: 1,
-  },
-];
-
-export const oneSuccessfulOneUnsuccessfulResponses = [
-  {
-    Entries: [{ EventId: 1 }],
-    FailedEntryCount: 0,
-  },
-  {
-    Entries: [{ EventId: null }],
-    FailedEntryCount: 1,
-  },
-];

package/src/types/UpdatedEvent.ts

@@ -1,39 +0,0 @@
-// eslint-disable-next-line @typescript-eslint/ban-types
-type PropertyKeys<T> = {
-  [K in keyof T as T[K] extends Function ? never : K]: T[K];
-};
-
-type UpdatedIdentifiers<
-  Entity,
-  Identifiers extends keyof PropertyKeys<Entity>,
-  PartialEntity = Pick<PropertyKeys<Entity>, Identifiers>
-> = {
-  [K in keyof PartialEntity]: PartialEntity[K];
-};
-
-type UpdatedFields<
-  Entity,
-  Identifiers extends keyof PropertyKeys<Entity>,
-  PartialEntity = Omit<PropertyKeys<Entity>, Identifiers>
-> = {
-  [K in keyof PartialEntity]?: PartialEntity[K];
-};
-
-export type CreatedEvent<
-  Entity,
-  Identifiers extends keyof PropertyKeys<Entity>
-> = UpdatedFields<Entity, Identifiers>;
-
-export type UpdatedEvent<
-  Entity,
-  Identifiers extends keyof PropertyKeys<Entity>
-> = UpdatedFields<Entity, Identifiers> &
-  UpdatedIdentifiers<Entity, Identifiers> & {
-    _previousValues?: UpdatedFields<Entity, Identifiers>;
-    modifiedKeys: (keyof UpdatedFields<Entity, Identifiers>)[];
-  };
-
-export type DeletedEvent<
-  Entity,
-  Identifiers extends keyof PropertyKeys<Entity>
-> = UpdatedIdentifiers<Entity, Identifiers>;

package/src/types/index.ts

@@ -1 +0,0 @@
-export * from "./UpdatedEvent";