@aws-lambda-powertools/batch
Version:
The batch processing package for the Powertools for AWS Lambda (TypeScript) library.
191 lines (190 loc) • 6.29 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.BatchProcessor = void 0;
const BasePartialBatchProcessor_js_1 = require("./BasePartialBatchProcessor.js");
const errors_js_1 = require("./errors.js");
/**
* Process records in a batch asynchronously and handle partial failure cases.
*
* The batch processor supports processing records coming from Amazon SQS,
* Amazon Kinesis Data Streams, and Amazon DynamoDB Streams.
*
* Items are processed asynchronously and in parallel.
*
* **Process batch triggered by SQS**
*
* @example
* ```typescript
* import {
* BatchProcessor,
* EventType,
* processPartialResponse,
* } from '@aws-lambda-powertools/batch';
* import type { SQSRecord, SQSHandler } from 'aws-lambda';
*
* const processor = new BatchProcessor(EventType.SQS);
*
* const recordHandler = async (record: SQSRecord): Promise<void> => {
* const payload = JSON.parse(record.body);
* };
*
* export const handler: SQSHandler = async (event, context) =>
* processPartialResponse(event, recordHandler, processor, {
* context,
* });
* ```
*
* **Process batch triggered by Kinesis Data Streams**
*
* @example
* ```typescript
* import {
* BatchProcessor,
* EventType,
* processPartialResponse,
* } from '@aws-lambda-powertools/batch';
* import type { KinesisStreamHandler, KinesisStreamRecord } from 'aws-lambda';
*
* const processor = new BatchProcessor(EventType.KinesisDataStreams);
*
* const recordHandler = async (record: KinesisStreamRecord): Promise<void> => {
* const payload = JSON.parse(record.kinesis.data);
* };
*
* export const handler: KinesisStreamHandler = async (event, context) =>
* processPartialResponse(event, recordHandler, processor, {
* context,
* });
* ```
*
* **Process batch triggered by DynamoDB Streams**
*
* @example
* ```typescript
* import {
* BatchProcessor,
* EventType,
* processPartialResponse,
* } from '@aws-lambda-powertools/batch';
* import type { DynamoDBRecord, DynamoDBStreamHandler } from 'aws-lambda';
*
* const processor = new BatchProcessor(EventType.DynamoDBStreams);
*
* const recordHandler = async (record: DynamoDBRecord): Promise<void> => {
* const payload = record.dynamodb.NewImage.Message.S;
* };
*
* export const handler: DynamoDBStreamHandler = async (event, context) =>
* processPartialResponse(event, recordHandler, processor, {
* context,
* });
* ```
*
* **Process batch with schema validation**
*
* @example
* ```typescript
* import {
* BatchProcessor,
* EventType,
* processPartialResponse,
* } from '@aws-lambda-powertools/batch';
* import { parser } from '@aws-lambda-powertools/batch/parser';
* import { SqsRecordSchema } from '@aws-lambda-powertools/parser/schemas';
* import type { SQSHandler } from 'aws-lambda';
* import { z } from 'zod';
*
* const myItemSchema = z.object({ name: z.string(), age: z.number() });
*
* const processor = new BatchProcessor(EventType.SQS, {
* parser,
* schema: SqsRecordSchema.extend({
* body: myItemSchema,
* }),
* });
*
* const recordHandler = async (record) => {
* // record is now fully typed and validated
* console.log(record.body.name, record.body.age);
* };
*
* export const handler: SQSHandler = async (event, context) =>
* processPartialResponse(event, recordHandler, processor, {
* context,
* });
* ```
*
* **Process batch with inner schema validation**
*
* @example
* ```typescript
* import {
* BatchProcessor,
* EventType,
* processPartialResponse,
* } from '@aws-lambda-powertools/batch';
* import { parser } from '@aws-lambda-powertools/batch/parser';
* import type { SQSHandler } from 'aws-lambda';
* import { z } from 'zod';
*
* const myItemSchema = z.object({ name: z.string(), age: z.number() });
*
* const processor = new BatchProcessor(EventType.SQS, {
* parser,
* innerSchema: myItemSchema,
* transformer: 'json'
* });
*
* const recordHandler = async (record) => {
* // record is now fully typed and validated
* console.log(record.body.name, record.body.age);
* };
*
* export const handler: SQSHandler = async (event, context) =>
* processPartialResponse(event, recordHandler, processor, {
* context,
* });
* ```
*
* Note: If `innerSchema` is used with DynamoDB streams, the schema will be applied to both the NewImage and the OldImage by default. If you want to have separate schema for both, you will need to extend the schema and use the full schema for parsing.
*
* @param eventType - The type of event to process (SQS, Kinesis, DynamoDB)
*/
class BatchProcessor extends BasePartialBatchProcessor_js_1.BasePartialBatchProcessor {
/**
* Handle a record asynchronously with the instance handler provided.
*
* This method implements the abstract method from the parent class,
* and orchestrates the processing of a single record.
*
* First, it converts the record to the appropriate type for the batch processor.
* Then, it calls the handler function with the record data and context.
*
* If the handler function completes successfully, the method returns a success response.
* Otherwise, it returns a failure response with the error that occurred during processing.
*
* @param record - The record to be processed
*/
async processRecord(record) {
try {
const recordToProcess = this.parserConfig?.parser
? await this.parserConfig.parser(record, this.eventType, this.logger, this.parserConfig)
: record;
const data = this.toBatchType(recordToProcess, this.eventType);
const result = await this.handler(data, this.options?.context);
return this.successHandler(record, result);
}
catch (error) {
return this.failureHandler(record, error);
}
}
/**
* @throws {BatchProcessingError} This method is not implemented for synchronous processing.
*
* @param _record - The record to be processed
*/
processRecordSync(_record) {
throw new errors_js_1.BatchProcessingError('Not implemented. Use asyncProcess() instead.');
}
}
exports.BatchProcessor = BatchProcessor;