dyno-table 1.0.0-alpha.1 → 1.0.0

package/dist/builders/transaction-builder.js

@@ -0,0 +1,892 @@
+// src/expression.ts
+var generateAttributeName = (params, attr) => {
+  for (const [existingName, existingAttr] of Object.entries(params.expressionAttributeNames)) {
+    if (existingAttr === attr) {
+      return existingName;
+    }
+  }
+  const attrName = `#${Object.keys(params.expressionAttributeNames).length}`;
+  params.expressionAttributeNames[attrName] = attr;
+  return attrName;
+};
+var generateValueName = (params, value) => {
+  const valueName = `:${params.valueCounter.count++}`;
+  params.expressionAttributeValues[valueName] = value;
+  return valueName;
+};
+var validateCondition = (condition, requiresAttr = true, requiresValue = true) => {
+  if (requiresAttr && !condition.attr) {
+    throw new Error(`Attribute is required for ${condition.type} condition`);
+  }
+  if (requiresValue && condition.value === void 0) {
+    throw new Error(`Value is required for ${condition.type} condition`);
+  }
+};
+var buildComparisonExpression = (condition, operator, params) => {
+  validateCondition(condition);
+  if (!condition.attr) {
+    throw new Error(`Attribute is required for ${condition.type} condition`);
+  }
+  const attrName = generateAttributeName(params, condition.attr);
+  const valueName = generateValueName(params, condition.value);
+  return `${attrName} ${operator} ${valueName}`;
+};
+var buildBetweenExpression = (condition, params) => {
+  validateCondition(condition);
+  if (!condition.attr) {
+    throw new Error(`Attribute is required for ${condition.type} condition`);
+  }
+  if (!Array.isArray(condition.value) || condition.value.length !== 2) {
+    throw new Error("Between condition requires an array of two values");
+  }
+  const attrName = generateAttributeName(params, condition.attr);
+  const lowerName = generateValueName(params, condition.value[0]);
+  const upperName = generateValueName(params, condition.value[1]);
+  return `${attrName} BETWEEN ${lowerName} AND ${upperName}`;
+};
+var buildFunctionExpression = (functionName, condition, params) => {
+  validateCondition(condition);
+  if (!condition.attr) {
+    throw new Error(`Attribute is required for ${condition.type} condition`);
+  }
+  const attrName = generateAttributeName(params, condition.attr);
+  const valueName = generateValueName(params, condition.value);
+  return `${functionName}(${attrName}, ${valueName})`;
+};
+var buildAttributeFunction = (functionName, condition, params) => {
+  validateCondition(condition, true, false);
+  if (!condition.attr) {
+    throw new Error(`Attribute is required for ${condition.type} condition`);
+  }
+  const attrName = generateAttributeName(params, condition.attr);
+  return `${functionName}(${attrName})`;
+};
+var buildLogicalExpression = (operator, conditions, params) => {
+  if (!conditions || conditions.length === 0) {
+    throw new Error(`At least one condition is required for ${operator} expression`);
+  }
+  const expressions = conditions.map((c) => buildExpression(c, params));
+  return `(${expressions.join(` ${operator} `)})`;
+};
+var buildExpression = (condition, params) => {
+  if (!condition) return "";
+  try {
+    const expressionBuilders = {
+      eq: () => buildComparisonExpression(condition, "=", params),
+      ne: () => buildComparisonExpression(condition, "<>", params),
+      lt: () => buildComparisonExpression(condition, "<", params),
+      lte: () => buildComparisonExpression(condition, "<=", params),
+      gt: () => buildComparisonExpression(condition, ">", params),
+      gte: () => buildComparisonExpression(condition, ">=", params),
+      between: () => buildBetweenExpression(condition, params),
+      beginsWith: () => buildFunctionExpression("begins_with", condition, params),
+      contains: () => buildFunctionExpression("contains", condition, params),
+      attributeExists: () => buildAttributeFunction("attribute_exists", condition, params),
+      attributeNotExists: () => buildAttributeFunction("attribute_not_exists", condition, params),
+      and: () => {
+        if (!condition.conditions) {
+          throw new Error("Conditions array is required for AND operator");
+        }
+        return buildLogicalExpression("AND", condition.conditions, params);
+      },
+      or: () => {
+        if (!condition.conditions) {
+          throw new Error("Conditions array is required for OR operator");
+        }
+        return buildLogicalExpression("OR", condition.conditions, params);
+      },
+      not: () => {
+        if (!condition.condition) {
+          throw new Error("Condition is required for NOT operator");
+        }
+        return `NOT (${buildExpression(condition.condition, params)})`;
+      }
+    };
+    const builder = expressionBuilders[condition.type];
+    if (!builder) {
+      throw new Error(`Unknown condition type: ${condition.type}`);
+    }
+    return builder();
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(`Error building expression for condition type ${condition.type}:`, error.message);
+    } else {
+      console.error(`Error building expression for condition type ${condition.type}:`, error);
+    }
+    throw error;
+  }
+};
+var prepareExpressionParams = (condition) => {
+  if (!condition) return {};
+  const params = {
+    expressionAttributeNames: {},
+    expressionAttributeValues: {},
+    valueCounter: { count: 0 }
+  };
+  const expression = buildExpression(condition, params);
+  return {
+    expression,
+    names: Object.keys(params.expressionAttributeNames).length > 0 ? params.expressionAttributeNames : void 0,
+    values: Object.keys(params.expressionAttributeValues).length > 0 ? params.expressionAttributeValues : void 0
+  };
+};
+
+// src/utils/debug-expression.ts
+function debugCommand(command) {
+  const result = {};
+  function replaceAliases(expressionString) {
+    if (!expressionString) {
+      return expressionString;
+    }
+    let replacedString = expressionString;
+    for (const alias in command.expressionAttributeNames) {
+      const attributeName = command.expressionAttributeNames[alias];
+      const regex = new RegExp(alias, "g");
+      replacedString = replacedString.replace(regex, attributeName);
+    }
+    for (const alias in command.expressionAttributeValues) {
+      let attributeValue = command.expressionAttributeValues[alias];
+      if (attributeValue instanceof Set) {
+        const array = Array.from(attributeValue);
+        attributeValue = `Set(${array.length}){${array.map((v) => JSON.stringify(v)).join(", ")}}`;
+      } else {
+        attributeValue = JSON.stringify(attributeValue);
+      }
+      const regex = new RegExp(alias, "g");
+      replacedString = replacedString.replace(regex, attributeValue);
+    }
+    return replacedString;
+  }
+  if (command.updateExpression) {
+    result.updateExpression = replaceAliases(command.updateExpression);
+  }
+  if (command.conditionExpression) {
+    result.conditionExpression = replaceAliases(command.conditionExpression);
+  }
+  if (command.filterExpression) {
+    result.filterExpression = replaceAliases(command.filterExpression);
+  }
+  if (command.keyConditionExpression) {
+    result.keyConditionExpression = replaceAliases(command.keyConditionExpression);
+  }
+  if (command.projectionExpression) {
+    result.projectionExpression = replaceAliases(command.projectionExpression);
+  }
+  return {
+    raw: command,
+    readable: result
+  };
+}
+
+// src/utils/debug-transaction.ts
+function debugTransactionItem(item) {
+  const result = {
+    type: item.type,
+    tableName: item.params.tableName
+  };
+  if ("key" in item.params) {
+    result.key = item.params.key;
+  }
+  if (item.type === "Put") {
+    result.item = item.params.item;
+  }
+  switch (item.type) {
+    case "Put":
+    case "Delete":
+    case "ConditionCheck":
+      result.readable = debugCommand(item.params).readable;
+      break;
+    case "Update":
+      result.readable = debugCommand(item.params).readable;
+      break;
+  }
+  return result;
+}
+function debugTransaction(items) {
+  return items.map((item) => debugTransactionItem(item));
+}
+
+// src/builders/transaction-builder.ts
+var TransactionBuilder = class {
+  items = [];
+  options = {};
+  indexConfig;
+  executor;
+  constructor(executor, indexConfig) {
+    this.executor = executor;
+    this.indexConfig = indexConfig;
+  }
+  /**
+   * Checks if an item with the same primary key already exists in the transaction
+   * @private
+   */
+  checkForDuplicateItem(tableName, newItem) {
+    const pkName = this.indexConfig.partitionKey;
+    const skName = this.indexConfig.sortKey ?? "";
+    const pkValue = newItem[pkName];
+    const skValue = skName ? newItem[skName] : void 0;
+    if (!pkValue) {
+      throw new Error(`Primary key value for '${pkName}' is missing`);
+    }
+    const duplicateItem = this.items.find((item) => {
+      let itemKey;
+      let itemTableName;
+      switch (item.type) {
+        case "Put":
+          itemTableName = item.params.tableName;
+          itemKey = item.params.item;
+          break;
+        case "Update":
+        case "Delete":
+        case "ConditionCheck":
+          itemTableName = item.params.tableName;
+          itemKey = item.params.key;
+          break;
+      }
+      if (itemTableName === tableName && itemKey) {
+        const itemPkValue = itemKey[pkName];
+        const itemSkValue = skName ? itemKey[skName] : void 0;
+        if (itemPkValue === pkValue) {
+          if (skValue === void 0 && itemSkValue === void 0) {
+            return true;
+          }
+          if (skValue !== void 0 && itemSkValue !== void 0 && skValue === itemSkValue) {
+            return true;
+          }
+        }
+      }
+      return false;
+    });
+    if (duplicateItem) {
+      throw new Error(
+        `Duplicate item detected in transaction: Table=${tableName}, ${pkName}=${String(pkValue)}, ${skName}=${skValue !== void 0 ? String(skValue) : "undefined"}. DynamoDB transactions do not allow multiple operations on the same item.`
+      );
+    }
+  }
+  createKeyForPrimaryIndex(key) {
+    const keyCondition = {
+      [this.indexConfig.partitionKey]: key.pk
+    };
+    if (this.indexConfig.sortKey) {
+      if (key.sk === void 0) {
+        throw new Error("Sort key is required for delete operation");
+      }
+      keyCondition[this.indexConfig.sortKey] = key.sk;
+    }
+    return keyCondition;
+  }
+  /**
+   * Adds a put operation to the transaction.
+   * Use this method when you need to:
+   * - Insert new items as part of a transaction
+   * - Replace existing items atomically
+   * - Ensure items meet certain conditions before insertion
+   *
+   * The method automatically checks for duplicate items within the transaction
+   * to prevent multiple operations on the same item.
+   *
+   * @example
+   * ```typescript
+   * // Simple put operation
+   * transaction.put('orders', {
+   *   orderId: '123',
+   *   status: 'PENDING',
+   *   amount: 100
+   * });
+   *
+   * // Conditional put operation
+   * transaction.put(
+   *   'inventory',
+   *   { productId: 'ABC', quantity: 50 },
+   *   op => op.attributeNotExists('productId')
+   * );
+   *
+   * // Put with complex condition
+   * transaction.put(
+   *   'users',
+   *   { userId: '123', status: 'ACTIVE' },
+   *   op => op.and([
+   *     op.attributeNotExists('userId'),
+   *     op.beginsWith('status', 'ACTIVE')
+   *   ])
+   * );
+   * ```
+   *
+   * @param tableName - The name of the DynamoDB table
+   * @param item - The item to put into the table
+   * @param condition - Optional condition that must be satisfied
+   * @returns The transaction builder for method chaining
+   * @throws {Error} If a duplicate item is detected in the transaction
+   */
+  put(tableName, item, condition) {
+    this.checkForDuplicateItem(tableName, item);
+    const transactionItem = {
+      type: "Put",
+      params: {
+        tableName,
+        item
+      }
+    };
+    if (condition) {
+      const { expression, names, values } = prepareExpressionParams(condition);
+      transactionItem.params.conditionExpression = expression;
+      transactionItem.params.expressionAttributeNames = names;
+      transactionItem.params.expressionAttributeValues = values;
+    }
+    this.items.push(transactionItem);
+    return this;
+  }
+  /**
+   * Adds a pre-configured put operation to the transaction.
+   * Use this method when you need to:
+   * - Reuse put commands from PutBuilder
+   * - Add complex put operations with pre-configured parameters
+   * - Integrate with existing put command configurations
+   *
+   * This method is particularly useful when working with PutBuilder
+   * to maintain consistency in put operations across your application.
+   *
+   * @example
+   * ```typescript
+   * // Create a put command with PutBuilder
+   * const putCommand = new PutBuilder(executor, newItem, 'users')
+   *   .condition(op => op.attributeNotExists('userId'))
+   *   .toDynamoCommand();
+   *
+   * // Add the command to the transaction
+   * transaction.putWithCommand(putCommand);
+   * ```
+   *
+   * @param command - The complete put command configuration
+   * @returns The transaction builder for method chaining
+   * @throws {Error} If a duplicate item is detected in the transaction
+   * @see PutBuilder for creating put commands
+   */
+  putWithCommand(command) {
+    this.checkForDuplicateItem(command.tableName, command.item);
+    const transactionItem = {
+      type: "Put",
+      params: command
+    };
+    this.items.push(transactionItem);
+    return this;
+  }
+  /**
+   * Adds a delete operation to the transaction.
+   * Use this method when you need to:
+   * - Remove items as part of a transaction
+   * - Conditionally delete items
+   * - Ensure items exist before deletion
+   *
+   * The method automatically checks for duplicate items within the transaction
+   * to prevent multiple operations on the same item.
+   *
+   * @example
+   * ```typescript
+   * // Simple delete operation
+   * transaction.delete('orders', {
+   *   pk: 'ORDER#123',
+   *   sk: 'METADATA'
+   * });
+   *
+   * // Conditional delete operation
+   * transaction.delete(
+   *   'users',
+   *   { pk: 'USER#123' },
+   *   op => op.eq('status', 'INACTIVE')
+   * );
+   *
+   * // Delete with complex condition
+   * transaction.delete(
+   *   'products',
+   *   { pk: 'PROD#ABC' },
+   *   op => op.and([
+   *     op.eq('status', 'DRAFT'),
+   *     op.lt('version', 5)
+   *   ])
+   * );
+   * ```
+   *
+   * @param tableName - The name of the DynamoDB table
+   * @param key - The primary key of the item to delete
+   * @param condition - Optional condition that must be satisfied
+   * @returns The transaction builder for method chaining
+   * @throws {Error} If a duplicate item is detected in the transaction
+   */
+  delete(tableName, key, condition) {
+    const keyCondition = this.createKeyForPrimaryIndex(key);
+    this.checkForDuplicateItem(tableName, keyCondition);
+    const transactionItem = {
+      type: "Delete",
+      params: {
+        tableName,
+        key: keyCondition
+      }
+    };
+    if (condition) {
+      const { expression, names, values } = prepareExpressionParams(condition);
+      transactionItem.params.conditionExpression = expression;
+      transactionItem.params.expressionAttributeNames = names;
+      transactionItem.params.expressionAttributeValues = values;
+    }
+    this.items.push(transactionItem);
+    return this;
+  }
+  /**
+   * Adds a pre-configured delete operation to the transaction.
+   * Use this method when you need to:
+   * - Reuse delete commands from DeleteBuilder
+   * - Add complex delete operations with pre-configured parameters
+   * - Integrate with existing delete command configurations
+   *
+   * This method is particularly useful when working with DeleteBuilder
+   * to maintain consistency in delete operations across your application.
+   *
+   * @example
+   * ```typescript
+   * // Create a delete command with DeleteBuilder
+   * const deleteCommand = new DeleteBuilder(executor, 'users', { pk: 'USER#123' })
+   *   .condition(op => op.and([
+   *     op.attributeExists('pk'),
+   *     op.eq('status', 'INACTIVE')
+   *   ]))
+   *   .toDynamoCommand();
+   *
+   * // Add the command to the transaction
+   * transaction.deleteWithCommand(deleteCommand);
+   * ```
+   *
+   * @param command - The complete delete command configuration
+   * @returns The transaction builder for method chaining
+   * @throws {Error} If a duplicate item is detected in the transaction
+   * @see DeleteBuilder for creating delete commands
+   */
+  deleteWithCommand(command) {
+    const keyCondition = this.createKeyForPrimaryIndex(command.key);
+    this.checkForDuplicateItem(command.tableName, keyCondition);
+    const transactionItem = {
+      type: "Delete",
+      params: {
+        ...command,
+        key: keyCondition
+      }
+    };
+    this.items.push(transactionItem);
+    return this;
+  }
+  /**
+   * Adds an update operation to the transaction.
+   * Use this method when you need to:
+   * - Modify existing items as part of a transaction
+   * - Update multiple attributes atomically
+   * - Apply conditional updates
+   * - Perform complex attribute manipulations
+   *
+   * The method supports all DynamoDB update expressions:
+   * - SET: Modify or add attributes
+   * - REMOVE: Delete attributes
+   * - ADD: Update numbers and sets
+   * - DELETE: Remove elements from a set
+   *
+   * @example
+   * ```typescript
+   * // Simple update
+   * transaction.update(
+   *   'orders',
+   *   { pk: 'ORDER#123' },
+   *   'SET #status = :status',
+   *   { '#status': 'status' },
+   *   { ':status': 'PROCESSING' }
+   * );
+   *
+   * // Complex update with multiple operations
+   * transaction.update(
+   *   'products',
+   *   { pk: 'PROD#ABC' },
+   *   'SET #qty = #qty - :amount, #status = :status REMOVE #oldAttr',
+   *   { '#qty': 'quantity', '#status': 'status', '#oldAttr': 'deprecated_field' },
+   *   { ':amount': 1, ':status': 'LOW_STOCK' }
+   * );
+   *
+   * // Conditional update
+   * transaction.update(
+   *   'users',
+   *   { pk: 'USER#123' },
+   *   'SET #lastLogin = :now',
+   *   { '#lastLogin': 'lastLoginDate' },
+   *   { ':now': new Date().toISOString() },
+   *   op => op.attributeExists('pk')
+   * );
+   * ```
+   *
+   * @param tableName - The name of the DynamoDB table
+   * @param key - The primary key of the item to update
+   * @param updateExpression - The update expression (SET, REMOVE, ADD, DELETE)
+   * @param expressionAttributeNames - Map of attribute name placeholders to actual names
+   * @param expressionAttributeValues - Map of value placeholders to actual values
+   * @param condition - Optional condition that must be satisfied
+   * @returns The transaction builder for method chaining
+   * @throws {Error} If a duplicate item is detected in the transaction
+   */
+  update(tableName, key, updateExpression, expressionAttributeNames, expressionAttributeValues, condition) {
+    const keyCondition = this.createKeyForPrimaryIndex(key);
+    this.checkForDuplicateItem(tableName, keyCondition);
+    const transactionItem = {
+      type: "Update",
+      params: {
+        tableName,
+        key: keyCondition,
+        updateExpression,
+        expressionAttributeNames,
+        expressionAttributeValues
+      }
+    };
+    if (condition) {
+      const { expression, names, values } = prepareExpressionParams(condition);
+      transactionItem.params.conditionExpression = expression;
+      transactionItem.params.expressionAttributeNames = {
+        ...transactionItem.params.expressionAttributeNames,
+        ...names
+      };
+      transactionItem.params.expressionAttributeValues = {
+        ...transactionItem.params.expressionAttributeValues,
+        ...values
+      };
+    }
+    this.items.push(transactionItem);
+    return this;
+  }
+  /**
+   * Adds a pre-configured update operation to the transaction.
+   * Use this method when you need to:
+   * - Reuse update commands from UpdateBuilder
+   * - Add complex update operations with pre-configured parameters
+   * - Integrate with existing update command configurations
+   *
+   * This method is particularly useful when working with UpdateBuilder
+   * to maintain consistency in update operations across your application.
+   *
+   * @example
+   * ```typescript
+   * // Create an update command with UpdateBuilder
+   * const updateCommand = new UpdateBuilder(executor, 'inventory', { pk: 'PROD#ABC' })
+   *   .set('quantity', ':qty')
+   *   .set('lastUpdated', ':now')
+   *   .values({
+   *     ':qty': 100,
+   *     ':now': new Date().toISOString()
+   *   })
+   *   .condition(op => op.gt('quantity', 0))
+   *   .toDynamoCommand();
+   *
+   * // Add the command to the transaction
+   * transaction.updateWithCommand(updateCommand);
+   * ```
+   *
+   * @param command - The complete update command configuration
+   * @returns The transaction builder for method chaining
+   * @throws {Error} If a duplicate item is detected in the transaction
+   * @see UpdateBuilder for creating update commands
+   */
+  updateWithCommand(command) {
+    const keyCondition = this.createKeyForPrimaryIndex(command.key);
+    this.checkForDuplicateItem(command.tableName, keyCondition);
+    const transactionItem = {
+      type: "Update",
+      params: {
+        ...command,
+        key: keyCondition
+      }
+    };
+    this.items.push(transactionItem);
+    return this;
+  }
+  /**
+   * Adds a condition check operation to the transaction.
+   * Use this method when you need to:
+   * - Validate item state without modifying it
+   * - Ensure data consistency across tables
+   * - Implement complex business rules
+   * - Verify preconditions for other operations
+   *
+   * Condition checks are particularly useful for:
+   * - Implementing optimistic locking
+   * - Ensuring referential integrity
+   * - Validating business rules atomically
+   *
+   * @example
+   * ```typescript
+   * // Check if order is in correct state
+   * transaction.conditionCheck(
+   *   'orders',
+   *   { pk: 'ORDER#123' },
+   *   op => op.eq('status', 'PENDING')
+   * );
+   *
+   * // Complex condition check
+   * transaction.conditionCheck(
+   *   'inventory',
+   *   { pk: 'PROD#ABC' },
+   *   op => op.and([
+   *     op.gt('quantity', 0),
+   *     op.eq('status', 'ACTIVE'),
+   *     op.attributeExists('lastRestockDate')
+   *   ])
+   * );
+   *
+   * // Check with multiple attributes
+   * transaction.conditionCheck(
+   *   'users',
+   *   { pk: 'USER#123' },
+   *   op => op.or([
+   *     op.eq('status', 'PREMIUM'),
+   *     op.gte('credits', 100)
+   *   ])
+   * );
+   * ```
+   *
+   * @param tableName - The name of the DynamoDB table
+   * @param key - The primary key of the item to check
+   * @param condition - The condition that must be satisfied
+   * @returns The transaction builder for method chaining
+   * @throws {Error} If a duplicate item is detected in the transaction
+   * @throws {Error} If condition expression generation fails
+   */
+  conditionCheck(tableName, key, condition) {
+    const keyCondition = this.createKeyForPrimaryIndex(key);
+    this.checkForDuplicateItem(tableName, keyCondition);
+    const { expression, names, values } = prepareExpressionParams(condition);
+    if (!expression) {
+      throw new Error("Failed to generate condition expression");
+    }
+    const transactionItem = {
+      type: "ConditionCheck",
+      params: {
+        tableName,
+        key: keyCondition,
+        conditionExpression: expression,
+        expressionAttributeNames: names,
+        expressionAttributeValues: values
+      }
+    };
+    this.items.push(transactionItem);
+    return this;
+  }
+  /**
+   * Adds a pre-configured condition check operation to the transaction.
+   * Use this method when you need to:
+   * - Reuse condition checks from ConditionCheckBuilder
+   * - Add complex condition checks with pre-configured parameters
+   * - Integrate with existing condition check configurations
+   *
+   * This method is particularly useful when working with ConditionCheckBuilder
+   * to maintain consistency in condition checks across your application.
+   *
+   * @example
+   * ```typescript
+   * // Create a condition check with ConditionCheckBuilder
+   * const checkCommand = new ConditionCheckBuilder('inventory', { pk: 'PROD#ABC' })
+   *   .condition(op => op.and([
+   *     op.between('quantity', 10, 100),
+   *     op.beginsWith('category', 'ELECTRONICS'),
+   *     op.attributeExists('lastAuditDate')
+   *   ]))
+   *   .toDynamoCommand();
+   *
+   * // Add the command to the transaction
+   * transaction.conditionCheckWithCommand(checkCommand);
+   * ```
+   *
+   * @param command - The complete condition check command configuration
+   * @returns The transaction builder for method chaining
+   * @throws {Error} If a duplicate item is detected in the transaction
+   * @see ConditionCheckBuilder for creating condition check commands
+   */
+  conditionCheckWithCommand(command) {
+    const keyCondition = this.createKeyForPrimaryIndex(command.key);
+    this.checkForDuplicateItem(command.tableName, keyCondition);
+    const transactionItem = {
+      type: "ConditionCheck",
+      params: {
+        ...command,
+        key: keyCondition
+      }
+    };
+    this.items.push(transactionItem);
+    return this;
+  }
+  /**
+   * Sets options for the transaction execution.
+   * Use this method when you need to:
+   * - Enable idempotent transactions
+   * - Track consumed capacity
+   * - Monitor item collection metrics
+   *
+   * @example
+   * ```typescript
+   * // Enable idempotency and capacity tracking
+   * transaction.withOptions({
+   *   clientRequestToken: 'unique-request-id-123',
+   *   returnConsumedCapacity: 'TOTAL'
+   * });
+   *
+   * // Track item collection metrics
+   * transaction.withOptions({
+   *   returnItemCollectionMetrics: 'SIZE'
+   * });
+   * ```
+   *
+   * Note: ClientRequestToken can be used to make transactions idempotent,
+   * ensuring the same transaction is not executed multiple times.
+   *
+   * @param options - Configuration options for the transaction
+   * @returns The transaction builder for method chaining
+   */
+  withOptions(options) {
+    this.options = { ...this.options, ...options };
+    return this;
+  }
+  /**
+   * Gets a human-readable representation of the transaction items.
+   * Use this method when you need to:
+   * - Debug complex transactions
+   * - Verify operation parameters
+   * - Log transaction details
+   * - Troubleshoot condition expressions
+   *
+   * The method resolves all expression placeholders with their actual values,
+   * making it easier to understand the transaction's operations.
+   *
+   * @example
+   * ```typescript
+   * // Add multiple operations
+   * transaction
+   *   .put('orders', { orderId: '123', status: 'PENDING' })
+   *   .update('inventory',
+   *     { productId: 'ABC' },
+   *     'SET quantity = quantity - :amount',
+   *     undefined,
+   *     { ':amount': 1 }
+   *   );
+   *
+   * // Debug the transaction
+   * const debugInfo = transaction.debug();
+   * console.log('Transaction operations:', debugInfo);
+   * ```
+   *
+   * @returns An array of readable representations of the transaction items
+   */
+  debug() {
+    return debugTransaction(this.items);
+  }
+  /**
+   * Executes all operations in the transaction atomically.
+   * Use this method when you need to:
+   * - Perform multiple operations atomically
+   * - Ensure all-or-nothing execution
+   * - Maintain data consistency across operations
+   *
+   * The transaction will only succeed if all operations succeed.
+   * If any operation fails, the entire transaction is rolled back.
+   *
+   * @example
+   * ```typescript
+   * try {
+   *   // Build and execute transaction
+   *   await transaction
+   *     .put('orders', newOrder)
+   *     .update('inventory',
+   *       { productId: 'ABC' },
+   *       'SET quantity = quantity - :qty',
+   *       undefined,
+   *       { ':qty': 1 }
+   *     )
+   *     .conditionCheck('products',
+   *       { productId: 'ABC' },
+   *       op => op.eq('status', 'ACTIVE')
+   *     )
+   *     .execute();
+   *
+   *   console.log('Transaction completed successfully');
+   * } catch (error) {
+   *   // Handle transaction failure
+   *   console.error('Transaction failed:', error);
+   * }
+   * ```
+   *
+   * @throws {Error} If no transaction items are specified
+   * @throws {Error} If any operation in the transaction fails
+   * @returns A promise that resolves when the transaction completes
+   */
+  async execute() {
+    if (this.items.length === 0) {
+      throw new Error("No transaction items specified");
+    }
+    const transactItems = this.items.map((item) => {
+      switch (item.type) {
+        case "Put":
+          return {
+            Put: {
+              TableName: item.params.tableName,
+              Item: item.params.item,
+              ConditionExpression: item.params.conditionExpression,
+              ExpressionAttributeNames: item.params.expressionAttributeNames,
+              ExpressionAttributeValues: item.params.expressionAttributeValues
+            }
+          };
+        case "Delete":
+          return {
+            Delete: {
+              TableName: item.params.tableName,
+              Key: item.params.key,
+              ConditionExpression: item.params.conditionExpression,
+              ExpressionAttributeNames: item.params.expressionAttributeNames,
+              ExpressionAttributeValues: item.params.expressionAttributeValues
+            }
+          };
+        case "Update":
+          return {
+            Update: {
+              TableName: item.params.tableName,
+              Key: item.params.key,
+              UpdateExpression: item.params.updateExpression,
+              ConditionExpression: item.params.conditionExpression,
+              ExpressionAttributeNames: item.params.expressionAttributeNames,
+              ExpressionAttributeValues: item.params.expressionAttributeValues
+            }
+          };
+        case "ConditionCheck":
+          return {
+            ConditionCheck: {
+              TableName: item.params.tableName,
+              Key: item.params.key,
+              ConditionExpression: item.params.conditionExpression,
+              ExpressionAttributeNames: item.params.expressionAttributeNames,
+              ExpressionAttributeValues: item.params.expressionAttributeValues
+            }
+          };
+        default: {
+          const exhaustiveCheck = item;
+          throw new Error(`Unsupported transaction item type: ${String(exhaustiveCheck)}`);
+        }
+      }
+    });
+    const params = {
+      TransactItems: transactItems,
+      ClientRequestToken: this.options.clientRequestToken,
+      ReturnConsumedCapacity: this.options.returnConsumedCapacity,
+      ReturnItemCollectionMetrics: this.options.returnItemCollectionMetrics
+    };
+    try {
+      await this.executor(params);
+    } catch (error) {
+      console.log(this.debug());
+      console.error("Error executing transaction:", error);
+      throw error;
+    }
+  }
+};
+
+export { TransactionBuilder };
+//# sourceMappingURL=transaction-builder.js.map
+//# sourceMappingURL=transaction-builder.js.map