or run

npx @tessl/cli init

Version

Tile

Overview

Evals

Files

docs

errors.md fifo.md index.md parser.md types.md

tile.json

SQS FIFO Queue Processing

FIFO processors handle message group ordering with short-circuit behavior to prevent out-of-order processing.

Behavior

Default (skipGroupOnError: false): When any record fails, all remaining records are marked as failed to preserve ordering.

With (skipGroupOnError: true): When a record fails, only records from the same message group are failed. Other groups continue processing.

APIs

SqsFifoPartialProcessor

Synchronous FIFO processor.

class SqsFifoPartialProcessor extends BatchProcessorSync {
  constructor();
}

SqsFifoPartialProcessorAsync

Asynchronous FIFO processor.

class SqsFifoPartialProcessorAsync extends BatchProcessor {
  constructor();
}

Usage

Basic (Default Short-Circuit)

import { SqsFifoPartialProcessor, processPartialResponseSync } from '@aws-lambda-powertools/batch';

const processor = new SqsFifoPartialProcessor();

const recordHandler = (record: SQSRecord): void => {
  const payload = JSON.parse(record.body);
  // If this fails, all remaining records are marked as failed
};

export const handler: SQSHandler = async (event, context) =>
  processPartialResponseSync(event, recordHandler, processor, { context });

With Message Group Tracking

import { SqsFifoPartialProcessor, processPartialResponseSync } from '@aws-lambda-powertools/batch';

const processor = new SqsFifoPartialProcessor();

const recordHandler = (record: SQSRecord): void => {
  const payload = JSON.parse(record.body);
  // If this fails, only records from this message group are marked as failed
};

export const handler: SQSHandler = async (event, context) =>
  processPartialResponseSync(event, recordHandler, processor, {
    context,
    skipGroupOnError: true,
  });

Async Processing

import { SqsFifoPartialProcessorAsync, processPartialResponse } from '@aws-lambda-powertools/batch';

const processor = new SqsFifoPartialProcessorAsync();

const recordHandler = async (record: SQSRecord): Promise<void> => {
  const payload = JSON.parse(record.body);
  await processAsync(payload);
};

export const handler: SQSHandler = async (event, context) =>
  processPartialResponse(event, recordHandler, processor, {
    context,
    skipGroupOnError: true,
  });

FIFO-Specific Errors

class SqsFifoShortCircuitError extends BatchProcessingError {
  constructor();
}

class SqsFifoMessageGroupShortCircuitError extends BatchProcessingError {
  constructor();
}

SqsFifoShortCircuitError: Applied to unprocessed records when short-circuiting (default behavior).

SqsFifoMessageGroupShortCircuitError: Applied to records from a failed message group when skipGroupOnError: true.

Options

type FifoProcessingOptions = {
  context?: Context;
  skipGroupOnError?: boolean;
  throwOnFullBatchFailure?: boolean;
};

Note: processInParallel is not available for FIFO processors - they process sequentially.

When to Use

SqsFifoPartialProcessor: Synchronous record handlers, no async operations.

SqsFifoPartialProcessorAsync: Async operations (API calls, database queries, etc.).