dyno-table 2.5.1 → 2.6.0

package/dist/errors.d.ts

@@ -0,0 +1,212 @@
+/**
+ * Base error class for all dyno-table errors
+ *
+ * All custom errors in the library extend this class, allowing consumers
+ * to catch all library errors with a single catch block if needed.
+ */
+export declare class DynoTableError extends Error {
+    /**
+     * Machine-readable error code for programmatic error handling
+     * @example "KEY_GENERATION_FAILED", "VALIDATION_ERROR", etc.
+     */
+    readonly code: string;
+    /**
+     * Additional context about the error
+     * Contains operation-specific details like entity names, table names,
+     * expressions, conditions, and other relevant debugging information
+     */
+    readonly context: Record<string, unknown>;
+    /**
+     * The original error that caused this error (if wrapping another error)
+     * Useful for preserving AWS SDK errors or other underlying errors
+     */
+    readonly cause?: Error;
+    constructor(message: string, code: string, context?: Record<string, unknown>, cause?: Error);
+}
+/**
+ * Error for schema validation and input validation failures
+ *
+ * Thrown when user-provided data doesn't match the expected schema
+ * or when required fields are missing.
+ */
+export declare class ValidationError extends DynoTableError {
+    constructor(message: string, code: string, context?: Record<string, unknown>, cause?: Error);
+}
+/**
+ * Error for DynamoDB operation failures
+ *
+ * Wraps AWS SDK errors and adds library-specific context like
+ * the operation type, table name, and generated expressions.
+ */
+export declare class OperationError extends DynoTableError {
+    constructor(message: string, code: string, context?: Record<string, unknown>, cause?: Error);
+}
+/**
+ * Error for transaction-specific failures
+ *
+ * Thrown when transaction operations fail, including duplicate item
+ * detection, transaction cancellation, and other transaction-related issues.
+ */
+export declare class TransactionError extends DynoTableError {
+    constructor(message: string, code: string, context?: Record<string, unknown>, cause?: Error);
+}
+/**
+ * Error for batch operation failures
+ *
+ * Thrown when batch operations fail or when batch limits are exceeded.
+ * Includes information about unprocessed items and operation details.
+ */
+export declare class BatchError extends DynoTableError {
+    /**
+     * The type of batch operation that failed
+     */
+    readonly operation: "write" | "read";
+    /**
+     * The items that were not processed during the batch operation
+     */
+    readonly unprocessedItems: unknown[];
+    constructor(message: string, code: string, operation: "write" | "read", unprocessedItems?: unknown[], context?: Record<string, unknown>, cause?: Error);
+}
+/**
+ * Error for expression building failures
+ *
+ * Thrown when building DynamoDB expressions (condition, filter, update, etc.)
+ * fails due to invalid conditions or missing required fields.
+ */
+export declare class ExpressionError extends DynoTableError {
+    constructor(message: string, code: string, context?: Record<string, unknown>, cause?: Error);
+}
+/**
+ * Error for table/index configuration issues
+ *
+ * Thrown when there are problems with table configuration,
+ * such as missing GSIs or invalid index references.
+ */
+export declare class ConfigurationError extends DynoTableError {
+    constructor(message: string, code: string, context?: Record<string, unknown>, cause?: Error);
+}
+/**
+ * Base error for all entity-related errors
+ *
+ * Parent class for entity-specific errors like key generation
+ * and index generation failures.
+ */
+export declare class EntityError extends DynoTableError {
+    constructor(message: string, code: string, context?: Record<string, unknown>, cause?: Error);
+}
+/**
+ * Error for primary key generation failures
+ *
+ * Thrown when generating entity primary keys fails due to missing
+ * attributes or invalid key formats.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await userRepo.create({ name: "John" }).execute();
+ * } catch (error) {
+ *   if (error instanceof KeyGenerationError) {
+ *     console.error("Failed to generate key");
+ *     console.error("Entity:", error.context.entityName);
+ *     console.error("Required attributes:", error.context.requiredAttributes);
+ *   }
+ * }
+ * ```
+ */
+export declare class KeyGenerationError extends EntityError {
+    constructor(message: string, code: string, context?: Record<string, unknown>, cause?: Error);
+}
+/**
+ * Error for index key generation failures
+ *
+ * Thrown when generating secondary index keys fails due to missing
+ * attributes or when trying to update readonly indexes without forcing.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await orderRepo.update({ id: "123" }, { status: "shipped" }).execute();
+ * } catch (error) {
+ *   if (error instanceof IndexGenerationError) {
+ *     console.error("Index failed:", error.context.indexName);
+ *     console.error("Suggestion:", error.context.suggestion);
+ *   }
+ * }
+ * ```
+ */
+export declare class IndexGenerationError extends EntityError {
+    constructor(message: string, code: string, context?: Record<string, unknown>, cause?: Error);
+}
+/**
+ * Error for entity schema validation failures
+ *
+ * Thrown when entity data doesn't pass schema validation.
+ * Includes validation issues and the entity context.
+ */
+export declare class EntityValidationError extends ValidationError {
+    constructor(message: string, code: string, context?: Record<string, unknown>, cause?: Error);
+}
+/**
+ * Error codes used throughout the library
+ *
+ * These codes allow for programmatic error handling and can be used
+ * to implement retry logic, user-friendly error messages, etc.
+ */
+export declare const ErrorCodes: {
+    readonly KEY_GENERATION_FAILED: "KEY_GENERATION_FAILED";
+    readonly KEY_MISSING_ATTRIBUTES: "KEY_MISSING_ATTRIBUTES";
+    readonly KEY_INVALID_FORMAT: "KEY_INVALID_FORMAT";
+    readonly INDEX_GENERATION_FAILED: "INDEX_GENERATION_FAILED";
+    readonly INDEX_MISSING_ATTRIBUTES: "INDEX_MISSING_ATTRIBUTES";
+    readonly INDEX_NOT_FOUND: "INDEX_NOT_FOUND";
+    readonly INDEX_READONLY_UPDATE_FAILED: "INDEX_READONLY_UPDATE_FAILED";
+    readonly INDEX_UNDEFINED_VALUES: "INDEX_UNDEFINED_VALUES";
+    readonly ENTITY_VALIDATION_FAILED: "ENTITY_VALIDATION_FAILED";
+    readonly ASYNC_VALIDATION_NOT_SUPPORTED: "ASYNC_VALIDATION_NOT_SUPPORTED";
+    readonly QUERY_INPUT_VALIDATION_FAILED: "QUERY_INPUT_VALIDATION_FAILED";
+    readonly VALIDATION_ERROR: "VALIDATION_ERROR";
+    readonly VALIDATION_FAILED: "VALIDATION_FAILED";
+    readonly SCHEMA_VALIDATION_FAILED: "SCHEMA_VALIDATION_FAILED";
+    readonly INVALID_PARAMETER: "INVALID_PARAMETER";
+    readonly MISSING_REQUIRED_FIELD: "MISSING_REQUIRED_FIELD";
+    readonly UNDEFINED_VALUE: "UNDEFINED_VALUE";
+    readonly EXPRESSION_MISSING_ATTRIBUTE: "EXPRESSION_MISSING_ATTRIBUTE";
+    readonly EXPRESSION_MISSING_VALUE: "EXPRESSION_MISSING_VALUE";
+    readonly EXPRESSION_INVALID_CONDITION: "EXPRESSION_INVALID_CONDITION";
+    readonly EXPRESSION_EMPTY_ARRAY: "EXPRESSION_EMPTY_ARRAY";
+    readonly EXPRESSION_UNKNOWN_TYPE: "EXPRESSION_UNKNOWN_TYPE";
+    readonly EXPRESSION_INVALID: "EXPRESSION_INVALID";
+    readonly EXPRESSION_INVALID_OPERATOR: "EXPRESSION_INVALID_OPERATOR";
+    readonly QUERY_FAILED: "QUERY_FAILED";
+    readonly SCAN_FAILED: "SCAN_FAILED";
+    readonly GET_FAILED: "GET_FAILED";
+    readonly PUT_FAILED: "PUT_FAILED";
+    readonly DELETE_FAILED: "DELETE_FAILED";
+    readonly UPDATE_FAILED: "UPDATE_FAILED";
+    readonly BATCH_GET_FAILED: "BATCH_GET_FAILED";
+    readonly BATCH_WRITE_FAILED: "BATCH_WRITE_FAILED";
+    readonly NO_UPDATE_ACTIONS: "NO_UPDATE_ACTIONS";
+    readonly CONDITIONAL_CHECK_FAILED: "CONDITIONAL_CHECK_FAILED";
+    readonly TRANSACTION_FAILED: "TRANSACTION_FAILED";
+    readonly TRANSACTION_DUPLICATE_ITEM: "TRANSACTION_DUPLICATE_ITEM";
+    readonly TRANSACTION_EMPTY: "TRANSACTION_EMPTY";
+    readonly TRANSACTION_UNSUPPORTED_TYPE: "TRANSACTION_UNSUPPORTED_TYPE";
+    readonly TRANSACTION_ITEM_LIMIT: "TRANSACTION_ITEM_LIMIT";
+    readonly TRANSACTION_CANCELLED: "TRANSACTION_CANCELLED";
+    readonly BATCH_EMPTY: "BATCH_EMPTY";
+    readonly BATCH_UNSUPPORTED_TYPE: "BATCH_UNSUPPORTED_TYPE";
+    readonly BATCH_UNPROCESSED_ITEMS: "BATCH_UNPROCESSED_ITEMS";
+    readonly BATCH_SIZE_EXCEEDED: "BATCH_SIZE_EXCEEDED";
+    readonly GSI_NOT_FOUND: "GSI_NOT_FOUND";
+    readonly SORT_KEY_REQUIRED: "SORT_KEY_REQUIRED";
+    readonly SORT_KEY_NOT_DEFINED: "SORT_KEY_NOT_DEFINED";
+    readonly PRIMARY_KEY_MISSING: "PRIMARY_KEY_MISSING";
+    readonly INVALID_CHUNK_SIZE: "INVALID_CHUNK_SIZE";
+    readonly CONDITION_REQUIRED: "CONDITION_REQUIRED";
+    readonly CONDITION_GENERATION_FAILED: "CONDITION_GENERATION_FAILED";
+    readonly PK_EXTRACTION_FAILED: "PK_EXTRACTION_FAILED";
+    readonly CONFIGURATION_INVALID: "CONFIGURATION_INVALID";
+    readonly CONFIGURATION_MISSING_SORT_KEY: "CONFIGURATION_MISSING_SORT_KEY";
+    readonly CONFIGURATION_INVALID_GSI: "CONFIGURATION_INVALID_GSI";
+};
+export type ErrorCode = (typeof ErrorCodes)[keyof typeof ErrorCodes];

