@adtrackify/at-service-common 5.0.7 → 5.1.2

package/dist/cjs/services/db/products-db-service.js

@@ -1,282 +1,311 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProductsDbService = void 0;
-const index_js_1 = require("../../clients/index.js");
-const index_js_2 = require("../../helpers/index.js");
-const index_js_3 = require("../../libs/index.js");
-const DYNAMO_BATCH_GET_LIMIT = 100;
-const DYNAMO_BATCH_WRITE_LIMIT = 25;
-class ProductsDbService {
-    TABLE_NAME;
-    TABLE_KEY;
-    constructor(tableName, tableKey) {
-        this.TABLE_NAME = tableName;
-        this.TABLE_KEY = tableKey;
-    }
-    buildVariantPk = (pixelId, productId, variantId) => `variant#${pixelId}_${productId}_${variantId}`;
-    buildProductPk = (pixelId, productId) => `product#${pixelId}_${productId}`;
-    getVariant = async (pixelId, productId, variantId) => {
-        try {
-            const pk = this.buildVariantPk(pixelId, productId, variantId);
-            const result = await index_js_1.DynamoDbClient.safeGet(this.TABLE_NAME, this.TABLE_KEY, pk);
-            return result ?? null;
-        }
-        catch (error) {
-            index_js_2.Logger.error('ProductsDbService.getVariant: failed', { error, pixelId, productId, variantId });
-            return null;
-        }
-    };
-    putVariant = async (record) => {
-        try {
-            const toWrite = { ...record, updatedAt: (0, index_js_3.getCurrentTimestamp)() };
-            await index_js_1.DynamoDbClient.safePut(this.TABLE_NAME, toWrite);
-            return toWrite;
-        }
-        catch (error) {
-            index_js_2.Logger.error('ProductsDbService.putVariant: failed', { error, pixelId: record.pixelId, productId: record.productId, variantId: record.variantId });
-            return null;
-        }
-    };
-    batchPutVariants = async (records, options) => {
-        const concurrency = options?.concurrency ?? 1;
-        const successfulRecords = [];
-        const failedRecords = [];
-        if (records.length === 0) {
-            return { successfulRecords, failedRecords };
-        }
-        try {
-            const now = (0, index_js_3.getCurrentTimestamp)();
-            const chunks = [];
-            for (let i = 0; i < records.length; i += DYNAMO_BATCH_WRITE_LIMIT) {
-                const chunk = records.slice(i, i + DYNAMO_BATCH_WRITE_LIMIT);
-                const itemsToWrite = chunk.map(record => ({ ...record, updatedAt: now }));
-                chunks.push({ chunk, itemsToWrite, chunkIndex: Math.floor(i / DYNAMO_BATCH_WRITE_LIMIT) });
-            }
-            for (let i = 0; i < chunks.length; i += concurrency) {
-                const parallelStart = performance.now();
-                const parallelChunks = chunks.slice(i, i + concurrency);
-                const results = await Promise.allSettled(parallelChunks.map(async ({ chunk, itemsToWrite, chunkIndex }) => {
-                    const result = await index_js_1.DynamoDbClient.safeBatchPut(this.TABLE_NAME, itemsToWrite);
-                    return { chunk, itemsToWrite, chunkIndex, success: !!result };
-                }));
-                for (const result of results) {
-                    if (result.status === 'fulfilled') {
-                        const { chunk, itemsToWrite, chunkIndex, success } = result.value;
-                        if (success) {
-                            successfulRecords.push(...itemsToWrite);
-                        }
-                        else {
-                            failedRecords.push(...chunk);
-                            index_js_2.Logger.error('ProductsDbService.batchPutVariants: chunk failed', { chunkIndex, chunkSize: chunk.length });
-                        }
-                    }
-                    else {
-                        const chunkData = parallelChunks[results.indexOf(result)];
-                        failedRecords.push(...chunkData.chunk);
-                        index_js_2.Logger.error('ProductsDbService.batchPutVariants: chunk threw', { chunkIndex: chunkData.chunkIndex, chunkSize: chunkData.chunk.length, error: result.reason });
-                    }
-                }
-                const parallelEnd = performance.now();
-                index_js_2.Logger.debug('ProductsDbService.batchPutVariants: completed parallel round', {
-                    parallelRound: Math.floor(i / concurrency),
-                    chunksInRound: parallelChunks.length,
-                    durationMs: parallelEnd - parallelStart,
-                });
-            }
-            return { successfulRecords, failedRecords };
-        }
-        catch (error) {
-            index_js_2.Logger.error('ProductsDbService.batchPutVariants: failed', { error, recordCount: records.length });
-            const processedCount = successfulRecords.length + failedRecords.length;
-            return { successfulRecords, failedRecords: [...failedRecords, ...records.slice(processedCount)] };
-        }
-    };
-    batchGetVariants = async (pixelIdProductIdVariantIds, options) => {
-        const concurrency = options?.concurrency ?? 1;
-        try {
-            if (pixelIdProductIdVariantIds.length === 0)
-                return [];
-            const chunks = [];
-            for (let i = 0; i < pixelIdProductIdVariantIds.length; i += DYNAMO_BATCH_GET_LIMIT) {
-                const keys = pixelIdProductIdVariantIds.slice(i, i + DYNAMO_BATCH_GET_LIMIT);
-                const dynamoKeys = keys.map(key => {
-                    const [pixelId, productId, variantId] = key.split('_');
-                    return {
-                        [this.TABLE_KEY]: this.buildVariantPk(pixelId, productId, variantId),
-                    };
-                });
-                chunks.push({ keys, dynamoKeys });
-            }
-            const allRecords = [];
-            const errors = [];
-            for (let i = 0; i < chunks.length; i += concurrency) {
-                const parallelChunks = chunks.slice(i, i + concurrency);
-                const results = await Promise.allSettled(parallelChunks.map(({ dynamoKeys }) => index_js_1.DynamoDbClient.safeBatchGet(this.TABLE_NAME, dynamoKeys)));
-                for (const result of results) {
-                    if (result.status === 'fulfilled' && result.value) {
-                        const records = result.value.filter(Boolean);
-                        allRecords.push(...records);
-                    }
-                    else if (result.status === 'rejected') {
-                        errors.push(result.reason);
-                    }
-                }
-            }
-            if (errors.length > 0) {
-                index_js_2.Logger.error('ProductsDbService.batchGetVariants: failed', { error: errors[0], keyCount: pixelIdProductIdVariantIds.length });
-            }
-            return allRecords;
-        }
-        catch (error) {
-            index_js_2.Logger.error('ProductsDbService.batchGetVariants: failed', { error, keyCount: pixelIdProductIdVariantIds.length });
-            return [];
-        }
-    };
-    batchGetVariantsMap = async (pixelIdProductIdVariantIds, options) => {
-        try {
-            const records = await this.batchGetVariants(pixelIdProductIdVariantIds, options);
-            const recordsMap = {};
-            records.forEach(record => {
-                recordsMap[`${record.pixelId}_${record.productId}_${record.variantId}`] = record;
-            });
-            return recordsMap;
-        }
-        catch (error) {
-            index_js_2.Logger.error('ProductsDbService.batchGetVariantsMap: failed', { error, keyCount: pixelIdProductIdVariantIds.length });
-            return {};
-        }
-    };
-    getProduct = async (pixelId, productId) => {
-        try {
-            const pk = this.buildProductPk(pixelId, productId);
-            const result = await index_js_1.DynamoDbClient.safeGet(this.TABLE_NAME, this.TABLE_KEY, pk);
-            return result ?? null;
-        }
-        catch (error) {
-            index_js_2.Logger.error('ProductsDbService.getProduct: failed', { error, pixelId, productId });
-            return null;
-        }
-    };
-    putProduct = async (record) => {
-        try {
-            const toWrite = { ...record, updatedAt: (0, index_js_3.getCurrentTimestamp)() };
-            await index_js_1.DynamoDbClient.safePut(this.TABLE_NAME, toWrite);
-            return toWrite;
-        }
-        catch (error) {
-            index_js_2.Logger.error('ProductsDbService.putProduct: failed', { error, pixelId: record.pixelId, productId: record.productId });
-            return null;
-        }
-    };
-    batchGetProducts = async (pixelIdProductIds, options) => {
-        const concurrency = options?.concurrency ?? 1;
-        try {
-            if (pixelIdProductIds.length === 0)
-                return [];
-            const chunks = [];
-            for (let i = 0; i < pixelIdProductIds.length; i += DYNAMO_BATCH_GET_LIMIT) {
-                const keys = pixelIdProductIds.slice(i, i + DYNAMO_BATCH_GET_LIMIT);
-                const dynamoKeys = keys.map(key => {
-                    const [pixelId, productId] = key.split('_');
-                    return {
-                        [this.TABLE_KEY]: this.buildProductPk(pixelId, productId),
-                    };
-                });
-                chunks.push({ keys, dynamoKeys });
-            }
-            const allRecords = [];
-            const errors = [];
-            for (let i = 0; i < chunks.length; i += concurrency) {
-                const parallelChunks = chunks.slice(i, i + concurrency);
-                const results = await Promise.allSettled(parallelChunks.map(({ dynamoKeys }) => index_js_1.DynamoDbClient.safeBatchGet(this.TABLE_NAME, dynamoKeys)));
-                for (const result of results) {
-                    if (result.status === 'fulfilled' && result.value) {
-                        const records = result.value.filter(Boolean);
-                        allRecords.push(...records);
-                    }
-                    else if (result.status === 'rejected') {
-                        errors.push(result.reason);
-                    }
-                }
-            }
-            if (errors.length > 0) {
-                index_js_2.Logger.error('ProductsDbService.batchGetProducts: failed', { error: errors[0], keyCount: pixelIdProductIds.length });
-            }
-            return allRecords;
-        }
-        catch (error) {
-            index_js_2.Logger.error('ProductsDbService.batchGetProducts: failed', { error, keyCount: pixelIdProductIds.length });
-            return [];
-        }
-    };
-    batchGetProductsMap = async (pixelIdProductIds, options) => {
-        try {
-            const records = await this.batchGetProducts(pixelIdProductIds, options);
-            const recordsMap = {};
-            records.forEach(record => {
-                recordsMap[`${record.pixelId}_${record.productId}`] = record;
-            });
-            return recordsMap;
-        }
-        catch (error) {
-            index_js_2.Logger.error('ProductsDbService.batchGetProductsMap: failed', { error, keyCount: pixelIdProductIds.length });
-            return {};
-        }
-    };
-    batchPutProducts = async (records, options) => {
-        const concurrency = options?.concurrency ?? 1;
-        const successfulRecords = [];
-        const failedRecords = [];
-        if (records.length === 0) {
-            return { successfulRecords, failedRecords };
-        }
-        try {
-            const now = (0, index_js_3.getCurrentTimestamp)();
-            const chunks = [];
-            for (let i = 0; i < records.length; i += DYNAMO_BATCH_WRITE_LIMIT) {
-                const chunk = records.slice(i, i + DYNAMO_BATCH_WRITE_LIMIT);
-                const itemsToWrite = chunk.map(record => ({ ...record, updatedAt: now }));
-                chunks.push({ chunk, itemsToWrite, chunkIndex: Math.floor(i / DYNAMO_BATCH_WRITE_LIMIT) });
-            }
-            for (let i = 0; i < chunks.length; i += concurrency) {
-                const parallelStart = performance.now();
-                const parallelChunks = chunks.slice(i, i + concurrency);
-                const results = await Promise.allSettled(parallelChunks.map(async ({ chunk, itemsToWrite, chunkIndex }) => {
-                    const result = await index_js_1.DynamoDbClient.safeBatchPut(this.TABLE_NAME, itemsToWrite);
-                    return { chunk, itemsToWrite, chunkIndex, success: !!result };
-                }));
-                for (const result of results) {
-                    if (result.status === 'fulfilled') {
-                        const { chunk, itemsToWrite, chunkIndex, success } = result.value;
-                        if (success) {
-                            successfulRecords.push(...itemsToWrite);
-                        }
-                        else {
-                            failedRecords.push(...chunk);
-                            index_js_2.Logger.error('ProductsDbService.batchPutProducts: chunk failed', { chunkIndex, chunkSize: chunk.length });
-                        }
-                    }
-                    else {
-                        const chunkData = parallelChunks[results.indexOf(result)];
-                        failedRecords.push(...chunkData.chunk);
-                        index_js_2.Logger.error('ProductsDbService.batchPutProducts: chunk threw', { chunkIndex: chunkData.chunkIndex, chunkSize: chunkData.chunk.length, error: result.reason });
-                    }
-                }
-                const parallelEnd = performance.now();
-                index_js_2.Logger.debug('ProductsDbService.batchPutProducts: completed parallel round', {
-                    parallelRound: Math.floor(i / concurrency),
-                    chunksInRound: parallelChunks.length,
-                    durationMs: parallelEnd - parallelStart,
-                });
-            }
-            return { successfulRecords, failedRecords };
-        }
-        catch (error) {
-            index_js_2.Logger.error('ProductsDbService.batchPutProducts: failed', { error, recordCount: records.length });
-            const processedCount = successfulRecords.length + failedRecords.length;
-            return { successfulRecords, failedRecords: [...failedRecords, ...records.slice(processedCount)] };
-        }
-    };
-}
-exports.ProductsDbService = ProductsDbService;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProductsDbService = void 0;
+const index_js_1 = require("../../clients/index.js");
+const index_js_2 = require("../../helpers/index.js");
+const index_js_3 = require("../../libs/index.js");
+const DYNAMO_BATCH_GET_LIMIT = 100;
+const DYNAMO_BATCH_WRITE_LIMIT = 25;
+class ProductsDbService {
+    TABLE_NAME;
+    TABLE_KEY;
+    constructor(tableName, tableKey) {
+        this.TABLE_NAME = tableName;
+        this.TABLE_KEY = tableKey;
+    }
+    buildVariantPk = (pixelId, productId, variantId) => `variant#${pixelId}_${productId}_${variantId}`;
+    buildProductPk = (pixelId, productId) => `product#${pixelId}_${productId}`;
+    getVariant = async (pixelId, productId, variantId) => {
+        try {
+            const pk = this.buildVariantPk(pixelId, productId, variantId);
+            const result = await index_js_1.DynamoDbClient.safeGet(this.TABLE_NAME, this.TABLE_KEY, pk);
+            return result ?? null;
+        }
+        catch (error) {
+            index_js_2.Logger.error('ProductsDbService.getVariant: failed', { error, pixelId, productId, variantId });
+            return null;
+        }
+    };
+    putVariant = async (record) => {
+        try {
+            const toWrite = { ...record, updatedAt: (0, index_js_3.getCurrentTimestamp)() };
+            await index_js_1.DynamoDbClient.safePut(this.TABLE_NAME, toWrite);
+            return toWrite;
+        }
+        catch (error) {
+            index_js_2.Logger.error('ProductsDbService.putVariant: failed', {
+                error,
+                pixelId: record.pixelId,
+                productId: record.productId,
+                variantId: record.variantId,
+            });
+            return null;
+        }
+    };
+    batchPutVariants = async (records, options) => {
+        const concurrency = options?.concurrency ?? 1;
+        const successfulRecords = [];
+        const failedRecords = [];
+        if (records.length === 0) {
+            return { successfulRecords, failedRecords };
+        }
+        try {
+            const now = (0, index_js_3.getCurrentTimestamp)();
+            const chunks = [];
+            for (let i = 0; i < records.length; i += DYNAMO_BATCH_WRITE_LIMIT) {
+                const chunk = records.slice(i, i + DYNAMO_BATCH_WRITE_LIMIT);
+                const itemsToWrite = chunk.map((record) => ({ ...record, updatedAt: now }));
+                chunks.push({ chunk, itemsToWrite, chunkIndex: Math.floor(i / DYNAMO_BATCH_WRITE_LIMIT) });
+            }
+            for (let i = 0; i < chunks.length; i += concurrency) {
+                const parallelStart = performance.now();
+                const parallelChunks = chunks.slice(i, i + concurrency);
+                const results = await Promise.allSettled(parallelChunks.map(async ({ chunk, itemsToWrite, chunkIndex }) => {
+                    const result = await index_js_1.DynamoDbClient.safeBatchPut(this.TABLE_NAME, itemsToWrite);
+                    return { chunk, itemsToWrite, chunkIndex, success: !!result };
+                }));
+                for (const result of results) {
+                    if (result.status === 'fulfilled') {
+                        const { chunk, itemsToWrite, chunkIndex, success } = result.value;
+                        if (success) {
+                            successfulRecords.push(...itemsToWrite);
+                        }
+                        else {
+                            failedRecords.push(...chunk);
+                            index_js_2.Logger.error('ProductsDbService.batchPutVariants: chunk failed', { chunkIndex, chunkSize: chunk.length });
+                        }
+                    }
+                    else {
+                        const chunkData = parallelChunks[results.indexOf(result)];
+                        failedRecords.push(...chunkData.chunk);
+                        index_js_2.Logger.error('ProductsDbService.batchPutVariants: chunk threw', {
+                            chunkIndex: chunkData.chunkIndex,
+                            chunkSize: chunkData.chunk.length,
+                            error: result.reason,
+                        });
+                    }
+                }
+                const parallelEnd = performance.now();
+                index_js_2.Logger.debug('ProductsDbService.batchPutVariants: completed parallel round', {
+                    parallelRound: Math.floor(i / concurrency),
+                    chunksInRound: parallelChunks.length,
+                    durationMs: parallelEnd - parallelStart,
+                });
+            }
+            return { successfulRecords, failedRecords };
+        }
+        catch (error) {
+            index_js_2.Logger.error('ProductsDbService.batchPutVariants: failed', { error, recordCount: records.length });
+            const processedCount = successfulRecords.length + failedRecords.length;
+            return { successfulRecords, failedRecords: [...failedRecords, ...records.slice(processedCount)] };
+        }
+    };
+    batchGetVariants = async (pixelIdProductIdVariantIds, options) => {
+        const concurrency = options?.concurrency ?? 1;
+        try {
+            if (pixelIdProductIdVariantIds.length === 0)
+                return [];
+            const chunks = [];
+            for (let i = 0; i < pixelIdProductIdVariantIds.length; i += DYNAMO_BATCH_GET_LIMIT) {
+                const keys = pixelIdProductIdVariantIds.slice(i, i + DYNAMO_BATCH_GET_LIMIT);
+                const dynamoKeys = keys.map((key) => {
+                    const [pixelId, productId, variantId] = key.split('_');
+                    return {
+                        [this.TABLE_KEY]: this.buildVariantPk(pixelId, productId, variantId),
+                    };
+                });
+                chunks.push({ keys, dynamoKeys });
+            }
+            const allRecords = [];
+            const errors = [];
+            for (let i = 0; i < chunks.length; i += concurrency) {
+                const parallelChunks = chunks.slice(i, i + concurrency);
+                const results = await Promise.allSettled(parallelChunks.map(async ({ dynamoKeys }) => await index_js_1.DynamoDbClient.safeBatchGet(this.TABLE_NAME, dynamoKeys)));
+                for (const result of results) {
+                    if (result.status === 'fulfilled' && result.value) {
+                        const records = result.value.filter(Boolean);
+                        allRecords.push(...records);
+                    }
+                    else if (result.status === 'rejected') {
+                        errors.push(result.reason);
+                    }
+                }
+            }
+            if (errors.length > 0) {
+                index_js_2.Logger.error('ProductsDbService.batchGetVariants: failed', {
+                    error: errors[0],
+                    keyCount: pixelIdProductIdVariantIds.length,
+                });
+            }
+            return allRecords;
+        }
+        catch (error) {
+            index_js_2.Logger.error('ProductsDbService.batchGetVariants: failed', {
+                error,
+                keyCount: pixelIdProductIdVariantIds.length,
+            });
+            return [];
+        }
+    };
+    batchGetVariantsMap = async (pixelIdProductIdVariantIds, options) => {
+        try {
+            const records = await this.batchGetVariants(pixelIdProductIdVariantIds, options);
+            const recordsMap = {};
+            records.forEach((record) => {
+                recordsMap[`${record.pixelId}_${record.productId}_${record.variantId}`] = record;
+            });
+            return recordsMap;
+        }
+        catch (error) {
+            index_js_2.Logger.error('ProductsDbService.batchGetVariantsMap: failed', {
+                error,
+                keyCount: pixelIdProductIdVariantIds.length,
+            });
+            return {};
+        }
+    };
+    getProduct = async (pixelId, productId) => {
+        try {
+            const pk = this.buildProductPk(pixelId, productId);
+            const result = await index_js_1.DynamoDbClient.safeGet(this.TABLE_NAME, this.TABLE_KEY, pk);
+            return result ?? null;
+        }
+        catch (error) {
+            index_js_2.Logger.error('ProductsDbService.getProduct: failed', { error, pixelId, productId });
+            return null;
+        }
+    };
+    putProduct = async (record) => {
+        try {
+            const toWrite = { ...record, updatedAt: (0, index_js_3.getCurrentTimestamp)() };
+            await index_js_1.DynamoDbClient.safePut(this.TABLE_NAME, toWrite);
+            return toWrite;
+        }
+        catch (error) {
+            index_js_2.Logger.error('ProductsDbService.putProduct: failed', {
+                error,
+                pixelId: record.pixelId,
+                productId: record.productId,
+            });
+            return null;
+        }
+    };
+    batchGetProducts = async (pixelIdProductIds, options) => {
+        const concurrency = options?.concurrency ?? 1;
+        try {
+            if (pixelIdProductIds.length === 0)
+                return [];
+            const chunks = [];
+            for (let i = 0; i < pixelIdProductIds.length; i += DYNAMO_BATCH_GET_LIMIT) {
+                const keys = pixelIdProductIds.slice(i, i + DYNAMO_BATCH_GET_LIMIT);
+                const dynamoKeys = keys.map((key) => {
+                    const [pixelId, productId] = key.split('_');
+                    return {
+                        [this.TABLE_KEY]: this.buildProductPk(pixelId, productId),
+                    };
+                });
+                chunks.push({ keys, dynamoKeys });
+            }
+            const allRecords = [];
+            const errors = [];
+            for (let i = 0; i < chunks.length; i += concurrency) {
+                const parallelChunks = chunks.slice(i, i + concurrency);
+                const results = await Promise.allSettled(parallelChunks.map(async ({ dynamoKeys }) => await index_js_1.DynamoDbClient.safeBatchGet(this.TABLE_NAME, dynamoKeys)));
+                for (const result of results) {
+                    if (result.status === 'fulfilled' && result.value) {
+                        const records = result.value.filter(Boolean);
+                        allRecords.push(...records);
+                    }
+                    else if (result.status === 'rejected') {
+                        errors.push(result.reason);
+                    }
+                }
+            }
+            if (errors.length > 0) {
+                index_js_2.Logger.error('ProductsDbService.batchGetProducts: failed', {
+                    error: errors[0],
+                    keyCount: pixelIdProductIds.length,
+                });
+            }
+            return allRecords;
+        }
+        catch (error) {
+            index_js_2.Logger.error('ProductsDbService.batchGetProducts: failed', { error, keyCount: pixelIdProductIds.length });
+            return [];
+        }
+    };
+    batchGetProductsMap = async (pixelIdProductIds, options) => {
+        try {
+            const records = await this.batchGetProducts(pixelIdProductIds, options);
+            const recordsMap = {};
+            records.forEach((record) => {
+                recordsMap[`${record.pixelId}_${record.productId}`] = record;
+            });
+            return recordsMap;
+        }
+        catch (error) {
+            index_js_2.Logger.error('ProductsDbService.batchGetProductsMap: failed', { error, keyCount: pixelIdProductIds.length });
+            return {};
+        }
+    };
+    batchPutProducts = async (records, options) => {
+        const concurrency = options?.concurrency ?? 1;
+        const successfulRecords = [];
+        const failedRecords = [];
+        if (records.length === 0) {
+            return { successfulRecords, failedRecords };
+        }
+        try {
+            const now = (0, index_js_3.getCurrentTimestamp)();
+            const chunks = [];
+            for (let i = 0; i < records.length; i += DYNAMO_BATCH_WRITE_LIMIT) {
+                const chunk = records.slice(i, i + DYNAMO_BATCH_WRITE_LIMIT);
+                const itemsToWrite = chunk.map((record) => ({ ...record, updatedAt: now }));
+                chunks.push({ chunk, itemsToWrite, chunkIndex: Math.floor(i / DYNAMO_BATCH_WRITE_LIMIT) });
+            }
+            for (let i = 0; i < chunks.length; i += concurrency) {
+                const parallelStart = performance.now();
+                const parallelChunks = chunks.slice(i, i + concurrency);
+                const results = await Promise.allSettled(parallelChunks.map(async ({ chunk, itemsToWrite, chunkIndex }) => {
+                    const result = await index_js_1.DynamoDbClient.safeBatchPut(this.TABLE_NAME, itemsToWrite);
+                    return { chunk, itemsToWrite, chunkIndex, success: !!result };
+                }));
+                for (const result of results) {
+                    if (result.status === 'fulfilled') {
+                        const { chunk, itemsToWrite, chunkIndex, success } = result.value;
+                        if (success) {
+                            successfulRecords.push(...itemsToWrite);
+                        }
+                        else {
+                            failedRecords.push(...chunk);
+                            index_js_2.Logger.error('ProductsDbService.batchPutProducts: chunk failed', { chunkIndex, chunkSize: chunk.length });
+                        }
+                    }
+                    else {
+                        const chunkData = parallelChunks[results.indexOf(result)];
+                        failedRecords.push(...chunkData.chunk);
+                        index_js_2.Logger.error('ProductsDbService.batchPutProducts: chunk threw', {
+                            chunkIndex: chunkData.chunkIndex,
+                            chunkSize: chunkData.chunk.length,
+                            error: result.reason,
+                        });
+                    }
+                }
+                const parallelEnd = performance.now();
+                index_js_2.Logger.debug('ProductsDbService.batchPutProducts: completed parallel round', {
+                    parallelRound: Math.floor(i / concurrency),
+                    chunksInRound: parallelChunks.length,
+                    durationMs: parallelEnd - parallelStart,
+                });
+            }
+            return { successfulRecords, failedRecords };
+        }
+        catch (error) {
+            index_js_2.Logger.error('ProductsDbService.batchPutProducts: failed', { error, recordCount: records.length });
+            const processedCount = successfulRecords.length + failedRecords.length;
+            return { successfulRecords, failedRecords: [...failedRecords, ...records.slice(processedCount)] };
+        }
+    };
+}
+exports.ProductsDbService = ProductsDbService;
 //# sourceMappingURL=products-db-service.js.map