dyno-table 2.2.0 → 2.2.1

package/dist/index.js

@@ -535,163 +535,6 @@ function debugCommand(command) {
   };
 }
 
-// src/builders/condition-check-builder.ts
-var ConditionCheckBuilder = class {
-  key;
-  tableName;
-  conditionExpression;
-  constructor(tableName, key) {
-    this.tableName = tableName;
-    this.key = key;
-  }
-  /**
-   * Adds a condition that must be satisfied for the check to succeed.
-   *
-   * @example
-   * ```typescript
-   * // Check dinosaur health and behavior
-   * builder.condition(op =>
-   *   op.and([
-   *     op.gt('stats.health', 50),
-   *     op.not(op.eq('status', 'SEDATED')),
-   *     op.lt('aggressionLevel', 8)
-   *   ])
-   * );
-   *
-   * // Verify habitat conditions
-   * builder.condition(op =>
-   *   op.and([
-   *     op.eq('powerStatus', 'ONLINE'),
-   *     op.between('temperature', 20, 30),
-   *     op.attributeExists('lastMaintenance')
-   *   ])
-   * );
-   *
-   * // Check breeding conditions
-   * builder.condition(op =>
-   *   op.and([
-   *     op.eq('species', 'VELOCIRAPTOR'),
-   *     op.gte('age', 3),
-   *     op.eq('geneticPurity', 100)
-   *   ])
-   * );
-   * ```
-   *
-   * @param condition - Either a Condition DynamoItem or a callback function that builds the condition
-   * @returns The builder instance for method chaining
-   */
-  condition(condition) {
-    if (typeof condition === "function") {
-      const conditionOperator = {
-        eq,
-        ne,
-        lt,
-        lte,
-        gt,
-        gte,
-        between,
-        inArray,
-        beginsWith,
-        contains,
-        attributeExists,
-        attributeNotExists,
-        and,
-        or,
-        not
-      };
-      this.conditionExpression = condition(conditionOperator);
-    } else {
-      this.conditionExpression = condition;
-    }
-    return this;
-  }
-  /**
-   * Generates the DynamoDB command parameters for direct execution.
-   * Use this method when you want to:
-   * - Execute the condition check as a standalone operation
-   * - Get the raw DynamoDB command for custom execution
-   * - Inspect the generated command parameters
-   *
-   * @example
-   * ```ts
-   * const command = new ConditionCheckBuilder('myTable', { id: '123' })
-   *   .condition(op => op.attributeExists('status'))
-   *   .toDynamoCommand();
-   * // Use command with DynamoDB client
-   * ```
-   *
-   * @throws {Error} If no condition has been set
-   * @returns The DynamoDB command parameters
-   */
-  toDynamoCommand() {
-    if (!this.conditionExpression) {
-      throw new Error("Condition is required for condition check operations");
-    }
-    const { expression, names, values } = prepareExpressionParams(this.conditionExpression);
-    if (!expression) {
-      throw new Error("Failed to generate condition expression");
-    }
-    return {
-      tableName: this.tableName,
-      key: this.key,
-      conditionExpression: expression,
-      expressionAttributeNames: names,
-      expressionAttributeValues: values
-    };
-  }
-  /**
-   * Adds this condition check operation to a transaction.
-   *
-   * @example
-   * ```ts
-   * const transaction = new TransactionBuilder();
-   * new ConditionCheckBuilder('habitats', { id: 'PADDOCK-B' })
-   *   .condition(op => op.and([
-   *     op.eq('securityStatus', 'ACTIVE'),
-   *     op.lt('currentOccupants', 3),
-   *     op.eq('habitatType', 'CARNIVORE')
-   *   ]))
-   *   .withTransaction(transaction);
-   * // Add dinosaur transfer operations
-   * ```
-   *
-   * @param transaction - The transaction builder to add this operation to
-   * @throws {Error} If no condition has been set
-   * @returns The builder instance for method chaining
-   */
-  withTransaction(transaction) {
-    if (!this.conditionExpression) {
-      throw new Error("Condition is required for condition check operations");
-    }
-    const command = this.toDynamoCommand();
-    transaction.conditionCheckWithCommand(command);
-    return this;
-  }
-  /**
-   * Gets a human-readable representation of the condition check command
-   * with all expression placeholders replaced by their actual values.
-   *
-   * @example
-   * ```ts
-   * const debugInfo = new ConditionCheckBuilder('dinosaurs', { id: 'TREX-001' })
-   *   .condition(op => op.and([
-   *     op.between('stats.health', 50, 100),
-   *     op.not(op.eq('status', 'SEDATED')),
-   *     op.attributeExists('lastFeedingTime')
-   *     op.eq('version', 1)
-   *   ]))
-   *   .debug();
-   * console.log(debugInfo);
-   * ```
-   *
-   * @returns A readable representation of the condition check command with resolved expressions
-   */
-  debug() {
-    const command = this.toDynamoCommand();
-    return debugCommand(command);
-  }
-};
-
 // src/builders/delete-builder.ts
 var DeleteBuilder = class {
   options = {
@@ -911,216 +754,58 @@ var DeleteBuilder = class {
   }
 };
 
-// src/builders/get-builder.ts
-var GetBuilder = class {
-  /**
-   * Creates a new GetBuilder instance.
-   *
-   * @param executor - Function that executes the get operation
-   * @param key - Primary key of the item to retrieve
-   * @param tableName - Name of the DynamoDB table
-   */
-  constructor(executor, key, tableName) {
+// src/builders/put-builder.ts
+var PutBuilder = class {
+  item;
+  options;
+  executor;
+  tableName;
+  constructor(executor, item, tableName) {
     this.executor = executor;
-    this.params = {
-      tableName,
-      key
+    this.item = item;
+    this.tableName = tableName;
+    this.options = {
+      returnValues: "NONE"
     };
   }
-  params;
-  options = {};
-  selectedFields = /* @__PURE__ */ new Set();
+  set(valuesOrPath, value) {
+    if (typeof valuesOrPath === "object") {
+      Object.assign(this.item, valuesOrPath);
+    } else {
+      this.item[valuesOrPath] = value;
+    }
+    return this;
+  }
   /**
-   * Specifies which attributes to return in the get results.
+   * Adds a condition that must be satisfied for the put operation to succeed.
    *
    * @example
-   * ```typescript
-   * // Select single attribute
-   * builder.select('species')
-   *
-   * // Select multiple attributes
-   * builder.select(['id', 'species', 'diet'])
+   * ```ts
+   * // Ensure item doesn't exist (insert only)
+   * builder.condition(op => op.attributeNotExists('id'))
    *
-   * // Chain multiple select calls
-   * builder
-   *   .select('id')
-   *   .select(['species', 'diet'])
+   * // Complex condition with version check
+   * builder.condition(op =>
+   *   op.and([
+   *     op.attributeExists('id'),
+   *     op.eq('version', currentVersion),
+   *     op.eq('status', 'ACTIVE')
+   *   ])
+   * )
    * ```
    *
-   * @param fields - A single field name or an array of field names to return
+   * @param condition - Either a Condition object or a callback function that builds the condition
    * @returns The builder instance for method chaining
    */
-  select(fields) {
-    if (typeof fields === "string") {
-      this.selectedFields.add(fields);
-    } else if (Array.isArray(fields)) {
-      for (const field of fields) {
-        this.selectedFields.add(field);
-      }
-    }
-    this.options.projection = Array.from(this.selectedFields);
-    return this;
-  }
   /**
-   * Sets whether to use strongly consistent reads for the get operation.
-   * Use this method when you need:
-   * - The most up-to-date dinosaur data
-   * - To ensure you're reading the latest dinosaur status
-   * - Critical safety information about dangerous species
-   *
-   * Note: Consistent reads consume twice the throughput
+   * Adds a condition that must be satisfied for the put operation to succeed.
    *
    * @example
    * ```typescript
-   * // Get the latest T-Rex data
-   * const result = await new GetBuilder(executor, { pk: 'dinosaur#123', sk: 'profile' })
-   *   .consistentRead()
-   *   .execute();
-   * ```
-   *
-   * @param consistentRead - Whether to use consistent reads (defaults to true)
-   * @returns The builder instance for method chaining
-   */
-  consistentRead(consistentRead = true) {
-    this.params.consistentRead = consistentRead;
-    return this;
-  }
-  /**
-   * Adds this get operation to a batch with optional entity type information.
-   *
-   * @example Basic Usage
-   * ```ts
-   * const batch = table.batchBuilder();
-   *
-   * // Add multiple get operations to batch
-   * dinosaurRepo.get({ id: 'dino-1' }).withBatch(batch);
-   * dinosaurRepo.get({ id: 'dino-2' }).withBatch(batch);
-   * dinosaurRepo.get({ id: 'dino-3' }).withBatch(batch);
-   *
-   * // Execute all gets efficiently
-   * const results = await batch.execute();
-   * ```
-   *
-   * @example Typed Usage
-   * ```ts
-   * const batch = table.batchBuilder<{
-   *   User: UserEntity;
-   *   Order: OrderEntity;
-   * }>();
-   *
-   * // Add operations with type information
-   * userRepo.get({ id: 'user-1' }).withBatch(batch, 'User');
-   * orderRepo.get({ id: 'order-1' }).withBatch(batch, 'Order');
-   *
-   * // Execute and get typed results
-   * const result = await batch.execute();
-   * const users: UserEntity[] = result.reads.itemsByType.User;
-   * const orders: OrderEntity[] = result.reads.itemsByType.Order;
-   * ```
-   *
-   * @param batch - The batch builder to add this operation to
-   * @param entityType - Optional entity type key for type tracking
-   */
-  withBatch(batch, entityType) {
-    const command = this.toDynamoCommand();
-    batch.getWithCommand(command, entityType);
-  }
-  /**
-   * Converts the builder configuration to a DynamoDB command
-   */
-  toDynamoCommand() {
-    const expressionParams = {
-      expressionAttributeNames: {}};
-    const projectionExpression = Array.from(this.selectedFields).map((p) => generateAttributeName(expressionParams, p)).join(", ");
-    const { expressionAttributeNames } = expressionParams;
-    return {
-      ...this.params,
-      projectionExpression: projectionExpression.length > 0 ? projectionExpression : void 0,
-      expressionAttributeNames: Object.keys(expressionAttributeNames).length > 0 ? expressionAttributeNames : void 0
-    };
-  }
-  /**
-   * Executes the get operation against DynamoDB.
-   *
-   * @example
-   * ```typescript
-   * try {
-   *   const result = await new GetBuilder(executor, { pk: 'dinosaur#123', sk: 'profile' })
-   *     .select(['species', 'name', 'diet'])
-   *     .consistentRead()
-   *     .execute();
-   *
-   *   if (result.item) {
-   *     console.log('Dinosaur found:', result.item);
-   *   } else {
-   *     console.log('Dinosaur not found');
-   *   }
-   * } catch (error) {
-   *   console.error('Error getting dinosaur:', error);
-   * }
-   * ```
-   *
-   * @returns A promise that resolves to an object containing:
-   *          - item: The retrieved dinosaur or undefined if not found
-   */
-  async execute() {
-    const command = this.toDynamoCommand();
-    return this.executor(command);
-  }
-};
-
-// src/builders/put-builder.ts
-var PutBuilder = class {
-  item;
-  options;
-  executor;
-  tableName;
-  constructor(executor, item, tableName) {
-    this.executor = executor;
-    this.item = item;
-    this.tableName = tableName;
-    this.options = {
-      returnValues: "NONE"
-    };
-  }
-  set(valuesOrPath, value) {
-    if (typeof valuesOrPath === "object") {
-      Object.assign(this.item, valuesOrPath);
-    } else {
-      this.item[valuesOrPath] = value;
-    }
-    return this;
-  }
-  /**
-   * Adds a condition that must be satisfied for the put operation to succeed.
-   *
-   * @example
-   * ```ts
-   * // Ensure item doesn't exist (insert only)
-   * builder.condition(op => op.attributeNotExists('id'))
-   *
-   * // Complex condition with version check
-   * builder.condition(op =>
-   *   op.and([
-   *     op.attributeExists('id'),
-   *     op.eq('version', currentVersion),
-   *     op.eq('status', 'ACTIVE')
-   *   ])
-   * )
-   * ```
-   *
-   * @param condition - Either a Condition object or a callback function that builds the condition
-   * @returns The builder instance for method chaining
-   */
-  /**
-   * Adds a condition that must be satisfied for the put operation to succeed.
-   *
-   * @example
-   * ```typescript
-   * // Ensure unique dinosaur ID
-   * builder.condition(op =>
-   *   op.attributeNotExists('id')
-   * );
+   * // Ensure unique dinosaur ID
+   * builder.condition(op =>
+   *   op.attributeNotExists('id')
+   * );
    *
    * // Verify habitat requirements
    * builder.condition(op =>
@@ -1669,12 +1354,26 @@ var FilterBuilder = class {
     const newCondition = typeof condition === "function" ? condition(this.getConditionOperator()) : condition;
     if (this.options.filter) {
       if (this.options.filter.type === "and" && this.options.filter.conditions) {
-        this.options.filter = {
-          type: "and",
-          conditions: [...this.options.filter.conditions, newCondition]
-        };
+        if (newCondition.type === "and" && newCondition.conditions) {
+          this.options.filter = {
+            type: "and",
+            conditions: [...this.options.filter.conditions, ...newCondition.conditions]
+          };
+        } else {
+          this.options.filter = {
+            type: "and",
+            conditions: [...this.options.filter.conditions, newCondition]
+          };
+        }
       } else {
-        this.options.filter = and(this.options.filter, newCondition);
+        if (newCondition.type === "and" && newCondition.conditions) {
+          this.options.filter = {
+            type: "and",
+            conditions: [this.options.filter, ...newCondition.conditions]
+          };
+        } else {
+          this.options.filter = and(this.options.filter, newCondition);
+        }
       }
     } else {
       this.options.filter = newCondition;
@@ -2051,78 +1750,6 @@ var QueryBuilder = class _QueryBuilder extends FilterBuilder {
   }
 };
 
-// src/builders/scan-builder.ts
-var ScanBuilder = class _ScanBuilder extends FilterBuilder {
-  executor;
-  constructor(executor) {
-    super();
-    this.executor = executor;
-  }
-  /**
-   * Creates a deep clone of this ScanBuilder instance.
-   *
-   * @returns A new ScanBuilder instance with the same configuration
-   */
-  clone() {
-    const clone = new _ScanBuilder(this.executor);
-    clone.options = {
-      ...this.options,
-      filter: this.deepCloneFilter(this.options.filter)
-    };
-    clone.selectedFields = new Set(this.selectedFields);
-    return clone;
-  }
-  deepCloneFilter(filter) {
-    if (!filter) return filter;
-    if (filter.type === "and" || filter.type === "or") {
-      return {
-        ...filter,
-        conditions: filter.conditions?.map((condition) => this.deepCloneFilter(condition)).filter((c) => c !== void 0)
-      };
-    }
-    return { ...filter };
-  }
-  /**
-   * Executes the scan against DynamoDB and returns a generator that behaves like an array.
-   *
-   * The generator automatically handles pagination and provides array-like methods
-   * for processing results efficiently without loading everything into memory at once.
-   *
-   * @example
-   * ```typescript
-   * try {
-   *   // Find all dinosaurs with high aggression levels with automatic pagination
-   *   const results = await new ScanBuilder(executor)
-   *     .filter(op =>
-   *       op.and([
-   *         op.eq('status', 'ACTIVE'),
-   *         op.gt('aggressionLevel', 7)
-   *       ])
-   *     )
-   *     .execute();
-   *
-   *   // Use like an array with automatic pagination
-   *   for await (const dinosaur of results) {
-   *     console.log(`Processing dangerous dinosaur: ${dinosaur.name}`);
-   *   }
-   *
-   *   // Or convert to array and use array methods
-   *   const allItems = await results.toArray();
-   *   const criticalThreats = allItems.filter(dino => dino.aggressionLevel > 9);
-   *   const totalCount = allItems.length;
-   * } catch (error) {
-   *   console.error('Security scan failed:', error);
-   * }
-   * ```
-   *
-   * @returns A promise that resolves to a ResultGenerator that behaves like an array
-   */
-  async execute() {
-    const directExecutor = () => this.executor(this.options);
-    return new ResultIterator(this, directExecutor);
-  }
-};
-
 // src/utils/debug-transaction.ts
 function debugTransactionItem(item) {
   const result = {
@@ -3226,1174 +2853,1561 @@ var UpdateBuilder = class {
   }
 };
 
-// src/utils/chunk-array.ts
-function* chunkArray(array, size) {
-  if (size <= 0) {
-    throw new Error("Chunk size must be greater than 0");
-  }
-  for (let i = 0; i < array.length; i += size) {
-    yield array.slice(i, i + size);
-  }
+// src/builders/entity-aware-builders.ts
+function createEntityAwareBuilder(builder, entityName) {
+  return new Proxy(builder, {
+    get(target, prop, receiver) {
+      if (prop === "entityName") {
+        return entityName;
+      }
+      if (prop === "withBatch" && typeof target[prop] === "function") {
+        return (batch, entityType) => {
+          const typeToUse = entityType ?? entityName;
+          const fn = target[prop];
+          return fn.call(target, batch, typeToUse);
+        };
+      }
+      return Reflect.get(target, prop, receiver);
+    }
+  });
 }
-
-// src/table.ts
-var DDB_BATCH_WRITE_LIMIT = 25;
-var DDB_BATCH_GET_LIMIT = 100;
-var Table = class {
-  dynamoClient;
-  tableName;
-  /**
-   * The column name of the partitionKey for the Table
-   */
-  partitionKey;
-  /**
-   * The column name of the sortKey for the Table
-   */
-  sortKey;
-  /**
-   * The Global Secondary Indexes that are configured on this table
-   */
-  gsis;
-  constructor(config) {
-    this.dynamoClient = config.client;
-    this.tableName = config.tableName;
-    this.partitionKey = config.indexes.partitionKey;
-    this.sortKey = config.indexes.sortKey;
-    this.gsis = config.indexes.gsis || {};
+function createEntityAwarePutBuilder(builder, entityName) {
+  return createEntityAwareBuilder(builder, entityName);
+}
+function createEntityAwareGetBuilder(builder, entityName) {
+  return createEntityAwareBuilder(builder, entityName);
+}
+function createEntityAwareDeleteBuilder(builder, entityName) {
+  return createEntityAwareBuilder(builder, entityName);
+}
+var EntityAwareUpdateBuilder = class {
+  forceRebuildIndexes = [];
+  entityName;
+  builder;
+  entityConfig;
+  updateDataApplied = false;
+  constructor(builder, entityName) {
+    this.builder = builder;
+    this.entityName = entityName;
   }
-  createKeyForPrimaryIndex(keyCondition) {
-    const primaryCondition = { [this.partitionKey]: keyCondition.pk };
-    if (this.sortKey) {
-      if (!keyCondition.sk) {
-        throw new Error("Sort key has not been provided but the Table has a sort key");
-      }
-      primaryCondition[this.sortKey] = keyCondition.sk;
-    }
-    return primaryCondition;
+  /**
+   * Configure entity-specific logic for automatic timestamp generation and index updates
+   */
+  configureEntityLogic(config) {
+    this.entityConfig = config;
   }
   /**
-   * Creates a new item in the table, it will fail if the item already exists.
-   *
-   * By default, this method returns the input values passed to the create operation
-   * upon successful creation.
-   *
-   * You can customise the return behaviour by chaining the `.returnValues()` method:
+   * Forces a rebuild of one or more readonly indexes during the update operation.
    *
-   * @param item The item to create
-   * @returns A PutBuilder instance for chaining additional conditions and executing the create operation
+   * By default, readonly indexes are not updated during entity updates to prevent
+   * errors when required index attributes are missing. This method allows you to
+   * override that behavior and force specific indexes to be rebuilt.
    *
    * @example
-   * ```ts
-   * // Create with default behavior (returns input values)
-   * const result = await table.create({
-   *   id: 'user-123',
-   *   name: 'John Doe',
-   *   email: 'john@example.com'
-   * }).execute();
-   * console.log(result); // Returns the input object
-   *
-   * // Create with no return value for better performance
-   * await table.create(userData).returnValues('NONE').execute();
+   * ```typescript
+   * // Force rebuild a single readonly index
+   * const result = await repo.update({ id: 'TREX-001' }, { status: 'ACTIVE' })
+   *   .forceIndexRebuild('gsi1')
+   *   .execute();
    *
-   * // Create and get fresh data from dynamodb using a strongly consistent read
-   * const freshData = await table.create(userData).returnValues('CONSISTENT').execute();
+   * // Force rebuild multiple readonly indexes
+   * const result = await repo.update({ id: 'TREX-001' }, { status: 'ACTIVE' })
+   *   .forceIndexRebuild(['gsi1', 'gsi2'])
+   *   .execute();
    *
-   * // Create and get previous values (if the item was overwritten)
-   * const oldData = await table.create(userData).returnValues('ALL_OLD').execute();
+   * // Chain with other update operations
+   * const result = await repo.update({ id: 'TREX-001' }, { status: 'ACTIVE' })
+   *   .set('lastUpdated', new Date().toISOString())
+   *   .forceIndexRebuild('gsi1')
+   *   .condition(op => op.eq('status', 'INACTIVE'))
+   *   .execute();
    * ```
+   *
+   * @param indexes - A single index name or array of index names to force rebuild
+   * @returns The builder instance for method chaining
    */
-  create(item) {
-    return this.put(item).condition((op) => op.attributeNotExists(this.partitionKey)).returnValues("INPUT");
+  forceIndexRebuild(indexes) {
+    if (Array.isArray(indexes)) {
+      this.forceRebuildIndexes = [...this.forceRebuildIndexes, ...indexes];
+    } else {
+      this.forceRebuildIndexes.push(indexes);
+    }
+    return this;
   }
-  get(keyCondition) {
-    const executor = async (params) => {
-      try {
-        const result = await this.dynamoClient.get({
-          TableName: params.tableName,
-          Key: this.createKeyForPrimaryIndex(keyCondition),
-          ProjectionExpression: params.projectionExpression,
-          ExpressionAttributeNames: params.expressionAttributeNames,
-          ConsistentRead: params.consistentRead
-        });
-        return {
-          item: result.Item ? result.Item : void 0
-        };
-      } catch (error) {
-        console.error("Error getting item:", error);
-        throw error;
+  /**
+   * Gets the list of indexes that should be force rebuilt.
+   * This is used internally by entity update logic.
+   *
+   * @returns Array of index names to force rebuild
+   */
+  getForceRebuildIndexes() {
+    return [...this.forceRebuildIndexes];
+  }
+  /**
+   * Apply entity-specific update data (timestamps and index updates)
+   * This is called automatically when needed
+   */
+  applyEntityUpdates() {
+    if (!this.entityConfig || this.updateDataApplied) return;
+    const timestamps = this.entityConfig.generateTimestamps();
+    const updatedItem = { ...this.entityConfig.key, ...this.entityConfig.data, ...timestamps };
+    const indexUpdates = this.entityConfig.buildIndexUpdates(
+      this.entityConfig.key,
+      updatedItem,
+      this.entityConfig.table,
+      this.entityConfig.indexes,
+      this.forceRebuildIndexes
+    );
+    this.builder.set({ ...this.entityConfig.data, ...timestamps, ...indexUpdates });
+    this.updateDataApplied = true;
+  }
+  set(valuesOrPath, value) {
+    if (typeof valuesOrPath === "object") {
+      this.builder.set(valuesOrPath);
+    } else {
+      if (value === void 0) {
+        throw new Error("Value is required when setting a single path");
       }
-    };
-    return new GetBuilder(executor, keyCondition, this.tableName);
+      this.builder.set(valuesOrPath, value);
+    }
+    return this;
+  }
+  remove(path) {
+    this.builder.remove(path);
+    return this;
+  }
+  add(path, value) {
+    this.builder.add(path, value);
+    return this;
+  }
+  deleteElementsFromSet(path, value) {
+    this.builder.deleteElementsFromSet(path, value);
+    return this;
+  }
+  condition(condition) {
+    this.builder.condition(condition);
+    return this;
+  }
+  returnValues(returnValues) {
+    this.builder.returnValues(returnValues);
+    return this;
+  }
+  toDynamoCommand() {
+    return this.builder.toDynamoCommand();
+  }
+  withTransaction(transaction) {
+    this.applyEntityUpdates();
+    this.builder.withTransaction(transaction);
+  }
+  debug() {
+    return this.builder.debug();
+  }
+  async execute() {
+    this.updateDataApplied = false;
+    this.applyEntityUpdates();
+    return this.builder.execute();
   }
+};
+function createEntityAwareUpdateBuilder(builder, entityName) {
+  return new EntityAwareUpdateBuilder(builder, entityName);
+}
+
+// src/entity/ddb-indexing.ts
+var IndexBuilder = class {
   /**
-   * Updates an item in the table
+   * Creates a new IndexBuilder instance
    *
-   * @param item The item to update
-   * @returns A PutBuilder instance for chaining conditions and executing the put operation
+   * @param table - The DynamoDB table instance
+   * @param indexes - The index definitions
    */
-  put(item) {
-    const executor = async (params) => {
-      try {
-        const result = await this.dynamoClient.put({
-          TableName: params.tableName,
-          Item: params.item,
-          ConditionExpression: params.conditionExpression,
-          ExpressionAttributeNames: params.expressionAttributeNames,
-          ExpressionAttributeValues: params.expressionAttributeValues,
-          // CONSISTENT and INPUT are not valid ReturnValues for DDB, so we set NONE as we are not interested in its
-          // response and will be handling these cases separately
-          ReturnValues: params.returnValues === "CONSISTENT" || params.returnValues === "INPUT" ? "NONE" : params.returnValues
-        });
-        if (params.returnValues === "INPUT") {
-          return params.item;
-        }
-        if (params.returnValues === "CONSISTENT") {
-          const getResult = await this.dynamoClient.get({
-            TableName: params.tableName,
-            Key: this.createKeyForPrimaryIndex({
-              pk: params.item[this.partitionKey],
-              ...this.sortKey && { sk: params.item[this.sortKey] }
-            }),
-            ConsistentRead: true
-          });
-          return getResult.Item;
-        }
-        return result.Attributes;
-      } catch (error) {
-        console.error("Error creating item:", error);
-        throw error;
-      }
-    };
-    return new PutBuilder(executor, item, this.tableName);
+  constructor(table, indexes = {}) {
+    this.table = table;
+    this.indexes = indexes;
   }
   /**
-   * Creates a query builder for complex queries
-   * If useIndex is called on the returned QueryBuilder, it will use the GSI configuration
+   * Build index attributes for item creation
+   *
+   * @param item - The item to generate indexes for
+   * @param options - Options for building indexes
+   * @returns Record of GSI attribute names to their values
    */
-  query(keyCondition) {
-    const pkAttributeName = this.partitionKey;
-    const skAttributeName = this.sortKey;
-    let keyConditionExpression = eq(pkAttributeName, keyCondition.pk);
-    if (keyCondition.sk) {
-      if (!skAttributeName) {
-        throw new Error("Sort key is not defined for Index");
+  buildForCreate(item, options = {}) {
+    const attributes = {};
+    for (const [indexName, indexDef] of Object.entries(this.indexes)) {
+      if (options.excludeReadOnly && indexDef.isReadOnly) {
+        continue;
       }
-      const keyConditionOperator = {
-        eq: (value) => eq(skAttributeName, value),
-        lt: (value) => lt(skAttributeName, value),
-        lte: (value) => lte(skAttributeName, value),
-        gt: (value) => gt(skAttributeName, value),
-        gte: (value) => gte(skAttributeName, value),
-        between: (lower, upper) => between(skAttributeName, lower, upper),
-        beginsWith: (value) => beginsWith(skAttributeName, value),
-        and: (...conditions) => and(...conditions)
-      };
-      const skCondition = keyCondition.sk(keyConditionOperator);
-      keyConditionExpression = and(eq(pkAttributeName, keyCondition.pk), skCondition);
-    }
-    const executor = async (originalKeyCondition, options) => {
-      let finalKeyCondition = originalKeyCondition;
-      if (options.indexName) {
-        const gsiName = String(options.indexName);
-        const gsi = this.gsis[gsiName];
-        if (!gsi) {
-          throw new Error(`GSI with name "${gsiName}" does not exist on table "${this.tableName}"`);
-        }
-        const gsiPkAttributeName = gsi.partitionKey;
-        const gsiSkAttributeName = gsi.sortKey;
-        let pkValue;
-        let skValue;
-        let extractedSkCondition;
-        if (originalKeyCondition.type === "eq") {
-          pkValue = originalKeyCondition.value;
-        } else if (originalKeyCondition.type === "and" && originalKeyCondition.conditions) {
-          const pkCondition = originalKeyCondition.conditions.find(
-            (c) => c.type === "eq" && c.attr === pkAttributeName
-          );
-          if (pkCondition && pkCondition.type === "eq") {
-            pkValue = pkCondition.value;
-          }
-          const skConditions = originalKeyCondition.conditions.filter((c) => c.attr === skAttributeName);
-          if (skConditions.length > 0) {
-            if (skConditions.length === 1) {
-              extractedSkCondition = skConditions[0];
-              if (extractedSkCondition && extractedSkCondition.type === "eq") {
-                skValue = extractedSkCondition.value;
-              }
-            } else if (skConditions.length > 1) {
-              extractedSkCondition = and(...skConditions);
-            }
-          }
-        }
-        if (!pkValue) {
-          throw new Error("Could not extract partition key value from key condition");
-        }
-        let gsiKeyCondition = eq(gsiPkAttributeName, pkValue);
-        if (skValue && gsiSkAttributeName) {
-          gsiKeyCondition = and(gsiKeyCondition, eq(gsiSkAttributeName, skValue));
-        } else if (extractedSkCondition && gsiSkAttributeName) {
-          if (extractedSkCondition.attr === skAttributeName) {
-            const updatedSkCondition = {
-              ...extractedSkCondition,
-              attr: gsiSkAttributeName
-            };
-            gsiKeyCondition = and(gsiKeyCondition, updatedSkCondition);
-          } else {
-            gsiKeyCondition = and(gsiKeyCondition, extractedSkCondition);
-          }
-        }
-        finalKeyCondition = gsiKeyCondition;
+      const key = indexDef.generateKey(item);
+      const gsiConfig = this.table.gsis[indexName];
+      if (!gsiConfig) {
+        throw new Error(`GSI configuration not found for index: ${indexName}`);
       }
-      const expressionParams = {
-        expressionAttributeNames: {},
-        expressionAttributeValues: {},
-        valueCounter: { count: 0 }
-      };
-      const keyConditionExpression2 = buildExpression(finalKeyCondition, expressionParams);
-      let filterExpression;
-      if (options.filter) {
-        filterExpression = buildExpression(options.filter, expressionParams);
+      if (key.pk) {
+        attributes[gsiConfig.partitionKey] = key.pk;
       }
-      const projectionExpression = options.projection?.map((p) => generateAttributeName(expressionParams, p)).join(", ");
-      const { expressionAttributeNames, expressionAttributeValues } = expressionParams;
-      const { indexName, limit, consistentRead, scanIndexForward, lastEvaluatedKey } = options;
-      const params = {
-        TableName: this.tableName,
-        KeyConditionExpression: keyConditionExpression2,
-        FilterExpression: filterExpression,
-        ExpressionAttributeNames: expressionAttributeNames,
-        ExpressionAttributeValues: expressionAttributeValues,
-        IndexName: indexName,
-        Limit: limit,
-        ConsistentRead: consistentRead,
-        ScanIndexForward: scanIndexForward,
-        ProjectionExpression: projectionExpression,
-        ExclusiveStartKey: lastEvaluatedKey
-      };
-      try {
-        const result = await this.dynamoClient.query(params);
-        return {
-          items: result.Items,
-          lastEvaluatedKey: result.LastEvaluatedKey
-        };
-      } catch (error) {
-        console.log(debugCommand(params));
-        console.error("Error querying items:", error);
-        throw error;
+      if (key.sk && gsiConfig.sortKey) {
+        attributes[gsiConfig.sortKey] = key.sk;
       }
-    };
-    return new QueryBuilder(executor, keyConditionExpression);
+    }
+    return attributes;
   }
   /**
-   * Creates a scan builder for scanning the entire table
-   * Use this when you need to:
-   * - Process all items in a table
-   * - Apply filters to a large dataset
-   * - Use a GSI for scanning
+   * Build index attributes for item updates
    *
-   * @returns A ScanBuilder instance for chaining operations
+   * @param currentData - The current data before update
+   * @param updates - The update data
+   * @param options - Options for building indexes
+   * @returns Record of GSI attribute names to their updated values
    */
-  scan() {
-    const executor = async (options) => {
-      const expressionParams = {
-        expressionAttributeNames: {},
-        expressionAttributeValues: {},
-        valueCounter: { count: 0 }
-      };
-      let filterExpression;
-      if (options.filter) {
-        filterExpression = buildExpression(options.filter, expressionParams);
+  buildForUpdate(currentData, updates, options = {}) {
+    const attributes = {};
+    const updatedItem = { ...currentData, ...updates };
+    if (options.forceRebuildIndexes && options.forceRebuildIndexes.length > 0) {
+      const invalidIndexes = options.forceRebuildIndexes.filter((indexName) => !this.indexes[indexName]);
+      if (invalidIndexes.length > 0) {
+        throw new Error(
+          `Cannot force rebuild unknown indexes: ${invalidIndexes.join(", ")}. Available indexes: ${Object.keys(this.indexes).join(", ")}`
+        );
       }
-      const projectionExpression = options.projection?.map((p) => generateAttributeName(expressionParams, p)).join(", ");
-      const { expressionAttributeNames, expressionAttributeValues } = expressionParams;
-      const { indexName, limit, consistentRead, lastEvaluatedKey } = options;
-      const params = {
-        TableName: this.tableName,
-        FilterExpression: filterExpression,
-        ExpressionAttributeNames: Object.keys(expressionAttributeNames).length > 0 ? expressionAttributeNames : void 0,
-        ExpressionAttributeValues: Object.keys(expressionAttributeValues).length > 0 ? expressionAttributeValues : void 0,
-        IndexName: indexName,
-        Limit: limit,
-        ConsistentRead: consistentRead,
-        ProjectionExpression: projectionExpression,
-        ExclusiveStartKey: lastEvaluatedKey
-      };
-      try {
-        const result = await this.dynamoClient.scan(params);
-        return {
-          items: result.Items,
-          lastEvaluatedKey: result.LastEvaluatedKey
-        };
-      } catch (error) {
-        console.log(debugCommand(params));
-        console.error("Error scanning items:", error);
-        throw error;
+    }
+    for (const [indexName, indexDef] of Object.entries(this.indexes)) {
+      const isForced = options.forceRebuildIndexes?.includes(indexName);
+      if (indexDef.isReadOnly && !isForced) {
+        continue;
       }
-    };
-    return new ScanBuilder(executor);
-  }
-  delete(keyCondition) {
-    const executor = async (params) => {
+      if (!isForced) {
+        let shouldUpdateIndex = false;
+        try {
+          const currentKey = indexDef.generateKey(currentData);
+          const updatedKey = indexDef.generateKey(updatedItem);
+          if (currentKey.pk !== updatedKey.pk || currentKey.sk !== updatedKey.sk) {
+            shouldUpdateIndex = true;
+          }
+        } catch {
+          shouldUpdateIndex = true;
+        }
+        if (!shouldUpdateIndex) {
+          continue;
+        }
+      }
+      let key;
       try {
-        const result = await this.dynamoClient.delete({
-          TableName: params.tableName,
-          Key: this.createKeyForPrimaryIndex(keyCondition),
-          ConditionExpression: params.conditionExpression,
-          ExpressionAttributeNames: params.expressionAttributeNames,
-          ExpressionAttributeValues: params.expressionAttributeValues,
-          ReturnValues: params.returnValues
-        });
-        return {
-          item: result.Attributes
-        };
+        key = indexDef.generateKey(updatedItem);
       } catch (error) {
-        console.error("Error deleting item:", error);
+        if (error instanceof Error) {
+          throw new Error(`Missing attributes: ${error.message}`);
+        }
         throw error;
       }
-    };
-    return new DeleteBuilder(executor, this.tableName, keyCondition);
+      if (this.hasUndefinedValues(key)) {
+        throw new Error(
+          `Missing attributes: Cannot update entity: insufficient data to regenerate index "${indexName}". All attributes required by the index must be provided in the update operation, or the index must be marked as readOnly.`
+        );
+      }
+      const gsiConfig = this.table.gsis[indexName];
+      if (!gsiConfig) {
+        throw new Error(`GSI configuration not found for index: ${indexName}`);
+      }
+      if (key.pk) {
+        attributes[gsiConfig.partitionKey] = key.pk;
+      }
+      if (key.sk && gsiConfig.sortKey) {
+        attributes[gsiConfig.sortKey] = key.sk;
+      }
+    }
+    return attributes;
   }
   /**
-   * Updates an item in the table
+   * Check if a key has undefined values
    *
-   * @param keyCondition The primary key of the item to update
-   * @returns An UpdateBuilder instance for chaining update operations and conditions
+   * @param key - The index key to check
+   * @returns True if the key contains undefined values, false otherwise
    */
-  update(keyCondition) {
-    const executor = async (params) => {
-      try {
-        const result = await this.dynamoClient.update({
-          TableName: params.tableName,
-          Key: this.createKeyForPrimaryIndex(keyCondition),
-          UpdateExpression: params.updateExpression,
-          ConditionExpression: params.conditionExpression,
-          ExpressionAttributeNames: params.expressionAttributeNames,
-          ExpressionAttributeValues: params.expressionAttributeValues,
-          ReturnValues: params.returnValues
-        });
-        return {
-          item: result.Attributes
-        };
-      } catch (error) {
-        console.error("Error updating item:", error);
-        throw error;
-      }
-    };
-    return new UpdateBuilder(executor, this.tableName, keyCondition);
+  hasUndefinedValues(key) {
+    return (key.pk?.includes("undefined") ?? false) || (key.sk?.includes("undefined") ?? false);
   }
-  /**
-   * Creates a transaction builder for performing multiple operations atomically
-   */
-  transactionBuilder() {
-    const executor = async (params) => {
-      await this.dynamoClient.transactWrite(params);
-    };
-    return new TransactionBuilder(executor, {
-      partitionKey: this.partitionKey,
-      sortKey: this.sortKey
-    });
+};
+
+// src/entity/index-utils.ts
+function buildIndexes(dataForKeyGeneration, table, indexes, excludeReadOnly = false) {
+  if (!indexes) {
+    return {};
   }
-  /**
-   * Creates a batch builder for performing multiple operations efficiently with optional type inference
-   *
-   * @example Basic Usage
-   * ```typescript
-   * const batch = table.batchBuilder();
-   *
-   * // Add operations
-   * userRepo.create(newUser).withBatch(batch);
-   * orderRepo.get({ id: 'order-1' }).withBatch(batch);
-   *
-   * // Execute operations
-   * const result = await batch.execute();
-   * ```
-   *
-   * @example Typed Usage
-   * ```typescript
-   * // Define entity types for the batch
-   * const batch = table.batchBuilder<{
-   *   User: UserEntity;
-   *   Order: OrderEntity;
-   *   Product: ProductEntity;
-   * }>();
-   *
-   * // Add operations with type information
-   * userRepo.create(newUser).withBatch(batch, 'User');
-   * orderRepo.get({ id: 'order-1' }).withBatch(batch, 'Order');
-   * productRepo.delete({ id: 'old-product' }).withBatch(batch, 'Product');
-   *
-   * // Execute and get typed results
-   * const result = await batch.execute();
-   * const users: UserEntity[] = result.reads.itemsByType.User;
-   * const orders: OrderEntity[] = result.reads.itemsByType.Order;
-   * ```
-   */
-  batchBuilder() {
-    const batchWriteExecutor = async (operations) => {
-      return this.batchWrite(operations);
-    };
-    const batchGetExecutor = async (keys) => {
-      return this.batchGet(keys);
-    };
-    return new BatchBuilder(batchWriteExecutor, batchGetExecutor, {
-      partitionKey: this.partitionKey,
-      sortKey: this.sortKey
-    });
+  const indexBuilder = new IndexBuilder(table, indexes);
+  return indexBuilder.buildForCreate(dataForKeyGeneration, { excludeReadOnly });
+}
+function buildIndexUpdates(currentData, updates, table, indexes, forceRebuildIndexes) {
+  if (!indexes) {
+    return {};
   }
-  /**
-   * Executes a transaction using a callback function
-   *
-   * @param callback A function that receives a transaction context and performs operations on it
-   * @param options Optional transaction options
-   * @returns A promise that resolves when the transaction is complete
-   */
-  async transaction(callback, options) {
-    const transactionExecutor = async (params) => {
-      await this.dynamoClient.transactWrite(params);
+  const indexBuilder = new IndexBuilder(table, indexes);
+  return indexBuilder.buildForUpdate(currentData, updates, { forceRebuildIndexes });
+}
+
+// src/entity/entity.ts
+function defineEntity(config) {
+  const entityTypeAttributeName = config.settings?.entityTypeAttributeName ?? "entityType";
+  const buildIndexes2 = (dataForKeyGeneration, table, excludeReadOnly = false) => {
+    return buildIndexes(dataForKeyGeneration, table, config.indexes, excludeReadOnly);
+  };
+  const wrapMethodWithPreparation = (originalMethod, prepareFn, context) => {
+    const wrappedMethod = (...args) => {
+      prepareFn();
+      return originalMethod.call(context, ...args);
     };
-    const transaction = new TransactionBuilder(transactionExecutor, {
-      partitionKey: this.partitionKey,
-      sortKey: this.sortKey
-    });
-    if (options) {
-      transaction.withOptions(options);
-    }
-    const result = await callback(transaction);
-    await transaction.execute();
-    return result;
-  }
-  /**
-   * Creates a condition check operation for use in transactions
-   *
-   * This is useful for when you require a transaction to succeed only when a specific condition is met on a
-   * a record within the database that you are not directly updating.
-   *
-   * For example, you are updating a record and you want to ensure that another record exists and/or has a specific value before proceeding.
-   */
-  conditionCheck(keyCondition) {
-    return new ConditionCheckBuilder(this.tableName, keyCondition);
-  }
-  /**
-   * Performs a batch get operation to retrieve multiple items at once
-   *
-   * @param keys Array of primary keys to retrieve
-   * @returns A promise that resolves to the retrieved items
-   */
-  async batchGet(keys) {
-    const allItems = [];
-    const allUnprocessedKeys = [];
-    for (const chunk of chunkArray(keys, DDB_BATCH_GET_LIMIT)) {
-      const formattedKeys = chunk.map((key) => ({
-        [this.partitionKey]: key.pk,
-        ...this.sortKey ? { [this.sortKey]: key.sk } : {}
-      }));
-      const params = {
-        RequestItems: {
-          [this.tableName]: {
-            Keys: formattedKeys
-          }
-        }
-      };
-      try {
-        const result = await this.dynamoClient.batchGet(params);
-        if (result.Responses?.[this.tableName]) {
-          allItems.push(...result.Responses[this.tableName]);
-        }
-        const unprocessedKeysArray = result.UnprocessedKeys?.[this.tableName]?.Keys || [];
-        const unprocessedKeys = unprocessedKeysArray.map((key) => ({
-          pk: key[this.partitionKey],
-          sk: this.sortKey ? key[this.sortKey] : void 0
-        }));
-        if (unprocessedKeys.length > 0) {
-          allUnprocessedKeys.push(...unprocessedKeys);
+    Object.setPrototypeOf(wrappedMethod, originalMethod);
+    const propertyNames = Object.getOwnPropertyNames(originalMethod);
+    for (let i = 0; i < propertyNames.length; i++) {
+      const prop = propertyNames[i];
+      if (prop !== "length" && prop !== "name" && prop !== "prototype") {
+        const descriptor = Object.getOwnPropertyDescriptor(originalMethod, prop);
+        if (descriptor && descriptor.writable !== false && !descriptor.get) {
+          wrappedMethod[prop] = originalMethod[prop];
         }
-      } catch (error) {
-        console.error("Error in batch get operation:", error);
-        throw error;
       }
     }
-    return {
-      items: allItems,
-      unprocessedKeys: allUnprocessedKeys
-    };
-  }
-  /**
-   * Performs a batch write operation to put or delete multiple items at once
-   *
-   * @param operations Array of put or delete operations
-   * @returns A promise that resolves to any unprocessed operations
-   */
-  async batchWrite(operations) {
-    const allUnprocessedItems = [];
-    for (const chunk of chunkArray(operations, DDB_BATCH_WRITE_LIMIT)) {
-      const writeRequests = chunk.map((operation) => {
-        if (operation.type === "put") {
-          return {
-            PutRequest: {
-              Item: operation.item
+    return wrappedMethod;
+  };
+  const generateTimestamps = (timestampsToGenerate, data) => {
+    if (!config.settings?.timestamps) return {};
+    const timestamps = {};
+    const now = /* @__PURE__ */ new Date();
+    const unixTime = Math.floor(Date.now() / 1e3);
+    const { createdAt, updatedAt } = config.settings.timestamps;
+    if (createdAt && timestampsToGenerate.includes("createdAt") && !data.createdAt) {
+      const name = createdAt.attributeName ?? "createdAt";
+      timestamps[name] = createdAt.format === "UNIX" ? unixTime : now.toISOString();
+    }
+    if (updatedAt && timestampsToGenerate.includes("updatedAt") && !data.updatedAt) {
+      const name = updatedAt.attributeName ?? "updatedAt";
+      timestamps[name] = updatedAt.format === "UNIX" ? unixTime : now.toISOString();
+    }
+    return timestamps;
+  };
+  return {
+    name: config.name,
+    createRepository: (table) => {
+      const repository = {
+        create: (data) => {
+          const builder = table.create({});
+          const prepareValidatedItemAsync = async () => {
+            const validatedData = await config.schema["~standard"].validate(data);
+            if ("issues" in validatedData && validatedData.issues) {
+              throw new Error(`Validation failed: ${validatedData.issues.map((i) => i.message).join(", ")}`);
             }
+            const dataForKeyGeneration = {
+              ...validatedData.value,
+              ...generateTimestamps(["createdAt", "updatedAt"], validatedData.value)
+            };
+            const primaryKey = config.primaryKey.generateKey(dataForKeyGeneration);
+            const indexes = buildIndexes(dataForKeyGeneration, table, config.indexes, false);
+            const validatedItem = {
+              ...dataForKeyGeneration,
+              [entityTypeAttributeName]: config.name,
+              [table.partitionKey]: primaryKey.pk,
+              ...table.sortKey ? { [table.sortKey]: primaryKey.sk } : {},
+              ...indexes
+            };
+            Object.assign(builder, { item: validatedItem });
+            return validatedItem;
           };
-        }
-        return {
-          DeleteRequest: {
-            Key: this.createKeyForPrimaryIndex(operation.key)
-          }
-        };
-      });
-      const params = {
-        RequestItems: {
-          [this.tableName]: writeRequests
-        }
-      };
-      try {
-        const result = await this.dynamoClient.batchWrite(params);
-        const unprocessedRequestsArray = result.UnprocessedItems?.[this.tableName] || [];
-        if (unprocessedRequestsArray.length > 0) {
-          const unprocessedItems = unprocessedRequestsArray.map((request) => {
-            if (request?.PutRequest?.Item) {
-              return {
-                type: "put",
-                item: request.PutRequest.Item
-              };
+          const prepareValidatedItemSync = () => {
+            const validationResult = config.schema["~standard"].validate(data);
+            if (validationResult instanceof Promise) {
+              throw new Error(
+                "Async validation is not supported in withBatch or withTransaction. The schema must support synchronous validation for compatibility."
+              );
             }
-            if (request?.DeleteRequest?.Key) {
-              return {
-                type: "delete",
-                key: {
-                  pk: request.DeleteRequest.Key[this.partitionKey],
-                  sk: this.sortKey ? request.DeleteRequest.Key[this.sortKey] : void 0
-                }
-              };
+            if ("issues" in validationResult && validationResult.issues) {
+              throw new Error(`Validation failed: ${validationResult.issues.map((i) => i.message).join(", ")}`);
             }
-            throw new Error("Invalid unprocessed item format returned from DynamoDB");
-          });
-          allUnprocessedItems.push(...unprocessedItems);
+            const dataForKeyGeneration = {
+              ...validationResult.value,
+              ...generateTimestamps(["createdAt", "updatedAt"], validationResult.value)
+            };
+            const primaryKey = config.primaryKey.generateKey(dataForKeyGeneration);
+            const indexes = buildIndexes(dataForKeyGeneration, table, config.indexes, false);
+            const validatedItem = {
+              ...dataForKeyGeneration,
+              [entityTypeAttributeName]: config.name,
+              [table.partitionKey]: primaryKey.pk,
+              ...table.sortKey ? { [table.sortKey]: primaryKey.sk } : {},
+              ...indexes
+            };
+            Object.assign(builder, { item: validatedItem });
+            return validatedItem;
+          };
+          const originalExecute = builder.execute;
+          builder.execute = async () => {
+            await prepareValidatedItemAsync();
+            return await originalExecute.call(builder);
+          };
+          const originalWithTransaction = builder.withTransaction;
+          if (originalWithTransaction) {
+            builder.withTransaction = wrapMethodWithPreparation(
+              originalWithTransaction,
+              prepareValidatedItemSync,
+              builder
+            );
+          }
+          const originalWithBatch = builder.withBatch;
+          if (originalWithBatch) {
+            builder.withBatch = wrapMethodWithPreparation(originalWithBatch, prepareValidatedItemSync, builder);
+          }
+          return createEntityAwarePutBuilder(builder, config.name);
+        },
+        upsert: (data) => {
+          const builder = table.put({});
+          const prepareValidatedItemAsync = async () => {
+            const validatedData = await config.schema["~standard"].validate(data);
+            if ("issues" in validatedData && validatedData.issues) {
+              throw new Error(`Validation failed: ${validatedData.issues.map((i) => i.message).join(", ")}`);
+            }
+            const dataForKeyGeneration = {
+              ...validatedData.value,
+              ...generateTimestamps(["createdAt", "updatedAt"], validatedData.value)
+            };
+            const primaryKey = config.primaryKey.generateKey(dataForKeyGeneration);
+            const indexes = buildIndexes2(dataForKeyGeneration, table, false);
+            const validatedItem = {
+              [table.partitionKey]: primaryKey.pk,
+              ...table.sortKey ? { [table.sortKey]: primaryKey.sk } : {},
+              ...dataForKeyGeneration,
+              [entityTypeAttributeName]: config.name,
+              ...indexes
+            };
+            Object.assign(builder, { item: validatedItem });
+            return validatedItem;
+          };
+          const prepareValidatedItemSync = () => {
+            const validationResult = config.schema["~standard"].validate(data);
+            if (validationResult instanceof Promise) {
+              throw new Error(
+                "Async validation is not supported in withTransaction or withBatch. Use execute() instead."
+              );
+            }
+            if ("issues" in validationResult && validationResult.issues) {
+              throw new Error(`Validation failed: ${validationResult.issues.map((i) => i.message).join(", ")}`);
+            }
+            const dataForKeyGeneration = {
+              ...validationResult.value,
+              ...generateTimestamps(["createdAt", "updatedAt"], validationResult.value)
+            };
+            const primaryKey = config.primaryKey.generateKey(dataForKeyGeneration);
+            const indexes = buildIndexes(dataForKeyGeneration, table, config.indexes, false);
+            const validatedItem = {
+              [table.partitionKey]: primaryKey.pk,
+              ...table.sortKey ? { [table.sortKey]: primaryKey.sk } : {},
+              ...dataForKeyGeneration,
+              [entityTypeAttributeName]: config.name,
+              ...indexes
+            };
+            Object.assign(builder, { item: validatedItem });
+            return validatedItem;
+          };
+          const originalExecute = builder.execute;
+          builder.execute = async () => {
+            await prepareValidatedItemAsync();
+            const result = await originalExecute.call(builder);
+            if (!result) {
+              throw new Error("Failed to upsert item");
+            }
+            return result;
+          };
+          const originalWithTransaction = builder.withTransaction;
+          if (originalWithTransaction) {
+            builder.withTransaction = wrapMethodWithPreparation(
+              originalWithTransaction,
+              prepareValidatedItemSync,
+              builder
+            );
+          }
+          const originalWithBatch = builder.withBatch;
+          if (originalWithBatch) {
+            builder.withBatch = wrapMethodWithPreparation(originalWithBatch, prepareValidatedItemSync, builder);
+          }
+          return createEntityAwarePutBuilder(builder, config.name);
+        },
+        get: (key) => {
+          return createEntityAwareGetBuilder(table.get(config.primaryKey.generateKey(key)), config.name);
+        },
+        update: (key, data) => {
+          const primaryKeyObj = config.primaryKey.generateKey(key);
+          const builder = table.update(primaryKeyObj);
+          builder.condition(eq(entityTypeAttributeName, config.name));
+          const entityAwareBuilder = createEntityAwareUpdateBuilder(builder, config.name);
+          entityAwareBuilder.configureEntityLogic({
+            data,
+            key,
+            table,
+            indexes: config.indexes,
+            generateTimestamps: () => generateTimestamps(["updatedAt"], data),
+            buildIndexUpdates
+          });
+          return entityAwareBuilder;
+        },
+        delete: (key) => {
+          const builder = table.delete(config.primaryKey.generateKey(key));
+          builder.condition(eq(entityTypeAttributeName, config.name));
+          return createEntityAwareDeleteBuilder(builder, config.name);
+        },
+        query: Object.entries(config.queries || {}).reduce((acc, [key, inputCallback]) => {
+          acc[key] = (input) => {
+            const queryEntity = {
+              scan: repository.scan,
+              get: (key2) => createEntityAwareGetBuilder(table.get(key2), config.name),
+              query: (keyCondition) => {
+                return table.query(keyCondition);
+              }
+            };
+            const queryBuilderCallback = inputCallback(input);
+            const builder = queryBuilderCallback(queryEntity);
+            if (builder && typeof builder === "object" && "filter" in builder && typeof builder.filter === "function") {
+              builder.filter(eq(entityTypeAttributeName, config.name));
+            }
+            if (builder && typeof builder === "object" && "execute" in builder) {
+              const originalExecute = builder.execute;
+              builder.execute = async () => {
+                const queryFn = config.queries[key];
+                if (queryFn && typeof queryFn === "function") {
+                  const schema = queryFn.schema;
+                  if (schema?.["~standard"]?.validate && typeof schema["~standard"].validate === "function") {
+                    const validationResult = schema["~standard"].validate(input);
+                    if ("issues" in validationResult && validationResult.issues) {
+                      throw new Error(
+                        `Validation failed: ${validationResult.issues.map((issue) => issue.message).join(", ")}`
+                      );
+                    }
+                  }
+                }
+                const result = await originalExecute.call(builder);
+                if (!result) {
+                  throw new Error("Failed to execute query");
+                }
+                return result;
+              };
+            }
+            return builder;
+          };
+          return acc;
+        }, {}),
+        scan: () => {
+          const builder = table.scan();
+          builder.filter(eq(entityTypeAttributeName, config.name));
+          return builder;
         }
-      } catch (error) {
-        console.error("Error in batch write operation:", error);
-        throw error;
+      };
+      return repository;
+    }
+  };
+}
+function createQueries() {
+  return {
+    input: (schema) => ({
+      query: (handler) => {
+        const queryFn = (input) => (entity) => handler({ input, entity });
+        queryFn.schema = schema;
+        return queryFn;
+      }
+    })
+  };
+}
+function createIndex() {
+  return {
+    input: (schema) => {
+      const createIndexBuilder = (isReadOnly = false) => ({
+        partitionKey: (pkFn) => ({
+          sortKey: (skFn) => {
+            const index = {
+              name: "custom",
+              partitionKey: "pk",
+              sortKey: "sk",
+              isReadOnly,
+              generateKey: (item) => {
+                const data = schema["~standard"].validate(item);
+                if ("issues" in data && data.issues) {
+                  throw new Error(`Index validation failed: ${data.issues.map((i) => i.message).join(", ")}`);
+                }
+                const validData = "value" in data ? data.value : item;
+                return { pk: pkFn(validData), sk: skFn(validData) };
+              }
+            };
+            return Object.assign(index, {
+              readOnly: (value = false) => ({
+                ...index,
+                isReadOnly: value
+              })
+            });
+          },
+          withoutSortKey: () => {
+            const index = {
+              name: "custom",
+              partitionKey: "pk",
+              isReadOnly,
+              generateKey: (item) => {
+                const data = schema["~standard"].validate(item);
+                if ("issues" in data && data.issues) {
+                  throw new Error(`Index validation failed: ${data.issues.map((i) => i.message).join(", ")}`);
+                }
+                const validData = "value" in data ? data.value : item;
+                return { pk: pkFn(validData) };
+              }
+            };
+            return Object.assign(index, {
+              readOnly: (value = true) => ({
+                ...index,
+                isReadOnly: value
+              })
+            });
+          }
+        }),
+        readOnly: (value = true) => createIndexBuilder(value)
+      });
+      return createIndexBuilder(false);
+    }
+  };
+}
+
+// src/builders/condition-check-builder.ts
+var ConditionCheckBuilder = class {
+  key;
+  tableName;
+  conditionExpression;
+  constructor(tableName, key) {
+    this.tableName = tableName;
+    this.key = key;
+  }
+  /**
+   * Adds a condition that must be satisfied for the check to succeed.
+   *
+   * @example
+   * ```typescript
+   * // Check dinosaur health and behavior
+   * builder.condition(op =>
+   *   op.and([
+   *     op.gt('stats.health', 50),
+   *     op.not(op.eq('status', 'SEDATED')),
+   *     op.lt('aggressionLevel', 8)
+   *   ])
+   * );
+   *
+   * // Verify habitat conditions
+   * builder.condition(op =>
+   *   op.and([
+   *     op.eq('powerStatus', 'ONLINE'),
+   *     op.between('temperature', 20, 30),
+   *     op.attributeExists('lastMaintenance')
+   *   ])
+   * );
+   *
+   * // Check breeding conditions
+   * builder.condition(op =>
+   *   op.and([
+   *     op.eq('species', 'VELOCIRAPTOR'),
+   *     op.gte('age', 3),
+   *     op.eq('geneticPurity', 100)
+   *   ])
+   * );
+   * ```
+   *
+   * @param condition - Either a Condition DynamoItem or a callback function that builds the condition
+   * @returns The builder instance for method chaining
+   */
+  condition(condition) {
+    if (typeof condition === "function") {
+      const conditionOperator = {
+        eq,
+        ne,
+        lt,
+        lte,
+        gt,
+        gte,
+        between,
+        inArray,
+        beginsWith,
+        contains,
+        attributeExists,
+        attributeNotExists,
+        and,
+        or,
+        not
+      };
+      this.conditionExpression = condition(conditionOperator);
+    } else {
+      this.conditionExpression = condition;
+    }
+    return this;
+  }
+  /**
+   * Generates the DynamoDB command parameters for direct execution.
+   * Use this method when you want to:
+   * - Execute the condition check as a standalone operation
+   * - Get the raw DynamoDB command for custom execution
+   * - Inspect the generated command parameters
+   *
+   * @example
+   * ```ts
+   * const command = new ConditionCheckBuilder('myTable', { id: '123' })
+   *   .condition(op => op.attributeExists('status'))
+   *   .toDynamoCommand();
+   * // Use command with DynamoDB client
+   * ```
+   *
+   * @throws {Error} If no condition has been set
+   * @returns The DynamoDB command parameters
+   */
+  toDynamoCommand() {
+    if (!this.conditionExpression) {
+      throw new Error("Condition is required for condition check operations");
+    }
+    const { expression, names, values } = prepareExpressionParams(this.conditionExpression);
+    if (!expression) {
+      throw new Error("Failed to generate condition expression");
+    }
+    return {
+      tableName: this.tableName,
+      key: this.key,
+      conditionExpression: expression,
+      expressionAttributeNames: names,
+      expressionAttributeValues: values
+    };
+  }
+  /**
+   * Adds this condition check operation to a transaction.
+   *
+   * @example
+   * ```ts
+   * const transaction = new TransactionBuilder();
+   * new ConditionCheckBuilder('habitats', { id: 'PADDOCK-B' })
+   *   .condition(op => op.and([
+   *     op.eq('securityStatus', 'ACTIVE'),
+   *     op.lt('currentOccupants', 3),
+   *     op.eq('habitatType', 'CARNIVORE')
+   *   ]))
+   *   .withTransaction(transaction);
+   * // Add dinosaur transfer operations
+   * ```
+   *
+   * @param transaction - The transaction builder to add this operation to
+   * @throws {Error} If no condition has been set
+   * @returns The builder instance for method chaining
+   */
+  withTransaction(transaction) {
+    if (!this.conditionExpression) {
+      throw new Error("Condition is required for condition check operations");
+    }
+    const command = this.toDynamoCommand();
+    transaction.conditionCheckWithCommand(command);
+    return this;
+  }
+  /**
+   * Gets a human-readable representation of the condition check command
+   * with all expression placeholders replaced by their actual values.
+   *
+   * @example
+   * ```ts
+   * const debugInfo = new ConditionCheckBuilder('dinosaurs', { id: 'TREX-001' })
+   *   .condition(op => op.and([
+   *     op.between('stats.health', 50, 100),
+   *     op.not(op.eq('status', 'SEDATED')),
+   *     op.attributeExists('lastFeedingTime')
+   *     op.eq('version', 1)
+   *   ]))
+   *   .debug();
+   * console.log(debugInfo);
+   * ```
+   *
+   * @returns A readable representation of the condition check command with resolved expressions
+   */
+  debug() {
+    const command = this.toDynamoCommand();
+    return debugCommand(command);
+  }
+};
+
+// src/builders/get-builder.ts
+var GetBuilder = class {
+  /**
+   * Creates a new GetBuilder instance.
+   *
+   * @param executor - Function that executes the get operation
+   * @param key - Primary key of the item to retrieve
+   * @param tableName - Name of the DynamoDB table
+   */
+  constructor(executor, key, tableName) {
+    this.executor = executor;
+    this.params = {
+      tableName,
+      key
+    };
+  }
+  params;
+  options = {};
+  selectedFields = /* @__PURE__ */ new Set();
+  /**
+   * Specifies which attributes to return in the get results.
+   *
+   * @example
+   * ```typescript
+   * // Select single attribute
+   * builder.select('species')
+   *
+   * // Select multiple attributes
+   * builder.select(['id', 'species', 'diet'])
+   *
+   * // Chain multiple select calls
+   * builder
+   *   .select('id')
+   *   .select(['species', 'diet'])
+   * ```
+   *
+   * @param fields - A single field name or an array of field names to return
+   * @returns The builder instance for method chaining
+   */
+  select(fields) {
+    if (typeof fields === "string") {
+      this.selectedFields.add(fields);
+    } else if (Array.isArray(fields)) {
+      for (const field of fields) {
+        this.selectedFields.add(field);
       }
     }
+    this.options.projection = Array.from(this.selectedFields);
+    return this;
+  }
+  /**
+   * Sets whether to use strongly consistent reads for the get operation.
+   * Use this method when you need:
+   * - The most up-to-date dinosaur data
+   * - To ensure you're reading the latest dinosaur status
+   * - Critical safety information about dangerous species
+   *
+   * Note: Consistent reads consume twice the throughput
+   *
+   * @example
+   * ```typescript
+   * // Get the latest T-Rex data
+   * const result = await new GetBuilder(executor, { pk: 'dinosaur#123', sk: 'profile' })
+   *   .consistentRead()
+   *   .execute();
+   * ```
+   *
+   * @param consistentRead - Whether to use consistent reads (defaults to true)
+   * @returns The builder instance for method chaining
+   */
+  consistentRead(consistentRead = true) {
+    this.params.consistentRead = consistentRead;
+    return this;
+  }
+  /**
+   * Adds this get operation to a batch with optional entity type information.
+   *
+   * @example Basic Usage
+   * ```ts
+   * const batch = table.batchBuilder();
+   *
+   * // Add multiple get operations to batch
+   * dinosaurRepo.get({ id: 'dino-1' }).withBatch(batch);
+   * dinosaurRepo.get({ id: 'dino-2' }).withBatch(batch);
+   * dinosaurRepo.get({ id: 'dino-3' }).withBatch(batch);
+   *
+   * // Execute all gets efficiently
+   * const results = await batch.execute();
+   * ```
+   *
+   * @example Typed Usage
+   * ```ts
+   * const batch = table.batchBuilder<{
+   *   User: UserEntity;
+   *   Order: OrderEntity;
+   * }>();
+   *
+   * // Add operations with type information
+   * userRepo.get({ id: 'user-1' }).withBatch(batch, 'User');
+   * orderRepo.get({ id: 'order-1' }).withBatch(batch, 'Order');
+   *
+   * // Execute and get typed results
+   * const result = await batch.execute();
+   * const users: UserEntity[] = result.reads.itemsByType.User;
+   * const orders: OrderEntity[] = result.reads.itemsByType.Order;
+   * ```
+   *
+   * @param batch - The batch builder to add this operation to
+   * @param entityType - Optional entity type key for type tracking
+   */
+  withBatch(batch, entityType) {
+    const command = this.toDynamoCommand();
+    batch.getWithCommand(command, entityType);
+  }
+  /**
+   * Converts the builder configuration to a DynamoDB command
+   */
+  toDynamoCommand() {
+    const expressionParams = {
+      expressionAttributeNames: {}};
+    const projectionExpression = Array.from(this.selectedFields).map((p) => generateAttributeName(expressionParams, p)).join(", ");
+    const { expressionAttributeNames } = expressionParams;
     return {
-      unprocessedItems: allUnprocessedItems
+      ...this.params,
+      projectionExpression: projectionExpression.length > 0 ? projectionExpression : void 0,
+      expressionAttributeNames: Object.keys(expressionAttributeNames).length > 0 ? expressionAttributeNames : void 0
     };
   }
+  /**
+   * Executes the get operation against DynamoDB.
+   *
+   * @example
+   * ```typescript
+   * try {
+   *   const result = await new GetBuilder(executor, { pk: 'dinosaur#123', sk: 'profile' })
+   *     .select(['species', 'name', 'diet'])
+   *     .consistentRead()
+   *     .execute();
+   *
+   *   if (result.item) {
+   *     console.log('Dinosaur found:', result.item);
+   *   } else {
+   *     console.log('Dinosaur not found');
+   *   }
+   * } catch (error) {
+   *   console.error('Error getting dinosaur:', error);
+   * }
+   * ```
+   *
+   * @returns A promise that resolves to an object containing:
+   *          - item: The retrieved dinosaur or undefined if not found
+   */
+  async execute() {
+    const command = this.toDynamoCommand();
+    return this.executor(command);
+  }
 };
 
-// src/builders/entity-aware-builders.ts
-function createEntityAwareBuilder(builder, entityName) {
-  return new Proxy(builder, {
-    get(target, prop, receiver) {
-      if (prop === "entityName") {
-        return entityName;
-      }
-      if (prop === "withBatch" && typeof target[prop] === "function") {
-        return (batch, entityType) => {
-          const typeToUse = entityType ?? entityName;
-          const fn = target[prop];
-          return fn.call(target, batch, typeToUse);
-        };
-      }
-      return Reflect.get(target, prop, receiver);
-    }
-  });
-}
-function createEntityAwarePutBuilder(builder, entityName) {
-  return createEntityAwareBuilder(builder, entityName);
-}
-function createEntityAwareGetBuilder(builder, entityName) {
-  return createEntityAwareBuilder(builder, entityName);
-}
-function createEntityAwareDeleteBuilder(builder, entityName) {
-  return createEntityAwareBuilder(builder, entityName);
-}
-var EntityAwareUpdateBuilder = class {
-  forceRebuildIndexes = [];
-  entityName;
-  builder;
-  entityConfig;
-  updateDataApplied = false;
-  constructor(builder, entityName) {
-    this.builder = builder;
-    this.entityName = entityName;
+// src/builders/scan-builder.ts
+var ScanBuilder = class _ScanBuilder extends FilterBuilder {
+  executor;
+  constructor(executor) {
+    super();
+    this.executor = executor;
   }
   /**
-   * Configure entity-specific logic for automatic timestamp generation and index updates
+   * Creates a deep clone of this ScanBuilder instance.
+   *
+   * @returns A new ScanBuilder instance with the same configuration
    */
-  configureEntityLogic(config) {
-    this.entityConfig = config;
+  clone() {
+    const clone = new _ScanBuilder(this.executor);
+    clone.options = {
+      ...this.options,
+      filter: this.deepCloneFilter(this.options.filter)
+    };
+    clone.selectedFields = new Set(this.selectedFields);
+    return clone;
+  }
+  deepCloneFilter(filter) {
+    if (!filter) return filter;
+    if (filter.type === "and" || filter.type === "or") {
+      return {
+        ...filter,
+        conditions: filter.conditions?.map((condition) => this.deepCloneFilter(condition)).filter((c) => c !== void 0)
+      };
+    }
+    return { ...filter };
   }
   /**
-   * Forces a rebuild of one or more readonly indexes during the update operation.
+   * Executes the scan against DynamoDB and returns a generator that behaves like an array.
    *
-   * By default, readonly indexes are not updated during entity updates to prevent
-   * errors when required index attributes are missing. This method allows you to
-   * override that behavior and force specific indexes to be rebuilt.
+   * The generator automatically handles pagination and provides array-like methods
+   * for processing results efficiently without loading everything into memory at once.
    *
    * @example
    * ```typescript
-   * // Force rebuild a single readonly index
-   * const result = await repo.update({ id: 'TREX-001' }, { status: 'ACTIVE' })
-   *   .forceIndexRebuild('gsi1')
-   *   .execute();
+   * try {
+   *   // Find all dinosaurs with high aggression levels with automatic pagination
+   *   const results = await new ScanBuilder(executor)
+   *     .filter(op =>
+   *       op.and([
+   *         op.eq('status', 'ACTIVE'),
+   *         op.gt('aggressionLevel', 7)
+   *       ])
+   *     )
+   *     .execute();
    *
-   * // Force rebuild multiple readonly indexes
-   * const result = await repo.update({ id: 'TREX-001' }, { status: 'ACTIVE' })
-   *   .forceIndexRebuild(['gsi1', 'gsi2'])
-   *   .execute();
+   *   // Use like an array with automatic pagination
+   *   for await (const dinosaur of results) {
+   *     console.log(`Processing dangerous dinosaur: ${dinosaur.name}`);
+   *   }
    *
-   * // Chain with other update operations
-   * const result = await repo.update({ id: 'TREX-001' }, { status: 'ACTIVE' })
-   *   .set('lastUpdated', new Date().toISOString())
-   *   .forceIndexRebuild('gsi1')
-   *   .condition(op => op.eq('status', 'INACTIVE'))
-   *   .execute();
+   *   // Or convert to array and use array methods
+   *   const allItems = await results.toArray();
+   *   const criticalThreats = allItems.filter(dino => dino.aggressionLevel > 9);
+   *   const totalCount = allItems.length;
+   * } catch (error) {
+   *   console.error('Security scan failed:', error);
+   * }
    * ```
    *
-   * @param indexes - A single index name or array of index names to force rebuild
-   * @returns The builder instance for method chaining
+   * @returns A promise that resolves to a ResultGenerator that behaves like an array
    */
-  forceIndexRebuild(indexes) {
-    if (Array.isArray(indexes)) {
-      this.forceRebuildIndexes = [...this.forceRebuildIndexes, ...indexes];
-    } else {
-      this.forceRebuildIndexes.push(indexes);
-    }
-    return this;
+  async execute() {
+    const directExecutor = () => this.executor(this.options);
+    return new ResultIterator(this, directExecutor);
+  }
+};
+
+// src/utils/chunk-array.ts
+function* chunkArray(array, size) {
+  if (size <= 0) {
+    throw new Error("Chunk size must be greater than 0");
+  }
+  for (let i = 0; i < array.length; i += size) {
+    yield array.slice(i, i + size);
   }
+}
+
+// src/table.ts
+var DDB_BATCH_WRITE_LIMIT = 25;
+var DDB_BATCH_GET_LIMIT = 100;
+var Table = class {
+  dynamoClient;
+  tableName;
   /**
-   * Gets the list of indexes that should be force rebuilt.
-   * This is used internally by entity update logic.
-   *
-   * @returns Array of index names to force rebuild
+   * The column name of the partitionKey for the Table
    */
-  getForceRebuildIndexes() {
-    return [...this.forceRebuildIndexes];
-  }
+  partitionKey;
   /**
-   * Apply entity-specific update data (timestamps and index updates)
-   * This is called automatically when needed
+   * The column name of the sortKey for the Table
    */
-  applyEntityUpdates() {
-    if (!this.entityConfig || this.updateDataApplied) return;
-    const timestamps = this.entityConfig.generateTimestamps();
-    const updatedItem = { ...this.entityConfig.key, ...this.entityConfig.data, ...timestamps };
-    const indexUpdates = this.entityConfig.buildIndexUpdates(
-      this.entityConfig.key,
-      updatedItem,
-      this.entityConfig.table,
-      this.entityConfig.indexes,
-      this.forceRebuildIndexes
-    );
-    this.builder.set({ ...this.entityConfig.data, ...timestamps, ...indexUpdates });
-    this.updateDataApplied = true;
+  sortKey;
+  /**
+   * The Global Secondary Indexes that are configured on this table
+   */
+  gsis;
+  constructor(config) {
+    this.dynamoClient = config.client;
+    this.tableName = config.tableName;
+    this.partitionKey = config.indexes.partitionKey;
+    this.sortKey = config.indexes.sortKey;
+    this.gsis = config.indexes.gsis || {};
   }
-  set(valuesOrPath, value) {
-    if (typeof valuesOrPath === "object") {
-      this.builder.set(valuesOrPath);
-    } else {
-      if (value === void 0) {
-        throw new Error("Value is required when setting a single path");
+  createKeyForPrimaryIndex(keyCondition) {
+    const primaryCondition = { [this.partitionKey]: keyCondition.pk };
+    if (this.sortKey) {
+      if (!keyCondition.sk) {
+        throw new Error("Sort key has not been provided but the Table has a sort key");
       }
-      this.builder.set(valuesOrPath, value);
+      primaryCondition[this.sortKey] = keyCondition.sk;
     }
-    return this;
-  }
-  remove(path) {
-    this.builder.remove(path);
-    return this;
-  }
-  add(path, value) {
-    this.builder.add(path, value);
-    return this;
-  }
-  deleteElementsFromSet(path, value) {
-    this.builder.deleteElementsFromSet(path, value);
-    return this;
-  }
-  condition(condition) {
-    this.builder.condition(condition);
-    return this;
-  }
-  returnValues(returnValues) {
-    this.builder.returnValues(returnValues);
-    return this;
-  }
-  toDynamoCommand() {
-    return this.builder.toDynamoCommand();
-  }
-  withTransaction(transaction) {
-    this.applyEntityUpdates();
-    this.builder.withTransaction(transaction);
-  }
-  debug() {
-    return this.builder.debug();
-  }
-  async execute() {
-    this.updateDataApplied = false;
-    this.applyEntityUpdates();
-    return this.builder.execute();
+    return primaryCondition;
   }
-};
-function createEntityAwareUpdateBuilder(builder, entityName) {
-  return new EntityAwareUpdateBuilder(builder, entityName);
-}
-
-// src/entity/ddb-indexing.ts
-var IndexBuilder = class {
   /**
-   * Creates a new IndexBuilder instance
+   * Creates a new item in the table, it will fail if the item already exists.
    *
-   * @param table - The DynamoDB table instance
-   * @param indexes - The index definitions
+   * By default, this method returns the input values passed to the create operation
+   * upon successful creation.
+   *
+   * You can customise the return behaviour by chaining the `.returnValues()` method:
+   *
+   * @param item The item to create
+   * @returns A PutBuilder instance for chaining additional conditions and executing the create operation
+   *
+   * @example
+   * ```ts
+   * // Create with default behavior (returns input values)
+   * const result = await table.create({
+   *   id: 'user-123',
+   *   name: 'John Doe',
+   *   email: 'john@example.com'
+   * }).execute();
+   * console.log(result); // Returns the input object
+   *
+   * // Create with no return value for better performance
+   * await table.create(userData).returnValues('NONE').execute();
+   *
+   * // Create and get fresh data from dynamodb using a strongly consistent read
+   * const freshData = await table.create(userData).returnValues('CONSISTENT').execute();
+   *
+   * // Create and get previous values (if the item was overwritten)
+   * const oldData = await table.create(userData).returnValues('ALL_OLD').execute();
+   * ```
    */
-  constructor(table, indexes = {}) {
-    this.table = table;
-    this.indexes = indexes;
+  create(item) {
+    return this.put(item).condition((op) => op.attributeNotExists(this.partitionKey)).returnValues("INPUT");
+  }
+  get(keyCondition) {
+    const executor = async (params) => {
+      try {
+        const result = await this.dynamoClient.get({
+          TableName: params.tableName,
+          Key: this.createKeyForPrimaryIndex(keyCondition),
+          ProjectionExpression: params.projectionExpression,
+          ExpressionAttributeNames: params.expressionAttributeNames,
+          ConsistentRead: params.consistentRead
+        });
+        return {
+          item: result.Item ? result.Item : void 0
+        };
+      } catch (error) {
+        console.error("Error getting item:", error);
+        throw error;
+      }
+    };
+    return new GetBuilder(executor, keyCondition, this.tableName);
   }
   /**
-   * Build index attributes for item creation
+   * Updates an item in the table
    *
-   * @param item - The item to generate indexes for
-   * @param options - Options for building indexes
-   * @returns Record of GSI attribute names to their values
+   * @param item The item to update
+   * @returns A PutBuilder instance for chaining conditions and executing the put operation
    */
-  buildForCreate(item, options = {}) {
-    const attributes = {};
-    for (const [indexName, indexDef] of Object.entries(this.indexes)) {
-      if (options.excludeReadOnly && indexDef.isReadOnly) {
-        continue;
-      }
-      const key = indexDef.generateKey(item);
-      const gsiConfig = this.table.gsis[indexName];
-      if (!gsiConfig) {
-        throw new Error(`GSI configuration not found for index: ${indexName}`);
-      }
-      if (key.pk) {
-        attributes[gsiConfig.partitionKey] = key.pk;
-      }
-      if (key.sk && gsiConfig.sortKey) {
-        attributes[gsiConfig.sortKey] = key.sk;
+  put(item) {
+    const executor = async (params) => {
+      try {
+        const result = await this.dynamoClient.put({
+          TableName: params.tableName,
+          Item: params.item,
+          ConditionExpression: params.conditionExpression,
+          ExpressionAttributeNames: params.expressionAttributeNames,
+          ExpressionAttributeValues: params.expressionAttributeValues,
+          // CONSISTENT and INPUT are not valid ReturnValues for DDB, so we set NONE as we are not interested in its
+          // response and will be handling these cases separately
+          ReturnValues: params.returnValues === "CONSISTENT" || params.returnValues === "INPUT" ? "NONE" : params.returnValues
+        });
+        if (params.returnValues === "INPUT") {
+          return params.item;
+        }
+        if (params.returnValues === "CONSISTENT") {
+          const getResult = await this.dynamoClient.get({
+            TableName: params.tableName,
+            Key: this.createKeyForPrimaryIndex({
+              pk: params.item[this.partitionKey],
+              ...this.sortKey && { sk: params.item[this.sortKey] }
+            }),
+            ConsistentRead: true
+          });
+          return getResult.Item;
+        }
+        return result.Attributes;
+      } catch (error) {
+        console.error("Error creating item:", error);
+        throw error;
       }
-    }
-    return attributes;
+    };
+    return new PutBuilder(executor, item, this.tableName);
   }
   /**
-   * Build index attributes for item updates
-   *
-   * @param currentData - The current data before update
-   * @param updates - The update data
-   * @param options - Options for building indexes
-   * @returns Record of GSI attribute names to their updated values
+   * Creates a query builder for complex queries
+   * If useIndex is called on the returned QueryBuilder, it will use the GSI configuration
    */
-  buildForUpdate(currentData, updates, options = {}) {
-    const attributes = {};
-    const updatedItem = { ...currentData, ...updates };
-    if (options.forceRebuildIndexes && options.forceRebuildIndexes.length > 0) {
-      const invalidIndexes = options.forceRebuildIndexes.filter((indexName) => !this.indexes[indexName]);
-      if (invalidIndexes.length > 0) {
-        throw new Error(
-          `Cannot force rebuild unknown indexes: ${invalidIndexes.join(", ")}. Available indexes: ${Object.keys(this.indexes).join(", ")}`
-        );
+  query(keyCondition) {
+    const pkAttributeName = this.partitionKey;
+    const skAttributeName = this.sortKey;
+    let keyConditionExpression = eq(pkAttributeName, keyCondition.pk);
+    if (keyCondition.sk) {
+      if (!skAttributeName) {
+        throw new Error("Sort key is not defined for Index");
       }
+      const keyConditionOperator = {
+        eq: (value) => eq(skAttributeName, value),
+        lt: (value) => lt(skAttributeName, value),
+        lte: (value) => lte(skAttributeName, value),
+        gt: (value) => gt(skAttributeName, value),
+        gte: (value) => gte(skAttributeName, value),
+        between: (lower, upper) => between(skAttributeName, lower, upper),
+        beginsWith: (value) => beginsWith(skAttributeName, value),
+        and: (...conditions) => and(...conditions)
+      };
+      const skCondition = keyCondition.sk(keyConditionOperator);
+      keyConditionExpression = and(eq(pkAttributeName, keyCondition.pk), skCondition);
     }
-    for (const [indexName, indexDef] of Object.entries(this.indexes)) {
-      const isForced = options.forceRebuildIndexes?.includes(indexName);
-      if (indexDef.isReadOnly && !isForced) {
-        continue;
-      }
-      if (!isForced) {
-        let shouldUpdateIndex = false;
-        try {
-          const currentKey = indexDef.generateKey(currentData);
-          const updatedKey = indexDef.generateKey(updatedItem);
-          if (currentKey.pk !== updatedKey.pk || currentKey.sk !== updatedKey.sk) {
-            shouldUpdateIndex = true;
+    const executor = async (originalKeyCondition, options) => {
+      let finalKeyCondition = originalKeyCondition;
+      if (options.indexName) {
+        const gsiName = String(options.indexName);
+        const gsi = this.gsis[gsiName];
+        if (!gsi) {
+          throw new Error(`GSI with name "${gsiName}" does not exist on table "${this.tableName}"`);
+        }
+        const gsiPkAttributeName = gsi.partitionKey;
+        const gsiSkAttributeName = gsi.sortKey;
+        let pkValue;
+        let skValue;
+        let extractedSkCondition;
+        if (originalKeyCondition.type === "eq") {
+          pkValue = originalKeyCondition.value;
+        } else if (originalKeyCondition.type === "and" && originalKeyCondition.conditions) {
+          const pkCondition = originalKeyCondition.conditions.find(
+            (c) => c.type === "eq" && c.attr === pkAttributeName
+          );
+          if (pkCondition && pkCondition.type === "eq") {
+            pkValue = pkCondition.value;
+          }
+          const skConditions = originalKeyCondition.conditions.filter((c) => c.attr === skAttributeName);
+          if (skConditions.length > 0) {
+            if (skConditions.length === 1) {
+              extractedSkCondition = skConditions[0];
+              if (extractedSkCondition && extractedSkCondition.type === "eq") {
+                skValue = extractedSkCondition.value;
+              }
+            } else if (skConditions.length > 1) {
+              extractedSkCondition = and(...skConditions);
+            }
           }
-        } catch {
-          shouldUpdateIndex = true;
         }
-        if (!shouldUpdateIndex) {
-          continue;
+        if (!pkValue) {
+          throw new Error("Could not extract partition key value from key condition");
+        }
+        let gsiKeyCondition = eq(gsiPkAttributeName, pkValue);
+        if (skValue && gsiSkAttributeName) {
+          gsiKeyCondition = and(gsiKeyCondition, eq(gsiSkAttributeName, skValue));
+        } else if (extractedSkCondition && gsiSkAttributeName) {
+          if (extractedSkCondition.attr === skAttributeName) {
+            const updatedSkCondition = {
+              ...extractedSkCondition,
+              attr: gsiSkAttributeName
+            };
+            gsiKeyCondition = and(gsiKeyCondition, updatedSkCondition);
+          } else {
+            gsiKeyCondition = and(gsiKeyCondition, extractedSkCondition);
+          }
         }
+        finalKeyCondition = gsiKeyCondition;
       }
-      let key;
+      const expressionParams = {
+        expressionAttributeNames: {},
+        expressionAttributeValues: {},
+        valueCounter: { count: 0 }
+      };
+      const keyConditionExpression2 = buildExpression(finalKeyCondition, expressionParams);
+      let filterExpression;
+      if (options.filter) {
+        filterExpression = buildExpression(options.filter, expressionParams);
+      }
+      const projectionExpression = options.projection?.map((p) => generateAttributeName(expressionParams, p)).join(", ");
+      const { expressionAttributeNames, expressionAttributeValues } = expressionParams;
+      const { indexName, limit, consistentRead, scanIndexForward, lastEvaluatedKey } = options;
+      const params = {
+        TableName: this.tableName,
+        KeyConditionExpression: keyConditionExpression2,
+        FilterExpression: filterExpression,
+        ExpressionAttributeNames: expressionAttributeNames,
+        ExpressionAttributeValues: expressionAttributeValues,
+        IndexName: indexName,
+        Limit: limit,
+        ConsistentRead: consistentRead,
+        ScanIndexForward: scanIndexForward,
+        ProjectionExpression: projectionExpression,
+        ExclusiveStartKey: lastEvaluatedKey
+      };
       try {
-        key = indexDef.generateKey(updatedItem);
+        const result = await this.dynamoClient.query(params);
+        return {
+          items: result.Items,
+          lastEvaluatedKey: result.LastEvaluatedKey
+        };
       } catch (error) {
-        if (error instanceof Error) {
-          throw new Error(`Missing attributes: ${error.message}`);
-        }
+        console.log(debugCommand(params));
+        console.error("Error querying items:", error);
         throw error;
       }
-      if (this.hasUndefinedValues(key)) {
-        throw new Error(
-          `Missing attributes: Cannot update entity: insufficient data to regenerate index "${indexName}". All attributes required by the index must be provided in the update operation, or the index must be marked as readOnly.`
-        );
+    };
+    return new QueryBuilder(executor, keyConditionExpression);
+  }
+  /**
+   * Creates a scan builder for scanning the entire table
+   * Use this when you need to:
+   * - Process all items in a table
+   * - Apply filters to a large dataset
+   * - Use a GSI for scanning
+   *
+   * @returns A ScanBuilder instance for chaining operations
+   */
+  scan() {
+    const executor = async (options) => {
+      const expressionParams = {
+        expressionAttributeNames: {},
+        expressionAttributeValues: {},
+        valueCounter: { count: 0 }
+      };
+      let filterExpression;
+      if (options.filter) {
+        filterExpression = buildExpression(options.filter, expressionParams);
       }
-      const gsiConfig = this.table.gsis[indexName];
-      if (!gsiConfig) {
-        throw new Error(`GSI configuration not found for index: ${indexName}`);
+      const projectionExpression = options.projection?.map((p) => generateAttributeName(expressionParams, p)).join(", ");
+      const { expressionAttributeNames, expressionAttributeValues } = expressionParams;
+      const { indexName, limit, consistentRead, lastEvaluatedKey } = options;
+      const params = {
+        TableName: this.tableName,
+        FilterExpression: filterExpression,
+        ExpressionAttributeNames: Object.keys(expressionAttributeNames).length > 0 ? expressionAttributeNames : void 0,
+        ExpressionAttributeValues: Object.keys(expressionAttributeValues).length > 0 ? expressionAttributeValues : void 0,
+        IndexName: indexName,
+        Limit: limit,
+        ConsistentRead: consistentRead,
+        ProjectionExpression: projectionExpression,
+        ExclusiveStartKey: lastEvaluatedKey
+      };
+      try {
+        const result = await this.dynamoClient.scan(params);
+        return {
+          items: result.Items,
+          lastEvaluatedKey: result.LastEvaluatedKey
+        };
+      } catch (error) {
+        console.log(debugCommand(params));
+        console.error("Error scanning items:", error);
+        throw error;
       }
-      if (key.pk) {
-        attributes[gsiConfig.partitionKey] = key.pk;
+    };
+    return new ScanBuilder(executor);
+  }
+  delete(keyCondition) {
+    const executor = async (params) => {
+      try {
+        const result = await this.dynamoClient.delete({
+          TableName: params.tableName,
+          Key: this.createKeyForPrimaryIndex(keyCondition),
+          ConditionExpression: params.conditionExpression,
+          ExpressionAttributeNames: params.expressionAttributeNames,
+          ExpressionAttributeValues: params.expressionAttributeValues,
+          ReturnValues: params.returnValues
+        });
+        return {
+          item: result.Attributes
+        };
+      } catch (error) {
+        console.error("Error deleting item:", error);
+        throw error;
       }
-      if (key.sk && gsiConfig.sortKey) {
-        attributes[gsiConfig.sortKey] = key.sk;
+    };
+    return new DeleteBuilder(executor, this.tableName, keyCondition);
+  }
+  /**
+   * Updates an item in the table
+   *
+   * @param keyCondition The primary key of the item to update
+   * @returns An UpdateBuilder instance for chaining update operations and conditions
+   */
+  update(keyCondition) {
+    const executor = async (params) => {
+      try {
+        const result = await this.dynamoClient.update({
+          TableName: params.tableName,
+          Key: this.createKeyForPrimaryIndex(keyCondition),
+          UpdateExpression: params.updateExpression,
+          ConditionExpression: params.conditionExpression,
+          ExpressionAttributeNames: params.expressionAttributeNames,
+          ExpressionAttributeValues: params.expressionAttributeValues,
+          ReturnValues: params.returnValues
+        });
+        return {
+          item: result.Attributes
+        };
+      } catch (error) {
+        console.error("Error updating item:", error);
+        throw error;
       }
-    }
-    return attributes;
+    };
+    return new UpdateBuilder(executor, this.tableName, keyCondition);
+  }
+  /**
+   * Creates a transaction builder for performing multiple operations atomically
+   */
+  transactionBuilder() {
+    const executor = async (params) => {
+      await this.dynamoClient.transactWrite(params);
+    };
+    return new TransactionBuilder(executor, {
+      partitionKey: this.partitionKey,
+      sortKey: this.sortKey
+    });
   }
   /**
-   * Check if a key has undefined values
+   * Creates a batch builder for performing multiple operations efficiently with optional type inference
    *
-   * @param key - The index key to check
-   * @returns True if the key contains undefined values, false otherwise
+   * @example Basic Usage
+   * ```typescript
+   * const batch = table.batchBuilder();
+   *
+   * // Add operations
+   * userRepo.create(newUser).withBatch(batch);
+   * orderRepo.get({ id: 'order-1' }).withBatch(batch);
+   *
+   * // Execute operations
+   * const result = await batch.execute();
+   * ```
+   *
+   * @example Typed Usage
+   * ```typescript
+   * // Define entity types for the batch
+   * const batch = table.batchBuilder<{
+   *   User: UserEntity;
+   *   Order: OrderEntity;
+   *   Product: ProductEntity;
+   * }>();
+   *
+   * // Add operations with type information
+   * userRepo.create(newUser).withBatch(batch, 'User');
+   * orderRepo.get({ id: 'order-1' }).withBatch(batch, 'Order');
+   * productRepo.delete({ id: 'old-product' }).withBatch(batch, 'Product');
+   *
+   * // Execute and get typed results
+   * const result = await batch.execute();
+   * const users: UserEntity[] = result.reads.itemsByType.User;
+   * const orders: OrderEntity[] = result.reads.itemsByType.Order;
+   * ```
    */
-  hasUndefinedValues(key) {
-    return (key.pk?.includes("undefined") ?? false) || (key.sk?.includes("undefined") ?? false);
-  }
-};
-
-// src/entity/index-utils.ts
-function buildIndexes(dataForKeyGeneration, table, indexes, excludeReadOnly = false) {
-  if (!indexes) {
-    return {};
-  }
-  const indexBuilder = new IndexBuilder(table, indexes);
-  return indexBuilder.buildForCreate(dataForKeyGeneration, { excludeReadOnly });
-}
-function buildIndexUpdates(currentData, updates, table, indexes, forceRebuildIndexes) {
-  if (!indexes) {
-    return {};
+  batchBuilder() {
+    const batchWriteExecutor = async (operations) => {
+      return this.batchWrite(operations);
+    };
+    const batchGetExecutor = async (keys) => {
+      return this.batchGet(keys);
+    };
+    return new BatchBuilder(batchWriteExecutor, batchGetExecutor, {
+      partitionKey: this.partitionKey,
+      sortKey: this.sortKey
+    });
   }
-  const indexBuilder = new IndexBuilder(table, indexes);
-  return indexBuilder.buildForUpdate(currentData, updates, { forceRebuildIndexes });
-}
-
-// src/entity/entity.ts
-function defineEntity(config) {
-  const entityTypeAttributeName = config.settings?.entityTypeAttributeName ?? "entityType";
-  const buildIndexes2 = (dataForKeyGeneration, table, excludeReadOnly = false) => {
-    return buildIndexes(dataForKeyGeneration, table, config.indexes, excludeReadOnly);
-  };
-  const wrapMethodWithPreparation = (originalMethod, prepareFn, context) => {
-    const wrappedMethod = (...args) => {
-      prepareFn();
-      return originalMethod.call(context, ...args);
+  /**
+   * Executes a transaction using a callback function
+   *
+   * @param callback A function that receives a transaction context and performs operations on it
+   * @param options Optional transaction options
+   * @returns A promise that resolves when the transaction is complete
+   */
+  async transaction(callback, options) {
+    const transactionExecutor = async (params) => {
+      await this.dynamoClient.transactWrite(params);
     };
-    Object.setPrototypeOf(wrappedMethod, originalMethod);
-    const propertyNames = Object.getOwnPropertyNames(originalMethod);
-    for (let i = 0; i < propertyNames.length; i++) {
-      const prop = propertyNames[i];
-      if (prop !== "length" && prop !== "name" && prop !== "prototype") {
-        const descriptor = Object.getOwnPropertyDescriptor(originalMethod, prop);
-        if (descriptor && descriptor.writable !== false && !descriptor.get) {
-          wrappedMethod[prop] = originalMethod[prop];
-        }
-      }
-    }
-    return wrappedMethod;
-  };
-  const generateTimestamps = (timestampsToGenerate, data) => {
-    if (!config.settings?.timestamps) return {};
-    const timestamps = {};
-    const now = /* @__PURE__ */ new Date();
-    const unixTime = Math.floor(Date.now() / 1e3);
-    const { createdAt, updatedAt } = config.settings.timestamps;
-    if (createdAt && timestampsToGenerate.includes("createdAt") && !data.createdAt) {
-      const name = createdAt.attributeName ?? "createdAt";
-      timestamps[name] = createdAt.format === "UNIX" ? unixTime : now.toISOString();
-    }
-    if (updatedAt && timestampsToGenerate.includes("updatedAt") && !data.updatedAt) {
-      const name = updatedAt.attributeName ?? "updatedAt";
-      timestamps[name] = updatedAt.format === "UNIX" ? unixTime : now.toISOString();
+    const transaction = new TransactionBuilder(transactionExecutor, {
+      partitionKey: this.partitionKey,
+      sortKey: this.sortKey
+    });
+    if (options) {
+      transaction.withOptions(options);
     }
-    return timestamps;
-  };
-  return {
-    name: config.name,
-    createRepository: (table) => {
-      const repository = {
-        create: (data) => {
-          const builder = table.create({});
-          const prepareValidatedItemAsync = async () => {
-            const validatedData = await config.schema["~standard"].validate(data);
-            if ("issues" in validatedData && validatedData.issues) {
-              throw new Error(`Validation failed: ${validatedData.issues.map((i) => i.message).join(", ")}`);
-            }
-            const dataForKeyGeneration = {
-              ...validatedData.value,
-              ...generateTimestamps(["createdAt", "updatedAt"], validatedData.value)
-            };
-            const primaryKey = config.primaryKey.generateKey(dataForKeyGeneration);
-            const indexes = buildIndexes(dataForKeyGeneration, table, config.indexes, false);
-            const validatedItem = {
-              ...dataForKeyGeneration,
-              [entityTypeAttributeName]: config.name,
-              [table.partitionKey]: primaryKey.pk,
-              ...table.sortKey ? { [table.sortKey]: primaryKey.sk } : {},
-              ...indexes
-            };
-            Object.assign(builder, { item: validatedItem });
-            return validatedItem;
-          };
-          const prepareValidatedItemSync = () => {
-            const validationResult = config.schema["~standard"].validate(data);
-            if (validationResult instanceof Promise) {
-              throw new Error(
-                "Async validation is not supported in withBatch or withTransaction. The schema must support synchronous validation for compatibility."
-              );
-            }
-            if ("issues" in validationResult && validationResult.issues) {
-              throw new Error(`Validation failed: ${validationResult.issues.map((i) => i.message).join(", ")}`);
-            }
-            const dataForKeyGeneration = {
-              ...validationResult.value,
-              ...generateTimestamps(["createdAt", "updatedAt"], validationResult.value)
-            };
-            const primaryKey = config.primaryKey.generateKey(dataForKeyGeneration);
-            const indexes = buildIndexes(dataForKeyGeneration, table, config.indexes, false);
-            const validatedItem = {
-              ...dataForKeyGeneration,
-              [entityTypeAttributeName]: config.name,
-              [table.partitionKey]: primaryKey.pk,
-              ...table.sortKey ? { [table.sortKey]: primaryKey.sk } : {},
-              ...indexes
-            };
-            Object.assign(builder, { item: validatedItem });
-            return validatedItem;
-          };
-          const originalExecute = builder.execute;
-          builder.execute = async () => {
-            await prepareValidatedItemAsync();
-            return await originalExecute.call(builder);
-          };
-          const originalWithTransaction = builder.withTransaction;
-          if (originalWithTransaction) {
-            builder.withTransaction = wrapMethodWithPreparation(
-              originalWithTransaction,
-              prepareValidatedItemSync,
-              builder
-            );
-          }
-          const originalWithBatch = builder.withBatch;
-          if (originalWithBatch) {
-            builder.withBatch = wrapMethodWithPreparation(originalWithBatch, prepareValidatedItemSync, builder);
-          }
-          return createEntityAwarePutBuilder(builder, config.name);
-        },
-        upsert: (data) => {
-          const builder = table.put({});
-          const prepareValidatedItemAsync = async () => {
-            const validatedData = await config.schema["~standard"].validate(data);
-            if ("issues" in validatedData && validatedData.issues) {
-              throw new Error(`Validation failed: ${validatedData.issues.map((i) => i.message).join(", ")}`);
-            }
-            const dataForKeyGeneration = {
-              ...validatedData.value,
-              ...generateTimestamps(["createdAt", "updatedAt"], validatedData.value)
-            };
-            const primaryKey = config.primaryKey.generateKey(dataForKeyGeneration);
-            const indexes = buildIndexes2(dataForKeyGeneration, table, false);
-            const validatedItem = {
-              [table.partitionKey]: primaryKey.pk,
-              ...table.sortKey ? { [table.sortKey]: primaryKey.sk } : {},
-              ...dataForKeyGeneration,
-              [entityTypeAttributeName]: config.name,
-              ...indexes
-            };
-            Object.assign(builder, { item: validatedItem });
-            return validatedItem;
-          };
-          const prepareValidatedItemSync = () => {
-            const validationResult = config.schema["~standard"].validate(data);
-            if (validationResult instanceof Promise) {
-              throw new Error(
-                "Async validation is not supported in withTransaction or withBatch. Use execute() instead."
-              );
-            }
-            if ("issues" in validationResult && validationResult.issues) {
-              throw new Error(`Validation failed: ${validationResult.issues.map((i) => i.message).join(", ")}`);
-            }
-            const dataForKeyGeneration = {
-              ...validationResult.value,
-              ...generateTimestamps(["createdAt", "updatedAt"], validationResult.value)
-            };
-            const primaryKey = config.primaryKey.generateKey(dataForKeyGeneration);
-            const indexes = buildIndexes(dataForKeyGeneration, table, config.indexes, false);
-            const validatedItem = {
-              [table.partitionKey]: primaryKey.pk,
-              ...table.sortKey ? { [table.sortKey]: primaryKey.sk } : {},
-              ...dataForKeyGeneration,
-              [entityTypeAttributeName]: config.name,
-              ...indexes
-            };
-            Object.assign(builder, { item: validatedItem });
-            return validatedItem;
-          };
-          const originalExecute = builder.execute;
-          builder.execute = async () => {
-            await prepareValidatedItemAsync();
-            const result = await originalExecute.call(builder);
-            if (!result) {
-              throw new Error("Failed to upsert item");
+    const result = await callback(transaction);
+    await transaction.execute();
+    return result;
+  }
+  /**
+   * Creates a condition check operation for use in transactions
+   *
+   * This is useful for when you require a transaction to succeed only when a specific condition is met on a
+   * a record within the database that you are not directly updating.
+   *
+   * For example, you are updating a record and you want to ensure that another record exists and/or has a specific value before proceeding.
+   */
+  conditionCheck(keyCondition) {
+    return new ConditionCheckBuilder(this.tableName, keyCondition);
+  }
+  /**
+   * Performs a batch get operation to retrieve multiple items at once
+   *
+   * @param keys Array of primary keys to retrieve
+   * @returns A promise that resolves to the retrieved items
+   */
+  async batchGet(keys) {
+    const allItems = [];
+    const allUnprocessedKeys = [];
+    for (const chunk of chunkArray(keys, DDB_BATCH_GET_LIMIT)) {
+      const formattedKeys = chunk.map((key) => ({
+        [this.partitionKey]: key.pk,
+        ...this.sortKey ? { [this.sortKey]: key.sk } : {}
+      }));
+      const params = {
+        RequestItems: {
+          [this.tableName]: {
+            Keys: formattedKeys
+          }
+        }
+      };
+      try {
+        const result = await this.dynamoClient.batchGet(params);
+        if (result.Responses?.[this.tableName]) {
+          allItems.push(...result.Responses[this.tableName]);
+        }
+        const unprocessedKeysArray = result.UnprocessedKeys?.[this.tableName]?.Keys || [];
+        const unprocessedKeys = unprocessedKeysArray.map((key) => ({
+          pk: key[this.partitionKey],
+          sk: this.sortKey ? key[this.sortKey] : void 0
+        }));
+        if (unprocessedKeys.length > 0) {
+          allUnprocessedKeys.push(...unprocessedKeys);
+        }
+      } catch (error) {
+        console.error("Error in batch get operation:", error);
+        throw error;
+      }
+    }
+    return {
+      items: allItems,
+      unprocessedKeys: allUnprocessedKeys
+    };
+  }
+  /**
+   * Performs a batch write operation to put or delete multiple items at once
+   *
+   * @param operations Array of put or delete operations
+   * @returns A promise that resolves to any unprocessed operations
+   */
+  async batchWrite(operations) {
+    const allUnprocessedItems = [];
+    for (const chunk of chunkArray(operations, DDB_BATCH_WRITE_LIMIT)) {
+      const writeRequests = chunk.map((operation) => {
+        if (operation.type === "put") {
+          return {
+            PutRequest: {
+              Item: operation.item
             }
-            return result;
           };
-          const originalWithTransaction = builder.withTransaction;
-          if (originalWithTransaction) {
-            builder.withTransaction = wrapMethodWithPreparation(
-              originalWithTransaction,
-              prepareValidatedItemSync,
-              builder
-            );
-          }
-          const originalWithBatch = builder.withBatch;
-          if (originalWithBatch) {
-            builder.withBatch = wrapMethodWithPreparation(originalWithBatch, prepareValidatedItemSync, builder);
+        }
+        return {
+          DeleteRequest: {
+            Key: this.createKeyForPrimaryIndex(operation.key)
           }
-          return createEntityAwarePutBuilder(builder, config.name);
-        },
-        get: (key) => {
-          return createEntityAwareGetBuilder(table.get(config.primaryKey.generateKey(key)), config.name);
-        },
-        update: (key, data) => {
-          const primaryKeyObj = config.primaryKey.generateKey(key);
-          const builder = table.update(primaryKeyObj);
-          builder.condition(eq(entityTypeAttributeName, config.name));
-          const entityAwareBuilder = createEntityAwareUpdateBuilder(builder, config.name);
-          entityAwareBuilder.configureEntityLogic({
-            data,
-            key,
-            table,
-            indexes: config.indexes,
-            generateTimestamps: () => generateTimestamps(["updatedAt"], data),
-            buildIndexUpdates
-          });
-          return entityAwareBuilder;
-        },
-        delete: (key) => {
-          const builder = table.delete(config.primaryKey.generateKey(key));
-          builder.condition(eq(entityTypeAttributeName, config.name));
-          return createEntityAwareDeleteBuilder(builder, config.name);
-        },
-        query: Object.entries(config.queries || {}).reduce((acc, [key, inputCallback]) => {
-          acc[key] = (input) => {
-            const queryEntity = {
-              scan: repository.scan,
-              get: (key2) => createEntityAwareGetBuilder(table.get(key2), config.name),
-              query: (keyCondition) => {
-                return table.query(keyCondition);
-              }
-            };
-            const queryBuilderCallback = inputCallback(input);
-            const builder = queryBuilderCallback(queryEntity);
-            if (builder && typeof builder === "object" && "filter" in builder && typeof builder.filter === "function") {
-              builder.filter(eq(entityTypeAttributeName, config.name));
+        };
+      });
+      const params = {
+        RequestItems: {
+          [this.tableName]: writeRequests
+        }
+      };
+      try {
+        const result = await this.dynamoClient.batchWrite(params);
+        const unprocessedRequestsArray = result.UnprocessedItems?.[this.tableName] || [];
+        if (unprocessedRequestsArray.length > 0) {
+          const unprocessedItems = unprocessedRequestsArray.map((request) => {
+            if (request?.PutRequest?.Item) {
+              return {
+                type: "put",
+                item: request.PutRequest.Item
+              };
             }
-            if (builder && typeof builder === "object" && "execute" in builder) {
-              const originalExecute = builder.execute;
-              builder.execute = async () => {
-                const queryFn = config.queries[key];
-                if (queryFn && typeof queryFn === "function") {
-                  const schema = queryFn.schema;
-                  if (schema?.["~standard"]?.validate && typeof schema["~standard"].validate === "function") {
-                    const validationResult = schema["~standard"].validate(input);
-                    if ("issues" in validationResult && validationResult.issues) {
-                      throw new Error(
-                        `Validation failed: ${validationResult.issues.map((issue) => issue.message).join(", ")}`
-                      );
-                    }
-                  }
-                }
-                const result = await originalExecute.call(builder);
-                if (!result) {
-                  throw new Error("Failed to execute query");
+            if (request?.DeleteRequest?.Key) {
+              return {
+                type: "delete",
+                key: {
+                  pk: request.DeleteRequest.Key[this.partitionKey],
+                  sk: this.sortKey ? request.DeleteRequest.Key[this.sortKey] : void 0
                 }
-                return result;
               };
             }
-            return builder;
-          };
-          return acc;
-        }, {}),
-        scan: () => {
-          const builder = table.scan();
-          builder.filter(eq(entityTypeAttributeName, config.name));
-          return builder;
+            throw new Error("Invalid unprocessed item format returned from DynamoDB");
+          });
+          allUnprocessedItems.push(...unprocessedItems);
         }
-      };
-      return repository;
-    }
-  };
-}
-function createQueries() {
-  return {
-    input: (schema) => ({
-      query: (handler) => {
-        const queryFn = (input) => (entity) => handler({ input, entity });
-        queryFn.schema = schema;
-        return queryFn;
+      } catch (error) {
+        console.error("Error in batch write operation:", error);
+        throw error;
       }
-    })
-  };
-}
-function createIndex() {
-  return {
-    input: (schema) => {
-      const createIndexBuilder = (isReadOnly = false) => ({
-        partitionKey: (pkFn) => ({
-          sortKey: (skFn) => {
-            const index = {
-              name: "custom",
-              partitionKey: "pk",
-              sortKey: "sk",
-              isReadOnly,
-              generateKey: (item) => {
-                const data = schema["~standard"].validate(item);
-                if ("issues" in data && data.issues) {
-                  throw new Error(`Index validation failed: ${data.issues.map((i) => i.message).join(", ")}`);
-                }
-                const validData = "value" in data ? data.value : item;
-                return { pk: pkFn(validData), sk: skFn(validData) };
-              }
-            };
-            return Object.assign(index, {
-              readOnly: (value = false) => ({
-                ...index,
-                isReadOnly: value
-              })
-            });
-          },
-          withoutSortKey: () => {
-            const index = {
-              name: "custom",
-              partitionKey: "pk",
-              isReadOnly,
-              generateKey: (item) => {
-                const data = schema["~standard"].validate(item);
-                if ("issues" in data && data.issues) {
-                  throw new Error(`Index validation failed: ${data.issues.map((i) => i.message).join(", ")}`);
-                }
-                const validData = "value" in data ? data.value : item;
-                return { pk: pkFn(validData) };
-              }
-            };
-            return Object.assign(index, {
-              readOnly: (value = true) => ({
-                ...index,
-                isReadOnly: value
-              })
-            });
-          }
-        }),
-        readOnly: (value = true) => createIndexBuilder(value)
-      });
-      return createIndexBuilder(false);
     }
-  };
-}
+    return {
+      unprocessedItems: allUnprocessedItems
+    };
+  }
+};
 
 // src/utils/partition-key-template.ts
 function partitionKey(strings, ...keys) {