ag-common 0.0.765 → 0.0.766

package/dist/api/helpers/cosmos/delete.d.ts

@@ -0,0 +1,5 @@
+import type { Container } from '@azure/cosmos';
+export declare function deleteItemCosmos(container: Container, pk: string): Promise<void>;
+export declare function deleteItemsByField(container: Container, field: string, value: string | number | boolean): Promise<{
+    error?: string;
+}>;

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

@@ -0,0 +1,111 @@
+"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.deleteItemCosmos = deleteItemCosmos;
+exports.deleteItemsByField = deleteItemsByField;
+const utils_1 = require("./utils");
+const log_1 = require("../../../common/helpers/log");
+const withRetry_1 = require("../withRetry");
+function deleteItemCosmos(container, pk) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            // First query to find items with matching PK
+            const querySpec = {
+                query: 'SELECT * FROM c WHERE c.PK = @pk',
+                parameters: [{ name: '@pk', value: pk }],
+            };
+            const { resources: items } = yield container.items
+                .query(querySpec)
+                .fetchAll();
+            // Delete each found item and collect their IDs
+            for (const item of items) {
+                (0, log_1.warn)('deleting items:', item.id, pk);
+                yield container.item(item.id, pk).delete();
+            }
+        }
+        catch (e) {
+            const em = e.message;
+            (0, log_1.error)('Error deleting item:', em);
+            throw e;
+        }
+    });
+}
+function deleteItemsByField(container, field, value) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const query = `
+      SELECT c.id, c.PK
+      FROM c 
+      WHERE c.${field} = @value
+    `;
+            const { resources } = yield container.items
+                .query({
+                query,
+                parameters: [{ name: '@value', value }],
+            })
+                .fetchAll();
+            if (resources.length === 0) {
+                return {};
+            }
+            (0, log_1.info)(`Deleting ${resources.length} items where ${field} = ${value} from Cosmos`);
+            //throw if item.id or PK doesn't exist on an item
+            resources.forEach((item) => {
+                if (!item.id || !item.PK) {
+                    throw new Error('Item missing required fields: ' + JSON.stringify(item));
+                }
+            });
+            const operations = resources.map((item) => ({
+                id: item.id,
+                partitionKey: item.PK,
+                operationType: 'Delete',
+            }));
+            for (let i = 0; i < operations.length; i += utils_1.BULK_CHUNK_SIZE) {
+                const chunk = operations.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)(`Deleting chunk ${i / utils_1.BULK_CHUNK_SIZE + 1} of ${Math.ceil(operations.length / utils_1.BULK_CHUNK_SIZE)}`);
+                    const bulkResponse = yield container.items.bulk(chunk);
+                    //if an item contains a statuscode 429, then throw an error
+                    bulkResponse.forEach((response) => {
+                        if (response.statusCode === 429) {
+                            throw new Error('429');
+                        }
+                    });
+                    // Process results
+                    let successCount = 0;
+                    let failureCount = 0;
+                    bulkResponse.forEach((response, index) => {
+                        if (response.statusCode === 204) {
+                            successCount++;
+                        }
+                        else if (response.statusCode === 404) {
+                            failureCount++;
+                        }
+                        else {
+                            const item = chunk[index];
+                            (0, log_1.error)(`Failed to delete item - ID: ${item.id}, PK: ${item.partitionKey}, Status: ${response.statusCode}`, response.resourceBody);
+                            failureCount++;
+                        }
+                    });
+                    (0, log_1.info)(`Chunk ${i / utils_1.BULK_CHUNK_SIZE + 1}/${Math.ceil(operations.length / utils_1.BULK_CHUNK_SIZE)} results - Success: ${successCount}, Failed: ${failureCount}`);
+                    return bulkResponse;
+                }), `bulk_delete_chunk_${i / utils_1.BULK_CHUNK_SIZE + 1}`);
+            }
+            (0, log_1.info)('All items deleted successfully');
+            return {};
+        }
+        catch (e) {
+            const em = e.message;
+            (0, log_1.error)('Error deleting items:', em);
+            throw e;
+        }
+    });
+}

package/dist/api/helpers/cosmos/get.d.ts

