npm install @siglo/core @siglo/sqs
npm install --save-dev @types/aws-lambda

function createSqsBatchHandler<TInput = any, TOutput = any>(
    workflow: Flow<TInput, TOutput>,
    options?: SigloSqsOptions<TInput, TOutput>,
): (event: SigloSqsEvent) => Promise<SqsBatchResponse>;

export interface SigloSqsRecord {
    messageId: string;
    receiptHandle: string;
    body: string;
    attributes?: Record<string, string>;
    messageAttributes?: Record<string, any>;
}

export interface SigloSqsEvent {
    Records: SigloSqsRecord[];
}

export interface SqsBatchResponse {
    batchItemFailures: Array<{ itemIdentifier: string }>;
    processedCount: number;
}

import { SQSEvent, SQSBatchResponse, Context } from 'aws-lambda';
import { Step, flow } from '@siglo/core';
import { createSqsBatchHandler } from '@siglo/sqs';
import { PostgresIdempotencyStore } from '@siglo/postgres';
import { Pool } from 'pg';

// 1. Initialize PostgreSQL Connection Pool outside handler
const pool = new Pool({
    connectionString: process.env.DATABASE_URL,
    max: 5,
});

const idempotencyStore = new PostgresIdempotencyStore({ client: pool });

// 2. Define Notification Workflow
interface NotificationPayload {
    userId: string;
    template: string;
    destination: string;
}

const formatNotification = Step.create('formatNotification', async (param: NotificationPayload) => {
    return { formattedBody: `Hello user ${param.userId}, template ${param.template}` };
});

const dispatchEmail = Step.create('dispatchEmail', async (param: any) => {
    // Send email via AWS SES or external provider
    return { dispatched: true, messageRef: `ses_${Date.now()}` };
});

const notificationFlow = flow(formatNotification, dispatchEmail);

// 3. Create SQS Batch Handler
const sqsHandler = createSqsBatchHandler(notificationFlow, {
    idempotencyStore,
    timeout: 10000, // 10-second deadline per message
    namespace: record => record.messageAttributes?.tenantId?.stringValue,
});

// 4. Export AWS Lambda Handler
export const handler = async (event: SQSEvent, context: Context): Promise<SQSBatchResponse> => {
    context.callbackWaitsForEmptyEventLoop = false;

    const response = await sqsHandler(event);
    console.log(`Processed ${response.processedCount} messages. Failures: ${response.batchItemFailures.length}`);

    return {
        batchItemFailures: response.batchItemFailures,
    };
};