dyno-table 2.3.2 → 2.4.0

package/dist/{chunk-NTA6GDPP.cjs → chunk-ZXM6LPRV.cjs}

@@ -1,5 +1,6 @@
 'use strict';
 
+var chunkELULXDSB_cjs = require('./chunk-ELULXDSB.cjs');
 var chunk7UJJ7JXM_cjs = require('./chunk-7UJJ7JXM.cjs');
 
 // src/builders/entity-aware-builders.ts
@@ -114,9 +115,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;
@@ -161,6 +159,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 {
   /**
@@ -186,10 +314,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 chunkELULXDSB_cjs.IndexErrors.undefinedValues(indexName, "create", key, item);
+        }
+      } catch (error) {
+        if (error instanceof chunkELULXDSB_cjs.DynoTableError) throw error;
+        throw chunkELULXDSB_cjs.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 chunkELULXDSB_cjs.ConfigurationErrors.gsiNotFound(indexName, this.table.tableName, Object.keys(this.table.gsis));
       }
       if (key.pk) {
         attributes[gsiConfig.partitionKey] = key.pk;
@@ -214,9 +358,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 chunkELULXDSB_cjs.IndexErrors.notFound(invalidIndexes, Object.keys(this.indexes), void 0, this.table.tableName);
       }
     }
     for (const [indexName, indexDef] of Object.entries(this.indexes)) {
@@ -243,19 +385,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 chunkELULXDSB_cjs.DynoTableError) throw error;
+        throw chunkELULXDSB_cjs.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 chunkELULXDSB_cjs.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 chunkELULXDSB_cjs.ConfigurationErrors.gsiNotFound(indexName, this.table.tableName, Object.keys(this.table.gsis));
       }
       if (key.pk) {
         attributes[gsiConfig.partitionKey] = key.pk;
@@ -342,13 +487,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 chunkELULXDSB_cjs.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 chunkELULXDSB_cjs.EntityErrors.keyInvalidFormat(config.name, "create", dataForKeyGeneration, primaryKey);
+              }
+            } catch (error) {
+              if (error instanceof chunkELULXDSB_cjs.DynoTableError) throw error;
+              throw chunkELULXDSB_cjs.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,
@@ -363,18 +523,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 chunkELULXDSB_cjs.EntityErrors.asyncValidationNotSupported(config.name, "create");
             }
             if ("issues" in validationResult && validationResult.issues) {
-              throw new Error(`Validation failed: ${validationResult.issues.map((i) => i.message).join(", ")}`);
+              throw chunkELULXDSB_cjs.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 chunkELULXDSB_cjs.EntityErrors.keyInvalidFormat(config.name, "create", dataForKeyGeneration, primaryKey);
+              }
+            } catch (error) {
+              if (error instanceof chunkELULXDSB_cjs.DynoTableError) throw error;
+              throw chunkELULXDSB_cjs.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,
@@ -410,13 +583,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 chunkELULXDSB_cjs.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 chunkELULXDSB_cjs.EntityErrors.keyInvalidFormat(config.name, "upsert", dataForKeyGeneration, primaryKey);
+              }
+            } catch (error) {
+              if (error instanceof chunkELULXDSB_cjs.DynoTableError) throw error;
+              throw chunkELULXDSB_cjs.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,
@@ -431,18 +619,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 chunkELULXDSB_cjs.EntityErrors.asyncValidationNotSupported(config.name, "upsert");
             }
             if ("issues" in validationResult && validationResult.issues) {
-              throw new Error(`Validation failed: ${validationResult.issues.map((i) => i.message).join(", ")}`);
+              throw chunkELULXDSB_cjs.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 chunkELULXDSB_cjs.EntityErrors.keyInvalidFormat(config.name, "upsert", dataForKeyGeneration, primaryKey);
+              }
+            } catch (error) {
+              if (error instanceof chunkELULXDSB_cjs.DynoTableError) throw error;
+              throw chunkELULXDSB_cjs.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,
@@ -459,7 +660,7 @@ function defineEntity(config) {
             await prepareValidatedItemAsync();
             const result = await originalExecute.call(builder);
             if (!result) {
-              throw new Error("Failed to upsert item");
+              throw chunkELULXDSB_cjs.OperationErrors.putFailed(config.name, {}, void 0);
             }
             return result;
           };
@@ -478,7 +679,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);
@@ -500,46 +702,47 @@ function defineEntity(config) {
           builder.condition(chunk7UJJ7JXM_cjs.eq(entityTypeAttributeName, config.name));
           return createEntityAwareDeleteBuilder(builder, config.name);
         },
-        query: Object.entries(config.queries || {}).reduce((acc, [key, inputCallback]) => {
-          acc[key] = (input) => {
-            const queryEntity = {
-              scan: repository.scan,
-              get: (key2) => createEntityAwareGetBuilder(table.get(key2), config.name),
-              query: (keyCondition) => {
-                return table.query(keyCondition);
+        query: Object.entries(config.queries || {}).reduce(
+          (acc, [key, inputCallback]) => {
+            acc[key] = (input) => {
+              const queryEntity = {
+                scan: repository.scan,
+                get: (key2) => createEntityAwareGetBuilder(table.get(key2), config.name),
+                query: (keyCondition) => {
+                  return table.query(keyCondition);
+                }
+              };
+              const queryBuilderCallback = inputCallback(input);
+              const builder = queryBuilderCallback(queryEntity);
+              if (builder && typeof builder === "object" && "filter" in builder && typeof builder.filter === "function") {
+                builder.filter(chunk7UJJ7JXM_cjs.eq(entityTypeAttributeName, config.name));
               }
-            };
-            const queryBuilderCallback = inputCallback(input);
-            const builder = queryBuilderCallback(queryEntity);
-            if (builder && typeof builder === "object" && "filter" in builder && typeof builder.filter === "function") {
-              builder.filter(chunk7UJJ7JXM_cjs.eq(entityTypeAttributeName, config.name));
-            }
-            if (builder && typeof builder === "object" && "execute" in builder) {
-              const originalExecute = builder.execute;
-              builder.execute = async () => {
-                const queryFn = config.queries[key];
-                if (queryFn && typeof queryFn === "function") {
-                  const schema = queryFn.schema;
-                  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(", ")}`
-                      );
+              if (builder && typeof builder === "object" && "execute" in builder) {
+                const originalExecute = builder.execute;
+                builder.execute = async () => {
+                  const queryFn = config.queries[key];
+                  if (queryFn && typeof queryFn === "function") {
+                    const schema = queryFn.schema;
+                    if (schema?.["~standard"]?.validate && typeof schema["~standard"].validate === "function") {
+                      const validationResult = schema["~standard"].validate(input);
+                      if ("issues" in validationResult && validationResult.issues) {
+                        throw chunkELULXDSB_cjs.EntityErrors.queryInputValidationFailed(config.name, key, validationResult.issues, input);
+                      }
                     }
                   }
-                }
-                const result = await originalExecute.call(builder);
-                if (!result) {
-                  throw new Error("Failed to execute query");
-                }
-                return result;
-              };
-            }
-            return builder;
-          };
-          return acc;
-        }, {}),
+                  const result = await originalExecute.call(builder);
+                  if (!result) {
+                    throw chunkELULXDSB_cjs.OperationErrors.queryFailed(config.name, { queryName: key }, void 0);
+                  }
+                  return result;
+                };
+              }
+              return builder;
+            };
+            return acc;
+          },
+          {}
+        ),
         scan: () => {
           const builder = table.scan();
           builder.filter(chunk7UJJ7JXM_cjs.eq(entityTypeAttributeName, config.name));
@@ -575,7 +778,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 chunkELULXDSB_cjs.ValidationErrors.indexSchemaValidationFailed(data.issues, "both");
                 }
                 const validData = "value" in data ? data.value : item;
                 return { pk: pkFn(validData), sk: skFn(validData) };
@@ -596,7 +799,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 chunkELULXDSB_cjs.ValidationErrors.indexSchemaValidationFailed(data.issues, "partition");
                 }
                 const validData = "value" in data ? data.value : item;
                 return { pk: pkFn(validData) };
@@ -620,3 +823,24 @@ function createIndex() {
 exports.createIndex = createIndex;
 exports.createQueries = createQueries;
 exports.defineEntity = defineEntity;
+exports.extractRequiredAttributes = extractRequiredAttributes;
+exports.formatErrorContext = formatErrorContext;
+exports.getAwsErrorCode = getAwsErrorCode;
+exports.getAwsErrorMessage = getAwsErrorMessage;
+exports.getErrorSummary = getErrorSummary;
+exports.isBatchError = isBatchError;
+exports.isConditionalCheckFailed = isConditionalCheckFailed;
+exports.isConfigurationError = isConfigurationError;
+exports.isDynoTableError = isDynoTableError;
+exports.isEntityError = isEntityError;
+exports.isEntityValidationError = isEntityValidationError;
+exports.isExpressionError = isExpressionError;
+exports.isIndexGenerationError = isIndexGenerationError;
+exports.isKeyGenerationError = isKeyGenerationError;
+exports.isOperationError = isOperationError;
+exports.isProvisionedThroughputExceeded = isProvisionedThroughputExceeded;
+exports.isRetryableError = isRetryableError;
+exports.isTransactionCanceled = isTransactionCanceled;
+exports.isTransactionError = isTransactionError;
+exports.isValidationError = isValidationError;
+exports.isValidationException = isValidationException;

package/dist/{conditions-D_w7vVYG.d.ts → conditions-BSAcZswY.d.ts}

@@ -728,4 +728,4 @@ type PrimaryKeyWithoutExpression = {
     sk?: string;
 };
 
-export { type ComparisonOperator as C, type ExpressionParams as E, type KeyConditionOperator as K, type LogicalOperator as L, type PrimaryKey as P, type Condition as a, type ConditionOperator as b, type PrimaryKeyWithoutExpression as c, and as d, attributeExists as e, attributeNotExists as f, beginsWith as g, between as h, contains as i, eq as j, gt as k, gte as l, inArray as m, lt as n, lte as o, ne as p, not as q, or as r, type Path as s, type PathType as t, createComparisonCondition as u };
+export { type ComparisonOperator as C, type ExpressionParams as E, type KeyConditionOperator as K, type LogicalOperator as L, type PrimaryKeyWithoutExpression as P, type PrimaryKey as a, type Condition as b, type ConditionOperator as c, and as d, attributeExists as e, attributeNotExists as f, beginsWith as g, between as h, contains as i, eq as j, gt as k, gte as l, inArray as m, lt as n, lte as o, ne as p, not as q, or as r, type Path as s, type PathType as t, createComparisonCondition as u };

package/dist/{conditions-CcZL0sR2.d.cts → conditions-C8bM__Pn.d.cts}

@@ -728,4 +728,4 @@ type PrimaryKeyWithoutExpression = {
     sk?: string;
 };
 
-export { type ComparisonOperator as C, type ExpressionParams as E, type KeyConditionOperator as K, type LogicalOperator as L, type PrimaryKey as P, type Condition as a, type ConditionOperator as b, type PrimaryKeyWithoutExpression as c, and as d, attributeExists as e, attributeNotExists as f, beginsWith as g, between as h, contains as i, eq as j, gt as k, gte as l, inArray as m, lt as n, lte as o, ne as p, not as q, or as r, type Path as s, type PathType as t, createComparisonCondition as u };
+export { type ComparisonOperator as C, type ExpressionParams as E, type KeyConditionOperator as K, type LogicalOperator as L, type PrimaryKeyWithoutExpression as P, type PrimaryKey as a, type Condition as b, type ConditionOperator as c, and as d, attributeExists as e, attributeNotExists as f, beginsWith as g, between as h, contains as i, eq as j, gt as k, gte as l, inArray as m, lt as n, lte as o, ne as p, not as q, or as r, type Path as s, type PathType as t, createComparisonCondition as u };

package/dist/conditions.d.cts

@@ -1,3 +1,3 @@
-export { C as ComparisonOperator, a as Condition, b as ConditionOperator, E as ExpressionParams, K as KeyConditionOperator, L as LogicalOperator, P as PrimaryKey, c as PrimaryKeyWithoutExpression, d as and, e as attributeExists, f as attributeNotExists, g as beginsWith, h as between, i as contains, u as createComparisonCondition, j as eq, k as gt, l as gte, m as inArray, n as lt, o as lte, p as ne, q as not, r as or } from './conditions-CcZL0sR2.cjs';
+export { C as ComparisonOperator, b as Condition, c as ConditionOperator, E as ExpressionParams, K as KeyConditionOperator, L as LogicalOperator, a as PrimaryKey, P as PrimaryKeyWithoutExpression, d as and, e as attributeExists, f as attributeNotExists, g as beginsWith, h as between, i as contains, u as createComparisonCondition, j as eq, k as gt, l as gte, m as inArray, n as lt, o as lte, p as ne, q as not, r as or } from './conditions-C8bM__Pn.cjs';
 import './types.cjs';
 import '@aws-sdk/lib-dynamodb';

package/dist/conditions.d.ts

@@ -1,3 +1,3 @@
-export { C as ComparisonOperator, a as Condition, b as ConditionOperator, E as ExpressionParams, K as KeyConditionOperator, L as LogicalOperator, P as PrimaryKey, c as PrimaryKeyWithoutExpression, d as and, e as attributeExists, f as attributeNotExists, g as beginsWith, h as between, i as contains, u as createComparisonCondition, j as eq, k as gt, l as gte, m as inArray, n as lt, o as lte, p as ne, q as not, r as or } from './conditions-D_w7vVYG.js';
+export { C as ComparisonOperator, b as Condition, c as ConditionOperator, E as ExpressionParams, K as KeyConditionOperator, L as LogicalOperator, a as PrimaryKey, P as PrimaryKeyWithoutExpression, d as and, e as attributeExists, f as attributeNotExists, g as beginsWith, h as between, i as contains, u as createComparisonCondition, j as eq, k as gt, l as gte, m as inArray, n as lt, o as lte, p as ne, q as not, r as or } from './conditions-BSAcZswY.js';
 import './types.js';
 import '@aws-sdk/lib-dynamodb';

package/dist/entity.cjs

@@ -1,19 +1,20 @@
 'use strict';
 
-var chunkNTA6GDPP_cjs = require('./chunk-NTA6GDPP.cjs');
+var chunkZXM6LPRV_cjs = require('./chunk-ZXM6LPRV.cjs');
+require('./chunk-ELULXDSB.cjs');
 require('./chunk-7UJJ7JXM.cjs');
 
 
 
 Object.defineProperty(exports, "createIndex", {
   enumerable: true,
-  get: function () { return chunkNTA6GDPP_cjs.createIndex; }
+  get: function () { return chunkZXM6LPRV_cjs.createIndex; }
 });
 Object.defineProperty(exports, "createQueries", {
   enumerable: true,
-  get: function () { return chunkNTA6GDPP_cjs.createQueries; }
+  get: function () { return chunkZXM6LPRV_cjs.createQueries; }
 });
 Object.defineProperty(exports, "defineEntity", {
   enumerable: true,
-  get: function () { return chunkNTA6GDPP_cjs.defineEntity; }
+  get: function () { return chunkZXM6LPRV_cjs.defineEntity; }
 });

package/dist/entity.d.cts

@@ -1,5 +1,5 @@
-import { s as Path, t as PathType, a as Condition, b as ConditionOperator, c as PrimaryKeyWithoutExpression, P as PrimaryKey } from './conditions-CcZL0sR2.cjs';
-import { P as PutBuilder, G as GetBuilder, U as UpdateBuilder, i as UpdateCommandParams, T as TransactionBuilder, D as DeleteBuilder, S as ScanBuilder, Q as QueryBuilder } from './index-DlN8G9hd.cjs';
+import { s as Path, t as PathType, b as Condition, c as ConditionOperator, P as PrimaryKeyWithoutExpression, a as PrimaryKey } from './conditions-C8bM__Pn.cjs';
+import { P as PutBuilder, G as GetBuilder, U as UpdateBuilder, p as UpdateCommandParams, T as TransactionBuilder, D as DeleteBuilder, S as ScanBuilder, Q as QueryBuilder } from './index-BX-MSZHj.cjs';
 import { StandardSchemaV1 } from './standard-schema.cjs';
 import { Table } from './table.cjs';
 import { DynamoItem, Index, TableConfig } from './types.cjs';
@@ -112,6 +112,9 @@ type QueryFunctionWithSchema<T extends DynamoItem, I, R> = QueryFunction<T, I, R
 type QueryRecord<T extends DynamoItem> = {
     [K: string]: QueryFunctionWithSchema<T, any, any>;
 };
+type MappedQueries<T extends DynamoItem, Q extends QueryRecord<T>> = {
+    [K in keyof Q]: Q[K] extends QueryFunctionWithSchema<T, infer I, infer R> ? (input: I) => R : never;
+};
 type QueryEntity<T extends DynamoItem> = {
     scan: () => ScanBuilder<T>;
     get: (key: PrimaryKeyWithoutExpression) => EntityAwareGetBuilder<T>;
@@ -195,7 +198,7 @@ Q extends QueryRecord<T> = QueryRecord<T>> {
     get: (key: I) => EntityAwareGetBuilder<T>;
     update: (key: I, data: Partial<T>) => EntityAwareUpdateBuilder<T>;
     delete: (key: I) => EntityAwareDeleteBuilder;
-    query: Q;
+    query: MappedQueries<T, Q>;
     scan: () => ScanBuilder<T>;
 }
 /**
@@ -255,4 +258,4 @@ declare function createIndex(): {
     };
 };
 
-export { type EntityConfig, type EntityRepository, type IndexDefinition, type QueryEntity, type QueryFunction, type QueryFunctionWithSchema, type QueryRecord, createIndex, createQueries, defineEntity };
+export { type EntityConfig, type EntityRepository, type IndexDefinition, type MappedQueries, type QueryEntity, type QueryFunction, type QueryFunctionWithSchema, type QueryRecord, createIndex, createQueries, defineEntity };

package/dist/entity.d.ts

@@ -1,5 +1,5 @@
-import { s as Path, t as PathType, a as Condition, b as ConditionOperator, c as PrimaryKeyWithoutExpression, P as PrimaryKey } from './conditions-D_w7vVYG.js';
-import { P as PutBuilder, G as GetBuilder, U as UpdateBuilder, i as UpdateCommandParams, T as TransactionBuilder, D as DeleteBuilder, S as ScanBuilder, Q as QueryBuilder } from './index-2cbm07Bi.js';
+import { s as Path, t as PathType, b as Condition, c as ConditionOperator, P as PrimaryKeyWithoutExpression, a as PrimaryKey } from './conditions-BSAcZswY.js';
+import { P as PutBuilder, G as GetBuilder, U as UpdateBuilder, p as UpdateCommandParams, T as TransactionBuilder, D as DeleteBuilder, S as ScanBuilder, Q as QueryBuilder } from './index-DdTolMJW.js';
 import { StandardSchemaV1 } from './standard-schema.js';
 import { Table } from './table.js';
 import { DynamoItem, Index, TableConfig } from './types.js';
@@ -112,6 +112,9 @@ type QueryFunctionWithSchema<T extends DynamoItem, I, R> = QueryFunction<T, I, R
 type QueryRecord<T extends DynamoItem> = {
     [K: string]: QueryFunctionWithSchema<T, any, any>;
 };
+type MappedQueries<T extends DynamoItem, Q extends QueryRecord<T>> = {
+    [K in keyof Q]: Q[K] extends QueryFunctionWithSchema<T, infer I, infer R> ? (input: I) => R : never;
+};
 type QueryEntity<T extends DynamoItem> = {
     scan: () => ScanBuilder<T>;
     get: (key: PrimaryKeyWithoutExpression) => EntityAwareGetBuilder<T>;
@@ -195,7 +198,7 @@ Q extends QueryRecord<T> = QueryRecord<T>> {
     get: (key: I) => EntityAwareGetBuilder<T>;
     update: (key: I, data: Partial<T>) => EntityAwareUpdateBuilder<T>;
     delete: (key: I) => EntityAwareDeleteBuilder;
-    query: Q;
+    query: MappedQueries<T, Q>;
     scan: () => ScanBuilder<T>;
 }
 /**
@@ -255,4 +258,4 @@ declare function createIndex(): {
     };
 };
 
-export { type EntityConfig, type EntityRepository, type IndexDefinition, type QueryEntity, type QueryFunction, type QueryFunctionWithSchema, type QueryRecord, createIndex, createQueries, defineEntity };
+export { type EntityConfig, type EntityRepository, type IndexDefinition, type MappedQueries, type QueryEntity, type QueryFunction, type QueryFunctionWithSchema, type QueryRecord, createIndex, createQueries, defineEntity };

package/dist/entity.js

@@ -1,2 +1,3 @@
-export { createIndex, createQueries, defineEntity } from './chunk-2EWNZOUK.js';
+export { createIndex, createQueries, defineEntity } from './chunk-U6MQGB6Y.js';
+import './chunk-FF7FYGDH.js';
 import './chunk-2WIBY7PZ.js';