feat(parser): add built-in schemas

packages/parser/src/schemas/cloudwatch.ts

@@ -16,9 +16,9 @@ const CloudWatchLogsDecodeSchema = z.object({
   logEvents: z.array(CloudWatchLogEventSchema),
 });
 
-function decompressRecordToJSON(
+const decompressRecordToJSON = (
   data: string
-): z.infer<typeof CloudWatchLogsDecodeSchema> {
+): z.infer<typeof CloudWatchLogsDecodeSchema> => {
   try {
     console.debug('Decoding data', data);
     const uncompressed = gunzipSync(Buffer.from(data, 'base64')).toString(
@@ -30,16 +30,23 @@ function decompressRecordToJSON(
     console.debug('Failed to gunzip data', e);
     throw e;
   }
-}
+};
 
 const CloudWatchLogsSchema = z.object({
   awslogs: z.object({
     data: z.string().transform((data) => decompressRecordToJSON(data)),
   }),
 });
 
+const extractCloudWatchLogFromEvent = (
+  data: string
+): z.infer<typeof CloudWatchLogsDecodeSchema> => {
+  return decompressRecordToJSON(data);
+};
+
 export {
   CloudWatchLogsSchema,
   CloudWatchLogsDecodeSchema,
   decompressRecordToJSON,
+  extractCloudWatchLogFromEvent,
 };

packages/parser/src/schemas/kinesis.ts

@@ -1,8 +1,4 @@
 import { z } from 'zod';
-import {
-  CloudWatchLogsDecodeSchema,
-  decompressRecordToJSON,
-} from './cloudwatch.js';
 
 const KinesisDataStreamRecordPayload = z.object({
   kinesisSchemaVersion: z.string(),
@@ -26,10 +22,4 @@ const KinesisDataStreamSchema = z.object({
   Records: z.array(KinesisDataStreamRecord),
 });
 
-const extractCloudWatchLogFromEvent = (
-  data: string
-): z.infer<typeof CloudWatchLogsDecodeSchema> => {
-  return decompressRecordToJSON(data);
-};
-
-export { KinesisDataStreamSchema, extractCloudWatchLogFromEvent };
+export { KinesisDataStreamSchema };

packages/parser/src/schemas/s3.ts

@@ -20,8 +20,9 @@ const S3Message = z.object({
   configurationId: z.string(),
   object: z.object({
     key: z.string(),
-    size: z.number(),
-    eTag: z.string(),
+    size: z.number().optional(),
+    urlDecodedKey: z.string().optional(),
+    eTag: z.string().optional(),
     sequencer: z.string(),
     versionId: z.optional(z.string()),
   }),
@@ -118,7 +119,9 @@ const S3ObjectSessionContext = z.object({
   }),
   attributes: z.object({
     creationDate: z.string(),
-    mfaAuthenticated: z.string(),
+    mfaAuthenticated: z
+      .union([z.boolean(), z.literal('true'), z.literal('false')])
+      .transform((value) => value === true || value === 'true'),
   }),
 });
 
@@ -129,13 +132,13 @@ const S3ObjectUserIdentity = z.object({
   userName: z.string().optional(),
   principalId: z.string(),
   arn: z.string(),
-  sessionContext: S3ObjectSessionContext,
+  sessionContext: S3ObjectSessionContext.optional(),
 });
 
 const S3ObjectLambdaEventSchema = z.object({
   xAmzRequestId: z.string(),
   getObjectContext: S3ObjectContext,
-  configurationId: S3ObjectConfiguration,
+  configuration: S3ObjectConfiguration,
   userRequest: S3ObjectUserRequest,
   userIdentity: S3ObjectUserIdentity,
   protocolVersion: z.string(),

packages/parser/tests/tsconfig.json

@@ -1,13 +1,11 @@
 {
     "extends": "../tsconfig.json",
     "compilerOptions": {
-        "resolveJsonModule": true,
         "rootDir": "../",
         "noEmit": true
     },
     "include": [
         "../src/**/*",
-        "./**/*.*",
-        "./**/*.json",
+        "./**/*.*"
     ]
 }

packages/parser/tests/unit/schema/alb.test.ts

@@ -7,20 +7,25 @@ import {
   AlbSchema,
   AlbMultiValueHeadersSchema,
 } from '../../../src/schemas/alb';
-import albEvent from '../../events/albEvent.json';
-import albEventPathTrailingSlash from '../../events/albEventPathTrailingSlash.json';
-import albMultiValueHeadersEvent from '../../events/albMultiValueHeadersEvent.json';
+import { loadExampleEvent } from './utils';
 
 describe('ALB ', () => {
   it('should parse alb event', () => {
+    const albEvent = loadExampleEvent('albEvent.json');
     expect(AlbSchema.parse(albEvent)).toEqual(albEvent);
   });
   it('should parse alb event path trailing slash', () => {
+    const albEventPathTrailingSlash = loadExampleEvent(
+      'albEventPathTrailingSlash.json'
+    );
     expect(AlbSchema.parse(albEventPathTrailingSlash)).toEqual(
       albEventPathTrailingSlash
     );
   });
   it('should parse alb event with multi value headers event', () => {
+    const albMultiValueHeadersEvent = loadExampleEvent(
+      'albMultiValueHeadersEvent.json'
+    );
     expect(AlbMultiValueHeadersSchema.parse(albMultiValueHeadersEvent)).toEqual(
       albMultiValueHeadersEvent
     );

packages/parser/tests/unit/schema/apigw.test.ts

@@ -4,52 +4,67 @@
  * @group unit/parser/schema/
  */
 import { APIGatewayProxyEventSchema } from '../../../src/schemas/apigw';
-import apiGatewayProxyEvent from '../../events/apiGatewayProxyEvent.json';
-import apiGatewayAuthorizerRequestEvent from '../../events/apiGatewayAuthorizerRequestEvent.json';
-import apiGatewaySchemaMiddlewareInvalidEvent from '../../events/apiGatewaySchemaMiddlewareInvalidEvent.json';
-import apiGatewaySchemaMiddlewareValidEvent from '../../events/apiGatewaySchemaMiddlewareValidEvent.json';
-import apiGatewayProxyEvent_noVersionAuth from '../../events/apiGatewayProxyEvent_noVersionAuth.json';
-import apiGatewayProxyEventAnotherPath from '../../events/apiGatewayProxyEventAnotherPath.json';
-import apiGatewayProxyEventPathTrailingSlash from '../../events/apiGatewayProxyEventPathTrailingSlash.json';
-import apiGatewayProxyOtherEvent from '../../events/apiGatewayProxyOtherEvent.json';
+import { loadExampleEvent } from './utils';
 
 describe('APIGateway ', () => {
   it('should parse api gateway event', () => {
+    const apiGatewayProxyEvent = loadExampleEvent('apiGatewayProxyEvent.json');
     expect(APIGatewayProxyEventSchema.parse(apiGatewayProxyEvent)).toEqual(
       apiGatewayProxyEvent
     );
   });
   it('should parse api gateway authorizer request event', () => {
+    const apiGatewayAuthorizerRequestEvent = loadExampleEvent(
+      'apiGatewayAuthorizerRequestEvent.json'
+    );
     expect(
       APIGatewayProxyEventSchema.parse(apiGatewayAuthorizerRequestEvent)
     ).toEqual(apiGatewayAuthorizerRequestEvent);
   });
   it('should parse schema middleware invalid event', () => {
+    const apiGatewaySchemaMiddlewareInvalidEvent = loadExampleEvent(
+      'apiGatewaySchemaMiddlewareInvalidEvent.json'
+    );
     expect(
       APIGatewayProxyEventSchema.parse(apiGatewaySchemaMiddlewareInvalidEvent)
     ).toEqual(apiGatewaySchemaMiddlewareInvalidEvent);
   });
   it('should parse schema middleware valid event', () => {
+    const apiGatewaySchemaMiddlewareValidEvent = loadExampleEvent(
+      'apiGatewaySchemaMiddlewareValidEvent.json'
+    );
     expect(
       APIGatewayProxyEventSchema.parse(apiGatewaySchemaMiddlewareValidEvent)
     ).toEqual(apiGatewaySchemaMiddlewareValidEvent);
   });
   it('should parse proxy event with no version auth', () => {
+    const apiGatewayProxyEvent_noVersionAuth = loadExampleEvent(
+      'apiGatewayProxyEvent_noVersionAuth.json'
+    );
     expect(
       APIGatewayProxyEventSchema.parse(apiGatewayProxyEvent_noVersionAuth)
     ).toEqual(apiGatewayProxyEvent_noVersionAuth);
   });
   it('should parse proxy event with another path', () => {
+    const apiGatewayProxyEventAnotherPath = loadExampleEvent(
+      'apiGatewayProxyEventAnotherPath.json'
+    );
     expect(
       APIGatewayProxyEventSchema.parse(apiGatewayProxyEventAnotherPath)
     ).toEqual(apiGatewayProxyEventAnotherPath);
   });
   it('should parse proxy event with path trailing slash', () => {
+    const apiGatewayProxyEventPathTrailingSlash = loadExampleEvent(
+      'apiGatewayProxyEventPathTrailingSlash.json'
+    );
     expect(
       APIGatewayProxyEventSchema.parse(apiGatewayProxyEventPathTrailingSlash)
     ).toEqual(apiGatewayProxyEventPathTrailingSlash);
   });
   it('should parse other proxy event', () => {
+    const apiGatewayProxyOtherEvent = loadExampleEvent(
+      'apiGatewayProxyOtherEvent.json'
+    );
     expect(APIGatewayProxyEventSchema.parse(apiGatewayProxyOtherEvent)).toEqual(
       apiGatewayProxyOtherEvent
     );

packages/parser/tests/unit/schema/apigwv2.test.ts

@@ -4,48 +4,63 @@
  * @group unit/parser/schema/
  */
 import { APIGatewayProxyEventV2Schema } from '../../../src/schemas/apigwv2';
-import apiGatewayProxyV2Event from '../../events/apiGatewayProxyV2Event.json';
-import apiGatewayProxyV2Event_GET from '../../events/apiGatewayProxyV2Event_GET.json';
-import apiGatewayProxyV2EventPathTrailingSlash from '../../events/apiGatewayProxyV2EventPathTrailingSlash.json';
-import apiGatewayProxyV2IamEvent from '../../events/apiGatewayProxyV2IamEvent.json';
-import apiGatewayProxyV2LambdaAuthorizerEvent from '../../events/apiGatewayProxyV2LambdaAuthorizerEvent.json';
-import apiGatewayProxyV2OtherGetEvent from '../../events/apiGatewayProxyV2OtherGetEvent.json';
-import apiGatewayProxyV2SchemaMiddlewareValidEvent from '../../events/apiGatewayProxyV2SchemaMiddlewareValidEvent.json';
+import { loadExampleEvent } from './utils';
 
 describe('API GW v2 ', () => {
   it('should parse api gateway v2 event', () => {
+    const apiGatewayProxyV2Event = loadExampleEvent(
+      'apiGatewayProxyV2Event.json'
+    );
     expect(APIGatewayProxyEventV2Schema.parse(apiGatewayProxyV2Event)).toEqual(
       apiGatewayProxyV2Event
     );
   });
   it('should parse api gateway v2 event with GET method', () => {
+    const apiGatewayProxyV2Event_GET = loadExampleEvent(
+      'apiGatewayProxyV2Event_GET.json'
+    );
     expect(
       APIGatewayProxyEventV2Schema.parse(apiGatewayProxyV2Event_GET)
     ).toEqual(apiGatewayProxyV2Event_GET);
   });
   it('should parse api gateway v2 event with path trailing slash', () => {
+    const apiGatewayProxyV2EventPathTrailingSlash = loadExampleEvent(
+      'apiGatewayProxyV2EventPathTrailingSlash.json'
+    );
     expect(
       APIGatewayProxyEventV2Schema.parse(
         apiGatewayProxyV2EventPathTrailingSlash
       )
     ).toEqual(apiGatewayProxyV2EventPathTrailingSlash);
   });
   it('should parse api gateway v2 event with iam', () => {
+    const apiGatewayProxyV2IamEvent = loadExampleEvent(
+      'apiGatewayProxyV2IamEvent.json'
+    );
     expect(
       APIGatewayProxyEventV2Schema.parse(apiGatewayProxyV2IamEvent)
     ).toEqual(apiGatewayProxyV2IamEvent);
   });
   it('should parse api gateway v2 event with lambda authorizer', () => {
+    const apiGatewayProxyV2LambdaAuthorizerEvent = loadExampleEvent(
+      'apiGatewayProxyV2LambdaAuthorizerEvent.json'
+    );
     expect(
       APIGatewayProxyEventV2Schema.parse(apiGatewayProxyV2LambdaAuthorizerEvent)
     ).toEqual(apiGatewayProxyV2LambdaAuthorizerEvent);
   });
   it('should parse api gateway v2 event with other get event', () => {
+    const apiGatewayProxyV2OtherGetEvent = loadExampleEvent(
+      'apiGatewayProxyV2OtherGetEvent.json'
+    );
     expect(
       APIGatewayProxyEventV2Schema.parse(apiGatewayProxyV2OtherGetEvent)
     ).toEqual(apiGatewayProxyV2OtherGetEvent);
   });
   it('should parse api gateway v2 event with schema middleware', () => {
+    const apiGatewayProxyV2SchemaMiddlewareValidEvent = loadExampleEvent(
+      'apiGatewayProxyV2SchemaMiddlewareValidEvent.json'
+    );
     expect(
       APIGatewayProxyEventV2Schema.parse(
         apiGatewayProxyV2SchemaMiddlewareValidEvent

packages/parser/tests/unit/schema/cloudformation-custom-resource.test.ts

@@ -8,12 +8,13 @@ import {
   CloudFormationCustomResourceUpdateSchema,
   CloudFormationCustomResourceDeleteSchema,
 } from '../../../src/schemas/cloudformation-custom-resource';
-import cloudFormationCustomResourceCreateEvent from '../../events/cloudformationCustomResourceCreate.json';
-import cloudFormationCustomResourceUpdateEvent from '../../events/cloudformationCustomResourceUpdate.json';
-import cloudFormationCustomResourceDeleteEvent from '../../events/cloudformationCustomResourceDelete.json';
+import { loadExampleEvent } from './utils';
 
 describe('CloudFormationCustomResource ', () => {
   it('should parse create event', () => {
+    const cloudFormationCustomResourceCreateEvent = loadExampleEvent(
+      'cloudFormationCustomResourceCreateEvent.json'
+    );
     console.log(CloudFormationCustomResourceCreateSchema.shape);
     expect(
       CloudFormationCustomResourceCreateSchema.parse(
@@ -22,13 +23,19 @@ describe('CloudFormationCustomResource ', () => {
     ).toEqual(cloudFormationCustomResourceCreateEvent);
   });
   it('should parse update event', () => {
+    const cloudFormationCustomResourceUpdateEvent = loadExampleEvent(
+      'cloudFormationCustomResourceUpdateEvent.json'
+    );
     expect(
       CloudFormationCustomResourceUpdateSchema.parse(
         cloudFormationCustomResourceUpdateEvent
       )
     ).toEqual(cloudFormationCustomResourceUpdateEvent);
   });
   it('should parse delete event', () => {
+    const cloudFormationCustomResourceDeleteEvent = loadExampleEvent(
+      'cloudFormationCustomResourceDeleteEvent.json'
+    );
     expect(
       CloudFormationCustomResourceDeleteSchema.parse(
         cloudFormationCustomResourceDeleteEvent

packages/parser/tests/unit/schema/cloudwatch.test.ts

@@ -4,10 +4,11 @@
  * @group unit/parser/schema/
  */
 import { CloudWatchLogsSchema } from '../../../src/schemas/cloudwatch';
-import cloudWatchLogEvent from '../../events/cloudWatchLogEvent.json';
+import { loadExampleEvent } from './utils';
 
 describe('CloudWatchLogs ', () => {
   it('should parse cloudwatch logs event', () => {
+    const cloudWatchLogEvent = loadExampleEvent('cloudWatchLogEvent.json');
     const parsed = CloudWatchLogsSchema.parse(cloudWatchLogEvent);
     expect(parsed.awslogs.data).toBeDefined();
     expect(parsed.awslogs.data?.logEvents[0]).toEqual({

packages/parser/tests/unit/schema/dynamodb.test.ts

@@ -4,12 +4,13 @@
  * @group unit/parser/schema/
  */
 import { DynamoDBStreamSchema } from '../../../src/schemas/dynamodb';
-import dynamodbStreamEvent from '../../events/dynamoStreamEvent.json';
+import { loadExampleEvent } from './utils';
 
 describe('DynamoDB ', () => {
+  const dynamoStreamEvent = loadExampleEvent('dynamoStreamEvent.json');
   it('should parse a stream of records', () => {
-    expect(DynamoDBStreamSchema.parse(dynamodbStreamEvent)).toEqual(
-      dynamodbStreamEvent
+    expect(DynamoDBStreamSchema.parse(dynamoStreamEvent)).toEqual(
+      dynamoStreamEvent
     );
   });
 });

packages/parser/tests/unit/schema/eventbridge.test.ts

@@ -5,10 +5,11 @@
  */
 
 import { EventBridgeSchema } from '../../../src/schemas/eventbridge';
-import eventBridgeEvent from '../../events/eventBridgeEvent.json';
+import { loadExampleEvent } from './utils';
 
 describe('EventBridge ', () => {
   it('should parse eventbridge event', () => {
+    const eventBridgeEvent = loadExampleEvent('eventBridgeEvent.json');
     expect(EventBridgeSchema.parse(eventBridgeEvent)).toEqual(eventBridgeEvent);
   });
 });