dyno-table 2.3.3 → 2.5.0

package/dist/{chunk-M5Y6JQJN.js → chunk-U6MQGB6Y.js}

@@ -1,3 +1,4 @@
+import { EntityErrors, OperationErrors, DynoTableError, ValidationErrors, IndexErrors, ConfigurationErrors } from './chunk-FF7FYGDH.js';
 import { eq } from './chunk-2WIBY7PZ.js';
 
 // src/builders/entity-aware-builders.ts
@@ -112,9 +113,6 @@ var EntityAwareUpdateBuilder = class {
     if (typeof valuesOrPath === "object") {
       this.builder.set(valuesOrPath);
     } else {
-      if (value === void 0) {
-        throw new Error("Value is required when setting a single path");
-      }
       this.builder.set(valuesOrPath, value);
     }
     return this;
@@ -159,6 +157,136 @@ function createEntityAwareUpdateBuilder(builder, entityName) {
   return new EntityAwareUpdateBuilder(builder, entityName);
 }
 
+// src/utils/error-utils.ts
+function isConditionalCheckFailed(error) {
+  if (typeof error === "object" && error !== null && "name" in error) {
+    return error.name === "ConditionalCheckFailedException";
+  }
+  return false;
+}
+function isTransactionCanceled(error) {
+  if (typeof error === "object" && error !== null && "name" in error) {
+    return error.name === "TransactionCanceledException";
+  }
+  return false;
+}
+function isValidationException(error) {
+  if (typeof error === "object" && error !== null && "name" in error) {
+    return error.name === "ValidationException";
+  }
+  return false;
+}
+function isProvisionedThroughputExceeded(error) {
+  if (typeof error === "object" && error !== null && "name" in error) {
+    return error.name === "ProvisionedThroughputExceededException";
+  }
+  return false;
+}
+function isRetryableError(error) {
+  if (typeof error === "object" && error !== null && "name" in error) {
+    const errorName = error.name;
+    return errorName === "ProvisionedThroughputExceededException" || errorName === "ThrottlingException" || errorName === "RequestLimitExceeded" || errorName === "InternalServerError" || errorName === "ServiceUnavailable";
+  }
+  return false;
+}
+function getAwsErrorCode(error) {
+  if (typeof error === "object" && error !== null && "name" in error) {
+    return error.name;
+  }
+  return void 0;
+}
+function getAwsErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (typeof error === "object" && error !== null && "message" in error) {
+    return String(error.message);
+  }
+  return void 0;
+}
+function extractRequiredAttributes(error) {
+  const message = getAwsErrorMessage(error);
+  if (!message) return void 0;
+  const patterns = [
+    /(?:missing|required)\s+(?:attribute|field|property)(?:s)?[:\s]+([a-zA-Z0-9_,\s]+)/i,
+    /(?:attribute|field|property)[:\s]+([a-zA-Z0-9_]+)\s+is\s+(?:missing|required)/i,
+    /"([a-zA-Z0-9_]+)"\s+is\s+(?:missing|required)/i
+  ];
+  for (const pattern of patterns) {
+    const match = message.match(pattern);
+    if (match?.[1]) {
+      return match[1].split(",").map((attr) => attr.trim()).filter((attr) => attr.length > 0);
+    }
+  }
+  return void 0;
+}
+function formatErrorContext(context, indent = 0) {
+  const indentStr = "  ".repeat(indent);
+  const lines = [];
+  for (const [key, value] of Object.entries(context)) {
+    if (value === void 0 || value === null) {
+      lines.push(`${indentStr}${key}: ${value}`);
+    } else if (Array.isArray(value)) {
+      lines.push(`${indentStr}${key}: [${value.map((v) => JSON.stringify(v)).join(", ")}]`);
+    } else if (typeof value === "object") {
+      lines.push(`${indentStr}${key}:`);
+      lines.push(formatErrorContext(value, indent + 1));
+    } else if (typeof value === "string" && value.length > 100) {
+      lines.push(`${indentStr}${key}: ${value.substring(0, 100)}...`);
+    } else {
+      lines.push(`${indentStr}${key}: ${JSON.stringify(value)}`);
+    }
+  }
+  return lines.join("\n");
+}
+function getErrorSummary(error) {
+  const parts = [];
+  parts.push(`Error: ${error.name}`);
+  parts.push(`Code: ${error.code}`);
+  parts.push(`Message: ${error.message}`);
+  if (Object.keys(error.context).length > 0) {
+    parts.push("Context:");
+    parts.push(formatErrorContext(error.context, 1));
+  }
+  if (error.cause) {
+    parts.push(`Caused by: ${error.cause.name}: ${error.cause.message}`);
+  }
+  return parts.join("\n");
+}
+function isDynoTableError(error) {
+  return typeof error === "object" && error !== null && "code" in error && "context" in error && error instanceof Error;
+}
+function isValidationError(error) {
+  return error instanceof Error && error.name === "ValidationError";
+}
+function isOperationError(error) {
+  return error instanceof Error && error.name === "OperationError";
+}
+function isTransactionError(error) {
+  return error instanceof Error && error.name === "TransactionError";
+}
+function isBatchError(error) {
+  return error instanceof Error && error.name === "BatchError";
+}
+function isExpressionError(error) {
+  return error instanceof Error && error.name === "ExpressionError";
+}
+function isConfigurationError(error) {
+  return error instanceof Error && error.name === "ConfigurationError";
+}
+function isEntityError(error) {
+  return error instanceof Error && error.name === "EntityError";
+}
+function isKeyGenerationError(error) {
+  return error instanceof Error && error.name === "KeyGenerationError";
+}
+function isIndexGenerationError(error) {
+  return error instanceof Error && error.name === "IndexGenerationError";
+}
+function isEntityValidationError(error) {
+  return error instanceof Error && error.name === "EntityValidationError";
+}
+
 // src/entity/ddb-indexing.ts
 var IndexBuilder = class {
   /**
@@ -184,10 +312,26 @@ var IndexBuilder = class {
       if (options.excludeReadOnly && indexDef.isReadOnly) {
         continue;
       }
-      const key = indexDef.generateKey(item);
+      let key;
+      try {
+        key = indexDef.generateKey(item);
+        if (this.hasUndefinedValues(key)) {
+          throw IndexErrors.undefinedValues(indexName, "create", key, item);
+        }
+      } catch (error) {
+        if (error instanceof DynoTableError) throw error;
+        throw IndexErrors.generationFailed(
+          indexName,
+          "create",
+          item,
+          indexDef.partitionKey,
+          indexDef.sortKey,
+          error instanceof Error ? error : void 0
+        );
+      }
       const gsiConfig = this.table.gsis[indexName];
       if (!gsiConfig) {
-        throw new Error(`GSI configuration not found for index: ${indexName}`);
+        throw ConfigurationErrors.gsiNotFound(indexName, this.table.tableName, Object.keys(this.table.gsis));
       }
       if (key.pk) {
         attributes[gsiConfig.partitionKey] = key.pk;
@@ -212,9 +356,7 @@ var IndexBuilder = class {
     if (options.forceRebuildIndexes && options.forceRebuildIndexes.length > 0) {
       const invalidIndexes = options.forceRebuildIndexes.filter((indexName) => !this.indexes[indexName]);
       if (invalidIndexes.length > 0) {
-        throw new Error(
-          `Cannot force rebuild unknown indexes: ${invalidIndexes.join(", ")}. Available indexes: ${Object.keys(this.indexes).join(", ")}`
-        );
+        throw IndexErrors.notFound(invalidIndexes, Object.keys(this.indexes), void 0, this.table.tableName);
       }
     }
     for (const [indexName, indexDef] of Object.entries(this.indexes)) {
@@ -241,19 +383,22 @@ var IndexBuilder = class {
       try {
         key = indexDef.generateKey(updatedItem);
       } catch (error) {
-        if (error instanceof Error) {
-          throw new Error(`Missing attributes: ${error.message}`);
-        }
-        throw error;
+        if (error instanceof DynoTableError) throw error;
+        throw IndexErrors.missingAttributes(
+          indexName,
+          "update",
+          [],
+          // We don't know which specific attributes are missing from the error
+          updates,
+          indexDef.isReadOnly
+        );
       }
       if (this.hasUndefinedValues(key)) {
-        throw new Error(
-          `Missing attributes: Cannot update entity: insufficient data to regenerate index "${indexName}". All attributes required by the index must be provided in the update operation, or the index must be marked as readOnly.`
-        );
+        throw IndexErrors.undefinedValues(indexName, "update", key, updates);
       }
       const gsiConfig = this.table.gsis[indexName];
       if (!gsiConfig) {
-        throw new Error(`GSI configuration not found for index: ${indexName}`);
+        throw ConfigurationErrors.gsiNotFound(indexName, this.table.tableName, Object.keys(this.table.gsis));
       }
       if (key.pk) {
         attributes[gsiConfig.partitionKey] = key.pk;
@@ -340,13 +485,28 @@ function defineEntity(config) {
           const prepareValidatedItemAsync = async () => {
             const validatedData = await config.schema["~standard"].validate(data);
             if ("issues" in validatedData && validatedData.issues) {
-              throw new Error(`Validation failed: ${validatedData.issues.map((i) => i.message).join(", ")}`);
+              throw EntityErrors.validationFailed(config.name, "create", validatedData.issues, data);
             }
             const dataForKeyGeneration = {
               ...validatedData.value,
               ...generateTimestamps(["createdAt", "updatedAt"], validatedData.value)
             };
-            const primaryKey = config.primaryKey.generateKey(dataForKeyGeneration);
+            let primaryKey;
+            try {
+              primaryKey = config.primaryKey.generateKey(dataForKeyGeneration);
+              if (primaryKey.pk === void 0 || primaryKey.pk === null) {
+                throw EntityErrors.keyInvalidFormat(config.name, "create", dataForKeyGeneration, primaryKey);
+              }
+            } catch (error) {
+              if (error instanceof DynoTableError) throw error;
+              throw EntityErrors.keyGenerationFailed(
+                config.name,
+                "create",
+                dataForKeyGeneration,
+                extractRequiredAttributes(error),
+                error instanceof Error ? error : void 0
+              );
+            }
             const indexes = buildIndexes(dataForKeyGeneration, table, config.indexes, false);
             const validatedItem = {
               ...dataForKeyGeneration,
@@ -361,18 +521,31 @@ function defineEntity(config) {
           const prepareValidatedItemSync = () => {
             const validationResult = config.schema["~standard"].validate(data);
             if (validationResult instanceof Promise) {
-              throw new Error(
-                "Async validation is not supported in withBatch or withTransaction. The schema must support synchronous validation for compatibility."
-              );
+              throw EntityErrors.asyncValidationNotSupported(config.name, "create");
             }
             if ("issues" in validationResult && validationResult.issues) {
-              throw new Error(`Validation failed: ${validationResult.issues.map((i) => i.message).join(", ")}`);
+              throw EntityErrors.validationFailed(config.name, "create", validationResult.issues, data);
             }
             const dataForKeyGeneration = {
               ...validationResult.value,
               ...generateTimestamps(["createdAt", "updatedAt"], validationResult.value)
             };
-            const primaryKey = config.primaryKey.generateKey(dataForKeyGeneration);
+            let primaryKey;
+            try {
+              primaryKey = config.primaryKey.generateKey(dataForKeyGeneration);
+              if (primaryKey.pk === void 0 || primaryKey.pk === null) {
+                throw EntityErrors.keyInvalidFormat(config.name, "create", dataForKeyGeneration, primaryKey);
+              }
+            } catch (error) {
+              if (error instanceof DynoTableError) throw error;
+              throw EntityErrors.keyGenerationFailed(
+                config.name,
+                "create",
+                dataForKeyGeneration,
+                extractRequiredAttributes(error),
+                error instanceof Error ? error : void 0
+              );
+            }
             const indexes = buildIndexes(dataForKeyGeneration, table, config.indexes, false);
             const validatedItem = {
               ...dataForKeyGeneration,
@@ -408,13 +581,28 @@ function defineEntity(config) {
           const prepareValidatedItemAsync = async () => {
             const validatedData = await config.schema["~standard"].validate(data);
             if ("issues" in validatedData && validatedData.issues) {
-              throw new Error(`Validation failed: ${validatedData.issues.map((i) => i.message).join(", ")}`);
+              throw EntityErrors.validationFailed(config.name, "upsert", validatedData.issues, data);
             }
             const dataForKeyGeneration = {
               ...validatedData.value,
               ...generateTimestamps(["createdAt", "updatedAt"], validatedData.value)
             };
-            const primaryKey = config.primaryKey.generateKey(dataForKeyGeneration);
+            let primaryKey;
+            try {
+              primaryKey = config.primaryKey.generateKey(dataForKeyGeneration);
+              if (primaryKey.pk === void 0 || primaryKey.pk === null) {
+                throw EntityErrors.keyInvalidFormat(config.name, "upsert", dataForKeyGeneration, primaryKey);
+              }
+            } catch (error) {
+              if (error instanceof DynoTableError) throw error;
+              throw EntityErrors.keyGenerationFailed(
+                config.name,
+                "upsert",
+                dataForKeyGeneration,
+                extractRequiredAttributes(error),
+                error instanceof Error ? error : void 0
+              );
+            }
             const indexes = buildIndexes2(dataForKeyGeneration, table, false);
             const validatedItem = {
               [table.partitionKey]: primaryKey.pk,
@@ -429,18 +617,31 @@ function defineEntity(config) {
           const prepareValidatedItemSync = () => {
             const validationResult = config.schema["~standard"].validate(data);
             if (validationResult instanceof Promise) {
-              throw new Error(
-                "Async validation is not supported in withTransaction or withBatch. Use execute() instead."
-              );
+              throw EntityErrors.asyncValidationNotSupported(config.name, "upsert");
             }
             if ("issues" in validationResult && validationResult.issues) {
-              throw new Error(`Validation failed: ${validationResult.issues.map((i) => i.message).join(", ")}`);
+              throw EntityErrors.validationFailed(config.name, "upsert", validationResult.issues, data);
             }
             const dataForKeyGeneration = {
               ...validationResult.value,
               ...generateTimestamps(["createdAt", "updatedAt"], validationResult.value)
             };
-            const primaryKey = config.primaryKey.generateKey(dataForKeyGeneration);
+            let primaryKey;
+            try {
+              primaryKey = config.primaryKey.generateKey(dataForKeyGeneration);
+              if (primaryKey.pk === void 0 || primaryKey.pk === null) {
+                throw EntityErrors.keyInvalidFormat(config.name, "upsert", dataForKeyGeneration, primaryKey);
+              }
+            } catch (error) {
+              if (error instanceof DynoTableError) throw error;
+              throw EntityErrors.keyGenerationFailed(
+                config.name,
+                "upsert",
+                dataForKeyGeneration,
+                extractRequiredAttributes(error),
+                error instanceof Error ? error : void 0
+              );
+            }
             const indexes = buildIndexes(dataForKeyGeneration, table, config.indexes, false);
             const validatedItem = {
               [table.partitionKey]: primaryKey.pk,
@@ -457,7 +658,7 @@ function defineEntity(config) {
             await prepareValidatedItemAsync();
             const result = await originalExecute.call(builder);
             if (!result) {
-              throw new Error("Failed to upsert item");
+              throw OperationErrors.putFailed(config.name, {}, void 0);
             }
             return result;
           };
@@ -476,7 +677,8 @@ function defineEntity(config) {
           return createEntityAwarePutBuilder(builder, config.name);
         },
         get: (key) => {
-          return createEntityAwareGetBuilder(table.get(config.primaryKey.generateKey(key)), config.name);
+          const builder = table.get(config.primaryKey.generateKey(key));
+          return createEntityAwareGetBuilder(builder, config.name);
         },
         update: (key, data) => {
           const primaryKeyObj = config.primaryKey.generateKey(key);
@@ -522,15 +724,13 @@ function defineEntity(config) {
                     if (schema?.["~standard"]?.validate && typeof schema["~standard"].validate === "function") {
                       const validationResult = schema["~standard"].validate(input);
                       if ("issues" in validationResult && validationResult.issues) {
-                        throw new Error(
-                          `Validation failed: ${validationResult.issues.map((issue) => issue.message).join(", ")}`
-                        );
+                        throw EntityErrors.queryInputValidationFailed(config.name, key, validationResult.issues, input);
                       }
                     }
                   }
                   const result = await originalExecute.call(builder);
                   if (!result) {
-                    throw new Error("Failed to execute query");
+                    throw OperationErrors.queryFailed(config.name, { queryName: key }, void 0);
                   }
                   return result;
                 };
@@ -576,7 +776,7 @@ function createIndex() {
               generateKey: (item) => {
                 const data = schema["~standard"].validate(item);
                 if ("issues" in data && data.issues) {
-                  throw new Error(`Index validation failed: ${data.issues.map((i) => i.message).join(", ")}`);
+                  throw ValidationErrors.indexSchemaValidationFailed(data.issues, "both");
                 }
                 const validData = "value" in data ? data.value : item;
                 return { pk: pkFn(validData), sk: skFn(validData) };
@@ -597,7 +797,7 @@ function createIndex() {
               generateKey: (item) => {
                 const data = schema["~standard"].validate(item);
                 if ("issues" in data && data.issues) {
-                  throw new Error(`Index validation failed: ${data.issues.map((i) => i.message).join(", ")}`);
+                  throw ValidationErrors.indexSchemaValidationFailed(data.issues, "partition");
                 }
                 const validData = "value" in data ? data.value : item;
                 return { pk: pkFn(validData) };
@@ -618,4 +818,4 @@ function createIndex() {
   };
 }
 
-export { createIndex, createQueries, defineEntity };
+export { createIndex, createQueries, defineEntity, extractRequiredAttributes, formatErrorContext, getAwsErrorCode, getAwsErrorMessage, getErrorSummary, isBatchError, isConditionalCheckFailed, isConfigurationError, isDynoTableError, isEntityError, isEntityValidationError, isExpressionError, isIndexGenerationError, isKeyGenerationError, isOperationError, isProvisionedThroughputExceeded, isRetryableError, isTransactionCanceled, isTransactionError, isValidationError, isValidationException };

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

@@ -1,12 +1,13 @@
 'use strict';
 
-var chunkXYL43FDX_cjs = require('./chunk-XYL43FDX.cjs');
+var chunk3DR6VOFW_cjs = require('./chunk-3DR6VOFW.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);
@@ -38,11 +39,21 @@ var Table = class {
     this.sortKey = config.indexes.sortKey;
     this.gsis = config.indexes.gsis || {};
   }
+  getIndexAttributeNames() {
+    const names = /* @__PURE__ */ new Set();
+    for (const gsi of Object.values(this.gsis)) {
+      names.add(gsi.partitionKey);
+      if (gsi.sortKey) {
+        names.add(gsi.sortKey);
+      }
+    }
+    return Array.from(names);
+  }
   createKeyForPrimaryIndex(keyCondition) {
     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;
     }
