Parser Decorator

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

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';
import type { LambdaInterface } from '@aws-lambda-powertools/commons/types';
import type { Context } from 'aws-lambda';
import { z } from 'zod';

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

type Order = z.infer<typeof orderSchema>;

class Lambda implements LambdaInterface {
  @parser({ schema: orderSchema })
  async handler(event: Order, _context: Context): Promise<void> {
    // event is validated Order
    console.log(event.id);
    event.items.forEach(item => console.log(item));
  }
}

const myFunction = new Lambda();
export const handler = myFunction.handler.bind(myFunction);

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

class Lambda implements LambdaInterface {
  @parser({ schema: orderSchema, envelope: EventBridgeEnvelope })
  async handler(event: Order, _context: Context): Promise<void> {
    // EventBridge detail extracted and typed as Order
    console.log('Order from EventBridge:', event.id);
  }
}

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

class Lambda implements LambdaInterface {
  @parser({ schema: orderSchema, envelope: SqsEnvelope, safeParse: true })
  async handler(
    event: ParsedResult<unknown, Order[]>,
    _context: Context
  ): Promise<void> {
    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';
import { SqsSchema } from '@aws-lambda-powertools/parser/schemas';
import type { SqsEvent } from '@aws-lambda-powertools/parser/types';

class Lambda implements LambdaInterface {
  @parser({ schema: SqsSchema })
  async handler(event: SqsEvent, _context: Context): Promise<void> {
    // event is validated SqsEvent
    event.Records.forEach(record => console.log(record.body));
  }
}

type ParserOutput<TSchema, TEnvelope, TSafeParse> =
  TSafeParse extends true
    ? ParsedResult<unknown, InferredType>
    : InferredType;

// Without envelope
parse({ schema })               → InferOutput<TSchema>

// With ObjectEnvelope
parse({ schema, envelope })     → InferOutput<TSchema>

// With ArrayEnvelope
parse({ schema, envelope })     → InferOutput<TSchema>[]

// With DynamoDBArrayEnvelope
parse({ schema, envelope })     → { NewImage?: T, OldImage?: T }[]

// With safeParse: true (wraps above in ParsedResult)
parse({ schema, safeParse: true }) → ParsedResult<unknown, Output>