ag-common 0.0.744 → 0.0.746

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

@@ -1,6 +1,5 @@
-import type { Key } from '../../types';
 import type { DynamoDBResult } from './types';
-import type { DynamoQueryParams, ScanOptions } from './types';
+import type { DynamoBatchQueryParams, DynamoQueryParams, ScanOptions } from './types';
 export declare const getItemsDynamo: <T>(params: {
     tableName: string;
     items: {
@@ -13,13 +12,45 @@ export declare const getItemDynamo: <T>(params: {
     pkName: string;
     pkValue: string;
 }) => Promise<DynamoDBResult<T>>;
-export declare const queryDynamo: <T>(params: DynamoQueryParams) => Promise<{
-    data: T[];
-    startKey?: Key;
-} | {
-    error: string;
-}>;
+export declare const queryDynamo: <T>(params: DynamoQueryParams) => Promise<DynamoDBResult<T[]>>;
 export declare const scan: <T>(tableName: string, options?: ScanOptions) => Promise<DynamoDBResult<T[]>>;
+/**
+ * Batch query DynamoDB using PartiQL to query multiple partition key values at once
+ *
+ * This function uses PartiQL's IN operator to query multiple partition key values
+ * in a single request, which is more efficient than making multiple individual queries.
+ *
+ * Note: AWS has limits on the number of items in WHERE IN queries:
+ * - Primary index: 100 items max
+ * - Secondary index (GSI/LSI): 50 items max
+ * This function automatically chunks requests to stay within these limits.
+ *
+ * @example
+ * // Basic usage with multiple partition keys
+ * const result = await batchQueryDynamo<User>({
+ *   tableName: 'Users',
+ *   pkName: 'userId',
+ *   pkValues: ['user1', 'user2', 'user3']
+ * });
+ *
+ * @example
+ * // With filter and limit
+ * const result = await batchQueryDynamo<Product>({
+ *   tableName: 'Products',
+ *   pkName: 'categoryId',
+ *   pkValues: ['electronics', 'books'],
+ *   filter: {
+ *     filterExpression: 'price < :maxPrice',
+ *     attrNames: {},
+ *     attrValues: { ':maxPrice': 100 }
+ *   },
+ *   limit: 50
+ * });
+ *
+ * @param params - The batch query parameters
+ * @returns Promise resolving to query results or error
+ */
+export declare const batchQueryDynamo: <T>(params: DynamoBatchQueryParams) => Promise<DynamoDBResult<T[]>>;
 export declare function queryWithGenerator<T>(params: DynamoQueryParams & {
     /** how many to return in query generator. default 100 */
     BATCH_SIZE?: number;

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

@@ -22,7 +22,7 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar
     function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.scan = exports.queryDynamo = exports.getItemDynamo = exports.getItemsDynamo = void 0;
+exports.batchQueryDynamo = exports.scan = exports.queryDynamo = exports.getItemDynamo = exports.getItemsDynamo = void 0;
 exports.queryWithGenerator = queryWithGenerator;
 exports.scanWithGenerator = scanWithGenerator;
 /* eslint-disable no-await-in-loop */
@@ -65,7 +65,9 @@ const executeQuery = (params, startKey) => __awaiter(void 0, void 0, void 0, fun
     const queryParams = Object.assign({ TableName: params.tableName, KeyConditionExpression: kce, ExpressionAttributeNames: Object.assign(Object.assign({}, ean), (_b = params.filter) === null || _b === void 0 ? void 0 : _b.attrNames), ExpressionAttributeValues: Object.assign(Object.assign({}, eav), (_c = params.filter) === null || _c === void 0 ? void 0 : _c.attrValues), ScanIndexForward: (_d = params.sortAscending) !== null && _d !== void 0 ? _d : true, Limit: (_e = params.BATCH_SIZE) !== null && _e !== void 0 ? _e : params.limit, IndexName: params.indexName, ExclusiveStartKey: startKey }, (params.filter && Object.assign({ FilterExpression: params.filter.filterExpression }, (params.filter.attrValues && {
         ExpressionAttributeValues: Object.assign(Object.assign({}, eav), params.filter.attrValues),
     }))));
-    return (0, withRetry_1.withRetry)(() => _1.dynamoDb.send(new lib_dynamodb_1.QueryCommand(queryParams)), 'queryDynamo');
+    return (0, withRetry_1.withRetry)(() => _1.dynamoDb.send(new lib_dynamodb_1.QueryCommand(queryParams)), 'queryDynamo', {
+        maxRetries: params.alwaysRetry ? null : undefined,
+    });
 });
 /**
  * Helper function that builds the scan parameters and executes the scan
@@ -133,10 +135,10 @@ const queryDynamo = (params) => __awaiter(void 0, void 0, void 0, function* () {
                 items.push(...result.Items);
             }
             startKey = result.LastEvaluatedKey;
+            // If we have a limit and we've reached it, stop processing
             if (params.limit && items.length >= params.limit) {
                 return {
                     data: items.slice(0, params.limit),
-                    startKey,
                 };
             }
         } while (startKey && Object.keys(startKey).length > 0);
@@ -165,6 +167,138 @@ const scan = (tableName, options) => __awaiter(void 0, void 0, void 0, function*
     }
 });
 exports.scan = scan;
+/**
+ * Batch query DynamoDB using PartiQL to query multiple partition key values at once
+ *
+ * This function uses PartiQL's IN operator to query multiple partition key values
+ * in a single request, which is more efficient than making multiple individual queries.
+ *
+ * Note: AWS has limits on the number of items in WHERE IN queries:
+ * - Primary index: 100 items max
+ * - Secondary index (GSI/LSI): 50 items max
+ * This function automatically chunks requests to stay within these limits.
+ *
+ * @example
+ * // Basic usage with multiple partition keys
+ * const result = await batchQueryDynamo<User>({
+ *   tableName: 'Users',
+ *   pkName: 'userId',
+ *   pkValues: ['user1', 'user2', 'user3']
+ * });
+ *
+ * @example
+ * // With filter and limit
+ * const result = await batchQueryDynamo<Product>({
+ *   tableName: 'Products',
+ *   pkName: 'categoryId',
+ *   pkValues: ['electronics', 'books'],
+ *   filter: {
+ *     filterExpression: 'price < :maxPrice',
+ *     attrNames: {},
+ *     attrValues: { ':maxPrice': 100 }
+ *   },
+ *   limit: 50
+ * });
+ *
+ * @param params - The batch query parameters
+ * @returns Promise resolving to query results or error
+ */
+const batchQueryDynamo = (params) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        if (params.pkValues.length === 0) {
+            return { data: [] };
+        }
+        // Determine chunk size based on whether we're using a secondary index
+        const isSecondaryIndex = !!params.indexName;
+        const chunkSize = isSecondaryIndex ? 50 : 100;
+        // Chunk the partition key values
+        const chunks = [];
+        for (let i = 0; i < params.pkValues.length; i += chunkSize) {
+            chunks.push(params.pkValues.slice(i, i + chunkSize));
+        }
+        const allItems = [];
+        let totalProcessed = 0;
+        // Process each chunk
+        for (const chunk of chunks) {
+            const result = yield executePartiQLQuery(Object.assign(Object.assign({}, params), { pkValues: chunk }));
+            if ('error' in result) {
+                return result;
+            }
+            allItems.push(...result.data);
+            totalProcessed += result.data.length;
+            // If we have a limit and we've reached it, stop processing
+            if (params.limit && totalProcessed >= params.limit) {
+                return {
+                    data: allItems.slice(0, params.limit),
+                };
+            }
+        }
+        return {
+            data: allItems,
+        };
+    }
+    catch (e) {
+        return { error: e.toString() };
+    }
+});
+exports.batchQueryDynamo = batchQueryDynamo;
+/**
+ * Helper function to execute a single PartiQL query for a chunk of partition keys
+ */
+const executePartiQLQuery = (params) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        // Build the PartiQL WHERE clause for multiple partition keys
+        const pkPlaceholders = params.pkValues.map(() => '?').join(', ');
+        let whereClause = `"${params.pkName}" IN (${pkPlaceholders})`;
+        // Build parameters array for PartiQL (positional parameters)
+        const parameters = [...params.pkValues];
+        // Add filter conditions if provided
+        if (params.filter) {
+            // For filters, we need to replace the named parameters with positional ones
+            let filterExpression = params.filter.filterExpression;
+            if (params.filter.attrValues) {
+                Object.entries(params.filter.attrValues).forEach(([key, value]) => {
+                    filterExpression = filterExpression.replace(new RegExp(key.replace(':', '\\:'), 'g'), '?');
+                    parameters.push(value);
+                });
+            }
+            whereClause += ` AND ${filterExpression}`;
+        }
+        // Build the PartiQL statement
+        const tableName = params.indexName
+            ? `"${params.tableName}"."${params.indexName}"`
+            : `"${params.tableName}"`;
+        const statement = `SELECT * FROM ${tableName} WHERE ${whereClause}`;
+        const allItems = [];
+        let nextToken;
+        // Loop until all results are retrieved
+        do {
+            const executeParams = {
+                Statement: statement,
+                Parameters: parameters,
+                Limit: params.limit,
+                NextToken: nextToken,
+            };
+            const result = yield (0, withRetry_1.withRetry)(() => _1.dynamoDb.send(new lib_dynamodb_1.ExecuteStatementCommand(executeParams)), 'batchQueryDynamo');
+            if (result.Items) {
+                allItems.push(...result.Items);
+            }
+            nextToken = result.NextToken;
+            // If we have a limit and we've reached it, stop processing
+            if (params.limit && allItems.length >= params.limit) {
+                return {
+                    data: allItems.slice(0, params.limit),
+                };
+            }
+        } while (nextToken);
+        return {
+            data: allItems,
+        };
+    }
+    catch (e) {
+        return { error: e.toString() };
+    }
+});
 function queryWithGenerator(params) {
     return __asyncGenerator(this, arguments, function* queryWithGenerator_1() {
         var _a;

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

@@ -19,12 +19,7 @@ export declare const getItemDynamo: <T>(params: {
         pkName: string;
         pkValue: string;
     }[];
-}) => Promise<import("./types").DynamoDBResult<T[]>>, queryDynamo: <T>(params: import("./types").DynamoQueryParams) => Promise<{
-    data: T[];
-    startKey?: import("../..").Key;
-} | {
-    error: string;
-}>, queryWithGenerator: typeof getOps.queryWithGenerator, scan: <T>(tableName: string, options?: import("./types").ScanOptions) => Promise<import("./types").DynamoDBResult<T[]>>, scanWithGenerator: typeof getOps.scanWithGenerator;
+}) => Promise<import("./types").DynamoDBResult<T[]>>, queryDynamo: <T>(params: import("./types").DynamoQueryParams) => Promise<import("./types").DynamoDBResult<T[]>>, batchQueryDynamo: <T>(params: import("./types").DynamoBatchQueryParams) => Promise<import("./types").DynamoDBResult<T[]>>, queryWithGenerator: typeof getOps.queryWithGenerator, scan: <T>(tableName: string, options?: import("./types").ScanOptions) => Promise<import("./types").DynamoDBResult<T[]>>, scanWithGenerator: typeof getOps.scanWithGenerator;
 export declare const putDynamo: <T extends Record<string, unknown>>(item: T, tableName: string, opt?: {
     pkName?: string;
 }) => Promise<import("./types").DynamoDBResult<void>>, batchWrite: <T extends Record<string, unknown>>(tableName: string, items: T[], opt?: {

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

@@ -36,7 +36,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.wipeTable = exports.batchDelete = exports.getDynamoUpdates = exports.batchWrite = exports.putDynamo = exports.scanWithGenerator = exports.scan = exports.queryWithGenerator = exports.queryDynamo = exports.getItemsDynamo = exports.getItemDynamo = exports.setDynamo = exports.dynamoDb = void 0;
+exports.wipeTable = exports.batchDelete = exports.getDynamoUpdates = exports.batchWrite = exports.putDynamo = exports.scanWithGenerator = exports.scan = exports.queryWithGenerator = exports.batchQueryDynamo = exports.queryDynamo = exports.getItemsDynamo = exports.getItemDynamo = exports.setDynamo = exports.dynamoDb = void 0;
 const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
 const lib_dynamodb_1 = require("@aws-sdk/lib-dynamodb");
 const deleteOps = __importStar(require("./delete"));
@@ -59,7 +59,7 @@ exports.setDynamo = setDynamo;
 // Initialize with default region
 exports.dynamoDb = (0, exports.setDynamo)('ap-southeast-2');
 // Export all operations
-exports.getItemDynamo = getOps.getItemDynamo, exports.getItemsDynamo = getOps.getItemsDynamo, exports.queryDynamo = getOps.queryDynamo, exports.queryWithGenerator = getOps.queryWithGenerator, exports.scan = getOps.scan, exports.scanWithGenerator = getOps.scanWithGenerator;
+exports.getItemDynamo = getOps.getItemDynamo, exports.getItemsDynamo = getOps.getItemsDynamo, exports.queryDynamo = getOps.queryDynamo, exports.batchQueryDynamo = getOps.batchQueryDynamo, exports.queryWithGenerator = getOps.queryWithGenerator, exports.scan = getOps.scan, exports.scanWithGenerator = getOps.scanWithGenerator;
 exports.putDynamo = setOps.putDynamo, exports.batchWrite = setOps.batchWrite, exports.getDynamoUpdates = setOps.getDynamoUpdates;
 exports.batchDelete = deleteOps.batchDelete, exports.wipeTable = deleteOps.wipeTable;
 // Export types

package/dist/api/helpers/dynamo/types.d.ts

@@ -1,4 +1,3 @@
-import type { Key } from '../../types';
 export type DynamoDBError = {
     error: string;
 };
@@ -36,8 +35,16 @@ export interface DynamoQueryParams {
     skOperator?: '=' | '<' | '>' | '<=' | '>=' | 'BETWEEN' | 'BEGINS_WITH';
     indexName?: string;
     limit?: number;
-    startKey?: Key;
     filter?: DynamoFilter;
     sortAscending?: boolean;
+    alwaysRetry?: boolean;
+}
+export interface DynamoBatchQueryParams {
+    tableName: string;
+    pkName: string;
+    pkValues: (string | number)[];
+    indexName?: string;
+    limit?: number;
+    filter?: DynamoFilter;
 }
 export declare const isError: <T>(result: DynamoDBResult<T>) => result is DynamoDBError;

package/dist/api/helpers/withRetry.js

@@ -10,6 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.withRetry = void 0;
+/* eslint-disable no-await-in-loop */
 const log_1 = require("../../common/helpers/log");
 const sleep_1 = require("../../common/helpers/sleep");
 const withRetry = (operation, operationName, opt) => __awaiter(void 0, void 0, void 0, function* () {
@@ -23,10 +24,11 @@ const withRetry = (operation, operationName, opt) => __awaiter(void 0, void 0, v
         }
         catch (e) {
             const error = e;
-            const errorString = error.toString().toLowerCase();
+            const errorString = error.toString().toLowerCase().replace(/\s+/gim, '');
             if (errorString.includes('429') ||
                 errorString.includes('provisionedthroughputexceeded') ||
-                errorString.includes('too large')) {
+                errorString.includes('toolarge') ||
+                errorString.includes('ratelimited')) {
                 retryCount++;
                 if (maxRetries !== null && retryCount >= maxRetries) {
                     (0, log_1.warn)(`${operationName}: Max retries exceeded`);

package/dist/ui/components/BarChart/Base.js

@@ -22,6 +22,7 @@ const BarChartBase = styled_1.default.div `
 const ItemStyled = (0, styled_1.default)(Item_1.Item) `
   margin-bottom: 0.75rem;
   height: auto;
+  overflow: hidden;
 
   &:last-of-type {
     margin-bottom: 0;

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.0.744",
+  "version": "0.0.746",
   "name": "ag-common",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",