@@ -83,6 +94,7 @@ var Table = class {
     return this.put(item).condition((op) => op.attributeNotExists(this.partitionKey)).returnValues("INPUT");
   }
   get(keyCondition) {
+    const indexAttributeNames = this.getIndexAttributeNames();
     const executor = async (params) => {
       try {
         const result = await this.dynamoClient.get({
@@ -96,11 +108,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 chunk3DR6VOFW_cjs.GetBuilder(executor, keyCondition, this.tableName, indexAttributeNames);
   }
   /**
    * Updates an item in the table
@@ -137,23 +148,23 @@ 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 chunk3DR6VOFW_cjs.PutBuilder(executor, item, this.tableName);
   }
   /**
    * Creates a query builder for complex queries
    * If useIndex is called on the returned QueryBuilder, it will use the GSI configuration
    */
   query(keyCondition) {
+    const indexAttributeNames = this.getIndexAttributeNames();
     const pkAttributeName = this.partitionKey;
     const skAttributeName = this.sortKey;
     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 +185,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 +214,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 +237,12 @@ var Table = class {
         expressionAttributeValues: {},
         valueCounter: { count: 0 }
       };
-      const keyConditionExpression2 = chunkXYL43FDX_cjs.buildExpression(finalKeyCondition, expressionParams);
+      const keyConditionExpression2 = chunk3DR6VOFW_cjs.buildExpression(finalKeyCondition, expressionParams);
       let filterExpression;
       if (options.filter) {
-        filterExpression = chunkXYL43FDX_cjs.buildExpression(options.filter, expressionParams);
+        filterExpression = chunk3DR6VOFW_cjs.buildExpression(options.filter, expressionParams);
       }
-      const projectionExpression = options.projection?.map((p) => chunkXYL43FDX_cjs.generateAttributeName(expressionParams, p)).join(", ");
+      const projectionExpression = options.projection?.map((p) => chunk3DR6VOFW_cjs.generateAttributeName(expressionParams, p)).join(", ");
       const { expressionAttributeNames, expressionAttributeValues } = expressionParams;
       const { indexName, limit, consistentRead, scanIndexForward, lastEvaluatedKey } = options;
       const params = {
@@ -254,12 +265,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 chunk3DR6VOFW_cjs.QueryBuilder(executor, keyConditionExpression, indexAttributeNames);
   }
   /**
    * Creates a scan builder for scanning the entire table
@@ -279,9 +292,9 @@ var Table = class {
       };
       let filterExpression;
       if (options.filter) {
-        filterExpression = chunkXYL43FDX_cjs.buildExpression(options.filter, expressionParams);
+        filterExpression = chunk3DR6VOFW_cjs.buildExpression(options.filter, expressionParams);
       }
-      const projectionExpression = options.projection?.map((p) => chunkXYL43FDX_cjs.generateAttributeName(expressionParams, p)).join(", ");
+      const projectionExpression = options.projection?.map((p) => chunk3DR6VOFW_cjs.generateAttributeName(expressionParams, p)).join(", ");
       const { expressionAttributeNames, expressionAttributeValues } = expressionParams;
       const { indexName, limit, consistentRead, lastEvaluatedKey } = options;
       const params = {
@@ -302,12 +315,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 chunk3DR6VOFW_cjs.ScanBuilder(executor);
   }
   delete(keyCondition) {
     const executor = async (params) => {
@@ -324,11 +339,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 chunk3DR6VOFW_cjs.DeleteBuilder(executor, this.tableName, keyCondition);
   }
   /**
    * Updates an item in the table
@@ -352,11 +366,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 chunk3DR6VOFW_cjs.UpdateBuilder(executor, this.tableName, keyCondition);
   }
   /**
    * Creates a transaction builder for performing multiple operations atomically
@@ -365,7 +378,7 @@ var Table = class {
     const executor = async (params) => {
       await this.dynamoClient.transactWrite(params);
     };
-    return new chunkXYL43FDX_cjs.TransactionBuilder(executor, {
+    return new chunk3DR6VOFW_cjs.TransactionBuilder(executor, {
       partitionKey: this.partitionKey,
       sortKey: this.sortKey
     });
@@ -412,7 +425,7 @@ var Table = class {
     const batchGetExecutor = async (keys) => {
       return this.batchGet(keys);
     };
-    return new chunkXYL43FDX_cjs.BatchBuilder(batchWriteExecutor, batchGetExecutor, {
+    return new chunk3DR6VOFW_cjs.BatchBuilder(batchWriteExecutor, batchGetExecutor, {
       partitionKey: this.partitionKey,
       sortKey: this.sortKey
     });
@@ -428,7 +441,7 @@ var Table = class {
     const transactionExecutor = async (params) => {
       await this.dynamoClient.transactWrite(params);
     };
-    const transaction = new chunkXYL43FDX_cjs.TransactionBuilder(transactionExecutor, {
+    const transaction = new chunk3DR6VOFW_cjs.TransactionBuilder(transactionExecutor, {
       partitionKey: this.partitionKey,
       sortKey: this.sortKey
     });
@@ -448,7 +461,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 chunk3DR6VOFW_cjs.ConditionCheckBuilder(this.tableName, keyCondition);
   }
   /**
    * Performs a batch get operation to retrieve multiple items at once
@@ -485,8 +498,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 +563,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 {