@devx-commerce/plugin-gati 0.0.2-beta.13 → 0.0.2-beta.130

package/.medusa/server/src/commands/bulk-jobs/erp-webhook-batch.js

@@ -0,0 +1,560 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = erpWebhookBatchProcessingScript;
+const client_s3_1 = require("@aws-sdk/client-s3");
+const s3_request_presigner_1 = require("@aws-sdk/s3-request-presigner");
+const utils_1 = require("@medusajs/framework/utils");
+const node_http_handler_1 = require("@smithy/node-http-handler");
+const config_1 = require("../../api/erp/webhook/config");
+const update_erp_event_1 = require("../../workflows/erp-event/workflows/update-erp-event");
+const notification_1 = require("../../workflows/notification");
+const command_args_1 = require("../utils/command-args");
+// Utility function to wait for a specified duration
+async function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+class S3MultipartUploader {
+    constructor(bucket, fileKey, s3Client, logger) {
+        this.uploadId = null;
+        this.parts = [];
+        this.currentPart = 1;
+        this.currentBuffer = Buffer.alloc(0);
+        this.minPartSize = 5 * 1024 * 1024; // 5MB minimum for multipart
+        this.totalSize = 0;
+        this.s3Client = s3Client;
+        this.bucket = bucket;
+        this.fileKey = fileKey;
+        this.logger = logger;
+    }
+    async initializeUpload() {
+        try {
+            const command = new client_s3_1.CreateMultipartUploadCommand({
+                Bucket: this.bucket,
+                Key: this.fileKey,
+                ContentType: "text/csv",
+                ContentDisposition: `attachment; filename="${this.fileKey
+                    .split("/")
+                    .pop()}"`,
+                Metadata: {
+                    "generated-by": "medusa-erp-batch-processor",
+                    "created-at": new Date().toISOString(),
+                    "export-type": "error-report",
+                },
+            });
+            const response = await this.s3Client.send(command);
+            this.uploadId = response.UploadId;
+            this.logger.info(`S3 multipart upload initialized. UploadId: ${this.uploadId}`);
+        }
+        catch (error) {
+            this.logger.error("Failed to initialize S3 multipart upload", error);
+            throw error;
+        }
+    }
+    async writeChunk(csvChunk) {
+        if (!this.uploadId) {
+            await this.initializeUpload();
+        }
+        const chunkBuffer = Buffer.from(csvChunk, "utf-8");
+        this.currentBuffer = Buffer.concat([this.currentBuffer, chunkBuffer]);
+        this.totalSize += chunkBuffer.length;
+        // Upload when buffer reaches minimum part size
+        if (this.currentBuffer.length >= this.minPartSize) {
+            await this.uploadPart();
+        }
+    }
+    async uploadPart() {
+        if (this.currentBuffer.length === 0 || !this.uploadId)
+            return;
+        try {
+            this.logger.info(`Uploading part ${this.currentPart}, size: ${(this.currentBuffer.length /
+                1024 /
+                1024).toFixed(2)}MB`);
+            const command = new client_s3_1.UploadPartCommand({
+                Bucket: this.bucket,
+                Key: this.fileKey,
+                PartNumber: this.currentPart,
+                UploadId: this.uploadId,
+                Body: this.currentBuffer,
+            });
+            const response = await this.s3Client.send(command);
+            if (!response.ETag) {
+                throw new Error(`Part ${this.currentPart} upload failed: Missing ETag in response`);
+            }
+            this.parts.push({
+                ETag: response.ETag,
+                PartNumber: this.currentPart,
+            });
+            this.logger.info(`Part ${this.currentPart} uploaded successfully, ETag: ${response.ETag}`);
+            // Clear buffer and increment part number
+            this.currentBuffer = Buffer.alloc(0);
+            this.currentPart++;
+        }
+        catch (error) {
+            this.logger.error(`Failed to upload part ${this.currentPart}`, error);
+            throw error;
+        }
+    }
+    async finalize() {
+        if (!this.uploadId) {
+            throw new Error("Upload not initialized");
+        }
+        try {
+            // Upload any remaining data in buffer as final part
+            if (this.currentBuffer.length > 0) {
+                await this.uploadPart();
+            }
+            if (this.parts.length === 0) {
+                throw new Error("No parts uploaded");
+            }
+            // Complete multipart upload
+            const command = new client_s3_1.CompleteMultipartUploadCommand({
+                Bucket: this.bucket,
+                Key: this.fileKey,
+                UploadId: this.uploadId,
+                MultipartUpload: {
+                    Parts: this.parts.sort((a, b) => a.PartNumber - b.PartNumber),
+                },
+            });
+            const response = await this.s3Client.send(command);
+            this.logger.info(`S3 multipart upload completed successfully`);
+            this.logger.info(`Location: ${response.Location}`);
+            this.logger.info(`Total parts: ${this.parts.length}`);
+            this.logger.info(`Total size: ${(this.totalSize / 1024 / 1024).toFixed(2)}MB`);
+            return {
+                fileId: this.fileKey,
+                fileKey: this.fileKey,
+                fileSize: this.totalSize,
+            };
+        }
+        catch (error) {
+            this.logger.error("Failed to complete S3 multipart upload", error);
+            await this.abort();
+            throw error;
+        }
+    }
+    async abort() {
+        if (!this.uploadId)
+            return;
+        try {
+            const command = new client_s3_1.AbortMultipartUploadCommand({
+                Bucket: this.bucket,
+                Key: this.fileKey,
+                UploadId: this.uploadId,
+            });
+            await this.s3Client.send(command);
+            this.logger.info(`S3 multipart upload aborted: ${this.uploadId}`);
+        }
+        catch (error) {
+            this.logger.error("Failed to abort S3 multipart upload", error);
+        }
+    }
+}
+async function generateErrorCSV(errors) {
+    const csvHeaders = [
+        "Batch Index",
+        "Batch Size",
+        "Failed Items",
+        "Error Message",
+        "Timestamp",
+    ];
+    const csvRows = errors.map((error) => [
+        error.batchIndex.toString(),
+        error.batchSize.toString(),
+        `"${error.items.join(", ")}"`, // Wrap in quotes and join items
+        `"${error.error.replace(/"/g, '""')}"`, // Escape quotes in error message
+        error.timestamp,
+    ]);
+    const csvContent = [
+        csvHeaders.join(","),
+        ...csvRows.map((row) => row.join(",")),
+    ].join("\n");
+    return csvContent;
+}
+async function uploadErrorCSVToS3(container, csvContent, jobId, datafor, operation) {
+    const logger = container.resolve(utils_1.ContainerRegistrationKeys.LOGGER);
+    let uploader = null;
+    try {
+        // Get S3 configuration from environment
+        const bucket = process.env.AWS_MEDIA_BUCKET;
+        if (!bucket) {
+            throw new Error("AWS_MEDIA_BUCKET not configured");
+        }
+        // Create optimized S3 client
+        const s3Client = new client_s3_1.S3Client({
+            region: process.env.AWS_REGION || "ap-south-1",
+            credentials: {
+                accessKeyId: process.env.AWS_ACCESS_KEY_ID,
+                secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
+            },
+            ...(process.env.S3_ENDPOINT && { endpoint: process.env.S3_ENDPOINT }),
+            requestHandler: new node_http_handler_1.NodeHttpHandler({
+                connectionTimeout: 30000, // 30s connection timeout
+                socketTimeout: 120000, // 2min socket timeout for large uploads
+                httpsAgent: {
+                    keepAlive: true,
+                    maxSockets: 50, // Connection pooling
+                    maxFreeSockets: 10,
+                    keepAliveMsecs: 30000, // Keep connections alive for 30s
+                },
+            }),
+            maxAttempts: 3, // Retry failed requests
+            retryMode: "adaptive", // Intelligent retry strategy
+        });
+        const fileName = `erp-batch-errors-${datafor}-${operation}-${jobId}-${Date.now()}.csv`;
+        const fileKey = `bulk-jobs/errors/${fileName}`;
+        // Initialize S3 multipart uploader
+        uploader = new S3MultipartUploader(bucket, fileKey, s3Client, logger);
+        // Upload CSV content in chunks
+        logger.info(`Uploading error CSV to S3: ${fileKey}`);
+        await uploader.writeChunk(csvContent);
+        // Finalize the upload
+        const uploadResult = await uploader.finalize();
+        logger.info(`Error CSV uploaded successfully: ${uploadResult.fileKey}`);
+        logger.info(`File size: ${(uploadResult.fileSize / 1024).toFixed(2)} KB`);
+        // Generate presigned download URL
+        let downloadUrl;
+        try {
+            // Generate presigned URL using AWS SDK
+            const getObjectCommand = new client_s3_1.GetObjectCommand({
+                Bucket: bucket,
+                Key: uploadResult.fileKey,
+            });
+            downloadUrl = await (0, s3_request_presigner_1.getSignedUrl)(s3Client, getObjectCommand, {
+                expiresIn: 24 * 60 * 60, // 24 hours expiration
+            });
+            logger.info(`Generated presigned download URL for: ${uploadResult.fileKey}`);
+            logger.info(`URL expires in 24 hours`);
+        }
+        catch (presignError) {
+            // Fallback to direct S3 URL (may not work if bucket is private)
+            logger.warn(`Presigned URL generation failed, using direct S3 URL: ${presignError.message}`);
+            downloadUrl = `https://${bucket}.s3.${process.env.AWS_REGION || "ap-south-1"}.amazonaws.com/${uploadResult.fileKey}`;
+            logger.warn("Using direct S3 URL - this may not work if the bucket is private");
+        }
+        return { fileKey: uploadResult.fileKey, downloadUrl };
+    }
+    catch (error) {
+        // Abort multipart upload if it was started
+        if (uploader) {
+            await uploader.abort();
+        }
+        logger.error("Failed to upload error CSV to S3:", error);
+        throw error;
+    }
+}
+async function sendErrorNotificationEmail(container, jobId, datafor, operation, totalItems, failedBatches, totalBatches, csvDownloadUrl, csvFileName) {
+    const logger = container.resolve(utils_1.ContainerRegistrationKeys.LOGGER);
+    try {
+        await (0, notification_1.createNotificationWorkflow)(container).run({
+            input: {
+                to: "vasu.chapadia@devxconsultancy.com", // Will be filled by notification service
+                channel: "email",
+                template: "erp-batch-report",
+                data: {
+                    jobId,
+                    datafor: JSON.stringify(datafor),
+                    operation,
+                    totalItems,
+                    failedBatches,
+                    totalBatches,
+                    errorRate: ((failedBatches / totalBatches) * 100).toFixed(2),
+                    csvFileName,
+                    csvDownloadUrl,
+                },
+            },
+        });
+        logger.info("Error notification email sent successfully");
+    }
+    catch (error) {
+        logger.error("Failed to send error notification email:", error);
+        // Don't throw here - we don't want email failure to fail the entire job
+    }
+}
+async function logJobStatus(container, jobId, status, errorMessage, result) {
+    const logger = container.resolve(utils_1.ContainerRegistrationKeys.LOGGER);
+    logger.info(`Job ${jobId} status: ${status}`);
+    if (errorMessage) {
+        logger.error(`Job ${jobId} error: ${errorMessage}`);
+    }
+    if (result) {
+        logger.info(`Job ${jobId} result: ${JSON.stringify(result)}`);
+    }
+}
+async function processBatch(container, datafor, operation, batch, batchIndex, totalBatches, logger, erpEventId) {
+    const errors = [];
+    let processed = 0;
+    try {
+        logger.info(`Processing batch ${batchIndex + 1}/${totalBatches} - ${batch.length} items for ${datafor} ${operation}`);
+        const workflowConfig = config_1.MASTER_WORKFLOW_CONFIG[datafor];
+        if (!workflowConfig) {
+            throw new Error(`Unsupported datafor type: ${datafor}`);
+        }
+        const workflowHandler = workflowConfig[operation];
+        if (!workflowHandler) {
+            throw new Error(`Unsupported operation: ${operation} for ${datafor}`);
+        }
+        const input = { datafor, operation, data: batch, eventId: erpEventId };
+        // Execute the workflow for this batch
+        await workflowHandler(container, input);
+        processed = batch.length;
+        logger.info(`✅ Successfully processed batch ${batchIndex + 1}/${totalBatches} - ${processed} items`);
+        return { success: true, processed, errors };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        errors.push(`Batch ${batchIndex + 1}: ${errorMessage}`);
+        logger.error(`❌ Failed to process batch ${batchIndex + 1}/${totalBatches}: ${errorMessage}`);
+        const batchError = {
+            batchIndex: batchIndex + 1,
+            batchSize: batch.length,
+            items: batch,
+            error: errorMessage,
+            timestamp: new Date().toISOString(),
+        };
+        return { success: false, processed, errors, batchError };
+    }
+}
+async function erpWebhookBatchProcessingScript({ container, }) {
+    const jobId = (0, command_args_1.getArgString)("job-id", `erp_webhook_batch_job_${Date.now()}`);
+    const batchSize = (0, command_args_1.getArgNumber)("batch-size", 200);
+    const erpEventId = (0, command_args_1.getArgString)("event-id");
+    const logger = container.resolve(utils_1.ContainerRegistrationKeys.LOGGER);
+    if (!erpEventId) {
+        logger.error("event-id parameter is required");
+        throw new Error("event-id parameter is required");
+    }
+    try {
+        const query = container.resolve(utils_1.ContainerRegistrationKeys.QUERY);
+        logger.info(`ERP webhook batch processing job started: ${jobId}`);
+        logger.info(`Event ID: ${erpEventId}`);
+        logger.info(`Batch size: ${batchSize} items per batch`);
+        logger.info(`Initial memory usage: ${Math.round(process.memoryUsage().heapUsed / 1024 / 1024)}MB`);
+        // Get the ERP event data
+        logger.info("Fetching ERP event data...");
+        const startTime = Date.now();
+        const { data: erpEventData } = await query.graph({
+            entity: "erp_event",
+            fields: ["id", "datafor", "operation", "data", "status"],
+            filters: {
+                id: erpEventId,
+            },
+            pagination: {
+                skip: 0,
+                take: 1,
+            },
+        });
+        logger.info(`erpEvent ${JSON.stringify(erpEventData)}`);
+        const erpEvent = erpEventData[0];
+        if (!erpEvent) {
+            logger.warn(`No ERP event found with ID: ${erpEventId}`);
+            await logJobStatus(container, jobId, "completed", undefined, {
+                message: "No ERP event found",
+            });
+            throw new Error("No ERP event found");
+        }
+        if (erpEvent.status !== "pending") {
+            logger.info(`ERP event ${erpEventId} is already completed`);
+            await logJobStatus(container, jobId, "completed", undefined, {
+                message: "ERP event is already completed",
+            });
+            throw new Error("ERP event is already completed");
+        }
+        await logJobStatus(container, jobId, "processing");
+        const { datafor, operation, data } = erpEvent;
+        const totalItems = data.length;
+        await (0, notification_1.createNotificationWorkflow)(container).run({
+            input: {
+                to: "",
+                channel: "feed",
+                template: "admin-ui",
+                data: {
+                    title: "ERP Batch Processing Started",
+                    description: `ERP batch processing job ${jobId} and event ${erpEventId} started. Total items to process: ${totalItems}`,
+                },
+            },
+        });
+        if (totalItems === 0) {
+            logger.warn("No data items to process in the ERP event");
+            await logJobStatus(container, jobId, "completed", undefined, {
+                message: "No data items to process",
+            });
+            return;
+        }
+        logger.info(`Processing ${totalItems} items for ${datafor} ${operation}`);
+        // Split data into batches
+        const batches = [];
+        for (let i = 0; i < totalItems; i += batchSize) {
+            batches.push(data.slice(i, i + batchSize));
+        }
+        const totalBatches = batches.length;
+        logger.info(`Split into ${totalBatches} batches of up to ${batchSize} items each`);
+        // Process batches
+        let totalProcessed = 0;
+        let totalErrors = 0;
+        const allErrors = [];
+        const batchErrors = [];
+        for (let i = 0; i < batches.length; i++) {
+            const batch = batches[i];
+            try {
+                const result = await processBatch(container, datafor, operation, batch, i, totalBatches, logger, erpEventId);
+                totalProcessed += result.processed;
+                if (!result.success) {
+                    totalErrors++;
+                    allErrors.push(...result.errors);
+                    if (result.batchError) {
+                        batchErrors.push(result.batchError);
+                    }
+                }
+                // Log progress every 5 batches
+                if ((i + 1) % 5 === 0 || i === totalBatches - 1) {
+                    const memUsage = Math.round(process.memoryUsage().heapUsed / 1024 / 1024);
+                    logger.info(`Progress: ${i + 1}/${totalBatches} batches, ${totalProcessed}/${totalItems} items processed, Memory: ${memUsage}MB`);
+                    // Force garbage collection for large jobs (if enabled)
+                    if (memUsage > 1500 && global.gc) {
+                        logger.info("High memory usage detected, triggering garbage collection");
+                        global.gc();
+                    }
+                }
+            }
+            catch (error) {
+                totalErrors++;
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                allErrors.push(`Batch ${i + 1}: ${errorMessage}`);
+                logger.error(`Failed to process batch ${i + 1}: ${errorMessage}`);
+                // Add to batch errors for CSV generation
+                const batchError = {
+                    batchIndex: i + 1,
+                    batchSize: batch.length,
+                    items: batch,
+                    error: errorMessage,
+                    timestamp: new Date().toISOString(),
+                };
+                batchErrors.push(batchError);
+                // Continue processing other batches even if one fails
+                continue;
+            }
+        }
+        const processingTime = Date.now() - startTime;
+        const throughput = Math.round(totalProcessed / (processingTime / 1000));
+        const successRate = totalItems > 0 ? (totalProcessed / totalItems) * 100 : 0;
+        logger.info(`Batch processing completed!`);
+        logger.info(`Total items: ${totalItems}`);
+        logger.info(`Successfully processed: ${totalProcessed}`);
+        logger.info(`Failed batches: ${totalErrors}/${totalBatches}`);
+        logger.info(`Success rate: ${successRate.toFixed(2)}%`);
+        logger.info(`Processing time: ${processingTime}ms`);
+        logger.info(`Throughput: ${throughput} items/second`);
+        // Generate CSV and send email if there were errors
+        let csvDownloadUrl = "";
+        let csvFileName = "";
+        if (totalErrors > 0 && batchErrors.length > 0) {
+            try {
+                logger.info(`Generating error CSV for ${batchErrors.length} failed batches...`);
+                const csvContent = await generateErrorCSV(batchErrors);
+                const uploadResult = await uploadErrorCSVToS3(container, csvContent, jobId, datafor, operation);
+                csvDownloadUrl = uploadResult.downloadUrl;
+                csvFileName =
+                    uploadResult.fileKey.split("/").pop() || "error-report.csv";
+                logger.info(`Error CSV generated and uploaded: ${csvFileName}`);
+                // Send error notification email
+                await sendErrorNotificationEmail(container, jobId, datafor, operation, totalItems, totalErrors, totalBatches, csvDownloadUrl, csvFileName);
+                logger.info("Error notification email sent with CSV attachment");
+            }
+            catch (csvError) {
+                logger.error("Failed to generate/send error CSV:", csvError);
+                // Don't throw here - the main job processing was completed
+            }
+        }
+        // Send completion notification
+        const notificationTitle = totalErrors === 0
+            ? `✅ ERP Batch Processing Completed Successfully`
+            : `⚠️ ERP Batch Processing Completed with Errors`;
+        const notificationDescription = totalErrors === 0
+            ? `Successfully processed all ${totalProcessed} items for ${datafor} ${operation}`
+            : `Processed ${totalProcessed}/${totalItems} items for ${datafor} ${operation}. ${totalErrors} batches failed.${csvFileName ? ` Error report: ${csvFileName}` : ""}`;
+        await (0, notification_1.createNotificationWorkflow)(container).run({
+            input: {
+                to: "",
+                channel: "feed",
+                template: "admin-ui",
+                data: {
+                    title: notificationTitle,
+                    description: notificationDescription,
+                },
+            },
+        });
+        await logJobStatus(container, jobId, totalErrors === 0 ? "completed" : "completed_with_errors", totalErrors > 0 ? `${totalErrors} batches failed` : undefined, {
+            datafor,
+            operation,
+            totalItems,
+            processedItems: totalProcessed,
+            failedBatches: totalErrors,
+            successRate: successRate.toFixed(2),
+            processingTimeMs: processingTime,
+            throughputPerSecond: throughput,
+            erpEventId,
+            errors: allErrors.slice(0, 10), // Only include first 10 errors to avoid log overflow
+        });
+        await (0, update_erp_event_1.updateErpEventWorkflow)(container).run({
+            input: {
+                id: erpEventId,
+                status: totalErrors > 0 ? "failed" : "completed",
+                sync_completed_at: new Date(),
+            },
+        });
+        logger.info(`ERP webhook batch processing job completed: ${jobId}`);
+        logger.info(`Final memory usage: ${Math.round(process.memoryUsage().heapUsed / 1024 / 1024)}MB`);
+        // Handle completion based on whether there were errors
+        if (totalErrors > 0) {
+            // For partial failures, update status and exit with error code
+            logger.warn(`Job completed with errors: ${totalErrors} out of ${totalBatches} batches failed`);
+            // Wait briefly for error notifications to complete
+            logger.info("Waiting 30 seconds for error processing to complete...");
+            await delay(30 * 1000); // 30 seconds
+            logger.info("Error processing completed, exiting with error code");
+            // Force exit for ECS task completion with error code to indicate partial failure
+            process.exit(1);
+        }
+        else {
+            // For successful completion, wait longer for sync processes
+            logger.info("All batches processed successfully");
+            // Wait for 2 minutes to allow all sync processes to complete
+            logger.info("Waiting 2 minutes for all sync processes to complete...");
+            await delay(2 * 60 * 1000); // 2 minutes in milliseconds
+            logger.info("Wait period completed, exiting process");
+            // Force exit for ECS task completion - prevents hanging connections from keeping task alive
+            process.exit(0);
+        }
+    }
+    catch (error) {
+        logger.error("Error in ERP webhook batch processing:", error);
+        await logJobStatus(container, jobId, "failed", error.message);
+        await (0, update_erp_event_1.updateErpEventWorkflow)(container).run({
+            input: {
+                id: erpEventId,
+                status: "failed",
+                sync_completed_at: new Date(),
+            },
+        });
+        // Send failure notification
+        await (0, notification_1.createNotificationWorkflow)(container).run({
+            input: {
+                to: "",
+                channel: "feed",
+                template: "admin-ui",
+                data: {
+                    title: "❌ ERP Batch Processing Failed",
+                    description: `ERP batch processing job ${jobId} and event ${erpEventId} failed. Cause: ${error.message}`,
+                },
+            },
+        });
+        // Wait briefly for error notifications to be sent
+        logger.info("Waiting 30 seconds for error notifications to complete...");
+        await delay(30 * 1000); // 30 seconds
+        logger.info("Error handling completed, exiting process");
+        // Force exit for ECS task completion with error code
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"erp-webhook-batch.js","sourceRoot":"","sources":["../../../../../src/commands/bulk-jobs/erp-webhook-batch.ts"],"names":[],"mappings":"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"}