@certik/skynet 0.22.1 → 0.22.2

package/dist/dynamodb.js

@@ -1,328 +1,479 @@
-import { DynamoDBDocumentClient, ScanCommand, BatchWriteCommand, GetCommand, PutCommand, QueryCommand, UpdateCommand, } from "@aws-sdk/lib-dynamodb";
+// src/object-hash.ts
+import xh from "@node-rs/xxhash";
+function getHash(obj) {
+  const xxh3 = xh.xxh3.Xxh3.withSeed();
+  hash(obj, xxh3);
+  return xxh3.digest().toString(16);
+}
+function hash(obj, xxh3) {
+  if (obj === null) {
+    xxh3.update("null");
+  } else if (obj === undefined) {
+    xxh3.update("undefined");
+  } else if (typeof obj === "string") {
+    xxh3.update(obj);
+  } else if (typeof obj === "number") {
+    xxh3.update(obj.toString());
+  } else if (typeof obj === "boolean") {
+    xxh3.update(obj.toString());
+  } else if (typeof obj === "bigint") {
+    xxh3.update(obj.toString());
+  } else if (obj instanceof Date) {
+    xxh3.update(obj.toISOString());
+  } else if (Array.isArray(obj)) {
+    arrayHash(obj, xxh3);
+  } else if (obj instanceof Set) {
+    setHash(obj, xxh3);
+  } else if (obj instanceof Map) {
+    mapHash(obj, xxh3);
+  } else if (typeof obj === "object") {
+    objectHash(obj, xxh3);
+  } else {
+    throw new Error(`Unsupported type: ${obj}`);
+  }
+}
+function arrayHash(array, xxh3) {
+  xxh3.update("[");
+  for (const obj of array) {
+    hash(obj, xxh3);
+  }
+  xxh3.update("]");
+}
+function setHash(_set, _xxh3) {
+  throw new Error("Set hashing not implemented");
+}
+function mapHash(map, xxh3) {
+  const array = Array.from(map.entries()).sort(([aKey], [bKey]) => aKey.localeCompare(bKey));
+  for (const [key, value] of array) {
+    hash(key, xxh3);
+    hash(value, xxh3);
+  }
+}
+function objectHash(obj, xxh3) {
+  const array = Object.entries(obj).sort(([aKey], [bKey]) => aKey.localeCompare(bKey));
+  for (const [key, value] of array) {
+    hash(key, xxh3);
+    hash(value, xxh3);
+  }
+}
+
+// src/availability.ts
+import pThrottle from "p-throttle";
+import pMemoize from "p-memoize";
+import QuickLRU from "quick-lru";
+async function wait(time) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, time);
+  });
+}
+async function exponentialRetry(func, {
+  maxRetry,
+  initialDuration,
+  growFactor,
+  test,
+  verbose
+}) {
+  let retries = maxRetry;
+  let duration = initialDuration || 5000;
+  const growFactorFinal = growFactor || 2;
+  let result = await func();
+  while (!test(result) && retries > 0) {
+    if (verbose) {
+      console.log("failed attempt result", result);
+      console.log(`sleep for ${duration}ms after failed attempt, remaining ${retries} attempts`);
+    }
+    retries = retries - 1;
+    await wait(duration);
+    result = await func();
+    duration = duration * growFactorFinal;
+  }
+  if (verbose) {
+    console.log(`function to retry ends with status ${test(result)}, number of retries done: ${maxRetry - retries}}`);
+  }
+  return result;
+}
+function withRetry(func, options) {
+  let retries = options?.maxRetry || 3;
+  let duration = options?.initialDuration || 500;
+  const growFactorFinal = options?.growFactor || 2;
+  return async (...args) => {
+    do {
+      try {
+        return await func(...args);
+      } catch (error) {
+        retries = retries - 1;
+        if (retries <= 0) {
+          throw error;
+        }
+        await wait(duration);
+        duration = duration * growFactorFinal;
+      }
+    } while (retries > 0);
+    throw new Error("unreachable");
+  };
+}
+function memoize(func, options) {
+  if (!options) {
+    options = {};
+  }
+  if (!options.cache) {
+    options.cache = new QuickLRU({ maxSize: options.lruMaxSize || 1e4 });
+  }
+  if (!options.cacheKey) {
+    options.cacheKey = (args) => getHash(args);
+  }
+  return pMemoize(func, options);
+}
+// src/util.ts
+function range(startAt, endAt, step) {
+  const arr = [];
+  for (let i = startAt;i <= endAt; i += step) {
+    arr.push([i, Math.min(endAt, i + step - 1)]);
+  }
+  return arr;
+}
+function arrayGroup(array, groupSize) {
+  const groups = [];
+  for (let i = 0;i < array.length; i += groupSize) {
+    groups.push(array.slice(i, i + groupSize));
+  }
+  return groups;
+}
+function fillRange(start, end) {
+  const result = [];
+  for (let i = start;i <= end; i++) {
+    result.push(i);
+  }
+  return result;
+}
+// src/dynamodb.ts
+import {
+  DynamoDBDocumentClient,
+  ScanCommand,
+  BatchWriteCommand,
+  GetCommand,
+  PutCommand,
+  QueryCommand,
+  UpdateCommand
+} from "@aws-sdk/lib-dynamodb";
 import { DynamoDBClient, DescribeTableCommand } from "@aws-sdk/client-dynamodb";
