dyno-table 2.3.2 → 2.4.0

package/dist/index.d.ts

@@ -1,8 +1,273 @@
-export { B as BatchBuilder, a as BatchError, b as BatchResult, D as DeleteBuilder, c as DeleteOptions, P as PutBuilder, d as PutOptions, Q as QueryBuilder, e as QueryOptions, T as TransactionBuilder, f as TransactionOptions, U as UpdateBuilder, g as UpdateOptions } from './index-2cbm07Bi.js';
-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, 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';
+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-DdTolMJW.js';
+export { B as BatchBuilder, i as BatchResult, D as DeleteBuilder, j as DeleteOptions, o as ErrorCode, n as ErrorCodes, P as PutBuilder, k as PutOptions, Q as QueryBuilder, l as QueryOptions, T as TransactionBuilder, a as TransactionOptions, U as UpdateBuilder, m as UpdateOptions } from './index-DdTolMJW.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 };

package/dist/index.js

@@ -1,5 +1,6 @@
-export { Table } from './chunk-EODPMYPE.js';
-export { createIndex, createQueries, defineEntity } from './chunk-2EWNZOUK.js';
+export { Table } from './chunk-64DG2EEI.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 { partitionKey, sortKey } from './chunk-QVRMYGC4.js';
-export { BatchBuilder, BatchError, DeleteBuilder, PutBuilder, QueryBuilder, TransactionBuilder, UpdateBuilder } from './chunk-DTFJJASK.js';
+export { BatchBuilder, DeleteBuilder, PutBuilder, QueryBuilder, TransactionBuilder, UpdateBuilder } from './chunk-GWHGUKAL.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';
 export { and, attributeExists, attributeNotExists, beginsWith, between, contains, eq, gt, gte, inArray, lt, lte, ne, not, or } from './chunk-2WIBY7PZ.js';

package/dist/table.cjs

@@ -1,12 +1,13 @@
 'use strict';
 
-var chunkKA3VPIPS_cjs = require('./chunk-KA3VPIPS.cjs');
-require('./chunk-XYL43FDX.cjs');
+var chunkOLURZQ7R_cjs = require('./chunk-OLURZQ7R.cjs');
+require('./chunk-AHF4H42Q.cjs');
+require('./chunk-ELULXDSB.cjs');
 require('./chunk-7UJJ7JXM.cjs');
 
 
 
 Object.defineProperty(exports, "Table", {
   enumerable: true,
-  get: function () { return chunkKA3VPIPS_cjs.Table; }
+  get: function () { return chunkOLURZQ7R_cjs.Table; }
 });

package/dist/table.d.cts

@@ -1,5 +1,5 @@
-import { P as PutBuilder, G as GetBuilder, Q as QueryBuilder, S as ScanBuilder, D as DeleteBuilder, U as UpdateBuilder, T as TransactionBuilder, B as BatchBuilder, f as TransactionOptions, C as ConditionCheckBuilder, h as BatchWriteOperation } from './index-DlN8G9hd.cjs';
-import { c as PrimaryKeyWithoutExpression, P as PrimaryKey } from './conditions-CcZL0sR2.cjs';
+import { P as PutBuilder, G as GetBuilder, Q as QueryBuilder, S as ScanBuilder, D as DeleteBuilder, U as UpdateBuilder, T as TransactionBuilder, B as BatchBuilder, a as TransactionOptions, C as ConditionCheckBuilder, b as BatchWriteOperation } from './index-BX-MSZHj.cjs';
+import { P as PrimaryKeyWithoutExpression, a as PrimaryKey } from './conditions-C8bM__Pn.cjs';
 import { TableConfig, Index, DynamoItem } from './types.cjs';
 import '@aws-sdk/lib-dynamodb';
 

package/dist/table.d.ts

@@ -1,5 +1,5 @@
-import { P as PutBuilder, G as GetBuilder, Q as QueryBuilder, S as ScanBuilder, D as DeleteBuilder, U as UpdateBuilder, T as TransactionBuilder, B as BatchBuilder, f as TransactionOptions, C as ConditionCheckBuilder, h as BatchWriteOperation } from './index-2cbm07Bi.js';
-import { c as PrimaryKeyWithoutExpression, P as PrimaryKey } from './conditions-D_w7vVYG.js';
+import { P as PutBuilder, G as GetBuilder, Q as QueryBuilder, S as ScanBuilder, D as DeleteBuilder, U as UpdateBuilder, T as TransactionBuilder, B as BatchBuilder, a as TransactionOptions, C as ConditionCheckBuilder, b as BatchWriteOperation } from './index-DdTolMJW.js';
+import { P as PrimaryKeyWithoutExpression, a as PrimaryKey } from './conditions-BSAcZswY.js';
 import { TableConfig, Index, DynamoItem } from './types.js';
 import '@aws-sdk/lib-dynamodb';
 

package/dist/table.js

@@ -1,3 +1,4 @@
-export { Table } from './chunk-EODPMYPE.js';
-import './chunk-DTFJJASK.js';
+export { Table } from './chunk-64DG2EEI.js';
+import './chunk-GWHGUKAL.js';
+import './chunk-FF7FYGDH.js';
 import './chunk-2WIBY7PZ.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dyno-table",
-  "version": "2.3.2",
+  "version": "2.4.0",
   "description": "A TypeScript library to simplify working with DynamoDB",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",