@@ -0,0 +1,28 @@
+import type { Container } from '@azure/cosmos';
+export declare function getItemCosmos<T>(container: Container, partitionValue: string): Promise<T | null>;
+export declare function getItemsByCosmos<T>(container: Container, partitionValues: string[]): Promise<T[]>;
+export declare function queryItemsByText<T>(container: Container, searchFields: {
+    fieldName: string;
+    fieldValue: string;
+    type: 'contains' | 'equals';
+}[], operator?: 'AND' | 'OR'): Promise<T[] | {
+    error: string;
+}>;
+export declare function scanCosmos<T>(container: Container): Promise<T[] | {
+    error: string;
+}>;
+export declare function queryItemsByNumber<T>(container: Container, options: {
+    type: string;
+    field: string;
+    minValue?: number;
+    limit?: number;
+    descending?: boolean;
+}): Promise<T[] | {
+    error: string;
+}>;
+export declare function queryItemsByType<T>(container: Container, type: string): Promise<T[] | {
+    error: string;
+}>;
+export declare function queryItemsByRelevancy<T>(container: Container, type: string, limit?: number): Promise<T[] | {
+    error: string;
+}>;

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

@@ -0,0 +1,233 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getItemCosmos = getItemCosmos;
+exports.getItemsByCosmos = getItemsByCosmos;
+exports.queryItemsByText = queryItemsByText;
+exports.scanCosmos = scanCosmos;
+exports.queryItemsByNumber = queryItemsByNumber;
+exports.queryItemsByType = queryItemsByType;
+exports.queryItemsByRelevancy = queryItemsByRelevancy;
+const log_1 = require("../../../common/helpers/log");
+const node_cache_1 = __importDefault(require("node-cache"));
+// Create a NodeCache instance with 5 second TTL
+const cache = new node_cache_1.default({ stdTTL: 5 });
+function getItemCosmos(container, partitionValue) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const querySpec = {
+                query: 'SELECT TOP 1 * FROM c WHERE c.PK = @val',
+                parameters: [
+                    {
+                        name: '@val',
+                        value: partitionValue,
+                    },
+                ],
+            };
+            const { resources, requestCharge } = yield container.items
+                .query(querySpec)
+                .fetchAll();
+            (0, log_1.info)(`getItemCosmos:${partitionValue}. chg=${requestCharge}`);
+            if (resources.length > 0) {
+                return resources[0];
+            }
+            else {
+                return null;
+            }
+        }
+        catch (e) {
+            if (e.message.includes('404')) {
+                return null;
+            }
+            const em = e.message;
+            (0, log_1.error)('Error deleting item:', em);
+            throw e;
+        }
+    });
+}
+function getItemsByCosmos(container, partitionValues) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            if (!partitionValues.length) {
+                return [];
+            }
+            const querySpec = {
+                query: 'SELECT * FROM c WHERE ARRAY_CONTAINS(@values, c.PK)',
+                parameters: [
+                    {
+                        name: '@values',
+                        value: partitionValues,
+                    },
+                ],
+            };
+            const { resources, requestCharge } = yield container.items
+                .query(querySpec)
+                .fetchAll();
+            (0, log_1.info)(`getItemsByCosmos: fetched ${resources.length} items. chg=${requestCharge}`);
+            return resources;
+        }
+        catch (e) {
+            const em = e.message;
+            (0, log_1.error)('Error getting multiple items:', em);
+            throw e;
+        }
+    });
+}
+function escapeSqlString(str) {
+    return str.replace(/'/g, "''");
+}
+function queryItemsCosmos(container, query, parameters) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const querySpec = {
+                query,
+                parameters: parameters
+                    ? Object.entries(parameters).map(([name, value]) => ({
+                        name: `@${name}`,
+                        value,
+                    }))
+                    : undefined,
+            };
+            const { resources, requestCharge } = yield container.items
+                .query(querySpec)
+                .fetchAll();
+            return { resources, requestCharge };
+        }
+        catch (e) {
+            const em = e.message;
+            (0, log_1.error)('Error queryItemsCosmos item:', em);
+            return { error: em };
+        }
+    });
+}
+function queryItemsByText(container_1, searchFields_1) {
+    return __awaiter(this, arguments, void 0, function* (container, searchFields, operator = 'AND') {
+        try {
+            const conditions = searchFields.map((field, index) => field.type === 'contains' //true to ignore case
+                ? `CONTAINS(c.${field.fieldName}, @value${index}, true)`
+                : `c.${field.fieldName} = @value${index}`);
+            const query = `SELECT * FROM c WHERE ${conditions.join(` ${operator} `)}`;
+            const parameters = searchFields.reduce((acc, field, index) => {
+                acc[`value${index}`] = escapeSqlString(field.fieldValue);
+                return acc;
+            }, {});
+            const x = yield queryItemsCosmos(container, query, parameters);
+            (0, log_1.debug)(`queryItemsByText: ${JSON.stringify(searchFields)}, operator=${operator}. chg=${x.requestCharge}`);
+            if ('error' in x) {
+                throw x.error;
+            }
+            return x.resources;
+        }
+        catch (e) {
+            const em = e.message;
+            (0, log_1.error)('Error queryItemsByText item:', em);
+            return { error: em };
+        }
+    });
+}
+function scanCosmos(container) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const query = `SELECT * FROM c`;
+            const x = yield queryItemsCosmos(container, query, {});
+            (0, log_1.info)(`scan. chg=${x.requestCharge}`);
+            if ('error' in x) {
+                throw x.error;
+            }
+            return x.resources;
+        }
+        catch (e) {
+            const em = e.message;
+            (0, log_1.error)('Error queryItemsByText item:', em);
+            return { error: em };
+        }
+    });
+}
+function queryItemsByNumber(container, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const { type, field, minValue = 0, limit, descending = true } = options;
+            const query = `
+      SELECT * FROM c 
+      WHERE IS_NUMBER(c.${field})
+      AND c.${field} > @minValue
+      AND c.type = @type
+      ORDER BY c.${field} ${descending ? 'DESC' : 'ASC'}
+      ${limit ? 'OFFSET 0 LIMIT @limit' : ''}
+    `;
+            const parameters = {
+                type,
+                minValue,
+            };
+            if (limit) {
+                parameters.limit = limit;
+            }
+            const x = yield queryItemsCosmos(container, query, parameters);
+            (0, log_1.debug)(`queryItemsByNumber: type=${type}, field=${field}, minValue=${minValue}, limit=${limit}. chg=${x.requestCharge}`);
+            if ('error' in x) {
+                throw x.error;
+            }
+            return x.resources;
+        }
+        catch (e) {
+            const em = e.message;
+            (0, log_1.error)('Error queryItemsByNumber:', em);
+            return { error: em };
+        }
+    });
+}
+function queryItemsByType(container, type) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            // Check if data is in cache
+            const cacheKey = `queryItemsByType:${type}`;
+            const cachedData = cache.get(cacheKey);
+            if (cachedData) {
+                (0, log_1.info)(`queryItemsByType: type=${type}. [CACHE HIT]`);
+                return cachedData;
+            }
+            const query = `
+      SELECT * FROM c 
+      WHERE c.type = @type
+    `;
+            const parameters = {
+                type,
+            };
+            const x = yield queryItemsCosmos(container, query, parameters);
+            (0, log_1.info)(`queryItemsByType: type=${type}. chg=${x.requestCharge}`);
+            if ('error' in x) {
+                throw x.error;
+            }
+            const result = x.resources;
+            // Store result in cache
+            cache.set(cacheKey, result);
+            return result;
+        }
+        catch (e) {
+            const em = e.message;
+            (0, log_1.error)('Error queryItemsByType:', em);
+            return { error: em };
+        }
+    });
+}
+function queryItemsByRelevancy(container, type, limit) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return queryItemsByNumber(container, {
+            type,
+            field: 'relevancy',
+            limit,
+            descending: true,
+        });
+    });
+}