package/dist/expression.d.ts

@@ -0,0 +1,9 @@
+import type { Condition, ExpressionParams } from "./conditions";
+export declare const generateAttributeName: (params: ExpressionParams, attr: string) => string;
+export declare const generateValueName: (params: ExpressionParams, value: unknown) => string;
+export declare const buildExpression: (condition: Condition, params: ExpressionParams) => string;
+export declare const prepareExpressionParams: (condition?: Condition) => {
+    expression?: string;
+    names?: Record<string, string>;
+    values?: Record<string, unknown>;
+};

package/dist/index-definition.d.ts

@@ -0,0 +1,10 @@
+import type { DynamoItem } from "./types";
+export interface IndexDefinition<T extends DynamoItem, P extends (item: T) => string, S extends ((item: T) => string) | undefined = undefined> {
+    name: string;
+    partitionKey: P;
+    sortKey?: S;
+    generateKey: (item: T) => {
+        pk: string;
+        sk?: string;
+    };
+}

package/dist/index.cjs

@@ -1,7 +1,7 @@
 'use strict';
 
 var chunkZUBCW3LA_cjs = require('./chunk-ZUBCW3LA.cjs');
-var chunkZXM6LPRV_cjs = require('./chunk-ZXM6LPRV.cjs');
+var chunkZ334X72N_cjs = require('./chunk-Z334X72N.cjs');
 var chunkPB7BBCZO_cjs = require('./chunk-PB7BBCZO.cjs');
 var chunk3DR6VOFW_cjs = require('./chunk-3DR6VOFW.cjs');
 var chunkELULXDSB_cjs = require('./chunk-ELULXDSB.cjs');