-import { wait } from "./availability.js";
-import { arrayGroup } from "./util.js";
-let _dynamoDB;
-let _docClient;
+var _dynamoDB;
+var _docClient;
 function getDynamoDB(forceNew = false) {
-    if (!_dynamoDB || forceNew) {
-        _dynamoDB = new DynamoDBClient();
-    }
-    return _dynamoDB;
+  if (!_dynamoDB || forceNew) {
+    _dynamoDB = new DynamoDBClient;
+  }
+  return _dynamoDB;
 }
 function getDocClient(forceNew = false) {
-    const marshallOptions = {
-        // Whether to automatically convert empty strings, blobs, and sets to `null`.
-        convertEmptyValues: true,
-        // Whether to remove undefined values while marshalling.
-        removeUndefinedValues: true,
-        // Whether to convert typeof object to map attribute.
-        convertClassInstanceToMap: true,
-    };
-    const unmarshallOptions = {
-        // Whether to return numbers as a string instead of converting them to native JavaScript numbers.
-        wrapNumbers: false, // false, by default.
-    };
-    if (!_docClient || forceNew) {
-        _docClient = DynamoDBDocumentClient.from(getDynamoDB(), {
-            marshallOptions,
-            unmarshallOptions,
-        });
-    }
-    return _docClient;
+  const marshallOptions = {
+    convertEmptyValues: true,
+    removeUndefinedValues: true,
+    convertClassInstanceToMap: true
+  };
+  const unmarshallOptions = {
+    wrapNumbers: false
+  };
+  if (!_docClient || forceNew) {
+    _docClient = DynamoDBDocumentClient.from(getDynamoDB(), {
+      marshallOptions,
+      unmarshallOptions
+    });
+  }
+  return _docClient;
 }
 async function scanWholeTable(options) {
-    const dynamodb = getDocClient();
-    let items = [];
-    let count = 0;
-    let scannedCount = 0;
-    let data = await dynamodb.send(new ScanCommand(options));
-    while (data.LastEvaluatedKey) {
-        if (data.Items) {
-            items = items.concat(data.Items);
-        }
-        count += data.Count || 0;
-        scannedCount += data.ScannedCount || 0;
-        data = await dynamodb.send(new ScanCommand({ ...options, ExclusiveStartKey: data.LastEvaluatedKey }));
-    }
+  const dynamodb = getDocClient();
+  let items = [];
+  let count = 0;
+  let scannedCount = 0;
+  let data = await dynamodb.send(new ScanCommand(options));
+  while (data.LastEvaluatedKey) {
     if (data.Items) {
-        items = items.concat(data.Items);
+      items = items.concat(data.Items);
     }
     count += data.Count || 0;
     scannedCount += data.ScannedCount || 0;
-    return {
-        Items: items,
-        Count: count,
-        ScannedCount: scannedCount,
-    };
+    data = await dynamodb.send(new ScanCommand({ ...options, ExclusiveStartKey: data.LastEvaluatedKey }));
+  }
+  if (data.Items) {
+    items = items.concat(data.Items);
+  }
+  count += data.Count || 0;
+  scannedCount += data.ScannedCount || 0;
+  return {
+    Items: items,
+    Count: count,
+    ScannedCount: scannedCount
+  };
 }
 async function batchCreateRecords(tableName, records, maxWritingCapacity, verbose = false) {
-    if (verbose) {
-        console.log(`creating ${records.length} items in ${tableName}`);
-    }
-    const docClient = getDocClient();
-    let remainingItems = records;
-    // an arbitrary number to ensure while first loop is entered
-    let prevRemainingCount = remainingItems.length + 1;
-    let factor = 1;
-    let rejection = undefined;
-    while (remainingItems.length > 0 && factor <= 128 && !rejection) {
-        if (prevRemainingCount === remainingItems.length) {
-            await wait(5000 * factor);
-            factor = factor * 2;
-        }
-        if (factor >= 32) {
-            console.log(`WARNING: no progress for a long time for batchCreateRecords, please check`);
-        }
-        const slices = arrayGroup(remainingItems.slice(0, maxWritingCapacity), 25);
-        const results = await Promise.allSettled(slices.map((rs) => docClient.send(new BatchWriteCommand({
-            RequestItems: {
-                [tableName]: rs.map((record) => ({ PutRequest: { Item: record } })),
-            },
-        }))));
-        const isFulfilled = (p) => p.status === "fulfilled";
-        const isRejected = (p) => p.status === "rejected";
-        prevRemainingCount = remainingItems.length;
-        remainingItems = remainingItems.slice(maxWritingCapacity);
-        results.forEach((rs, idx) => {
-            if (isRejected(rs)) {
-                // whole slice fails, redo whole slice
-                remainingItems = remainingItems.concat(slices[idx]);
-                rejection = rs;
-            }
-            else if (isFulfilled(rs) && rs.value.UnprocessedItems && Object.keys(rs.value.UnprocessedItems).length > 0) {
-                // partially fails, redo unprocessedItems
-                const unprocessedItems = rs.value.UnprocessedItems[tableName].map((it) => it.PutRequest?.Item ?? []).flat();
-                remainingItems = remainingItems.concat(unprocessedItems);
-            }
-        });
-        if (verbose) {
-            console.log(`processed=${prevRemainingCount - remainingItems.length}, remaining=${remainingItems.length}`);
-        }
+  if (verbose) {
+    console.log(`creating ${records.length} items in ${tableName}`);
+  }
+  const docClient = getDocClient();
+  let remainingItems = records;
+  let prevRemainingCount = remainingItems.length + 1;
+  let factor = 1;
+  let rejection = undefined;
+  while (remainingItems.length > 0 && factor <= 128 && !rejection) {
+    if (prevRemainingCount === remainingItems.length) {
+      await wait(5000 * factor);
+      factor = factor * 2;
     }
-    if (rejection) {
-        console.log("batchCreateRecords rejected", rejection);
-        throw new Error(`batchCreateRecords rejected, failed items=${remainingItems.length}`);
+    if (factor >= 32) {
+      console.log(`WARNING: no progress for a long time for batchCreateRecords, please check`);
     }
-    if (remainingItems.length > 0) {
-        console.log(`failed batchCreateRecords, failed items=${remainingItems.length}`);
-        throw new Error(`batchCreateRecords retry failed, failed items=${remainingItems.length}`);
+    const slices = arrayGroup(remainingItems.slice(0, maxWritingCapacity), 25);
+    const results = await Promise.allSettled(slices.map((rs) => docClient.send(new BatchWriteCommand({
+      RequestItems: {
+        [tableName]: rs.map((record) => ({ PutRequest: { Item: record } }))
+      }
+    }))));
+    const isFulfilled = (p) => p.status === "fulfilled";
+    const isRejected = (p) => p.status === "rejected";
+    prevRemainingCount = remainingItems.length;
+    remainingItems = remainingItems.slice(maxWritingCapacity);
+    results.forEach((rs, idx) => {
+      if (isRejected(rs)) {
+        remainingItems = remainingItems.concat(slices[idx]);
+        rejection = rs;
+      } else if (isFulfilled(rs) && rs.value.UnprocessedItems && Object.keys(rs.value.UnprocessedItems).length > 0) {
+        const unprocessedItems = rs.value.UnprocessedItems[tableName].map((it) => it.PutRequest?.Item ?? []).flat();
+        remainingItems = remainingItems.concat(unprocessedItems);
+      }
+    });
+    if (verbose) {
+      console.log(`processed=${prevRemainingCount - remainingItems.length}, remaining=${remainingItems.length}`);
     }
+  }
+  if (rejection) {
+    console.log("batchCreateRecords rejected", rejection);
+    throw new Error(`batchCreateRecords rejected, failed items=${remainingItems.length}`);
+  }
+  if (remainingItems.length > 0) {
+    console.log(`failed batchCreateRecords, failed items=${remainingItems.length}`);
+    throw new Error(`batchCreateRecords retry failed, failed items=${remainingItems.length}`);
+  }
 }
 async function createRecord(tableName, fields, verbose = false) {
-    if (verbose) {
-        console.log("creating", tableName, fields);
-    }
-    const docClient = getDocClient();
-    const params = {
-        TableName: tableName,
-        Item: fields,
-    };
-    return docClient.send(new PutCommand(params));
+  if (verbose) {
+    console.log("creating", tableName, fields);
+  }
+  const docClient = getDocClient();
+  const params = {
+    TableName: tableName,
+    Item: fields
+  };
+  return docClient.send(new PutCommand(params));
 }
 async function readRecord(tableName, key, verbose = false) {
-    if (verbose) {
-        console.log("reading", tableName, key);
-    }
-    const docClient = getDocClient();
-    const record = await docClient.send(new GetCommand({
-        TableName: tableName,
-        Key: key,
-    }));
-    return record.Item;
+  if (verbose) {
+    console.log("reading", tableName, key);
+  }
+  const docClient = getDocClient();
+  const record = await docClient.send(new GetCommand({
+    TableName: tableName,
+    Key: key
+  }));
+  return record.Item;
 }
 async function getRecordsByKey(tableName, keys, indexName) {
-    const docClient = getDocClient();
-    const keyNames = Object.keys(keys);
-    const conditionExpression = keyNames.map((key) => `#${key} = :${key}`).join(" and ");
-    const params = {
-        TableName: tableName,
-        KeyConditionExpression: conditionExpression,
-        ExpressionAttributeNames: generateExpressionNames(keyNames),
-        ExpressionAttributeValues: generateExpressionValues(keyNames, keys),
-    };
-    if (indexName) {
-        params.IndexName = indexName;
-    }
-    try {
-        let data = await docClient.send(new QueryCommand(params));
-        let items = data.Items ?? [];
-        while (data.LastEvaluatedKey) {
-            data = await docClient.send(new QueryCommand({
-                ...params,
-                ExclusiveStartKey: data.LastEvaluatedKey,
-            }));
-            if (data.Items) {
-                items = items.concat(data.Items);
-            }
-        }
-        return items;
+  const docClient = getDocClient();
+  const keyNames = Object.keys(keys);
+  const conditionExpression = keyNames.map((key) => `#${key} = :${key}`).join(" and ");
+  const params = {
+    TableName: tableName,
+    KeyConditionExpression: conditionExpression,
+    ExpressionAttributeNames: generateExpressionNames(keyNames),
+    ExpressionAttributeValues: generateExpressionValues(keyNames, keys)
+  };
+  if (indexName) {
+    params.IndexName = indexName;
+  }
+  try {
+    let data = await docClient.send(new QueryCommand(params));
+    let items = data.Items ?? [];
+    while (data.LastEvaluatedKey) {
+      data = await docClient.send(new QueryCommand({
+        ...params,
+        ExclusiveStartKey: data.LastEvaluatedKey
+      }));
+      if (data.Items) {
+        items = items.concat(data.Items);
+      }
     }
-    catch (err) {
-        console.log(err);
-        if (err instanceof Error && "statusCode" in err && err.statusCode === 400) {
-            return null;
-        }
-        throw err;
+    return items;
+  } catch (err) {
+    console.log(err);
+    if (err instanceof Error && "statusCode" in err && err.statusCode === 400) {
+      return null;
     }
+    throw err;
+  }
 }
-// Dual purpose for compatibility. If indexName is provided, it will use query command to get the record; if not, use get command which is most efficient.
 async function getRecordByKey(tableName, keys, indexName) {
-    if (indexName) {
-        const records = await getRecordsByKey(tableName, keys, indexName);
-        if (records) {
-            return records[0];
-        }
-        else {
-            return null;
-        }
-    }
-    else {
-        return readRecord(tableName, keys);
+  if (indexName) {
+    const records = await getRecordsByKey(tableName, keys, indexName);
+    if (records) {
+      return records[0];
+    } else {
+      return null;
     }
+  } else {
+    return readRecord(tableName, keys);
+  }
 }
 function generateExpressionNames(keys) {
-    return keys.reduce((acc, key) => ({ ...acc, [`#${key}`]: key }), {});
+  return keys.reduce((acc, key) => ({ ...acc, [`#${key}`]: key }), {});
 }
 function generateExpressionValues(keys, fields) {
-    return keys.reduce((acc, key) => ({ ...acc, [`:${key}`]: fields[key] }), {});
+  return keys.reduce((acc, key) => ({ ...acc, [`:${key}`]: fields[key] }), {});
 }
 async function updateRecordByKey(tableName, idKey, fields, conditionExpressions = null, verbose = false) {
+  if (verbose) {
+    console.log("update", tableName, idKey, fields);
+  }
+  const docClient = getDocClient();
+  const idKeyNames = Object.keys(idKey);
+  const fieldsToDelete = Object.keys(fields).filter((f) => fields[f] === undefined);
+  const fieldsToUpdate = Object.keys(fields).filter((k) => !idKeyNames.includes(k) && !fieldsToDelete.includes(k));
+  let data;
+  if (fieldsToDelete.length > 0) {
     if (verbose) {
-        console.log("update", tableName, idKey, fields);
+      console.log("delete fields", tableName, fieldsToDelete);
     }
-    const docClient = getDocClient();
-    const idKeyNames = Object.keys(idKey);
-    const fieldsToDelete = Object.keys(fields).filter((f) => fields[f] === undefined);
-    const fieldsToUpdate = Object.keys(fields).filter((k) => !idKeyNames.includes(k) && !fieldsToDelete.includes(k));
-    let data;
-    if (fieldsToDelete.length > 0) {
-        if (verbose) {
-            console.log("delete fields", tableName, fieldsToDelete);
-        }
-        const deleteParams = {
-            TableName: tableName,
-            Key: idKey,
-            ExpressionAttributeNames: generateExpressionNames(fieldsToDelete),
-            UpdateExpression: `REMOVE ${fieldsToDelete.map((f) => `#${f}`).join(", ")}`,
-            ReturnValues: "ALL_NEW",
-        };
-        if (conditionExpressions) {
-            deleteParams.ConditionExpression = conditionExpressions;
-        }
-        data = await docClient.send(new UpdateCommand(deleteParams));
+    const deleteParams = {
+      TableName: tableName,
+      Key: idKey,
+      ExpressionAttributeNames: generateExpressionNames(fieldsToDelete),
+      UpdateExpression: `REMOVE ${fieldsToDelete.map((f) => `#${f}`).join(", ")}`,
+      ReturnValues: "ALL_NEW"
+    };
+    if (conditionExpressions) {
+      deleteParams.ConditionExpression = conditionExpressions;
     }
-    if (fieldsToUpdate.length > 0) {
-        if (verbose) {
-            console.log("update fields", tableName, fieldsToUpdate);
-        }
-        const updateExpressions = fieldsToUpdate.map((key) => `#${key} = :${key}`);
-        const params = {
-            TableName: tableName,
-            Key: idKey,
-            ExpressionAttributeNames: generateExpressionNames(fieldsToUpdate),
-            ExpressionAttributeValues: generateExpressionValues(fieldsToUpdate, fields),
-            UpdateExpression: `SET ${updateExpressions.join(", ")}`,
-            ReturnValues: "ALL_NEW",
-        };
-        if (conditionExpressions) {
-            params.ConditionExpression = conditionExpressions;
-        }
-        data = await docClient.send(new UpdateCommand(params));
+    data = await docClient.send(new UpdateCommand(deleteParams));
+  }
+  if (fieldsToUpdate.length > 0) {
+    if (verbose) {
+      console.log("update fields", tableName, fieldsToUpdate);
+    }
+    const updateExpressions = fieldsToUpdate.map((key) => `#${key} = :${key}`);
+    const params = {
+      TableName: tableName,
+      Key: idKey,
+      ExpressionAttributeNames: generateExpressionNames(fieldsToUpdate),
+      ExpressionAttributeValues: generateExpressionValues(fieldsToUpdate, fields),
+      UpdateExpression: `SET ${updateExpressions.join(", ")}`,
+      ReturnValues: "ALL_NEW"
+    };
+    if (conditionExpressions) {
+      params.ConditionExpression = conditionExpressions;
     }
-    return data?.Attributes;
+    data = await docClient.send(new UpdateCommand(params));
+  }
+  return data?.Attributes;
 }
 async function batchDeleteRecords(tableName, keys) {
-    const docClient = getDocClient();
-    for (let start = 0; start < keys.length; start += 25) {
-        const slice = keys.slice(start, start + 25);
-        await docClient.send(new BatchWriteCommand({
-            RequestItems: {
-                [tableName]: slice.map((key) => {
-                    return { DeleteRequest: { Key: key } };
-                }),
-            },
-        }));
-    }
+  const docClient = getDocClient();
+  for (let start = 0;start < keys.length; start += 25) {
+    const slice = keys.slice(start, start + 25);
+    await docClient.send(new BatchWriteCommand({
+      RequestItems: {
+        [tableName]: slice.map((key) => {
+          return { DeleteRequest: { Key: key } };
+        })
+      }
+    }));
+  }
 }
 function getKeyName(keySchema, type) {
-    const key = keySchema.find((k) => k.KeyType === type);
-    return key?.AttributeName;
+  const key = keySchema.find((k) => k.KeyType === type);
+  return key?.AttributeName;
 }
 function getIndexKeyName(globalSecondaryIndexes, indexName, type) {
-    const idx = globalSecondaryIndexes.find((i) => i.IndexName === indexName);
-    return idx?.KeySchema && getKeyName(idx.KeySchema, type);
+  const idx = globalSecondaryIndexes.find((i) => i.IndexName === indexName);
+  return idx?.KeySchema && getKeyName(idx.KeySchema, type);
 }
 async function deleteRecordsByHashKey(tableName, indexName, hashKeyValue, verbose = false) {
-    const docClient = getDocClient();
-    const meta = await getDynamoDB().send(new DescribeTableCommand({ TableName: tableName }));
-    if (!meta.Table) {
-        throw new Error(`cannot find table ${tableName}`);
-    }
-    if (indexName && !meta.Table.GlobalSecondaryIndexes) {
-        throw new Error(`cannot find global secondary indexes for table ${tableName}`);
-    }
-    if (!meta.Table.KeySchema) {
-        throw new Error(`cannot find key schema for table ${tableName}`);
-    }
-    const hashKeyName = indexName
-        ? getIndexKeyName(meta.Table.GlobalSecondaryIndexes, indexName, "HASH")
-        : getKeyName(meta.Table.KeySchema, "HASH");
-    if (!hashKeyName) {
-        throw new Error(`cannot find hash key name for table ${tableName}`);
-    }
-    const mainHashKeyName = getKeyName(meta.Table.KeySchema, "HASH");
-    if (!mainHashKeyName) {
-        throw new Error(`cannot find main hash key name for table ${tableName}`);
-    }
-    const mainRangeKeyName = getKeyName(meta.Table.KeySchema, "RANGE");
-    if (!mainRangeKeyName) {
-        throw new Error(`cannot find main range key name for table ${tableName}`);
-    }
-    let totalDeleted = 0;
-    const params = {
-        TableName: tableName,
-        KeyConditionExpression: "#hashKeyName = :hashKeyValue",
-        ExpressionAttributeNames: { "#hashKeyName": hashKeyName },
-        ExpressionAttributeValues: { ":hashKeyValue": hashKeyValue },
-    };
-    if (indexName) {
-        params.IndexName = indexName;
-    }
-    let data = await docClient.send(new QueryCommand(params));
+  const docClient = getDocClient();
+  const meta = await getDynamoDB().send(new DescribeTableCommand({ TableName: tableName }));
+  if (!meta.Table) {
+    throw new Error(`cannot find table ${tableName}`);
+  }
+  if (indexName && !meta.Table.GlobalSecondaryIndexes) {
+    throw new Error(`cannot find global secondary indexes for table ${tableName}`);
+  }
+  if (!meta.Table.KeySchema) {
+    throw new Error(`cannot find key schema for table ${tableName}`);
+  }
+  const hashKeyName = indexName ? getIndexKeyName(meta.Table.GlobalSecondaryIndexes, indexName, "HASH") : getKeyName(meta.Table.KeySchema, "HASH");
+  if (!hashKeyName) {
+    throw new Error(`cannot find hash key name for table ${tableName}`);
+  }
+  const mainHashKeyName = getKeyName(meta.Table.KeySchema, "HASH");
+  if (!mainHashKeyName) {
+    throw new Error(`cannot find main hash key name for table ${tableName}`);
+  }
+  const mainRangeKeyName = getKeyName(meta.Table.KeySchema, "RANGE");
+  if (!mainRangeKeyName) {
+    throw new Error(`cannot find main range key name for table ${tableName}`);
+  }
+  let totalDeleted = 0;
+  const params = {
+    TableName: tableName,
+    KeyConditionExpression: "#hashKeyName = :hashKeyValue",
+    ExpressionAttributeNames: { "#hashKeyName": hashKeyName },
+    ExpressionAttributeValues: { ":hashKeyValue": hashKeyValue }
+  };
+  if (indexName) {
+    params.IndexName = indexName;
+  }
+  let data = await docClient.send(new QueryCommand(params));
+  if (data.Items) {
+    await batchDeleteRecords(tableName, data.Items.map((item) => mainRangeKeyName ? {
+      [mainHashKeyName]: item[mainHashKeyName],
+      [mainRangeKeyName]: item[mainRangeKeyName]
+    } : {
+      [mainHashKeyName]: item[mainHashKeyName]
+    }));
+    totalDeleted += data.Items.length;
+  }
+  while (data.LastEvaluatedKey) {
+    data = await docClient.send(new QueryCommand({
+      ...params,
+      ExclusiveStartKey: data.LastEvaluatedKey
+    }));
     if (data.Items) {
-        await batchDeleteRecords(tableName, data.Items.map((item) => mainRangeKeyName
-            ? {
-                [mainHashKeyName]: item[mainHashKeyName],
-                [mainRangeKeyName]: item[mainRangeKeyName],
-            }
-            : {
-                [mainHashKeyName]: item[mainHashKeyName],
-            }));
-        totalDeleted += data.Items.length;
-    }
-    while (data.LastEvaluatedKey) {
-        data = await docClient.send(new QueryCommand({
-            ...params,
-            ExclusiveStartKey: data.LastEvaluatedKey,
-        }));
-        if (data.Items) {
-            await batchDeleteRecords(tableName, data.Items.map((item) => mainRangeKeyName
-                ? {
-                    [mainHashKeyName]: item[mainHashKeyName],
-                    [mainRangeKeyName]: item[mainRangeKeyName],
-                }
-                : {
-                    [mainHashKeyName]: item[mainHashKeyName],
-                }));
-            totalDeleted += data.Items.length;
-        }
-    }
-    if (verbose) {
-        console.log(`successfully delete ${totalDeleted} items`);
+      await batchDeleteRecords(tableName, data.Items.map((item) => mainRangeKeyName ? {
+        [mainHashKeyName]: item[mainHashKeyName],
+        [mainRangeKeyName]: item[mainRangeKeyName]
+      } : {
+        [mainHashKeyName]: item[mainHashKeyName]
+      }));
+      totalDeleted += data.Items.length;
     }
-    return totalDeleted;
+  }
+  if (verbose) {
+    console.log(`successfully delete ${totalDeleted} items`);
+  }
+  return totalDeleted;
 }
-export { getDocClient, 
-// export common dynamodb commands to make it easier to use
-ScanCommand, BatchWriteCommand, GetCommand, PutCommand, QueryCommand, UpdateCommand, scanWholeTable, batchCreateRecords, createRecord, getRecordsByKey, getRecordByKey, updateRecordByKey, batchDeleteRecords, deleteRecordsByHashKey, };
+export {
+  updateRecordByKey,
+  scanWholeTable,
+  getRecordsByKey,
+  getRecordByKey,
+  getDocClient,
+  deleteRecordsByHashKey,
+  createRecord,
+  batchDeleteRecords,
+  batchCreateRecords,
+  UpdateCommand,
+  ScanCommand,
+  QueryCommand,
+  PutCommand,
+  GetCommand,
+  BatchWriteCommand
+};