index.mjs

// @ts-nocheck
import { S3Client, GetObjectCommand, PutObjectCommand, DeleteObjectCommand } from '@aws-sdk/client-s3';
import { SQSClient, SendMessageCommand } from '@aws-sdk/client-sqs';
import archiver from 'archiver';
import unzipper from 'unzipper';
import fs from 'fs';

const s3 = new S3Client();
const sqs = new SQSClient({
    region: 'us-east-2',
    endpoint: 'https://sqs.us-east-2.amazonaws.com'
});

export const handler = async (event) => {
    try {
        const { bucket, partKeys, finalKey, updatesQueueUrl, queueId, totalSize, fileCount } = event;

        if (!bucket || !partKeys || !finalKey || !updatesQueueUrl) {
            throw new Error('Missing required parameters');
        }

        const zipKeys = partKeys.map(item => item.zipKey).filter(key => key !== null && key !== undefined);

        if (zipKeys.length === 0) {
            throw new Error('No valid zipKeys found');
        }

        const tmpZipPath = `/tmp/final.zip`;
        const output = fs.createWriteStream(tmpZipPath);
        const archive = archiver('zip', { zlib: { level: 9 } });
        archive.pipe(output);

        for (const zipKey of zipKeys) {
            const { Body } = await s3.send(new GetObjectCommand({ Bucket: bucket, Key: zipKey }));

            await Body.pipe(unzipper.Parse())
                .on('entry', entry => {
                    if (entry.type === 'File') {
                        archive.append(entry, { name: entry.path });
                    } else {
                        entry.autodrain();
                    }
                })
                .promise();
        }

        await archive.finalize();
        await new Promise(resolve => output.on('close', resolve));

        const body = fs.createReadStream(tmpZipPath);
        await s3.send(new PutObjectCommand({ Bucket: bucket, Key: finalKey, Body: body, ContentType: 'application/zip' }));
        fs.unlinkSync(tmpZipPath);

        // CLEANUP: Delete all partial ZIPs
        for (const item of partKeys) {
            const partKey = item?.zipKey;
            if (partKey) {
                try {
                    await s3.send(new DeleteObjectCommand({ Bucket: bucket, Key: partKey }));
                } catch (err) {
                    console.error(`Failed to delete partial ZIP ${partKey}: ${err.message}`);
                }
            }
        }

        await sqs.send(new SendMessageCommand({
            QueueUrl: updatesQueueUrl,
            MessageBody: JSON.stringify({
                queueId,
                zipFileName: finalKey.split('/').pop(),
                status: 'zip-ready',
                function: 'BiospexZipMerger',
                totalSize,
                fileCount,
                zipKey: finalKey
            }),
        }));

        return { status: 'success', finalKey };
    } catch (error) {
        console.error('Merge failed:', error.message);

        try {
            const { updatesQueueUrl, queueId } = event;
            if (updatesQueueUrl) {
                await sqs.send(new SendMessageCommand({
                    QueueUrl: updatesQueueUrl,
                    MessageBody: JSON.stringify({
                        queueId,
                        status: 'zip-failed',
                        error: error.message,
                        function: 'BiospexZipMerger'
                    }),
                }));
            }
        } catch (sendError) {
            console.error('Failed to send failure notification:', sendError.message);
        }

        throw error;
    }
};