dyno-table 2.2.1 → 2.3.0

package/dist/builders/transaction-builder.js

@@ -1,904 +0,0 @@
-// src/expression.ts
-var generateAttributeName = (params, attr) => {
-  if (attr.includes(".")) {
-    const pathSegments = attr.split(".");
-    const segmentNames = [];
-    for (const segment of pathSegments) {
-      let segmentName;
-      for (const [existingName, existingAttr] of Object.entries(params.expressionAttributeNames)) {
-        if (existingAttr === segment) {
-          segmentName = existingName;
-          break;
-        }
-      }
-      if (!segmentName) {
-        segmentName = `#${Object.keys(params.expressionAttributeNames).length}`;
-        params.expressionAttributeNames[segmentName] = segment;
-      }
-      segmentNames.push(segmentName);
-    }
-    return segmentNames.join(".");
-  }
-  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 buildInExpression = (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 === 0) {
-    throw new Error("In condition requires a non-empty array of values");
-  }
-  if (condition.value.length > 100) {
-    throw new Error("In condition supports a maximum of 100 values");
-  }
-  const attrName = generateAttributeName(params, condition.attr);
-  const valueNames = condition.value.map((value) => generateValueName(params, value));
-  return `${attrName} IN (${valueNames.join(", ")})`;
-};
-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),
-      in: () => buildInExpression(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.
-   *
-   * 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.
-   *
-   * 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.
-   *
-   * 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.
-   *
-   * 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) {
-    let keyForDuplicateCheck;
-    let keyForTransaction;
-    if (typeof command.key === "object" && command.key !== null && "pk" in command.key) {
-      keyForTransaction = this.createKeyForPrimaryIndex(command.key);
-      keyForDuplicateCheck = keyForTransaction;
-    } else {
-      keyForTransaction = command.key;
-      keyForDuplicateCheck = command.key;
-    }
-    this.checkForDuplicateItem(command.tableName, keyForDuplicateCheck);
-    const transactionItem = {
-      type: "Delete",
-      params: {
-        ...command,
-        key: keyForTransaction
-      }
-    };
-    this.items.push(transactionItem);
-    return this;
-  }
-  /**
-   * Adds an update operation to the transaction.
-   *
-   * 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.
-   *
-   * 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) {
-    let keyForDuplicateCheck;
-    let keyForTransaction;
-    if (typeof command.key === "object" && command.key !== null && "pk" in command.key) {
-      keyForTransaction = this.createKeyForPrimaryIndex(command.key);
-      keyForDuplicateCheck = keyForTransaction;
-    } else {
-      keyForTransaction = command.key;
-      keyForDuplicateCheck = command.key;
-    }
-    this.checkForDuplicateItem(command.tableName, keyForDuplicateCheck);
-    const transactionItem = {
-      type: "Update",
-      params: {
-        ...command,
-        key: keyForTransaction
-      }
-    };
-    this.items.push(transactionItem);
-    return this;
-  }
-  /**
-   * Adds a condition check operation to the transaction.
-   *
-   * 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.
-   *
-   * 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) {
-    let keyForDuplicateCheck;
-    let keyForTransaction;
-    if (typeof command.key === "object" && command.key !== null && "pk" in command.key) {
-      keyForTransaction = this.createKeyForPrimaryIndex(command.key);
-      keyForDuplicateCheck = keyForTransaction;
-    } else {
-      keyForTransaction = command.key;
-      keyForDuplicateCheck = command.key;
-    }
-    this.checkForDuplicateItem(command.tableName, keyForDuplicateCheck);
-    const transactionItem = {
-      type: "ConditionCheck",
-      params: {
-        ...command,
-        key: keyForTransaction
-      }
-    };
-    this.items.push(transactionItem);
-    return this;
-  }
-  /**
-   * Sets options for the transaction execution.
-   *
-   * @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.
-   *
-   * 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.
-   *
-   * 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