@@ -15,99 +15,99 @@ Object.defineProperty(exports, "Table", {
 });
 Object.defineProperty(exports, "createIndex", {
   enumerable: true,
-  get: function () { return chunkZXM6LPRV_cjs.createIndex; }
+  get: function () { return chunkZ334X72N_cjs.createIndex; }
 });
 Object.defineProperty(exports, "createQueries", {
   enumerable: true,
-  get: function () { return chunkZXM6LPRV_cjs.createQueries; }
+  get: function () { return chunkZ334X72N_cjs.createQueries; }
 });
 Object.defineProperty(exports, "defineEntity", {
   enumerable: true,
-  get: function () { return chunkZXM6LPRV_cjs.defineEntity; }
+  get: function () { return chunkZ334X72N_cjs.defineEntity; }
 });
 Object.defineProperty(exports, "extractRequiredAttributes", {
   enumerable: true,
-  get: function () { return chunkZXM6LPRV_cjs.extractRequiredAttributes; }
+  get: function () { return chunkZ334X72N_cjs.extractRequiredAttributes; }
 });
 Object.defineProperty(exports, "formatErrorContext", {
   enumerable: true,
-  get: function () { return chunkZXM6LPRV_cjs.formatErrorContext; }
+  get: function () { return chunkZ334X72N_cjs.formatErrorContext; }
 });
 Object.defineProperty(exports, "getAwsErrorCode", {
   enumerable: true,
-  get: function () { return chunkZXM6LPRV_cjs.getAwsErrorCode; }
+  get: function () { return chunkZ334X72N_cjs.getAwsErrorCode; }
 });
 Object.defineProperty(exports, "getAwsErrorMessage", {
   enumerable: true,
-  get: function () { return chunkZXM6LPRV_cjs.getAwsErrorMessage; }
+  get: function () { return chunkZ334X72N_cjs.getAwsErrorMessage; }
 });
 Object.defineProperty(exports, "getErrorSummary", {
   enumerable: true,
-  get: function () { return chunkZXM6LPRV_cjs.getErrorSummary; }
+  get: function () { return chunkZ334X72N_cjs.getErrorSummary; }
 });
 Object.defineProperty(exports, "isBatchError", {
   enumerable: true,
-  get: function () { return chunkZXM6LPRV_cjs.isBatchError; }
+  get: function () { return chunkZ334X72N_cjs.isBatchError; }
 });
 Object.defineProperty(exports, "isConditionalCheckFailed", {
   enumerable: true,
-  get: function () { return chunkZXM6LPRV_cjs.isConditionalCheckFailed; }
+  get: function () { return chunkZ334X72N_cjs.isConditionalCheckFailed; }
 });
 Object.defineProperty(exports, "isConfigurationError", {
   enumerable: true,
-  get: function () { return chunkZXM6LPRV_cjs.isConfigurationError; }
+  get: function () { return chunkZ334X72N_cjs.isConfigurationError; }
 });
 Object.defineProperty(exports, "isDynoTableError", {
   enumerable: true,
-  get: function () { return chunkZXM6LPRV_cjs.isDynoTableError; }
+  get: function () { return chunkZ334X72N_cjs.isDynoTableError; }
 });
 Object.defineProperty(exports, "isEntityError", {
   enumerable: true,
-  get: function () { return chunkZXM6LPRV_cjs.isEntityError; }
+  get: function () { return chunkZ334X72N_cjs.isEntityError; }
 });
 Object.defineProperty(exports, "isEntityValidationError", {
   enumerable: true,
-  get: function () { return chunkZXM6LPRV_cjs.isEntityValidationError; }
+  get: function () { return chunkZ334X72N_cjs.isEntityValidationError; }
 });
 Object.defineProperty(exports, "isExpressionError", {
   enumerable: true,
-  get: function () { return chunkZXM6LPRV_cjs.isExpressionError; }
+  get: function () { return chunkZ334X72N_cjs.isExpressionError; }
 });
 Object.defineProperty(exports, "isIndexGenerationError", {
   enumerable: true,
-  get: function () { return chunkZXM6LPRV_cjs.isIndexGenerationError; }
+  get: function () { return chunkZ334X72N_cjs.isIndexGenerationError; }
 });
 Object.defineProperty(exports, "isKeyGenerationError", {
   enumerable: true,
-  get: function () { return chunkZXM6LPRV_cjs.isKeyGenerationError; }
+  get: function () { return chunkZ334X72N_cjs.isKeyGenerationError; }
 });
 Object.defineProperty(exports, "isOperationError", {
   enumerable: true,
-  get: function () { return chunkZXM6LPRV_cjs.isOperationError; }
+  get: function () { return chunkZ334X72N_cjs.isOperationError; }
 });
 Object.defineProperty(exports, "isProvisionedThroughputExceeded", {
   enumerable: true,
-  get: function () { return chunkZXM6LPRV_cjs.isProvisionedThroughputExceeded; }
+  get: function () { return chunkZ334X72N_cjs.isProvisionedThroughputExceeded; }
 });
 Object.defineProperty(exports, "isRetryableError", {
   enumerable: true,
-  get: function () { return chunkZXM6LPRV_cjs.isRetryableError; }
+  get: function () { return chunkZ334X72N_cjs.isRetryableError; }
 });
 Object.defineProperty(exports, "isTransactionCanceled", {
   enumerable: true,
-  get: function () { return chunkZXM6LPRV_cjs.isTransactionCanceled; }
+  get: function () { return chunkZ334X72N_cjs.isTransactionCanceled; }
 });
 Object.defineProperty(exports, "isTransactionError", {
   enumerable: true,
-  get: function () { return chunkZXM6LPRV_cjs.isTransactionError; }
+  get: function () { return chunkZ334X72N_cjs.isTransactionError; }
 });
 Object.defineProperty(exports, "isValidationError", {
   enumerable: true,
-  get: function () { return chunkZXM6LPRV_cjs.isValidationError; }
+  get: function () { return chunkZ334X72N_cjs.isValidationError; }
 });
 Object.defineProperty(exports, "isValidationException", {
   enumerable: true,
-  get: function () { return chunkZXM6LPRV_cjs.isValidationException; }
+  get: function () { return chunkZ334X72N_cjs.isValidationException; }
 });
 Object.defineProperty(exports, "partitionKey", {
   enumerable: true,

package/dist/index.d.ts

@@ -1,273 +1,16 @@
-import { c as BatchError, d as ConfigurationError, E as ExpressionError, e as EntityValidationError, K as KeyGenerationError, I as IndexGenerationError, O as OperationError, f as TransactionError, V as ValidationError, g as DynoTableError, h as EntityError } from './index-Bc-ra0im.js';
-export { B as BatchBuilder, i as BatchResult, D as DeleteBuilder, j as DeleteOptions, k as ErrorCode, l as ErrorCodes, P as PutBuilder, m as PutOptions, Q as QueryBuilder, n as QueryOptions, T as TransactionBuilder, a as TransactionOptions, U as UpdateBuilder, o as UpdateOptions } from './index-Bc-ra0im.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, 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';
-export { EntityConfig, EntityRepository, IndexDefinition, QueryEntity, QueryRecord, createIndex, createQueries, defineEntity } from './entity.js';
-export { Table } from './table.js';
-export { partitionKey, sortKey } from './utils.js';
-import './types.js';
-import '@aws-sdk/lib-dynamodb';
-import './standard-schema.js';
-
-/**
- * Factory functions for Expression errors
- */
-declare const ExpressionErrors: {
-    missingAttribute: (conditionType: string, condition: unknown) => ExpressionError;
-    missingValue: (conditionType: string, condition: unknown) => ExpressionError;
-    invalidCondition: (conditionType: string, condition: unknown, suggestion?: string) => ExpressionError;
-    emptyArray: (conditionType: string, providedValue: unknown) => ExpressionError;
-    unknownType: (conditionType: string, condition: unknown) => ExpressionError;
-};
-/**
- * Factory functions for Validation errors
- */
-declare const ValidationErrors: {
-    indexSchemaValidationFailed: (validationIssues: unknown, keyType: "partition" | "sort" | "both") => ValidationError;
-    noUpdateActions: (tableName: string, key: Record<string, unknown>) => ValidationError;
-    conditionRequired: (tableName: string, key: Record<string, unknown>) => ValidationError;
-    queryInputValidationFailed: (entityName: string, queryName: string, validationIssues: unknown, providedInput: unknown) => ValidationError;
-    undefinedValue: (path: string, tableName: string, key: Record<string, unknown>) => ValidationError;
-};
-/**
- * Factory functions for Configuration errors
- */
-declare const ConfigurationErrors: {
-    invalidChunkSize: (size: number) => ConfigurationError;
-    sortKeyRequired: (tableName: string, partitionKey: string, sortKey?: string) => ConfigurationError;
-    sortKeyNotDefined: (tableName: string, partitionKey: string, indexName?: string) => ConfigurationError;
-    gsiNotFound: (indexName: string, tableName: string, availableIndexes: string[]) => ConfigurationError;
-    primaryKeyMissing: (tableName: string, partitionKeyName: string, providedItem: unknown) => ConfigurationError;
-    pkExtractionFailed: (tableName: string, indexName: string, item: unknown, cause?: Error) => ConfigurationError;
-    conditionGenerationFailed: (condition: unknown, suggestion?: string) => ExpressionError;
-};
-/**
- * Factory functions for Operation errors
- */
-declare const OperationErrors: {
-    queryFailed: (tableName: string, context: Record<string, unknown>, cause?: Error) => OperationError;
-    scanFailed: (tableName: string, context: Record<string, unknown>, cause?: Error) => OperationError;
-    getFailed: (tableName: string, key: Record<string, unknown>, cause?: Error) => OperationError;
-    putFailed: (tableName: string, item: unknown, cause?: Error) => OperationError;
-    updateFailed: (tableName: string, key: Record<string, unknown>, cause?: Error) => OperationError;
-    deleteFailed: (tableName: string, key: Record<string, unknown>, cause?: Error) => OperationError;
-    batchGetFailed: (tableName: string, context: Record<string, unknown>, cause?: Error) => OperationError;
-    batchWriteFailed: (tableName: string, context: Record<string, unknown>, cause?: Error) => OperationError;
-};
-/**
- * Factory functions for Transaction errors
- */
-declare const TransactionErrors: {
-    transactionFailed: (itemCount: number, context: Record<string, unknown>, cause?: Error) => TransactionError;
-    duplicateItem: (tableName: string, partitionKey: {
-        name: string;
-        value: unknown;
-    }, sortKey?: {
-        name: string;
-        value: unknown;
-    }) => TransactionError;
-    transactionEmpty: () => TransactionError;
-    unsupportedType: (item: unknown) => TransactionError;
-};
-/**
- * Factory functions for Batch errors
- */
-declare const BatchErrors: {
-    batchEmpty: (operation: "write" | "read") => BatchError;
-    unsupportedType: (operation: "write" | "read", item: unknown) => BatchError;
-    batchWriteFailed: (unprocessedItems: unknown[], context: Record<string, unknown>, cause?: Error) => BatchError;
-    batchGetFailed: (unprocessedItems: unknown[], context: Record<string, unknown>, cause?: Error) => BatchError;
-};
-/**
- * Factory functions for Entity errors
- */
-declare const EntityErrors: {
-    validationFailed: (entityName: string, operation: string, validationIssues: unknown, providedData: unknown) => EntityValidationError;
-    queryInputValidationFailed: (entityName: string, queryName: string, validationIssues: unknown, providedInput: unknown) => EntityValidationError;
-    asyncValidationNotSupported: (entityName: string, operation: string) => EntityValidationError;
-    keyGenerationFailed: (entityName: string, operation: string, providedData: unknown, requiredAttributes?: string[], cause?: Error) => KeyGenerationError;
-    keyInvalidFormat: (entityName: string, operation: string, providedData: unknown, generatedKey: unknown) => KeyGenerationError;
-    keyMissingAttributes: (entityName: string, operation: string, missingAttributes: string[], providedData: unknown) => KeyGenerationError;
-};
-/**
- * Factory functions for Index errors
- */
-declare const IndexErrors: {
-    generationFailed: (indexName: string, operation: string, providedItem: unknown, partitionKeyAttribute?: string, sortKeyAttribute?: string, cause?: Error) => IndexGenerationError;
-    missingAttributes: (indexName: string, operation: string, missingAttributes: string[], providedData: unknown, isReadOnly: boolean) => IndexGenerationError;
-    undefinedValues: (indexName: string, operation: string, generatedKey: unknown, providedItem: unknown) => IndexGenerationError;
-    notFound: (requestedIndexes: string[], availableIndexes: string[], entityName?: string, tableName?: string) => IndexGenerationError;
-    readonlyUpdateFailed: (indexName: string, operation: string, providedData: unknown) => IndexGenerationError;
-};
-
-/**
- * Utility functions for error handling
- *
- * This module provides helper functions for wrapping AWS SDK errors,
- * extracting information from errors, and formatting error context.
- */
-
-/**
- * Checks if an error is a DynamoDB conditional check failure
- *
- * @param error - The error to check
- * @returns true if the error is a conditional check failure
- */
-declare function isConditionalCheckFailed(error: unknown): boolean;
-/**
- * Checks if an error is a DynamoDB transaction cancellation
- *
- * @param error - The error to check
- * @returns true if the error is a transaction cancellation
- */
-declare function isTransactionCanceled(error: unknown): boolean;
-/**
- * Checks if an error is a DynamoDB validation exception
- *
- * @param error - The error to check
- * @returns true if the error is a validation exception
- */
-declare function isValidationException(error: unknown): boolean;
-/**
- * Checks if an error is a DynamoDB provisioned throughput exceeded exception
- *
- * @param error - The error to check
- * @returns true if the error is a throughput exceeded exception
- */
-declare function isProvisionedThroughputExceeded(error: unknown): boolean;
-/**
- * Checks if an error is a retryable error
- *
- * Retryable errors include:
- * - ProvisionedThroughputExceededException
- * - ThrottlingException
- * - RequestLimitExceeded
- * - InternalServerError
- * - ServiceUnavailable
- *
- * @param error - The error to check
- * @returns true if the error is retryable
- */
-declare function isRetryableError(error: unknown): boolean;
-/**
- * Extracts the AWS error code from an error
- *
- * @param error - The error to extract the code from
- * @returns The error code, or undefined if not found
- */
-declare function getAwsErrorCode(error: unknown): string | undefined;
-/**
- * Extracts the AWS error message from an error
- *
- * @param error - The error to extract the message from
- * @returns The error message, or undefined if not found
- */
-declare function getAwsErrorMessage(error: unknown): string | undefined;
-/**
- * Attempts to extract required attribute names from an error message
- *
- * This is a best-effort function that looks for common patterns in error
- * messages to identify which attributes are missing or required.
- *
- * @param error - The error to extract attributes from
- * @returns Array of attribute names, or undefined if none found
- */
-declare function extractRequiredAttributes(error: unknown): string[] | undefined;
-/**
- * Formats error context for logging
- *
- * Converts the error context object to a readable string format,
- * handling special types like arrays and nested objects.
- *
- * @param context - The error context to format
- * @param indent - The indentation level (for nested objects)
- * @returns Formatted context string
- */
-declare function formatErrorContext(context: Record<string, unknown>, indent?: number): string;
-/**
- * Creates a detailed error summary including context
- *
- * Useful for logging or displaying error information to developers.
- *
- * @param error - The DynoTableError to summarize
- * @returns Formatted error summary
- */
-declare function getErrorSummary(error: DynoTableError): string;
-/**
- * Type guard to check if an error is a DynoTableError
- *
- * @param error - The error to check
- * @returns true if the error is a DynoTableError
- */
-declare function isDynoTableError(error: unknown): error is DynoTableError;
-/**
- * Type guard to check if an error is a ValidationError
- *
- * @param error - The error to check
- * @returns true if the error is a ValidationError
- */
-declare function isValidationError(error: unknown): error is ValidationError;
-/**
- * Type guard to check if an error is an OperationError
- *
- * @param error - The error to check
- * @returns true if the error is an OperationError
- */
-declare function isOperationError(error: unknown): error is OperationError;
-/**
- * Type guard to check if an error is a TransactionError
- *
- * @param error - The error to check
- * @returns true if the error is a TransactionError
- */
-declare function isTransactionError(error: unknown): error is TransactionError;
-/**
- * Type guard to check if an error is a BatchError
- *
- * @param error - The error to check
- * @returns true if the error is a BatchError
- */
-declare function isBatchError(error: unknown): error is BatchError;
-/**
- * Type guard to check if an error is an ExpressionError
- *
- * @param error - The error to check
- * @returns true if the error is an ExpressionError
- */
-declare function isExpressionError(error: unknown): error is ExpressionError;
-/**
- * Type guard to check if an error is a ConfigurationError
- *
- * @param error - The error to check
- * @returns true if the error is a ConfigurationError
- */
-declare function isConfigurationError(error: unknown): error is ConfigurationError;
-/**
- * Type guard to check if an error is an EntityError
- *
- * @param error - The error to check
- * @returns true if the error is an EntityError
- */
-declare function isEntityError(error: unknown): error is EntityError;
-/**
- * Type guard to check if an error is a KeyGenerationError
- *
- * @param error - The error to check
- * @returns true if the error is a KeyGenerationError
- */
-declare function isKeyGenerationError(error: unknown): error is KeyGenerationError;
-/**
- * Type guard to check if an error is an IndexGenerationError
- *
- * @param error - The error to check
- * @returns true if the error is an IndexGenerationError
- */
-declare function isIndexGenerationError(error: unknown): error is IndexGenerationError;
-/**
- * Type guard to check if an error is an EntityValidationError
- *
- * @param error - The error to check
- * @returns true if the error is an EntityValidationError
- */
-declare function isEntityValidationError(error: unknown): error is EntityValidationError;
-
-export { BatchError, BatchErrors, ConfigurationError, ConfigurationErrors, DynoTableError, EntityError, EntityErrors, EntityValidationError, ExpressionError, ExpressionErrors, IndexErrors, IndexGenerationError, KeyGenerationError, OperationError, OperationErrors, TransactionError, TransactionErrors, ValidationError, ValidationErrors, extractRequiredAttributes, formatErrorContext, getAwsErrorCode, getAwsErrorMessage, getErrorSummary, isBatchError, isConditionalCheckFailed, isConfigurationError, isDynoTableError, isEntityError, isEntityValidationError, isExpressionError, isIndexGenerationError, isKeyGenerationError, isOperationError, isProvisionedThroughputExceeded, isRetryableError, isTransactionCanceled, isTransactionError, isValidationError, isValidationException };
+export { BatchBuilder, type BatchResult } from "./builders/batch-builder";
+export { DeleteBuilder, type DeleteOptions } from "./builders/delete-builder";
+export { PutBuilder, type PutOptions } from "./builders/put-builder";
+export { QueryBuilder, type QueryOptions } from "./builders/query-builder";
+export { TransactionBuilder, type TransactionOptions } from "./builders/transaction-builder";
+export { UpdateBuilder, type UpdateOptions } from "./builders/update-builder";
+export type { ComparisonOperator, Condition, ConditionOperator, ExpressionParams, KeyConditionOperator, LogicalOperator, PrimaryKey, PrimaryKeyWithoutExpression, } from "./conditions";
+export { and, attributeExists, attributeNotExists, beginsWith, between, contains, eq, gt, gte, inArray, lt, lte, ne, not, or, } from "./conditions";
+export type { EntityConfig, EntityDefinition, EntityDeleteBuilder, EntityGetBuilder, EntityPutBuilder, EntityRepository, EntityUpdateBuilder, IndexDefinition, QueryEntity, QueryRecord, } from "./entity/entity";
+export { createIndex, createQueries, defineEntity } from "./entity/entity";
+export * from "./errors";
+export { Table } from "./table";
+export { BatchErrors, ConfigurationErrors, EntityErrors, ExpressionErrors, IndexErrors, OperationErrors, TransactionErrors, ValidationErrors, } from "./utils/error-factory";
+export * from "./utils/error-utils";
+export { partitionKey } from "./utils/partition-key-template";
+export { sortKey } from "./utils/sort-key-template";

package/dist/index.js

@@ -1,5 +1,5 @@
 export { Table } from './chunk-42LH2UEM.js';
-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 } from './chunk-U6MQGB6Y.js';
+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 } from './chunk-JZB6TYST.js';
 export { partitionKey, sortKey } from './chunk-QVRMYGC4.js';
 export { BatchBuilder, DeleteBuilder, PutBuilder, QueryBuilder, TransactionBuilder, UpdateBuilder } from './chunk-NYJGW3XH.js';
 export { BatchError, BatchErrors, ConfigurationError, ConfigurationErrors, DynoTableError, EntityError, EntityErrors, EntityValidationError, ErrorCodes, ExpressionError, ExpressionErrors, IndexErrors, IndexGenerationError, KeyGenerationError, OperationError, OperationErrors, TransactionError, TransactionErrors, ValidationError, ValidationErrors } from './chunk-FF7FYGDH.js';