Middy.js Middleware

function parser<TSchema, TEnvelope, TSafeParse>(
  options: ParserOptions<TSchema, TEnvelope, TSafeParse>
): MiddlewareObj;

interface ParserOptions<TSchema, TEnvelope, TSafeParse> {
  schema: TSchema;              // Standard Schema compatible
  envelope?: TEnvelope;         // Optional envelope
  safeParse?: TSafeParse;       // Return ParsedResult vs throw
}

import { parser } from '@aws-lambda-powertools/parser/middleware';
import middy from '@middy/core';
import { z } from 'zod';

const orderSchema = z.object({
  id: z.number(),
  items: z.array(z.object({ id: z.number(), quantity: z.number() })),
});

export const handler = middy()
  .use(parser({ schema: orderSchema }))
  .handler(async (event) => {
    // event is validated Order
    console.log(event.id);
  });

import { parser } from '@aws-lambda-powertools/parser/middleware';
import { SqsEnvelope } from '@aws-lambda-powertools/parser/envelopes';

export const handler = middy()
  .use(parser({ schema: orderSchema, envelope: SqsEnvelope }))
  .handler(async (event) => {
    // event is Order[] (extracted from SQS records)
    event.forEach(order => console.log(order.id));
  });

import { parser } from '@aws-lambda-powertools/parser/middleware';
import { SqsEnvelope } from '@aws-lambda-powertools/parser/envelopes';
import type { ParsedResult } from '@aws-lambda-powertools/parser/types';

export const handler = middy()
  .use(parser({ schema: orderSchema, envelope: SqsEnvelope, safeParse: true }))
  .handler(async (event: ParsedResult<unknown, Order[]>) => {
    if (event.success) {
      event.data.forEach(order => console.log(order.id));
    } else {
      console.error(event.error.message);
      console.error(event.originalEvent);
    }
  });

import { parser } from '@aws-lambda-powertools/parser/middleware';
import { object, string, number, pipe, toMinValue } from 'valibot';

const orderSchema = object({
  id: pipe(number(), toMinValue(1)),
  description: string(),
});

export const handler = middy()
  .use(parser({ schema: orderSchema }))
  .handler(async (event) => {
    console.log(event.id);
  });

import { parser } from '@aws-lambda-powertools/parser/middleware';
import { SqsEnvelope } from '@aws-lambda-powertools/parser/envelopes';
import { Logger } from '@aws-lambda-powertools/logger';
import { injectLambdaContext } from '@aws-lambda-powertools/logger/middleware';
import middy from '@middy/core';

const logger = new Logger();

export const handler = middy()
  .use(injectLambdaContext(logger))  // Runs first
  .use(parser({ schema: orderSchema, envelope: SqsEnvelope }))  // Runs second
  .handler(async (event) => {
    // event is Order[]
    event.forEach(order => logger.info('Processing', { order }));
  });

import { parser } from '@aws-lambda-powertools/parser/middleware';
import { EventBridgeSchema } from '@aws-lambda-powertools/parser/schemas';
import type { EventBridgeEvent } from '@aws-lambda-powertools/parser/types';

export const handler = middy()
  .use(parser({ schema: EventBridgeSchema }))
  .handler(async (event: EventBridgeEvent) => {
    console.log(event.source, event['detail-type']);
  });