ag-common 0.0.893 → 0.0.895

package/dist/api/helpers/cosmos/write.js

@@ -1,107 +1,103 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.putItemCosmos = putItemCosmos;
 exports.putItemsCosmos = putItemsCosmos;
 const log_1 = require("../../../common/helpers/log");
 const withRetry_1 = require("../../../common/helpers/withRetry");
 const utils_1 = require("./utils");
-function putItemCosmos(container, item) {
-    return __awaiter(this, void 0, void 0, function* () {
-        try {
-            // First, try to find existing item with the same PK
-            const querySpec = {
-                query: 'SELECT * FROM c WHERE c.PK = @pk',
-                parameters: [{ name: '@pk', value: item.PK }],
+async function putItemCosmos(container, item) {
+    try {
+        // First, try to find existing item with the same PK
+        const querySpec = {
+            query: 'SELECT * FROM c WHERE c.PK = @pk',
+            parameters: [{ name: '@pk', value: item.PK }],
+        };
+        const { resources: existingItems } = await container.items
+            .query(querySpec)
+            .fetchAll();
+        if (existingItems.length > 0) {
+            // If item exists, update it with the existing ID
+            const existingItem = existingItems[0];
+            const updatedItem = {
+                ...item,
+                id: existingItem.id, // Preserve the existing Cosmos DB id
             };
-            const { resources: existingItems } = yield container.items
-                .query(querySpec)
-                .fetchAll();
-            if (existingItems.length > 0) {
-                // If item exists, update it with the existing ID
-                const existingItem = existingItems[0];
-                const updatedItem = Object.assign(Object.assign({}, item), { id: existingItem.id });
-                const { resource: result } = yield container.items.upsert(updatedItem);
-                return result;
-            }
-            else {
-                // If no existing item, create new one (let Cosmos generate the id)
-                const newItem = Object.assign(Object.assign({}, item), { id: undefined });
-                const { resource: result } = yield container.items.create(newItem);
-                return result;
-            }
+            const { resource: result } = await container.items.upsert(updatedItem);
+            return result;
         }
-        catch (e) {
-            const em = e.message;
-            (0, log_1.error)('Error upserting item:', em);
-            throw e;
+        else {
+            // If no existing item, create new one (let Cosmos generate the id)
+            const newItem = {
+                ...item,
+                id: undefined, // Ensure we let Cosmos generate a new id
+            };
+            const { resource: result } = await container.items.create(newItem);
+            return result;
         }
-    });
+    }
+    catch (e) {
+        const em = e.message;
+        (0, log_1.error)('Error upserting item:', em);
+        throw e;
+    }
 }
-function putItemsCosmos(container, items) {
-    return __awaiter(this, void 0, void 0, function* () {
-        try {
-            if (items.length === 0) {
-                return {};
-            }
-            (0, log_1.info)(`Bulk writing ${items.length} items to Cosmos`);
-            for (let i = 0; i < items.length; i += utils_1.BULK_CHUNK_SIZE) {
-                const chunk = items.slice(i, i + utils_1.BULK_CHUNK_SIZE);
-                // Execute bulk operation with retry
-                yield (0, withRetry_1.withRetry)(() => __awaiter(this, void 0, void 0, function* () {
-                    (0, log_1.info)(`Writing chunk ${i / utils_1.BULK_CHUNK_SIZE + 1} of ${Math.ceil(items.length / utils_1.BULK_CHUNK_SIZE)}`);
-                    const operations = yield Promise.all(chunk.map((item) => __awaiter(this, void 0, void 0, function* () {
-                        // Query to check if item exists
-                        const querySpec = {
-                            query: 'SELECT * FROM c WHERE c.PK = @pk',
-                            parameters: [{ name: '@pk', value: item.PK }],
-                        };
-                        const { resources: existingItems } = yield container.items
-                            .query(querySpec)
-                            .fetchAll();
-                        const existingItem = existingItems[0];
-                        return {
-                            operationType: 'Upsert',
-                            partitionKey: item.PK,
-                            resourceBody: Object.assign(Object.assign({}, item), { id: existingItem === null || existingItem === void 0 ? void 0 : existingItem.id }),
-                        };
-                    })));
-                    const bulkResponse = yield container.items.bulk(operations);
-                    // Process results
-                    let successCount = 0;
-                    let failureCount = 0;
-                    bulkResponse.forEach((response, index) => {
-                        if (response.statusCode === 429) {
-                            throw new Error('429');
-                        }
-                        if (response.statusCode >= 200 && response.statusCode < 300) {
-                            successCount++;
-                        }
-                        else {
-                            const item = chunk[index];
-                            (0, log_1.error)(`Failed to write item - PK: ${item.PK}, Status: ${response.statusCode}`, response.resourceBody);
-                            failureCount++;
-                        }
-                    });
-                    (0, log_1.info)(`Chunk ${i / utils_1.BULK_CHUNK_SIZE + 1}/${Math.ceil(items.length / utils_1.BULK_CHUNK_SIZE)} results - Success: ${successCount}, Failed: ${failureCount}`);
-                    return bulkResponse;
-                }), `bulk_write_chunk_${i / utils_1.BULK_CHUNK_SIZE + 1}`);
-            }
-            (0, log_1.info)('All items written successfully');
+async function putItemsCosmos(container, items) {
+    try {
+        if (items.length === 0) {
             return {};
         }
-        catch (e) {
-            const em = e.message;
-            (0, log_1.error)('Error bulk writing items:', em);
-            throw e;
+        (0, log_1.info)(`Bulk writing ${items.length} items to Cosmos`);
+        for (let i = 0; i < items.length; i += utils_1.BULK_CHUNK_SIZE) {
+            const chunk = items.slice(i, i + utils_1.BULK_CHUNK_SIZE);
+            // Execute bulk operation with retry
+            await (0, withRetry_1.withRetry)(async () => {
+                (0, log_1.info)(`Writing chunk ${i / utils_1.BULK_CHUNK_SIZE + 1} of ${Math.ceil(items.length / utils_1.BULK_CHUNK_SIZE)}`);
+                const operations = await Promise.all(chunk.map(async (item) => {
+                    // Query to check if item exists
+                    const querySpec = {
+                        query: 'SELECT * FROM c WHERE c.PK = @pk',
+                        parameters: [{ name: '@pk', value: item.PK }],
+                    };
+                    const { resources: existingItems } = await container.items
+                        .query(querySpec)
+                        .fetchAll();
+                    const existingItem = existingItems[0];
+                    return {
+                        operationType: 'Upsert',
+                        partitionKey: item.PK,
+                        resourceBody: {
+                            ...item,
+                            id: existingItem?.id,
+                        },
+                    };
+                }));
+                const bulkResponse = await container.items.bulk(operations);
+                // Process results
+                let successCount = 0;
+                let failureCount = 0;
+                bulkResponse.forEach((response, index) => {
+                    if (response.statusCode === 429) {
+                        throw new Error('429');
+                    }
+                    if (response.statusCode >= 200 && response.statusCode < 300) {
+                        successCount++;
+                    }
+                    else {
+                        const item = chunk[index];
+                        (0, log_1.error)(`Failed to write item - PK: ${item.PK}, Status: ${response.statusCode}`, response.resourceBody);
+                        failureCount++;
+                    }
+                });
+                (0, log_1.info)(`Chunk ${i / utils_1.BULK_CHUNK_SIZE + 1}/${Math.ceil(items.length / utils_1.BULK_CHUNK_SIZE)} results - Success: ${successCount}, Failed: ${failureCount}`);
+                return bulkResponse;
+            }, `bulk_write_chunk_${i / utils_1.BULK_CHUNK_SIZE + 1}`);
         }
-    });
+        (0, log_1.info)('All items written successfully');
+        return {};
+    }
+    catch (e) {
+        const em = e.message;
+        (0, log_1.error)('Error bulk writing items:', em);
+        throw e;
+    }
 }

package/dist/api/helpers/dynamo/delete.js

@@ -1,20 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __asyncValues = (this && this.__asyncValues) || function (o) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var m = o[Symbol.asyncIterator], i;
-    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
-    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
-    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.wipeTable = exports.batchDelete = void 0;
 const lib_dynamodb_1 = require("@aws-sdk/lib-dynamodb");
@@ -23,13 +7,12 @@ const async_1 = require("../../../common/helpers/async");
 const withRetry_1 = require("../../../common/helpers/withRetry");
 const _1 = require(".");
 const get_1 = require("./get");
-const batchDelete = (params) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a;
+const batchDelete = async (params) => {
     try {
-        const { batchSize = 20, maxRetries } = (_a = params.opt) !== null && _a !== void 0 ? _a : {};
+        const { batchSize = 20, maxRetries } = params.opt ?? {};
         const chunked = (0, array_1.chunk)(params.keys, batchSize);
         let processed = 0;
-        yield (0, async_1.asyncForEach)(chunked, (chunk) => __awaiter(void 0, void 0, void 0, function* () {
+        await (0, async_1.asyncForEach)(chunked, async (chunk) => {
             const batchDeleteParams = {
                 RequestItems: {
                     [params.tableName]: chunk.map((key) => ({
@@ -37,58 +20,45 @@ const batchDelete = (params) => __awaiter(void 0, void 0, void 0, function* () {
                     })),
                 },
             };
-            yield (0, withRetry_1.withRetry)(() => _1.dynamoDb.send(new lib_dynamodb_1.BatchWriteCommand(batchDeleteParams)), `batchdelete ${processed}/${params.keys.length}. size=${batchSize}`, {
+            await (0, withRetry_1.withRetry)(() => _1.dynamoDb.send(new lib_dynamodb_1.BatchWriteCommand(batchDeleteParams)), `batchdelete ${processed}/${params.keys.length}. size=${batchSize}`, {
                 maxRetries: maxRetries === undefined ? 3 : maxRetries,
             });
             processed += chunk.length;
-        }));
+        });
         return { data: undefined };
     }
     catch (e) {
         return { error: e.toString() };
     }
-});
+};
 exports.batchDelete = batchDelete;
-const wipeTable = (tableName) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, e_1, _b, _c;
+const wipeTable = async (tableName) => {
     try {
         const generator = (0, get_1.scanWithGenerator)(tableName, {
             limit: 100, // Process in chunks of 100 items
             maxRetries: null, // Always retry on 429 since we want to ensure complete deletion
         });
-        try {
-            // Process each batch of items
-            for (var _d = true, generator_1 = __asyncValues(generator), generator_1_1; generator_1_1 = yield generator_1.next(), _a = generator_1_1.done, !_a; _d = true) {
-                _c = generator_1_1.value;
-                _d = false;
-                const batch = _c;
-                const pks = batch.map((item) => item.PK);
-                if (pks.length > 0) {
-                    const result = yield (0, exports.batchDelete)({
-                        tableName,
-                        keys: pks,
-                        pkName: 'PK',
-                        opt: {
-                            maxRetries: null, // Always retry on 429 since we want to ensure complete deletion
-                        },
-                    });
-                    if ('error' in result) {
-                        return result;
-                    }
+        // Process each batch of items
+        for await (const batch of generator) {
+            const pks = batch.map((item) => item.PK);
+            if (pks.length > 0) {
+                const result = await (0, exports.batchDelete)({
+                    tableName,
+                    keys: pks,
+                    pkName: 'PK',
+                    opt: {
+                        maxRetries: null, // Always retry on 429 since we want to ensure complete deletion
+                    },
+                });
+                if ('error' in result) {
+                    return result;
                 }
             }
         }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (!_d && !_a && (_b = generator_1.return)) yield _b.call(generator_1);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
         return { data: undefined };
     }
     catch (e) {
         return { error: e.toString() };
     }
-});
+};
 exports.wipeTable = wipeTable;