skuba 12.1.0-hoist-less-20250722131939 → 12.1.0-main-20250810101347

package/template/lambda-sqs-worker-cdk/src/framework/handler.ts

@@ -1,8 +1,14 @@
-import type { Context as LambdaContext } from 'aws-lambda';
+import type {
+  Context as LambdaContext,
+  SQSBatchItemFailure,
+  SQSBatchResponse,
+  SQSEvent,
+  SQSRecord,
+} from 'aws-lambda';
 import { datadog } from 'datadog-lambda-js';
 
 import { config } from 'src/config.js';
-import { logger, loggerContext } from 'src/framework/logging.js';
+import { lambdaContext, logger, recordContext } from 'src/framework/logging.js';
 
 type Handler<Event, Output> = (
   event: Event,
@@ -20,15 +26,15 @@ const withDatadog = <Event, Output = unknown>(
   // istanbul ignore next
   config.metrics ? (datadog(fn) as Handler<Event, Output>) : fn;
 
-export const createHandler = <Event, Output = unknown>(
+export const createHandler = <Event extends SQSEvent, Output = unknown>(
   fn: (event: Event, ctx: LambdaContext) => Promise<Output>,
 ) =>
   withDatadog<Event>((event, ctx) =>
-    loggerContext.run({ awsRequestId: ctx.awsRequestId }, async () => {
+    lambdaContext.run({ awsRequestId: ctx.awsRequestId }, async () => {
       try {
         const output = await fn(event, ctx);
 
-        logger.debug('Function succeeded');
+        logger.debug({ output }, 'Function completed');
 
         return output;
       } catch (err) {
@@ -38,3 +44,30 @@ export const createHandler = <Event, Output = unknown>(
       }
     }),
   );
+
+export const createBatchSQSHandler =
+  (
+    fn: (record: SQSRecord, ctx: LambdaContext) => Promise<unknown>,
+  ): Handler<SQSEvent, SQSBatchResponse> =>
+  async (event, ctx) => {
+    const processRecord = (
+      record: SQSRecord,
+    ): Promise<SQSBatchItemFailure | undefined> =>
+      recordContext.run({ sqsMessageId: record.messageId }, async () => {
+        try {
+          await fn(record, ctx);
+          return;
+        } catch (err) {
+          logger.error({ err }, 'Processing record failed');
+          return {
+            itemIdentifier: record.messageId,
+          };
+        }
+      });
+
+    const results = await Promise.all(event.Records.map(processRecord));
+
+    return {
+      batchItemFailures: results.filter((item) => item !== undefined),
+    };
+  };

package/template/lambda-sqs-worker-cdk/src/framework/logging.ts

@@ -4,11 +4,16 @@ import createLogger, { createDestination } from '@seek/logger';
 
 import { config } from 'src/config.js';
 
-interface LoggerContext {
+interface LambdaContext {
   awsRequestId: string;
 }
 
-export const loggerContext = new AsyncLocalStorage<LoggerContext>();
+interface RecordContext {
+  sqsMessageId: string;
+}
+
+export const lambdaContext = new AsyncLocalStorage<LambdaContext>();
+export const recordContext = new AsyncLocalStorage<RecordContext>();
 
 const { destination, stdoutMock } = createDestination({
   mock: config.environment === 'test' && {
@@ -27,7 +32,10 @@ export const logger = createLogger(
 
     level: config.logLevel,
 
-    mixin: () => ({ ...loggerContext.getStore() }),
+    mixin: () => ({
+      ...lambdaContext.getStore(),
+      ...recordContext.getStore(),
+    }),
 
     name: config.name,
 

package/template/lambda-sqs-worker-cdk/src/testing/handler.ts

@@ -9,5 +9,8 @@ export const createCtx = () =>
 
 export const createSqsEvent = (bodies: string[]) =>
   ({
-    Records: bodies.map((body) => ({ body })),
+    Records: bodies.map((body) => ({
+      body,
+      messageId: chance.guid({ version: 4 }),
+    })),
   }) as SQSEvent;