dyno-table 2.3.2 → 2.4.0

package/dist/{chunk-DTFJJASK.js → chunk-GWHGUKAL.js}

@@ -1,16 +1,7 @@
+import { BatchErrors, BatchError, ErrorCodes, ExpressionErrors, ConfigurationErrors, TransactionErrors, ValidationErrors } from './chunk-FF7FYGDH.js';
 import { not, or, and, attributeNotExists, attributeExists, contains, beginsWith, inArray, between, gte, gt, lte, lt, ne, eq } from './chunk-2WIBY7PZ.js';
 
 // src/builders/batch-builder.ts
-var BatchError = class extends Error {
-  operation;
-  cause;
-  constructor(message, operation, cause) {
-    super(message);
-    this.name = "BatchError";
-    this.operation = operation;
-    this.cause = cause;
-  }
-};
 var BatchBuilder = class {
   constructor(batchWriteExecutor, batchGetExecutor, config) {
     this.batchWriteExecutor = batchWriteExecutor;
@@ -45,10 +36,7 @@ var BatchBuilder = class {
    */
   validateNotEmpty() {
     if (this.isEmpty()) {
-      throw new BatchError(
-        "Cannot execute empty batch. Add operations using entity builders with .withBatch()",
-        "write"
-      );
+      throw BatchErrors.batchEmpty("write");
     }
   }
   /**
@@ -139,13 +127,14 @@ var BatchBuilder = class {
             key
           };
         }
-        throw new BatchError(`Unsupported batch item type for write operation: ${item.type}`, "write");
+        throw BatchErrors.unsupportedType("write", item);
       });
       return await this.batchWriteExecutor(operations);
     } catch (error) {
-      throw new BatchError(
-        `Failed to execute batch write operations: ${error instanceof Error ? error.message : "Unknown error"}`,
-        "write",
+      if (error instanceof BatchError) throw error;
+      throw BatchErrors.batchWriteFailed(
+        [],
+        { operationCount: this.writeItems.length },
         error instanceof Error ? error : void 0
       );
     }
@@ -172,13 +161,14 @@ var BatchBuilder = class {
             sk: this.config.sortKey ? tableKey[this.config.sortKey] : void 0
           };
         }
-        throw new BatchError(`Unsupported batch item type for get operation: ${item.type}`, "read");
+        throw BatchErrors.unsupportedType("read", item);
       });
       return await this.batchGetExecutor(keys);
     } catch (error) {
-      throw new BatchError(
-        `Failed to execute batch get operations: ${error instanceof Error ? error.message : "Unknown error"}`,
-        "read",
+      if (error instanceof BatchError) throw error;
+      throw BatchErrors.batchGetFailed(
+        [],
+        { operationCount: this.getItems.length },
         error instanceof Error ? error : void 0
       );
     }
@@ -230,7 +220,10 @@ var BatchBuilder = class {
           errors.push(
             new BatchError(
               "Unexpected error during write operations",
+              ErrorCodes.BATCH_WRITE_FAILED,
               "write",
+              [],
+              {},
               error instanceof Error ? error : void 0
             )
           );
@@ -247,7 +240,10 @@ var BatchBuilder = class {
           errors.push(
             new BatchError(
               "Unexpected error during read operations",
+              ErrorCodes.BATCH_GET_FAILED,
               "read",
+              [],
+              {},
               error instanceof Error ? error : void 0
             )
           );
@@ -314,16 +310,16 @@ var generateValueName = (params, value) => {
 };
 var validateCondition = (condition, requiresAttr = true, requiresValue = true) => {
   if (requiresAttr && !condition.attr) {
-    throw new Error(`Attribute is required for ${condition.type} condition`);
+    throw ExpressionErrors.missingAttribute(condition.type, condition);
   }
   if (requiresValue && condition.value === void 0) {
-    throw new Error(`Value is required for ${condition.type} condition`);
+    throw ExpressionErrors.missingValue(condition.type, condition);
   }
 };
 var buildComparisonExpression = (condition, operator, params) => {
   validateCondition(condition);
   if (!condition.attr) {
-    throw new Error(`Attribute is required for ${condition.type} condition`);
+    throw ExpressionErrors.missingAttribute(condition.type, condition);
   }
   const attrName = generateAttributeName(params, condition.attr);
   const valueName = generateValueName(params, condition.value);
@@ -332,10 +328,14 @@ var buildComparisonExpression = (condition, operator, params) => {
 var buildBetweenExpression = (condition, params) => {
   validateCondition(condition);
   if (!condition.attr) {
-    throw new Error(`Attribute is required for ${condition.type} condition`);
+    throw ExpressionErrors.missingAttribute(condition.type, condition);
   }
   if (!Array.isArray(condition.value) || condition.value.length !== 2) {
-    throw new Error("Between condition requires an array of two values");
+    throw ExpressionErrors.invalidCondition(
+      condition.type,
+      condition,
+      "Provide an array with exactly two values: [lowerBound, upperBound]"
+    );
   }
   const attrName = generateAttributeName(params, condition.attr);
   const lowerName = generateValueName(params, condition.value[0]);
@@ -345,13 +345,17 @@ var buildBetweenExpression = (condition, params) => {
 var buildInExpression = (condition, params) => {
   validateCondition(condition);
   if (!condition.attr) {
-    throw new Error(`Attribute is required for ${condition.type} condition`);
+    throw ExpressionErrors.missingAttribute(condition.type, condition);
   }
   if (!Array.isArray(condition.value) || condition.value.length === 0) {
-    throw new Error("In condition requires a non-empty array of values");
+    throw ExpressionErrors.emptyArray(condition.type, condition.value);
   }
   if (condition.value.length > 100) {
-    throw new Error("In condition supports a maximum of 100 values");
+    throw ExpressionErrors.invalidCondition(
+      condition.type,
+      condition,
+      "Split your query into multiple operations or use a different condition type"
+    );
   }
   const attrName = generateAttributeName(params, condition.attr);
   const valueNames = condition.value.map((value) => generateValueName(params, value));
@@ -360,7 +364,7 @@ var buildInExpression = (condition, params) => {
 var buildFunctionExpression = (functionName, condition, params) => {
   validateCondition(condition);
   if (!condition.attr) {
-    throw new Error(`Attribute is required for ${condition.type} condition`);
+    throw ExpressionErrors.missingAttribute(condition.type, condition);
   }
   const attrName = generateAttributeName(params, condition.attr);
   const valueName = generateValueName(params, condition.value);
@@ -369,66 +373,65 @@ var buildFunctionExpression = (functionName, condition, params) => {
 var buildAttributeFunction = (functionName, condition, params) => {
   validateCondition(condition, true, false);
   if (!condition.attr) {
-    throw new Error(`Attribute is required for ${condition.type} condition`);
+    throw ExpressionErrors.missingAttribute(condition.type, condition);
   }
   const attrName = generateAttributeName(params, condition.attr);
   return `${functionName}(${attrName})`;
 };
 var buildLogicalExpression = (operator, conditions, params) => {
   if (!conditions || conditions.length === 0) {
-    throw new Error(`At least one condition is required for ${operator} expression`);
+    throw ExpressionErrors.emptyArray(operator, conditions);
   }
   const expressions = conditions.map((c) => buildExpression(c, params));
   return `(${expressions.join(` ${operator} `)})`;
 };
 var buildExpression = (condition, params) => {
   if (!condition) return "";
-  try {
-    const expressionBuilders = {
-      eq: () => buildComparisonExpression(condition, "=", params),
-      ne: () => buildComparisonExpression(condition, "<>", params),
-      lt: () => buildComparisonExpression(condition, "<", params),
-      lte: () => buildComparisonExpression(condition, "<=", params),
-      gt: () => buildComparisonExpression(condition, ">", params),
-      gte: () => buildComparisonExpression(condition, ">=", params),
-      between: () => buildBetweenExpression(condition, params),
-      in: () => buildInExpression(condition, params),
-      beginsWith: () => buildFunctionExpression("begins_with", condition, params),
-      contains: () => buildFunctionExpression("contains", condition, params),
-      attributeExists: () => buildAttributeFunction("attribute_exists", condition, params),
-      attributeNotExists: () => buildAttributeFunction("attribute_not_exists", condition, params),
-      and: () => {
-        if (!condition.conditions) {
-          throw new Error("Conditions array is required for AND operator");
-        }
-        return buildLogicalExpression("AND", condition.conditions, params);
-      },
-      or: () => {
-        if (!condition.conditions) {
-          throw new Error("Conditions array is required for OR operator");
-        }
-        return buildLogicalExpression("OR", condition.conditions, params);
-      },
-      not: () => {
-        if (!condition.condition) {
-          throw new Error("Condition is required for NOT operator");
-        }
-        return `NOT (${buildExpression(condition.condition, params)})`;
+  const expressionBuilders = {
+    eq: () => buildComparisonExpression(condition, "=", params),
+    ne: () => buildComparisonExpression(condition, "<>", params),
+    lt: () => buildComparisonExpression(condition, "<", params),
+    lte: () => buildComparisonExpression(condition, "<=", params),
+    gt: () => buildComparisonExpression(condition, ">", params),
+    gte: () => buildComparisonExpression(condition, ">=", params),
+    between: () => buildBetweenExpression(condition, params),
+    in: () => buildInExpression(condition, params),
+    beginsWith: () => buildFunctionExpression("begins_with", condition, params),
+    contains: () => buildFunctionExpression("contains", condition, params),
+    attributeExists: () => buildAttributeFunction("attribute_exists", condition, params),
+    attributeNotExists: () => buildAttributeFunction("attribute_not_exists", condition, params),
+    and: () => {
+      if (!condition.conditions) {
+        throw ExpressionErrors.invalidCondition(
+          condition.type,
+          condition,
+          "Provide an array of conditions to combine with AND"
+        );
       }
-    };
-    const builder = expressionBuilders[condition.type];
-    if (!builder) {
-      throw new Error(`Unknown condition type: ${condition.type}`);
-    }
-    return builder();
-  } catch (error) {
-    if (error instanceof Error) {
-      console.error(`Error building expression for condition type ${condition.type}:`, error.message);
-    } else {
-      console.error(`Error building expression for condition type ${condition.type}:`, error);
+      return buildLogicalExpression("AND", condition.conditions, params);
+    },
+    or: () => {
+      if (!condition.conditions) {
+        throw ExpressionErrors.invalidCondition(
+          condition.type,
+          condition,
+          "Provide an array of conditions to combine with OR"
+        );
+      }
+      return buildLogicalExpression("OR", condition.conditions, params);
+    },
+    not: () => {
+      if (!condition.condition) {
+        throw ExpressionErrors.invalidCondition(condition.type, condition, "Provide a condition to negate with NOT");
+      }
+      return `NOT (${buildExpression(condition.condition, params)})`;
     }
-    throw error;
+  };
+  const builder = expressionBuilders[condition.type];
+  if (!builder) {
+    throw ExpressionErrors.unknownType(condition.type, condition);
   }
+  return builder();
 };
 var prepareExpressionParams = (condition) => {
   if (!condition) return {};
@@ -1755,7 +1758,7 @@ var TransactionBuilder = class {
     const pkValue = newItem[pkName];
     const skValue = skName ? newItem[skName] : void 0;
     if (!pkValue) {
-      throw new Error(`Primary key value for '${pkName}' is missing`);
+      throw ConfigurationErrors.primaryKeyMissing(tableName, pkName, newItem);
     }
     const duplicateItem = this.items.find((item) => {
       let itemKey;
@@ -1787,8 +1790,10 @@ var TransactionBuilder = class {
       return false;
     });
     if (duplicateItem) {
-      throw new Error(
-        `Duplicate item detected in transaction: Table=${tableName}, ${pkName}=${String(pkValue)}, ${skName}=${skValue !== void 0 ? String(skValue) : "undefined"}. DynamoDB transactions do not allow multiple operations on the same item.`
+      throw TransactionErrors.duplicateItem(
+        tableName,
+        { name: pkName, value: pkValue },
+        skName ? { name: skName, value: skValue } : void 0
       );
     }
   }
@@ -1798,7 +1803,7 @@ var TransactionBuilder = class {
     };
     if (this.indexConfig.sortKey) {
       if (key.sk === void 0) {
-        throw new Error("Sort key is required for delete operation");
+        throw ConfigurationErrors.sortKeyRequired("", this.indexConfig.partitionKey, this.indexConfig.sortKey);
       }
       keyCondition[this.indexConfig.sortKey] = key.sk;
     }
@@ -2172,7 +2177,7 @@ var TransactionBuilder = class {
     this.checkForDuplicateItem(tableName, keyCondition);
     const { expression, names, values } = prepareExpressionParams(condition);
     if (!expression) {
-      throw new Error("Failed to generate condition expression");
+      throw ConfigurationErrors.conditionGenerationFailed(condition);
     }
     const transactionItem = {
       type: "ConditionCheck",
@@ -2326,7 +2331,7 @@ var TransactionBuilder = class {
    */
   async execute() {
     if (this.items.length === 0) {
-      throw new Error("No transaction items specified");
+      throw TransactionErrors.transactionEmpty();
     }
     const transactItems = this.items.map((item) => {
       switch (item.type) {
@@ -2373,7 +2378,7 @@ var TransactionBuilder = class {
           };
         default: {
           const exhaustiveCheck = item;
-          throw new Error(`Unsupported transaction item type: ${String(exhaustiveCheck)}`);
+          throw TransactionErrors.unsupportedType(exhaustiveCheck);
         }
       }
     });
@@ -2386,9 +2391,7 @@ var TransactionBuilder = class {
     try {
       await this.executor(params);
     } catch (error) {
-      console.log(this.debug());
-      console.error("Error executing transaction:", error);
-      throw error;
+      throw TransactionErrors.transactionFailed(this.items.length, {}, error instanceof Error ? error : void 0);
     }
   }
 };
@@ -2410,6 +2413,9 @@ var UpdateBuilder = class {
   set(valuesOrPath, value) {
     if (typeof valuesOrPath === "object") {
       for (const [key, value2] of Object.entries(valuesOrPath)) {
+        if (value2 === void 0) {
+          throw ValidationErrors.undefinedValue(key, this.tableName, this.key);
+        }
         this.updates.push({
           type: "SET",
           path: key,
@@ -2417,6 +2423,9 @@ var UpdateBuilder = class {
         });
       }
     } else {
+      if (value === void 0) {
+        throw ValidationErrors.undefinedValue(valuesOrPath, this.tableName, this.key);
+      }
       this.updates.push({
         type: "SET",
         path: valuesOrPath,
@@ -2472,6 +2481,9 @@ var UpdateBuilder = class {
    * @returns The builder instance for method chaining
    */
   add(path, value) {
+    if (value === void 0) {
+      throw ValidationErrors.undefinedValue(path, this.tableName, this.key);
+    }
     this.updates.push({
       type: "ADD",
       path,
@@ -2508,6 +2520,9 @@ var UpdateBuilder = class {
    * @returns The builder instance for method chaining
    */
   deleteElementsFromSet(path, value) {
+    if (value === void 0) {
+      throw ValidationErrors.undefinedValue(path, this.tableName, this.key);
+    }
     let valuesToDelete;
     if (Array.isArray(value)) {
       valuesToDelete = new Set(value);
@@ -2626,7 +2641,7 @@ var UpdateBuilder = class {
    */
   toDynamoCommand() {
     if (this.updates.length === 0) {
-      throw new Error("No update actions specified");
+      throw ValidationErrors.noUpdateActions(this.tableName, this.key);
     }
     const expressionParams = {
       expressionAttributeNames: {},
@@ -2900,11 +2915,11 @@ var ConditionCheckBuilder = class {
    */
   toDynamoCommand() {
     if (!this.conditionExpression) {
-      throw new Error("Condition is required for condition check operations");
+      throw ValidationErrors.conditionRequired(this.tableName, this.key);
     }
     const { expression, names, values } = prepareExpressionParams(this.conditionExpression);
     if (!expression) {
-      throw new Error("Failed to generate condition expression");
+      throw ConfigurationErrors.conditionGenerationFailed(this.conditionExpression);
     }
     return {
       tableName: this.tableName,
@@ -2936,7 +2951,7 @@ var ConditionCheckBuilder = class {
    */
   withTransaction(transaction) {
     if (!this.conditionExpression) {
-      throw new Error("Condition is required for condition check operations");
+      throw ValidationErrors.conditionRequired(this.tableName, this.key);
     }
     const command = this.toDynamoCommand();
     transaction.conditionCheckWithCommand(command);
@@ -3197,4 +3212,4 @@ var ScanBuilder = class _ScanBuilder extends FilterBuilder {
   }
 };
 
-export { BatchBuilder, BatchError, ConditionCheckBuilder, DeleteBuilder, FilterBuilder, GetBuilder, Paginator, PutBuilder, QueryBuilder, ResultIterator, ScanBuilder, TransactionBuilder, UpdateBuilder, buildExpression, debugCommand, generateAttributeName };
+export { BatchBuilder, ConditionCheckBuilder, DeleteBuilder, FilterBuilder, GetBuilder, Paginator, PutBuilder, QueryBuilder, ResultIterator, ScanBuilder, TransactionBuilder, UpdateBuilder, buildExpression, generateAttributeName };

package/dist/{chunk-KA3VPIPS.cjs → chunk-OLURZQ7R.cjs}

@@ -1,12 +1,13 @@
 'use strict';
 
-var chunkXYL43FDX_cjs = require('./chunk-XYL43FDX.cjs');
+var chunkAHF4H42Q_cjs = require('./chunk-AHF4H42Q.cjs');
+var chunkELULXDSB_cjs = require('./chunk-ELULXDSB.cjs');
 var chunk7UJJ7JXM_cjs = require('./chunk-7UJJ7JXM.cjs');
 
 // src/utils/chunk-array.ts
 function* chunkArray(array, size) {
   if (size <= 0) {
-    throw new Error("Chunk size must be greater than 0");
+    throw chunkELULXDSB_cjs.ConfigurationErrors.invalidChunkSize(size);
   }
   for (let i = 0; i < array.length; i += size) {
     yield array.slice(i, i + size);
@@ -42,7 +43,7 @@ var Table = class {
     const primaryCondition = { [this.partitionKey]: keyCondition.pk };
     if (this.sortKey) {
       if (!keyCondition.sk) {
-        throw new Error("Sort key has not been provided but the Table has a sort key");
+        throw chunkELULXDSB_cjs.ConfigurationErrors.sortKeyRequired(this.tableName, this.partitionKey, this.sortKey);
       }
       primaryCondition[this.sortKey] = keyCondition.sk;
     }
@@ -96,11 +97,10 @@ var Table = class {
           item: result.Item ? result.Item : void 0
         };
       } catch (error) {
-        console.error("Error getting item:", error);
-        throw error;
+        throw chunkELULXDSB_cjs.OperationErrors.getFailed(params.tableName, keyCondition, error instanceof Error ? error : void 0);
       }
     };
-    return new chunkXYL43FDX_cjs.GetBuilder(executor, keyCondition, this.tableName);
+    return new chunkAHF4H42Q_cjs.GetBuilder(executor, keyCondition, this.tableName);
   }
   /**
    * Updates an item in the table
@@ -137,11 +137,10 @@ var Table = class {
         }
         return result.Attributes;
       } catch (error) {
-        console.error("Error creating item:", error);
-        throw error;
+        throw chunkELULXDSB_cjs.OperationErrors.putFailed(params.tableName, params.item, error instanceof Error ? error : void 0);
       }
     };
-    return new chunkXYL43FDX_cjs.PutBuilder(executor, item, this.tableName);
+    return new chunkAHF4H42Q_cjs.PutBuilder(executor, item, this.tableName);
   }
   /**
    * Creates a query builder for complex queries
@@ -153,7 +152,7 @@ var Table = class {
     let keyConditionExpression = chunk7UJJ7JXM_cjs.eq(pkAttributeName, keyCondition.pk);
     if (keyCondition.sk) {
       if (!skAttributeName) {
-        throw new Error("Sort key is not defined for Index");
+        throw chunkELULXDSB_cjs.ConfigurationErrors.sortKeyNotDefined(this.tableName, pkAttributeName);
       }
       const keyConditionOperator = {
         eq: (value) => chunk7UJJ7JXM_cjs.eq(skAttributeName, value),
@@ -174,7 +173,7 @@ var Table = class {
         const gsiName = String(options.indexName);
         const gsi = this.gsis[gsiName];
         if (!gsi) {
-          throw new Error(`GSI with name "${gsiName}" does not exist on table "${this.tableName}"`);
+          throw chunkELULXDSB_cjs.ConfigurationErrors.gsiNotFound(gsiName, this.tableName, Object.keys(this.gsis));
         }
         const gsiPkAttributeName = gsi.partitionKey;
         const gsiSkAttributeName = gsi.sortKey;
@@ -203,7 +202,7 @@ var Table = class {
           }
         }
         if (!pkValue) {
-          throw new Error("Could not extract partition key value from key condition");
+          throw chunkELULXDSB_cjs.ConfigurationErrors.pkExtractionFailed(this.tableName, options.indexName, originalKeyCondition);
         }
         let gsiKeyCondition = chunk7UJJ7JXM_cjs.eq(gsiPkAttributeName, pkValue);
         if (skValue && gsiSkAttributeName) {
@@ -226,12 +225,12 @@ var Table = class {
         expressionAttributeValues: {},
         valueCounter: { count: 0 }
       };
-      const keyConditionExpression2 = chunkXYL43FDX_cjs.buildExpression(finalKeyCondition, expressionParams);
+      const keyConditionExpression2 = chunkAHF4H42Q_cjs.buildExpression(finalKeyCondition, expressionParams);
       let filterExpression;
       if (options.filter) {
-        filterExpression = chunkXYL43FDX_cjs.buildExpression(options.filter, expressionParams);
+        filterExpression = chunkAHF4H42Q_cjs.buildExpression(options.filter, expressionParams);
       }
-      const projectionExpression = options.projection?.map((p) => chunkXYL43FDX_cjs.generateAttributeName(expressionParams, p)).join(", ");
+      const projectionExpression = options.projection?.map((p) => chunkAHF4H42Q_cjs.generateAttributeName(expressionParams, p)).join(", ");
       const { expressionAttributeNames, expressionAttributeValues } = expressionParams;
       const { indexName, limit, consistentRead, scanIndexForward, lastEvaluatedKey } = options;
       const params = {
@@ -254,12 +253,14 @@ var Table = class {
           lastEvaluatedKey: result.LastEvaluatedKey
         };
       } catch (error) {
-        console.log(chunkXYL43FDX_cjs.debugCommand(params));
-        console.error("Error querying items:", error);
-        throw error;
+        throw chunkELULXDSB_cjs.OperationErrors.queryFailed(
+          this.tableName,
+          { indexName, keyConditionExpression: keyConditionExpression2, filterExpression },
+          error instanceof Error ? error : void 0
+        );
       }
     };
-    return new chunkXYL43FDX_cjs.QueryBuilder(executor, keyConditionExpression);
+    return new chunkAHF4H42Q_cjs.QueryBuilder(executor, keyConditionExpression);
   }
   /**
    * Creates a scan builder for scanning the entire table
@@ -279,9 +280,9 @@ var Table = class {
       };
       let filterExpression;
       if (options.filter) {
-        filterExpression = chunkXYL43FDX_cjs.buildExpression(options.filter, expressionParams);
+        filterExpression = chunkAHF4H42Q_cjs.buildExpression(options.filter, expressionParams);
       }
-      const projectionExpression = options.projection?.map((p) => chunkXYL43FDX_cjs.generateAttributeName(expressionParams, p)).join(", ");
+      const projectionExpression = options.projection?.map((p) => chunkAHF4H42Q_cjs.generateAttributeName(expressionParams, p)).join(", ");
       const { expressionAttributeNames, expressionAttributeValues } = expressionParams;
       const { indexName, limit, consistentRead, lastEvaluatedKey } = options;
       const params = {
@@ -302,12 +303,14 @@ var Table = class {
           lastEvaluatedKey: result.LastEvaluatedKey
         };
       } catch (error) {
-        console.log(chunkXYL43FDX_cjs.debugCommand(params));
-        console.error("Error scanning items:", error);
-        throw error;
+        throw chunkELULXDSB_cjs.OperationErrors.scanFailed(
+          this.tableName,
+          { indexName: options.indexName, filterExpression },
+          error instanceof Error ? error : void 0
+        );
       }
     };
-    return new chunkXYL43FDX_cjs.ScanBuilder(executor);
+    return new chunkAHF4H42Q_cjs.ScanBuilder(executor);
   }
   delete(keyCondition) {
     const executor = async (params) => {
@@ -324,11 +327,10 @@ var Table = class {
           item: result.Attributes
         };
       } catch (error) {
-        console.error("Error deleting item:", error);
-        throw error;
+        throw chunkELULXDSB_cjs.OperationErrors.deleteFailed(params.tableName, keyCondition, error instanceof Error ? error : void 0);
       }
     };
-    return new chunkXYL43FDX_cjs.DeleteBuilder(executor, this.tableName, keyCondition);
+    return new chunkAHF4H42Q_cjs.DeleteBuilder(executor, this.tableName, keyCondition);
   }
   /**
    * Updates an item in the table
@@ -352,11 +354,10 @@ var Table = class {
           item: result.Attributes
         };
       } catch (error) {
-        console.error("Error updating item:", error);
-        throw error;
+        throw chunkELULXDSB_cjs.OperationErrors.updateFailed(params.tableName, keyCondition, error instanceof Error ? error : void 0);
       }
     };
-    return new chunkXYL43FDX_cjs.UpdateBuilder(executor, this.tableName, keyCondition);
+    return new chunkAHF4H42Q_cjs.UpdateBuilder(executor, this.tableName, keyCondition);
   }
   /**
    * Creates a transaction builder for performing multiple operations atomically
@@ -365,7 +366,7 @@ var Table = class {
     const executor = async (params) => {
       await this.dynamoClient.transactWrite(params);
     };
-    return new chunkXYL43FDX_cjs.TransactionBuilder(executor, {
+    return new chunkAHF4H42Q_cjs.TransactionBuilder(executor, {
       partitionKey: this.partitionKey,
       sortKey: this.sortKey
     });
@@ -412,7 +413,7 @@ var Table = class {
     const batchGetExecutor = async (keys) => {
       return this.batchGet(keys);
     };
-    return new chunkXYL43FDX_cjs.BatchBuilder(batchWriteExecutor, batchGetExecutor, {
+    return new chunkAHF4H42Q_cjs.BatchBuilder(batchWriteExecutor, batchGetExecutor, {
       partitionKey: this.partitionKey,
       sortKey: this.sortKey
     });
@@ -428,7 +429,7 @@ var Table = class {
     const transactionExecutor = async (params) => {
       await this.dynamoClient.transactWrite(params);
     };
-    const transaction = new chunkXYL43FDX_cjs.TransactionBuilder(transactionExecutor, {
+    const transaction = new chunkAHF4H42Q_cjs.TransactionBuilder(transactionExecutor, {
       partitionKey: this.partitionKey,
       sortKey: this.sortKey
     });
@@ -448,7 +449,7 @@ var Table = class {
    * For example, you are updating a record and you want to ensure that another record exists and/or has a specific value before proceeding.
    */
   conditionCheck(keyCondition) {
-    return new chunkXYL43FDX_cjs.ConditionCheckBuilder(this.tableName, keyCondition);
+    return new chunkAHF4H42Q_cjs.ConditionCheckBuilder(this.tableName, keyCondition);
   }
   /**
    * Performs a batch get operation to retrieve multiple items at once
@@ -485,8 +486,11 @@ var Table = class {
           allUnprocessedKeys.push(...unprocessedKeys);
         }
       } catch (error) {
-        console.error("Error in batch get operation:", error);
-        throw error;
+        throw chunkELULXDSB_cjs.OperationErrors.batchGetFailed(
+          this.tableName,
+          { requestedKeys: keys.length },
+          error instanceof Error ? error : void 0
+        );
       }
     }
     return {
@@ -547,8 +551,11 @@ var Table = class {
           allUnprocessedItems.push(...unprocessedItems);
         }
       } catch (error) {
-        console.error("Error in batch write operation:", error);
-        throw error;
+        throw chunkELULXDSB_cjs.OperationErrors.batchWriteFailed(
+          this.tableName,
+          { requestedOperations: operations.length },
+          error instanceof Error ? error : void 0
+        );
       }
     }
     return {