@adtrackify/at-service-common 3.19.20 → 3.19.22

package/dist/esm/clients/generic/sqs-bundled-client.js

@@ -1,308 +1,308 @@
-import { Logger } from '../../helpers/logging-helper.js';
-import { compressToBase64 } from '../../utils/compression.js';
-import { sizeInBytes, chunkArrayBySize } from '../../utils/size.js';
-import { SQS_LIMITS } from '../../constants/sqs.js';
-import { CompressionAlgorithm, DEFAULT_BUNDLE_CONFIG, } from './sqs-bundled-client.types.js';
-export class BundledSQSClient {
-    sqsClient;
-    config;
-    constructor(sqsClient, config = {}) {
-        this.sqsClient = sqsClient;
-        this.config = { ...DEFAULT_BUNDLE_CONFIG, ...config };
-    }
-    async sendBundled(messageType, items, delaySeconds = 0) {
-        if (items.length === 0) {
-            return this.emptyResult();
-        }
-        try {
-            const startTime = Date.now();
-            let resizeOccurred = false;
-            let skippedItems = 0;
-            const bundles = chunkArrayBySize(items, this.config.maxUncompressedBundleSizeBytes, this.config.maxItemsPerBundle);
-            const envelopes = [];
-            for (const bundle of bundles) {
-                const result = await this.createEnvelope(bundle);
-                if (!result.success) {
-                    const bundleSizeBytes = sizeInBytes(bundle);
-                    Logger.error('BundledSQSClient: envelope creation failed, skipping bundle', {
-                        messageType,
-                        bundleItems: bundle.length,
-                        bundleSizeBytes,
-                        compression: this.config.compression,
-                        compressionLevel: this.config.compressionLevel,
-                        errorMessage: result.error,
-                        stage: 'createEnvelope',
-                    });
-                    skippedItems += result.itemCount;
-                    continue;
-                }
-                const envelope = result.envelope;
-                const validation = this.validateMessage(envelope);
-                if (!validation.valid && this.config.autoResize) {
-                    Logger.warn('BundledSQSClient: bundle exceeds size limit, auto-resizing', {
-                        messageType,
-                        bundleItems: bundle.length,
-                        compressedSizeBytes: validation.sizeBytes,
-                        maxSizeBytes: this.sqsClient.limits.safeMaxMessageSizeBytes,
-                        compression: this.config.compression,
-                        compressionLevel: this.config.compressionLevel,
-                    });
-                    resizeOccurred = true;
-                    const splitResult = await this.splitAndRetry(bundle);
-                    envelopes.push(...splitResult.envelopes);
-                    skippedItems += splitResult.skippedItems;
-                }
-                else if (!validation.valid) {
-                    Logger.error('BundledSQSClient: bundle exceeds size limit, skipping (autoResize disabled)', {
-                        messageType,
-                        bundleItems: bundle.length,
-                        compressedSizeBytes: validation.sizeBytes,
-                        maxSizeBytes: this.sqsClient.limits.safeMaxMessageSizeBytes,
-                        autoResize: this.config.autoResize,
-                        compression: this.config.compression,
-                        stage: 'validateMessage',
-                        suggestion: 'Enable autoResize or reduce bundle size',
-                    });
-                    skippedItems += bundle.length;
-                }
-                else {
-                    envelopes.push(envelope);
-                }
-            }
-            const result = await this.sendBatched(messageType, envelopes, delaySeconds);
-            const durationMs = Date.now() - startTime;
-            const initialBundleCount = bundles.length;
-            const messageCount = envelopes.length;
-            const metrics = this.calculateMetrics(items, result.totalSizeBytes, messageCount, durationMs, resizeOccurred);
-            Logger.debug('BundledSQSClient: batch sent', {
-                queue: this.sqsClient.queueUrl,
-                messageType,
-                totalItems: items.length,
-                bundleCount: initialBundleCount,
-                messageCount,
-                skippedItems,
-                totalUncompressedBytes: metrics.originalSizeBytes,
-                totalCompressedBytes: metrics.finalSizeBytes,
-                compressionRatio: Number(metrics.compressionRatio.toFixed(2)),
-                avgCompressedBundleSize: messageCount > 0 ? Math.round(metrics.finalSizeBytes / messageCount) : 0,
-                avgItemsPerBundle: Number(metrics.avgItemsPerBundle.toFixed(2)),
-                apiCallCount: result.apiCalls,
-                billableRequests: result.billableRequests,
-                durationMs,
-            });
-            return {
-                totalItems: items.length,
-                bundleCount: bundles.length,
-                messageCount: envelopes.length,
-                apiCallCount: result.apiCalls,
-                billableRequests: result.billableRequests,
-                failedBundles: result.failedCount,
-                skippedItems,
-                metrics,
-            };
-        }
-        catch (error) {
-            Logger.error('BundledSQSClient: sendBundled failed', {
-                error,
-                errorMessage: error instanceof Error ? error.message : String(error),
-                errorStack: error instanceof Error ? error.stack : undefined,
-                errorName: error instanceof Error ? error.name : undefined,
-                messageType,
-                itemCount: items.length,
-                compression: this.config.compression,
-                compressionLevel: this.config.compressionLevel,
-            });
-            return {
-                ...this.emptyResult(),
-                totalItems: items.length,
-                failedBundles: 1,
-                error: error instanceof Error ? error.message : String(error),
-            };
-        }
-    }
-    async createEnvelope(bundle) {
-        try {
-            if (this.config.compression === CompressionAlgorithm.NONE) {
-                return {
-                    success: true,
-                    envelope: {
-                        v: 1,
-                        c: CompressionAlgorithm.NONE,
-                        n: bundle.length,
-                        s: sizeInBytes(bundle),
-                        p: bundle,
-                    },
-                    itemCount: bundle.length,
-                };
-            }
-            const { base64, originalSize } = await compressToBase64(bundle, this.config.compression, this.config.compressionLevel);
-            return {
-                success: true,
-                envelope: {
-                    v: 1,
-                    c: this.config.compression,
-                    n: bundle.length,
-                    s: originalSize,
-                    p: base64,
-                },
-                itemCount: bundle.length,
-            };
-        }
-        catch (error) {
-            Logger.error('BundledSQSClient: compression failed', {
-                error,
-                bundleItemCount: bundle.length,
-                compression: this.config.compression,
-                compressionLevel: this.config.compressionLevel,
-            });
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : String(error),
-                itemCount: bundle.length,
-            };
-        }
-    }
-    validateMessage(envelope) {
-        const messageSizeBytes = sizeInBytes(envelope);
-        const maxSafeSize = this.sqsClient.limits.safeMaxMessageSizeBytes;
-        if (messageSizeBytes > maxSafeSize) {
-            return {
-                valid: false,
-                sizeBytes: messageSizeBytes,
-                error: `Message size ${messageSizeBytes} exceeds limit ${maxSafeSize}`,
-            };
-        }
-        return { valid: true, sizeBytes: messageSizeBytes };
-    }
-    async splitAndRetry(items) {
-        if (items.length <= 1) {
-            const itemSizeBytes = items.length > 0 ? sizeInBytes(items[0]) : 0;
-            Logger.error('BundledSQSClient: single item exceeds size limit, skipping', {
-                itemCount: items.length,
-                itemSizeBytes,
-                maxSizeBytes: this.sqsClient.limits.safeMaxMessageSizeBytes,
-                compression: this.config.compression,
-                stage: 'splitAndRetry',
-                suggestion: 'Consider using S3 for large payloads',
-            });
-            return { envelopes: [], skippedItems: items.length };
-        }
-        const midpoint = Math.ceil(items.length / 2);
-        const firstHalf = items.slice(0, midpoint);
-        const secondHalf = items.slice(midpoint);
-        const processHalf = async (half) => {
-            try {
-                const result = await this.createEnvelope(half);
-                if (!result.success) {
-                    Logger.error('BundledSQSClient: compression failed in splitAndRetry, skipping half', {
-                        itemCount: half.length,
-                        errorMessage: result.error,
-                        compression: this.config.compression,
-                        compressionLevel: this.config.compressionLevel,
-                        stage: 'splitAndRetry.createEnvelope',
-                    });
-                    return { envelopes: [], skippedItems: result.itemCount };
-                }
-                const envelope = result.envelope;
-                const validation = this.validateMessage(envelope);
-                if (!validation.valid) {
-                    return this.splitAndRetry(half);
-                }
-                return { envelopes: [envelope], skippedItems: 0 };
-            }
-            catch (error) {
-                Logger.error('BundledSQSClient: unexpected error in splitAndRetry, skipping half', {
-                    error,
-                    errorMessage: error instanceof Error ? error.message : String(error),
-                    errorStack: error instanceof Error ? error.stack : undefined,
-                    itemCount: half.length,
-                    compression: this.config.compression,
-                    stage: 'splitAndRetry',
-                });
-                return { envelopes: [], skippedItems: half.length };
-            }
-        };
-        const [firstResult, secondResult] = await Promise.all([processHalf(firstHalf), processHalf(secondHalf)]);
-        return {
-            envelopes: [...firstResult.envelopes, ...secondResult.envelopes],
-            skippedItems: firstResult.skippedItems + secondResult.skippedItems,
-        };
-    }
-    async sendBatched(messageType, envelopes, delaySeconds = 0, maxRetries = 2) {
-        let toSend = envelopes;
-        let totalApiCalls = 0;
-        let totalSuccessCount = 0;
-        let retriesRemaining = maxRetries;
-        while (toSend.length > 0 && retriesRemaining >= 0) {
-            const result = await this.sqsClient.buildAndSendMessagesV2(messageType, toSend, delaySeconds);
-            totalApiCalls += result.batchCount;
-            totalSuccessCount += result.successCount;
-            if (result.failedCount === 0) {
-                toSend = [];
-            }
-            else if (retriesRemaining > 0) {
-                Logger.warn('BundledSQSClient [sendBatched]: retrying failed messages', {
-                    failedCount: result.failedCount,
-                    retriesRemaining,
-                    messageType,
-                });
-                toSend = result.failedMessages ?? [];
-                retriesRemaining--;
-                if (toSend.length > 0) {
-                    await this.delay(Math.pow(2, maxRetries - retriesRemaining) * 100);
-                }
-            }
-            else {
-                Logger.error('BundledSQSClient: messages failed after retries', {
-                    failedCount: result.failedCount,
-                    maxRetries,
-                    messageType,
-                });
-                break;
-            }
-        }
-        const totalSizeBytes = envelopes.reduce((sum, env) => sum + sizeInBytes(env), 0);
-        const billableRequests = Math.ceil(totalSizeBytes / SQS_LIMITS.BILLING_CHUNK_BYTES);
-        const finalFailedCount = envelopes.length - totalSuccessCount;
-        return {
-            apiCalls: totalApiCalls,
-            billableRequests,
-            failedCount: finalFailedCount,
-            totalSizeBytes,
-        };
-    }
-    delay(ms) {
-        return new Promise((resolve) => setTimeout(resolve, ms));
-    }
-    calculateMetrics(items, finalSizeBytes, messageCount, durationMs, resizeOccurred) {
-        const originalSizeBytes = items.reduce((sum, item) => sum + sizeInBytes(item), 0);
-        return {
-            originalSizeBytes,
-            finalSizeBytes,
-            compressionRatio: originalSizeBytes / Math.max(finalSizeBytes, 1),
-            compressionTimeMs: durationMs,
-            avgItemsPerBundle: items.length / Math.max(messageCount, 1),
-            resizeOccurred,
-        };
-    }
-    emptyResult() {
-        return {
-            totalItems: 0,
-            bundleCount: 0,
-            messageCount: 0,
-            apiCallCount: 0,
-            billableRequests: 0,
-            failedBundles: 0,
-            skippedItems: 0,
-            metrics: {
-                originalSizeBytes: 0,
-                finalSizeBytes: 0,
-                compressionRatio: 1,
-                compressionTimeMs: 0,
-                avgItemsPerBundle: 0,
-                resizeOccurred: false,
-            },
-        };
-    }
-}
+import { Logger } from '../../helpers/logging-helper.js';
+import { compressToBase64 } from '../../utils/compression.js';
+import { sizeInBytes, chunkArrayBySize } from '../../utils/size.js';
+import { SQS_LIMITS } from '../../constants/sqs.js';
+import { CompressionAlgorithm, DEFAULT_BUNDLE_CONFIG, } from './sqs-bundled-client.types.js';
+export class BundledSQSClient {
+    sqsClient;
+    config;
+    constructor(sqsClient, config = {}) {
+        this.sqsClient = sqsClient;
+        this.config = { ...DEFAULT_BUNDLE_CONFIG, ...config };
+    }
+    async sendBundled(messageType, items, delaySeconds = 0) {
+        if (items.length === 0) {
+            return this.emptyResult();
+        }
+        try {
+            const startTime = Date.now();
+            let resizeOccurred = false;
+            let skippedItems = 0;
+            const bundles = chunkArrayBySize(items, this.config.maxUncompressedBundleSizeBytes, this.config.maxItemsPerBundle);
+            const envelopes = [];
+            for (const bundle of bundles) {
+                const result = await this.createEnvelope(bundle);
+                if (!result.success) {
+                    const bundleSizeBytes = sizeInBytes(bundle);
+                    Logger.error('BundledSQSClient: envelope creation failed, skipping bundle', {
+                        messageType,
+                        bundleItems: bundle.length,
+                        bundleSizeBytes,
+                        compression: this.config.compression,
+                        compressionLevel: this.config.compressionLevel,
+                        errorMessage: result.error,
+                        stage: 'createEnvelope',
+                    });
+                    skippedItems += result.itemCount;
+                    continue;
+                }
+                const envelope = result.envelope;
+                const validation = this.validateMessage(envelope);
+                if (!validation.valid && this.config.autoResize) {
+                    Logger.warn('BundledSQSClient: bundle exceeds size limit, auto-resizing', {
+                        messageType,
+                        bundleItems: bundle.length,
+                        compressedSizeBytes: validation.sizeBytes,
+                        maxSizeBytes: this.sqsClient.limits.safeMaxMessageSizeBytes,
+                        compression: this.config.compression,
+                        compressionLevel: this.config.compressionLevel,
+                    });
+                    resizeOccurred = true;
+                    const splitResult = await this.splitAndRetry(bundle);
+                    envelopes.push(...splitResult.envelopes);
+                    skippedItems += splitResult.skippedItems;
+                }
+                else if (!validation.valid) {
+                    Logger.error('BundledSQSClient: bundle exceeds size limit, skipping (autoResize disabled)', {
+                        messageType,
+                        bundleItems: bundle.length,
+                        compressedSizeBytes: validation.sizeBytes,
+                        maxSizeBytes: this.sqsClient.limits.safeMaxMessageSizeBytes,
+                        autoResize: this.config.autoResize,
+                        compression: this.config.compression,
+                        stage: 'validateMessage',
+                        suggestion: 'Enable autoResize or reduce bundle size',
+                    });
+                    skippedItems += bundle.length;
+                }
+                else {
+                    envelopes.push(envelope);
+                }
+            }
+            const result = await this.sendBatched(messageType, envelopes, delaySeconds);
+            const durationMs = Date.now() - startTime;
+            const initialBundleCount = bundles.length;
+            const messageCount = envelopes.length;
+            const metrics = this.calculateMetrics(items, result.totalSizeBytes, messageCount, durationMs, resizeOccurred);
+            Logger.debug('BundledSQSClient: batch sent', {
+                queue: this.sqsClient.queueUrl,
+                messageType,
+                totalItems: items.length,
+                bundleCount: initialBundleCount,
+                messageCount,
+                skippedItems,
+                totalUncompressedBytes: metrics.originalSizeBytes,
+                totalCompressedBytes: metrics.finalSizeBytes,
+                compressionRatio: Number(metrics.compressionRatio.toFixed(2)),
+                avgCompressedBundleSize: messageCount > 0 ? Math.round(metrics.finalSizeBytes / messageCount) : 0,
+                avgItemsPerBundle: Number(metrics.avgItemsPerBundle.toFixed(2)),
+                apiCallCount: result.apiCalls,
+                billableRequests: result.billableRequests,
+                durationMs,
+            });
+            return {
+                totalItems: items.length,
+                bundleCount: bundles.length,
+                messageCount: envelopes.length,
+                apiCallCount: result.apiCalls,
+                billableRequests: result.billableRequests,
+                failedBundles: result.failedCount,
+                skippedItems,
+                metrics,
+            };
+        }
+        catch (error) {
+            Logger.error('BundledSQSClient: sendBundled failed', {
+                error,
+                errorMessage: error instanceof Error ? error.message : String(error),
+                errorStack: error instanceof Error ? error.stack : undefined,
+                errorName: error instanceof Error ? error.name : undefined,
+                messageType,
+                itemCount: items.length,
+                compression: this.config.compression,
+                compressionLevel: this.config.compressionLevel,
+            });
+            return {
+                ...this.emptyResult(),
+                totalItems: items.length,
+                failedBundles: 1,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    async createEnvelope(bundle) {
+        try {
+            if (this.config.compression === CompressionAlgorithm.NONE) {
+                return {
+                    success: true,
+                    envelope: {
+                        v: 1,
+                        c: CompressionAlgorithm.NONE,
+                        n: bundle.length,
+                        s: sizeInBytes(bundle),
+                        p: bundle,
+                    },
+                    itemCount: bundle.length,
+                };
+            }
+            const { base64, originalSize } = await compressToBase64(bundle, this.config.compression, this.config.compressionLevel);
+            return {
+                success: true,
+                envelope: {
+                    v: 1,
+                    c: this.config.compression,
+                    n: bundle.length,
+                    s: originalSize,
+                    p: base64,
+                },
+                itemCount: bundle.length,
+            };
+        }
+        catch (error) {
+            Logger.error('BundledSQSClient: compression failed', {
+                error,
+                bundleItemCount: bundle.length,
+                compression: this.config.compression,
+                compressionLevel: this.config.compressionLevel,
+            });
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+                itemCount: bundle.length,
+            };
+        }
+    }
+    validateMessage(envelope) {
+        const messageSizeBytes = sizeInBytes(envelope);
+        const maxSafeSize = this.sqsClient.limits.safeMaxMessageSizeBytes;
+        if (messageSizeBytes > maxSafeSize) {
+            return {
+                valid: false,
+                sizeBytes: messageSizeBytes,
+                error: `Message size ${messageSizeBytes} exceeds limit ${maxSafeSize}`,
+            };
+        }
+        return { valid: true, sizeBytes: messageSizeBytes };
+    }
+    async splitAndRetry(items) {
+        if (items.length <= 1) {
+            const itemSizeBytes = items.length > 0 ? sizeInBytes(items[0]) : 0;
+            Logger.error('BundledSQSClient: single item exceeds size limit, skipping', {
+                itemCount: items.length,
+                itemSizeBytes,
+                maxSizeBytes: this.sqsClient.limits.safeMaxMessageSizeBytes,
+                compression: this.config.compression,
+                stage: 'splitAndRetry',
+                suggestion: 'Consider using S3 for large payloads',
+            });
+            return { envelopes: [], skippedItems: items.length };
+        }
+        const midpoint = Math.ceil(items.length / 2);
+        const firstHalf = items.slice(0, midpoint);
+        const secondHalf = items.slice(midpoint);
+        const processHalf = async (half) => {
+            try {
+                const result = await this.createEnvelope(half);
+                if (!result.success) {
+                    Logger.error('BundledSQSClient: compression failed in splitAndRetry, skipping half', {
+                        itemCount: half.length,
+                        errorMessage: result.error,
+                        compression: this.config.compression,
+                        compressionLevel: this.config.compressionLevel,
+                        stage: 'splitAndRetry.createEnvelope',
+                    });
+                    return { envelopes: [], skippedItems: result.itemCount };
+                }
+                const envelope = result.envelope;
+                const validation = this.validateMessage(envelope);
+                if (!validation.valid) {
+                    return this.splitAndRetry(half);
+                }
+                return { envelopes: [envelope], skippedItems: 0 };
+            }
+            catch (error) {
+                Logger.error('BundledSQSClient: unexpected error in splitAndRetry, skipping half', {
+                    error,
+                    errorMessage: error instanceof Error ? error.message : String(error),
+                    errorStack: error instanceof Error ? error.stack : undefined,
+                    itemCount: half.length,
+                    compression: this.config.compression,
+                    stage: 'splitAndRetry',
+                });
+                return { envelopes: [], skippedItems: half.length };
+            }
+        };
+        const [firstResult, secondResult] = await Promise.all([processHalf(firstHalf), processHalf(secondHalf)]);
+        return {
+            envelopes: [...firstResult.envelopes, ...secondResult.envelopes],
+            skippedItems: firstResult.skippedItems + secondResult.skippedItems,
+        };
+    }
+    async sendBatched(messageType, envelopes, delaySeconds = 0, maxRetries = 2) {
+        let toSend = envelopes;
+        let totalApiCalls = 0;
+        let totalSuccessCount = 0;
+        let retriesRemaining = maxRetries;
+        while (toSend.length > 0 && retriesRemaining >= 0) {
+            const result = await this.sqsClient.buildAndSendMessagesV2(messageType, toSend, delaySeconds);
+            totalApiCalls += result.batchCount;
+            totalSuccessCount += result.successCount;
+            if (result.failedCount === 0) {
+                toSend = [];
+            }
+            else if (retriesRemaining > 0) {
+                Logger.warn('BundledSQSClient [sendBatched]: retrying failed messages', {
+                    failedCount: result.failedCount,
+                    retriesRemaining,
+                    messageType,
+                });
+                toSend = result.failedMessages ?? [];
+                retriesRemaining--;
+                if (toSend.length > 0) {
+                    await this.delay(Math.pow(2, maxRetries - retriesRemaining) * 100);
+                }
+            }
+            else {
+                Logger.error('BundledSQSClient: messages failed after retries', {
+                    failedCount: result.failedCount,
+                    maxRetries,
+                    messageType,
+                });
+                break;
+            }
+        }
+        const totalSizeBytes = envelopes.reduce((sum, env) => sum + sizeInBytes(env), 0);
+        const billableRequests = Math.ceil(totalSizeBytes / SQS_LIMITS.BILLING_CHUNK_BYTES);
+        const finalFailedCount = envelopes.length - totalSuccessCount;
+        return {
+            apiCalls: totalApiCalls,
+            billableRequests,
+            failedCount: finalFailedCount,
+            totalSizeBytes,
+        };
+    }
+    delay(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    calculateMetrics(items, finalSizeBytes, messageCount, durationMs, resizeOccurred) {
+        const originalSizeBytes = items.reduce((sum, item) => sum + sizeInBytes(item), 0);
+        return {
+            originalSizeBytes,
+            finalSizeBytes,
+            compressionRatio: originalSizeBytes / Math.max(finalSizeBytes, 1),
+            compressionTimeMs: durationMs,
+            avgItemsPerBundle: items.length / Math.max(messageCount, 1),
+            resizeOccurred,
+        };
+    }
+    emptyResult() {
+        return {
+            totalItems: 0,
+            bundleCount: 0,
+            messageCount: 0,
+            apiCallCount: 0,
+            billableRequests: 0,
+            failedBundles: 0,
+            skippedItems: 0,
+            metrics: {
+                originalSizeBytes: 0,
+                finalSizeBytes: 0,
+                compressionRatio: 1,
+                compressionTimeMs: 0,
+                avgItemsPerBundle: 0,
+                resizeOccurred: false,
+            },
+        };
+    }
+}
 //# sourceMappingURL=sqs-bundled-client.js.map