refactored from class to function envelopes

Author: am29d

packages/parser/src/envelopes/Envelope.ts

@@ -1,23 +1,18 @@
-import { Envelope } from './Envelope.js';
+import { parse } from './envelope.js';
 import { z, ZodSchema } from 'zod';
 import { APIGatewayProxyEventSchema } from '../schemas/apigw.js';
-import { type ApiGatewayProxyEvent } from '../types/schema.js';
 
 /**
- * API Gateway envelope to extract data within body key"
+ * API Gateway envelope to extract data within body key
  */
-export class ApiGatewayEnvelope extends Envelope {
-  public constructor() {
-    super();
+export const apiGatewayEnvelope = <T extends ZodSchema>(
+  data: unknown,
+  schema: T
+): z.infer<T> => {
+  const parsedEnvelope = APIGatewayProxyEventSchema.parse(data);
+  if (!parsedEnvelope.body) {
+    throw new Error('Body field of API Gateway event is undefined');
   }
 
-  public parse<T extends ZodSchema>(data: unknown, schema: T): z.infer<T> {
-    const parsedEnvelope: ApiGatewayProxyEvent =
-      APIGatewayProxyEventSchema.parse(data);
-    if (parsedEnvelope.body) {
-      return this._parse(parsedEnvelope.body, schema);
-    } else {
-      throw new Error('Body field of API Gateway event is undefined');
-    }
-  }
-}
+  return parse(parsedEnvelope.body, schema);
+};

packages/parser/src/envelopes/Envelopes.ts

@@ -1,21 +1,18 @@
-import { Envelope } from './Envelope.js';
+import { parse } from './envelope.js';
 import { z, ZodSchema } from 'zod';
 import { APIGatewayProxyEventV2Schema } from '../schemas/apigwv2.js';
 
 /**
  * API Gateway V2 envelope to extract data within body key
  */
-export class ApiGatwayV2Envelope extends Envelope {
-  public constructor() {
-    super();
+export const apiGatewayV2Envelope = <T extends ZodSchema>(
+  data: unknown,
+  schema: T
+): z.infer<T> => {
+  const parsedEnvelope = APIGatewayProxyEventV2Schema.parse(data);
+  if (!parsedEnvelope.body) {
+    throw new Error('Body field of API Gateway event is undefined');
   }
 
-  public parse<T extends ZodSchema>(data: unknown, schema: T): z.infer<T> {
-    const parsedEnvelope = APIGatewayProxyEventV2Schema.parse(data);
-    if (parsedEnvelope.body) {
-      return this._parse(parsedEnvelope.body, schema);
-    } else {
-      throw new Error('Body field of API Gateway V2 event is undefined');
-    }
-  }
-}
+  return parse(parsedEnvelope.body, schema);
+};

packages/parser/src/envelopes/apigw.ts

@@ -1,4 +1,4 @@
-import { Envelope } from './Envelope.js';
+import { parse } from './envelope.js';
 import { z, ZodSchema } from 'zod';
 import { CloudWatchLogsSchema } from '../schemas/cloudwatch.js';
 
@@ -11,16 +11,13 @@ import { CloudWatchLogsSchema } from '../schemas/cloudwatch.js';
  *
  *  Note: The record will be parsed the same way so if model is str
  */
-export class CloudWatchEnvelope extends Envelope {
-  public constructor() {
-    super();
-  }
+export const cloudWatchEnvelope = <T extends ZodSchema>(
+  data: unknown,
+  schema: T
+): z.infer<T> => {
+  const parsedEnvelope = CloudWatchLogsSchema.parse(data);
 
-  public parse<T extends ZodSchema>(data: unknown, schema: T): z.infer<T>[] {
-    const parsedEnvelope = CloudWatchLogsSchema.parse(data);
-
-    return parsedEnvelope.awslogs.data.logEvents.map((record) => {
-      return this._parse(record.message, schema);
-    });
-  }
-}
+  return parsedEnvelope.awslogs.data.logEvents.map((record) => {
+    return parse(record.message, schema);
+  });
+};

packages/parser/src/envelopes/apigwv2.ts

@@ -1,4 +1,4 @@
-import { Envelope } from './Envelope.js';
+import { parse } from './envelope.js';
 import { z, ZodSchema } from 'zod';
 import { DynamoDBStreamSchema } from '../schemas/dynamodb.js';
 
@@ -13,22 +13,16 @@ type DynamoDBStreamEnvelopeResponse<T extends ZodSchema> = {
  * Note: Values are the parsed models. Images' values can also be None, and
  * length of the list is the record's amount in the original event.
  */
-export class DynamoDBStreamEnvelope extends Envelope {
-  public constructor() {
-    super();
-  }
+export const dynamoDDStreamEnvelope = <T extends ZodSchema>(
+  data: unknown,
+  schema: T
+): DynamoDBStreamEnvelopeResponse<T>[] => {
+  const parsedEnvelope = DynamoDBStreamSchema.parse(data);
 
-  public parse<T extends ZodSchema>(
-    data: unknown,
-    schema: T
-  ): DynamoDBStreamEnvelopeResponse<T>[] {
-    const parsedEnvelope = DynamoDBStreamSchema.parse(data);
-
-    return parsedEnvelope.Records.map((record) => {
-      return {
-        NewImage: this._parse(record.dynamodb.NewImage, schema),
-        OldImage: this._parse(record.dynamodb.OldImage, schema),
-      };
-    });
-  }
-}
+  return parsedEnvelope.Records.map((record) => {
+    return {
+      NewImage: parse(record.dynamodb.NewImage, schema),
+      OldImage: parse(record.dynamodb.OldImage, schema),
+    };
+  });
+};

packages/parser/src/envelopes/cloudwatch.ts

@@ -0,0 +1,23 @@
+import { z, ZodSchema } from 'zod';
+
+/**
+ * Abstract function to parse the content of the envelope using provided schema.
+ * Both inputs are provided as unknown by the user.
+ * We expect the data to be either string that can be parsed to json or object.
+ * @internal
+ * @param data data to parse
+ * @param schema schema
+ */
+export const parse = <T extends ZodSchema>(
+  data: unknown,
+  schema: T
+): z.infer<T>[] => {
+  if (typeof data === 'string') {
+    return schema.parse(JSON.parse(data));
+  } else if (typeof data === 'object') {
+    return schema.parse(data);
+  } else
+    throw new Error(
+      `Invalid data type for envelope. Expected string or object, got ${typeof data}`
+    );
+};

packages/parser/src/envelopes/dynamodb.ts

@@ -1,18 +1,13 @@
-import { Envelope } from './Envelope.js';
+import { parse } from './envelope.js';
 import { z, ZodSchema } from 'zod';
 import { EventBridgeSchema } from '../schemas/eventbridge.js';
 
 /**
  * Envelope for EventBridge schema that extracts and parses data from the `detail` key.
  */
-export class EventBridgeEnvelope extends Envelope {
-  public constructor() {
-    super();
-  }
-
-  public parse<T extends ZodSchema>(data: unknown, schema: T): z.infer<T> {
-    const parsedEnvelope = EventBridgeSchema.parse(data);
-
-    return this._parse(parsedEnvelope.detail, schema);
-  }
-}
+export const eventBridgeEnvelope = <T extends ZodSchema>(
+  data: unknown,
+  schema: T
+): z.infer<T> => {
+  return parse(EventBridgeSchema.parse(data).detail, schema);
+};

packages/parser/src/envelopes/envelope.ts

@@ -1,5 +1,5 @@
 import { z, ZodSchema } from 'zod';
-import { Envelope } from './Envelope.js';
+import { parse } from './envelope.js';
 import {
   KafkaMskEventSchema,
   KafkaSelfManagedEventSchema,
@@ -14,29 +14,26 @@ import { type KafkaRecord } from '../types/schema.js';
  * Note: Records will be parsed the same way so if model is str,
  * all items in the list will be parsed as str and not as JSON (and vice versa)
  */
-export class KafkaEnvelope extends Envelope {
-  public constructor() {
-    super();
-  }
+export const kafkaEnvelope = <T extends ZodSchema>(
+  data: unknown,
+  schema: T
+): z.infer<T> => {
+  // manually fetch event source to deside between Msk or SelfManaged
 
-  public parse<T extends ZodSchema>(data: unknown, schema: T): z.infer<T> {
-    // manually fetch event source to deside between Msk or SelfManaged
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore
+  const eventSource = data['eventSource'];
 
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    // @ts-ignore
-    const eventSource = data['eventSource'];
+  const parsedEnvelope:
+    | z.infer<typeof KafkaMskEventSchema>
+    | z.infer<typeof KafkaSelfManagedEventSchema> =
+    eventSource === 'aws:kafka'
+      ? KafkaMskEventSchema.parse(data)
+      : KafkaSelfManagedEventSchema.parse(data);
 
-    const parsedEnvelope:
-      | z.infer<typeof KafkaMskEventSchema>
-      | z.infer<typeof KafkaSelfManagedEventSchema> =
-      eventSource === 'aws:kafka'
-        ? KafkaMskEventSchema.parse(data)
-        : KafkaSelfManagedEventSchema.parse(data);
-
-    return Object.values(parsedEnvelope.records).map((topicRecord) => {
-      return topicRecord.map((record: KafkaRecord) => {
-        return this._parse(record.value, schema);
-      });
+  return Object.values(parsedEnvelope.records).map((topicRecord) => {
+    return topicRecord.map((record: KafkaRecord) => {
+      return parse(record.value, schema);
     });
-  }
-}
+  });
+};

packages/parser/src/envelopes/eventBridgeEnvelope.ts

@@ -1,4 +1,4 @@
-import { Envelope } from './Envelope.js';
+import { parse } from './envelope.js';
 import { z, ZodSchema } from 'zod';
 import { KinesisFirehoseSchema } from '../schemas/kinesis-firehose.js';
 
@@ -14,16 +14,13 @@ import { KinesisFirehoseSchema } from '../schemas/kinesis-firehose.js';
  *
  *  https://docs.aws.amazon.com/lambda/latest/dg/services-kinesisfirehose.html
  */
-export class KinesisFirehoseEnvelope extends Envelope {
-  public constructor() {
-    super();
-  }
+export const kinesisFirehoseEnvelope = <T extends ZodSchema>(
+  data: unknown,
+  schema: T
+): z.infer<T> => {
+  const parsedEnvelope = KinesisFirehoseSchema.parse(data);
 
-  public parse<T extends ZodSchema>(data: unknown, schema: T): z.infer<T> {
-    const parsedEnvelope = KinesisFirehoseSchema.parse(data);
-
-    return parsedEnvelope.records.map((record) => {
-      return this._parse(record.data, schema);
-    });
-  }
-}
+  return parsedEnvelope.records.map((record) => {
+    return parse(record.data, schema);
+  });
+};

packages/parser/src/envelopes/kafka.ts

@@ -1,4 +1,4 @@
-import { Envelope } from './Envelope.js';
+import { parse } from './envelope.js';
 import { z, ZodSchema } from 'zod';
 import { KinesisDataStreamSchema } from '../schemas/kinesis.js';
 
@@ -12,16 +12,13 @@ import { KinesisDataStreamSchema } from '../schemas/kinesis.js';
  * Note: Records will be parsed the same way so if model is str,
  * all items in the list will be parsed as str and not as JSON (and vice versa)
  */
-export class KinesisEnvelope extends Envelope {
-  public constructor() {
-    super();
-  }
+export const kinesisEnvelope = <T extends ZodSchema>(
+  data: unknown,
+  schema: T
+): z.infer<T> => {
+  const parsedEnvelope = KinesisDataStreamSchema.parse(data);
 
-  public parse<T extends ZodSchema>(data: unknown, schema: T): z.infer<T> {
-    const parsedEnvelope = KinesisDataStreamSchema.parse(data);
-
-    return parsedEnvelope.Records.map((record) => {
-      return this._parse(record.kinesis.data, schema);
-    });
-  }
-}
+  return parsedEnvelope.Records.map((record) => {
+    return parse(record.kinesis.data, schema);
+  });
+};