package/dist/api/helpers/cosmos/index.d.ts

@@ -0,0 +1,44 @@
+import { type CosmosSettings } from './utils';
+export declare class Cosmos {
+    private container;
+    constructor(settings: CosmosSettings);
+    getItem<T>(partitionValue: string): Promise<T | null>;
+    getItemsBy<T>(partitionValues: string[]): Promise<T[]>;
+    queryItemsByText<T>(searchFields: {
+        fieldName: string;
+        fieldValue: string;
+        type: 'contains' | 'equals';
+    }[], operator?: 'AND' | 'OR'): Promise<T[] | {
+        error: string;
+    }>;
+    scan<T>(): Promise<T[] | {
+        error: string;
+    }>;
+    queryItemsByNumber<T>(options: {
+        type: string;
+        field: string;
+        minValue?: number;
+        limit?: number;
+        descending?: boolean;
+    }): Promise<T[] | {
+        error: string;
+    }>;
+    queryItemsByType<T>(type: string): Promise<T[] | {
+        error: string;
+    }>;
+    queryItemsByRelevancy<T>(type: string, limit?: number): Promise<T[] | {
+        error: string;
+    }>;
+    putItem<T extends {
+        PK: string;
+    }>(item: T): Promise<T>;
+    putItems<T extends {
+        PK: string;
+    }>(items: T[]): Promise<{
+        error?: string;
+    }>;
+    deleteItem(pk: string): Promise<void>;
+    deleteItemsByField(field: string, value: string | number | boolean): Promise<{
+        error?: string;
+    }>;
+}

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

