fix(parser): allow VPC envelopes to handle non-JSON strings

packages/parser/package.json

@@ -379,8 +379,5 @@
     "@middy/core": {
       "optional": true
     }
-  },
-  "devDependencies": {
-    "@anatine/zod-mock": "^3.13.3"
   }
 }

packages/parser/src/envelopes/envelope.ts

@@ -1,82 +1,7 @@
-import type { ZodSchema, z } from 'zod';
-import { ParseError } from '../errors.js';
-import type { ParsedResult } from '../types/parser.js';
-
-/* v8 ignore start */
-const Envelope = {
-  /**
-   * 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
-   */
-  parse<T extends ZodSchema>(data: unknown, schema: T): z.infer<T> {
-    if (typeof data !== 'object' && typeof data !== 'string') {
-      throw new ParseError(
-        `Invalid data type for envelope. Expected string or object, got ${typeof data}`
-      );
-    }
-    try {
-      if (typeof data === 'string') {
-        return schema.parse(JSON.parse(data));
-      }
-      if (typeof data === 'object') {
-        return schema.parse(data);
-      }
-    } catch (e) {
-      throw new ParseError('Failed to parse envelope', { cause: e as Error });
-    }
-  },
-
-  /**
-   * Abstract function to safely parse the content of the envelope using provided schema.
-   * safeParse is used to avoid throwing errors, thus we catuch all errors and wrap them in the result.
-   * @param input
-   * @param schema
-   */
-  safeParse<T extends ZodSchema>(
-    input: unknown,
-    schema: T
-  ): ParsedResult<unknown, z.infer<T>> {
-    try {
-      if (typeof input !== 'object' && typeof input !== 'string') {
-        return {
-          success: false,
-          error: new Error(
-            `Invalid data type for envelope. Expected string or object, got ${typeof input}`
-          ),
-        };
-      }
-
-      const parsed = schema.safeParse(
-        typeof input === 'string' ? JSON.parse(input) : input
-      );
-
-      return parsed.success
-        ? {
-            success: true,
-            data: parsed.data,
-          }
-        : {
-            success: false,
-            error: parsed.error,
-          };
-    } catch (e) {
-      return {
-        success: false,
-        error: e as Error,
-      };
-    }
-  },
-};
-
 /**
  * This is a discriminator to differentiate whether an envelope returns an array or an object
  * @hidden
  */
 const envelopeDiscriminator = Symbol.for('returnType');
 
-export { Envelope, envelopeDiscriminator };
-/* v8 ignore stop */
+export { envelopeDiscriminator };

packages/parser/src/envelopes/vpc-lattice.ts

@@ -2,7 +2,7 @@ import type { ZodSchema, z } from 'zod';
 import { ParseError } from '../errors.js';
 import { VpcLatticeSchema } from '../schemas/index.js';
 import type { ParsedResult } from '../types/index.js';
-import { Envelope, envelopeDiscriminator } from './envelope.js';
+import { envelopeDiscriminator } from './envelope.js';
 
 /**
  * Amazon VPC Lattice envelope to extract data within body key
@@ -15,35 +15,38 @@ export const VpcLatticeEnvelope = {
    */
   [envelopeDiscriminator]: 'object' as const,
   parse<T extends ZodSchema>(data: unknown, schema: T): z.infer<T> {
-    const parsedEnvelope = VpcLatticeSchema.parse(data);
-
-    return Envelope.parse(parsedEnvelope.body, schema);
-  },
-
-  safeParse<T extends ZodSchema>(data: unknown, schema: T): ParsedResult<unknown, z.infer<T>> {
-    const parsedEnvelope = VpcLatticeSchema.safeParse(data);
-    if (!parsedEnvelope.success) {
-      return {
-        success: false,
-        error: new ParseError('Failed to parse VpcLattice envelope', {
-          cause: parsedEnvelope.error,
-        }),
-        originalEvent: data,
-      };
+    try {
+      return VpcLatticeSchema.extend({
+        body: schema,
+      }).parse(data).body;
+    } catch (error) {
+      throw new ParseError('Failed to parse VPC Lattice body', {
+        cause: error as Error,
+      });
     }
+  },
 
-    const parsedBody = Envelope.safeParse(parsedEnvelope.data.body, schema);
+  safeParse<T extends ZodSchema>(
+    data: unknown,
+    schema: T
+  ): ParsedResult<unknown, z.infer<T>> {
+    const result = VpcLatticeSchema.extend({
+      body: schema,
+    }).safeParse(data);
 
-    if (!parsedBody.success) {
+    if (!result.success) {
       return {
         success: false,
-        error: new ParseError('Failed to parse VpcLattice envelope body', {
-          cause: parsedBody.error,
+        error: new ParseError('Failed to parse VPC Lattice body', {
+          cause: result.error,
         }),
         originalEvent: data,
       };
     }
 
-    return parsedBody;
+    return {
+      success: true,
+      data: result.data.body,
+    };
   },
 };

packages/parser/src/envelopes/vpc-latticev2.ts

@@ -2,7 +2,7 @@ import type { ZodSchema, z } from 'zod';
 import { ParseError } from '../errors.js';
 import { VpcLatticeV2Schema } from '../schemas/index.js';
 import type { ParsedResult } from '../types/index.js';
-import { Envelope, envelopeDiscriminator } from './envelope.js';
+import { envelopeDiscriminator } from './envelope.js';
 
 /**
  * Amazon VPC Lattice envelope to extract data within body key
@@ -14,35 +14,38 @@ export const VpcLatticeV2Envelope = {
    */
   [envelopeDiscriminator]: 'object' as const,
   parse<T extends ZodSchema>(data: unknown, schema: T): z.infer<T> {
-    const parsedEnvelope = VpcLatticeV2Schema.parse(data);
-
-    return Envelope.parse(parsedEnvelope.body, schema);
-  },
-
-  safeParse<T extends ZodSchema>(data: unknown, schema: T): ParsedResult<unknown, z.infer<T>> {
-    const parsedEnvelope = VpcLatticeV2Schema.safeParse(data);
-    if (!parsedEnvelope.success) {
-      return {
-        success: false,
-        error: new ParseError('Failed to parse VpcLatticeV2 envelope.', {
-          cause: parsedEnvelope.error,
-        }),
-        originalEvent: data,
-      };
+    try {
+      return VpcLatticeV2Schema.extend({
+        body: schema,
+      }).parse(data).body;
+    } catch (error) {
+      throw new ParseError('Failed to parse VPC Lattice v2 body', {
+        cause: error as Error,
+      });
     }
+  },
 
-    const parsedBody = Envelope.safeParse(parsedEnvelope.data.body, schema);
+  safeParse<T extends ZodSchema>(
+    data: unknown,
+    schema: T
+  ): ParsedResult<unknown, z.infer<T>> {
+    const result = VpcLatticeV2Schema.extend({
+      body: schema,
+    }).safeParse(data);
 
-    if (!parsedBody.success) {
+    if (!result.success) {
       return {
         success: false,
-        error: new ParseError('Failed to parse VpcLatticeV2 body.', {
-          cause: parsedBody.error,
+        error: new ParseError('Failed to parse VPC Lattice v2 body', {
+          cause: result.error,
         }),
         originalEvent: data,
       };
     }
 
-    return parsedBody;
+    return {
+      success: true,
+      data: result.data.body,
+    };
   },
 };

packages/parser/tests/events/vpcLatticeEvent.json → packages/parser/tests/events/vpc-lattice/base.json

@@ -10,6 +10,6 @@
   "query_string_parameters": {
     "order-id": "1"
   },
-  "body": "eyJ0ZXN0IjogImV2ZW50In0=",
-  "is_base64_encoded": true
-}
+  "body": "{\"message\": \"Hello from Lambda!\"}",
+  "is_base64_encoded": false
+}