@@ -0,0 +1,80 @@
+"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.Cosmos = void 0;
+const utils_1 = require("./utils");
+const delete_1 = require("./delete");
+const get_1 = require("./get");
+const write_1 = require("./write");
+class Cosmos {
+    constructor(settings) {
+        this.container = (0, utils_1.createContainer)(settings);
+    }
+    // Get operations
+    getItem(partitionValue) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (0, get_1.getItemCosmos)(this.container, partitionValue);
+        });
+    }
+    getItemsBy(partitionValues) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (0, get_1.getItemsByCosmos)(this.container, partitionValues);
+        });
+    }
+    queryItemsByText(searchFields_1) {
+        return __awaiter(this, arguments, void 0, function* (searchFields, operator = 'AND') {
+            return (0, get_1.queryItemsByText)(this.container, searchFields, operator);
+        });
+    }
+    scan() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (0, get_1.scanCosmos)(this.container);
+        });
+    }
+    queryItemsByNumber(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (0, get_1.queryItemsByNumber)(this.container, options);
+        });
+    }
+    queryItemsByType(type) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (0, get_1.queryItemsByType)(this.container, type);
+        });
+    }
+    queryItemsByRelevancy(type, limit) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (0, get_1.queryItemsByRelevancy)(this.container, type, limit);
+        });
+    }
+    // Write operations
+    putItem(item) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (0, write_1.putItemCosmos)(this.container, item);
+        });
+    }
+    putItems(items) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (0, write_1.putItemsCosmos)(this.container, items);
+        });
+    }
+    // Delete operations
+    deleteItem(pk) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (0, delete_1.deleteItemCosmos)(this.container, pk);
+        });
+    }
+    deleteItemsByField(field, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (0, delete_1.deleteItemsByField)(this.container, field, value);
+        });
+    }
+}
+exports.Cosmos = Cosmos;

package/dist/api/helpers/cosmos/utils.d.ts

@@ -0,0 +1,9 @@
+import type { Container } from '@azure/cosmos';
+export declare const BULK_CHUNK_SIZE = 50;
+export interface CosmosSettings {
+    endpoint: string;
+    key: string;
+    database_name: string;
+    container_name: string;
+}
+export declare function createContainer(settings: CosmosSettings): Container;

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BULK_CHUNK_SIZE = void 0;
+exports.createContainer = createContainer;
+const cosmos_1 = require("@azure/cosmos");
+exports.BULK_CHUNK_SIZE = 50;
+function createContainer(settings) {
+    if (!settings.endpoint ||
+        !settings.key ||
+        !settings.database_name ||
+        !settings.container_name) {
+        throw new Error('no cosmos settings');
+    }
+    const client = new cosmos_1.CosmosClient(settings);
+    const database = client.database(settings.database_name);
+    const container = database.container(settings.container_name);
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (!container) {
+        throw new Error('error, cosmos container undefined!!');
+    }
+    return container;
+}

package/dist/api/helpers/cosmos/write.d.ts

@@ -0,0 +1,9 @@
+import type { Container } from '@azure/cosmos';
+export declare function putItemCosmos<T extends {
+    PK: string;
+}>(container: Container, item: T): Promise<T>;
+export declare function putItemsCosmos<T extends {
+    PK: string;
+}>(container: Container, items: T[]): Promise<{
+    error?: string;
+}>;

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

@@ -0,0 +1,107 @@
+"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 withRetry_1 = require("../withRetry");
+const log_1 = require("../../../common/helpers/log");
+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 }],
+            };
+            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;
+            }
+        }
+        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');
+            return {};
+        }
+        catch (e) {
+            const em = e.message;
+            (0, log_1.error)('Error bulk writing items:', em);
+            throw e;
+        }
+    });
+}

package/dist/api/helpers/index.d.ts

@@ -10,3 +10,4 @@ export * from './ssm';
 export * from './ssmInfra';
 export * from './sts';
 export * from './validations';
+export * from './cosmos';

package/dist/api/helpers/index.js

@@ -26,3 +26,4 @@ __exportStar(require("./ssm"), exports);
 __exportStar(require("./ssmInfra"), exports);
 __exportStar(require("./sts"), exports);
 __exportStar(require("./validations"), exports);
+__exportStar(require("./cosmos"), exports);

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.0.765",
+  "version": "0.0.766",
   "name": "ag-common",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -25,10 +25,12 @@
     "@aws-sdk/client-sts": "^3.879.0",
     "@aws-sdk/lib-dynamodb": "^3.879.0",
     "@aws-sdk/s3-presigned-post": "^3.879.0",
+    "@azure/cosmos": "^4.5.1",
     "aws-cdk-lib": "^2.213.0",
     "buffer": "^6.0.3",
     "jsonwebtoken": "^9.0.2",
     "jwks-rsa": "^3.2.0",
+    "node-cache": "^5.1.2",
     "react": "^19.1.1",
     "react-dom": "^19.1.1",
     "typescript": "^5.9.2"