dyno-table 1.6.0 → 1.7.0

package/dist/{query-builder-CbHvimBk.d.cts → query-builder-BDuHHrb-.d.cts}

@@ -40,10 +40,6 @@ declare abstract class FilterBuilder<T extends DynamoItem, TConfig extends Table
     protected selectedFields: Set<string>;
     /**
      * Sets the maximum number of items to return.
-     * Use this method when you need to:
-     * - Limit the number of dinosaurs returned
-     * - Control the size of habitat reports
-     * - Implement manual pagination of security logs
      *
      * Note: This limit applies to the items that match the key condition
      * before any filter expressions are applied.
@@ -69,11 +65,6 @@ declare abstract class FilterBuilder<T extends DynamoItem, TConfig extends Table
     getLimit(): number | undefined;
     /**
      * Specifies a Global Secondary Index (GSI) to use for the operation.
-     * Use this method when you need to:
-     * - Find dinosaurs by species or status
-     * - Search habitats by security level
-     * - Find incidents by date
-     * - List feeding schedules by time
      *
      * @example
      * ```typescript
@@ -99,11 +90,6 @@ declare abstract class FilterBuilder<T extends DynamoItem, TConfig extends Table
     useIndex<I extends GSINames<TConfig>>(indexName: I): this;
     /**
      * Sets whether to use strongly consistent reads for the operation.
-     * Use this method when you need to:
-     * - Get real-time dinosaur status updates
-     * - Monitor critical security systems
-     * - Track immediate habitat changes
-     * - Verify containment protocols
      *
      * Note:
      * - Consistent reads are not available on GSIs
@@ -131,11 +117,6 @@ declare abstract class FilterBuilder<T extends DynamoItem, TConfig extends Table
     consistentRead(consistentRead?: boolean): this;
     /**
      * Adds a filter expression to refine the operation results.
-     * Use this method when you need to:
-     * - Filter dinosaurs by behavior patterns
-     * - Find habitats with specific conditions
-     * - Search for security incidents
-     * - Monitor feeding patterns
      *
      * @example
      * ```typescript
@@ -164,11 +145,6 @@ declare abstract class FilterBuilder<T extends DynamoItem, TConfig extends Table
     filter(condition: Condition | ((op: ConditionOperator<T>) => Condition)): this;
     /**
      * Specifies which attributes to return in the results.
-     * Use this method when you need to:
-     * - Get specific dinosaur attributes
-     * - Retrieve habitat statistics
-     * - Monitor security metrics
-     * - Optimize response size
      *
      * @example
      * ```typescript
@@ -223,11 +199,6 @@ declare abstract class FilterBuilder<T extends DynamoItem, TConfig extends Table
     paginate(pageSize: number): Paginator<T, TConfig>;
     /**
      * Sets the starting point using a previous lastEvaluatedKey.
-     * Use this method when you need to:
-     * - Implement manual dinosaur list pagination
-     * - Resume habitat inspection reviews
-     * - Continue security incident analysis
-     * - Store operation position between sessions
      *
      * Note: This method is typically used for manual pagination.
      * For automatic pagination, use the paginate() method instead.
@@ -258,11 +229,6 @@ declare abstract class FilterBuilder<T extends DynamoItem, TConfig extends Table
     startFrom(lastEvaluatedKey: DynamoItem): this;
     /**
      * Creates a deep clone of this builder instance.
-     * Use this method when you need to:
-     * - Query different dinosaur statuses
-     * - Check multiple habitat conditions
-     * - Monitor various security levels
-     * - Create report templates
      *
      * This is particularly useful when:
      * - Implementing pagination (used internally by paginate())

package/dist/{query-builder-BhrR31oO.d.ts → query-builder-C6XjVEFH.d.ts}

@@ -40,10 +40,6 @@ declare abstract class FilterBuilder<T extends DynamoItem, TConfig extends Table
     protected selectedFields: Set<string>;
     /**
      * Sets the maximum number of items to return.
-     * Use this method when you need to:
-     * - Limit the number of dinosaurs returned
-     * - Control the size of habitat reports
-     * - Implement manual pagination of security logs
      *
      * Note: This limit applies to the items that match the key condition
      * before any filter expressions are applied.
@@ -69,11 +65,6 @@ declare abstract class FilterBuilder<T extends DynamoItem, TConfig extends Table
     getLimit(): number | undefined;
     /**
      * Specifies a Global Secondary Index (GSI) to use for the operation.
-     * Use this method when you need to:
-     * - Find dinosaurs by species or status
-     * - Search habitats by security level
-     * - Find incidents by date
-     * - List feeding schedules by time
      *
      * @example
      * ```typescript
@@ -99,11 +90,6 @@ declare abstract class FilterBuilder<T extends DynamoItem, TConfig extends Table
     useIndex<I extends GSINames<TConfig>>(indexName: I): this;
     /**
      * Sets whether to use strongly consistent reads for the operation.
-     * Use this method when you need to:
-     * - Get real-time dinosaur status updates
-     * - Monitor critical security systems
-     * - Track immediate habitat changes
-     * - Verify containment protocols
      *
      * Note:
      * - Consistent reads are not available on GSIs
@@ -131,11 +117,6 @@ declare abstract class FilterBuilder<T extends DynamoItem, TConfig extends Table
     consistentRead(consistentRead?: boolean): this;
     /**
      * Adds a filter expression to refine the operation results.
-     * Use this method when you need to:
-     * - Filter dinosaurs by behavior patterns
-     * - Find habitats with specific conditions
-     * - Search for security incidents
-     * - Monitor feeding patterns
      *
      * @example
      * ```typescript
@@ -164,11 +145,6 @@ declare abstract class FilterBuilder<T extends DynamoItem, TConfig extends Table
     filter(condition: Condition | ((op: ConditionOperator<T>) => Condition)): this;
     /**
      * Specifies which attributes to return in the results.
-     * Use this method when you need to:
-     * - Get specific dinosaur attributes
-     * - Retrieve habitat statistics
-     * - Monitor security metrics
-     * - Optimize response size
      *
      * @example
      * ```typescript
@@ -223,11 +199,6 @@ declare abstract class FilterBuilder<T extends DynamoItem, TConfig extends Table
     paginate(pageSize: number): Paginator<T, TConfig>;
     /**
      * Sets the starting point using a previous lastEvaluatedKey.
-     * Use this method when you need to:
-     * - Implement manual dinosaur list pagination
-     * - Resume habitat inspection reviews
-     * - Continue security incident analysis
-     * - Store operation position between sessions
      *
      * Note: This method is typically used for manual pagination.
      * For automatic pagination, use the paginate() method instead.
@@ -258,11 +229,6 @@ declare abstract class FilterBuilder<T extends DynamoItem, TConfig extends Table
     startFrom(lastEvaluatedKey: DynamoItem): this;
     /**
      * Creates a deep clone of this builder instance.
-     * Use this method when you need to:
-     * - Query different dinosaur statuses
-     * - Check multiple habitat conditions
-     * - Monitor various security levels
-     * - Create report templates
      *
      * This is particularly useful when:
      * - Implementing pagination (used internally by paginate())

package/dist/{table-Des8C2od.d.ts → table-BWa4tx63.d.ts}

@@ -1,153 +1,14 @@
 import { DynamoItem, TableConfig, Index } from './types.js';
 import { r as PrimaryKeyWithoutExpression, P as PrimaryKey } from './conditions-BtynAviC.js';
-import { F as FilterBuilder, b as FilterOptions, Q as QueryBuilder } from './query-builder-BhrR31oO.js';
+import { F as FilterBuilder, b as FilterOptions, Q as QueryBuilder } from './query-builder-C6XjVEFH.js';
 import { PutBuilder } from './builders/put-builder.js';
 import { DeleteBuilder } from './builders/delete-builder.js';
 import { UpdateBuilder } from './builders/update-builder.js';
 import { TransactionBuilder, TransactionOptions } from './builders/transaction-builder.js';
+import { G as GetBuilder, B as BatchBuilder, c as BatchWriteOperation } from './batch-builder-Dz1yPGrJ.js';
 import { ConditionCheckBuilder } from './builders/condition-check-builder.js';
 import { S as ScanBuilderInterface } from './builder-types-B_tCpn9F.js';
 
-type BatchWriteOperation<T extends Record<string, unknown>> = {
-    type: "put";
-    item: T;
-} | {
-    type: "delete";
-    key: PrimaryKeyWithoutExpression;
-};
-
-/**
- * Parameters for the DynamoDB get command.
- */
-interface GetCommandParams {
-    /** The name of the DynamoDB table */
-    tableName: string;
-    /** The primary key of the item to get */
-    key: PrimaryKeyWithoutExpression;
-    /** Comma-separated list of attributes to return */
-    projectionExpression?: string;
-    /** Map of expression attribute name placeholders to actual names */
-    expressionAttributeNames?: Record<string, string>;
-    /** Whether to use strongly consistent reads */
-    consistentRead?: boolean;
-}
-/**
- * Function type for executing DynamoDB get operations.
- * @typeParam T - The type of item being retrieved
- */
-type GetExecutor<T extends DynamoItem> = (params: GetCommandParams) => Promise<{
-    item: T | undefined;
-}>;
-/**
- * Builder for creating DynamoDB get operations.
- * Use this builder when you need to:
- * - Retrieve a single dinosaur by its primary key
- * - Project specific dinosaur attributes
- * - Use consistent reads for critical dinosaur data
- *
- * @example
- * ```typescript
- * // Simple get
- * const result = await new GetBuilder(executor, { pk: 'dinosaur#123', sk: 'profile' })
- *   .execute();
- *
- * // Get with projection and consistent read
- * const result = await new GetBuilder(executor, { pk: 'dinosaur#123', sk: 'profile' })
- *   .select(['species', 'name', 'diet'])
- *   .consistentRead()
- *   .execute();
- * ```
- *
- * @typeParam T - The type of item being retrieved
- */
-declare class GetBuilder<T extends DynamoItem> {
-    private readonly executor;
-    private readonly params;
-    private options;
-    private selectedFields;
-    /**
-     * 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: GetExecutor<T>, key: PrimaryKeyWithoutExpression, tableName: string);
-    /**
-     * Specifies which attributes to return in the get results.
-     * Use this method when you need to:
-     * - Reduce data transfer by selecting specific dinosaur attributes
-     * - Optimize response size for dinosaur records
-     * - Focus on relevant dinosaur characteristics only
-     *
-     * @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: string | string[]): GetBuilder<T>;
-    /**
-     * 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?: boolean): GetBuilder<T>;
-    /**
-     * 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
-     */
-    execute(): Promise<{
-        item: T | undefined;
-    }>;
-}
-
 /**
  * Configuration options for DynamoDB scan operations.
  * Extends the base FilterOptions.
@@ -211,21 +72,12 @@ declare class ScanBuilder<T extends DynamoItem, TConfig extends TableConfig = Ta
     constructor(executor: ScanExecutor<T>);
     /**
      * Creates a deep clone of this ScanBuilder instance.
-     * Use this method when you need to:
-     * - Create scan templates
-     * - Run multiple variations of a scan
-     * - Implement pagination (used internally by paginate())
      *
      * @returns A new ScanBuilder instance with the same configuration
      */
     clone(): ScanBuilder<T, TConfig>;
     /**
      * Executes the scan against DynamoDB.
-     * Use this method when you need to:
-     * - Search across the entire table
-     * - Find items matching specific criteria
-     * - Perform full table analysis
-     * - Generate reports across all data
      *
      * The method returns both the matched items and, if there are more results,
      * a lastEvaluatedKey that can be used with startFrom() to continue the scan.
@@ -348,6 +200,42 @@ declare class Table<TConfig extends TableConfig = TableConfig> {
      * Creates a transaction builder for performing multiple operations atomically
      */
     transactionBuilder(): TransactionBuilder;
+    /**
+     * 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<TEntities extends Record<string, DynamoItem> = Record<string, DynamoItem>>(): BatchBuilder<TEntities>;
     /**
      * Executes a transaction using a callback function
      *
@@ -386,4 +274,4 @@ declare class Table<TConfig extends TableConfig = TableConfig> {
     }>;
 }
 
-export { GetBuilder as G, ScanBuilder as S, Table as T };
+export { ScanBuilder as S, Table as T };

package/dist/{table-CY9byPEg.d.cts → table-DAKlzQsK.d.cts}

@@ -1,153 +1,14 @@
 import { DynamoItem, TableConfig, Index } from './types.cjs';
 import { r as PrimaryKeyWithoutExpression, P as PrimaryKey } from './conditions-3ae5znV_.cjs';
-import { F as FilterBuilder, b as FilterOptions, Q as QueryBuilder } from './query-builder-CbHvimBk.cjs';
+import { F as FilterBuilder, b as FilterOptions, Q as QueryBuilder } from './query-builder-BDuHHrb-.cjs';
 import { PutBuilder } from './builders/put-builder.cjs';
 import { DeleteBuilder } from './builders/delete-builder.cjs';
 import { UpdateBuilder } from './builders/update-builder.cjs';
 import { TransactionBuilder, TransactionOptions } from './builders/transaction-builder.cjs';
+import { G as GetBuilder, B as BatchBuilder, c as BatchWriteOperation } from './batch-builder-DNsz6zvh.cjs';
 import { ConditionCheckBuilder } from './builders/condition-check-builder.cjs';
 import { S as ScanBuilderInterface } from './builder-types-DlaUSc-b.cjs';
 
-type BatchWriteOperation<T extends Record<string, unknown>> = {
-    type: "put";
-    item: T;
-} | {
-    type: "delete";
-    key: PrimaryKeyWithoutExpression;
-};
-
-/**
- * Parameters for the DynamoDB get command.
- */
-interface GetCommandParams {
-    /** The name of the DynamoDB table */
-    tableName: string;
-    /** The primary key of the item to get */
-    key: PrimaryKeyWithoutExpression;
-    /** Comma-separated list of attributes to return */
-    projectionExpression?: string;
-    /** Map of expression attribute name placeholders to actual names */
-    expressionAttributeNames?: Record<string, string>;
-    /** Whether to use strongly consistent reads */
-    consistentRead?: boolean;
-}
-/**
- * Function type for executing DynamoDB get operations.
- * @typeParam T - The type of item being retrieved
- */
-type GetExecutor<T extends DynamoItem> = (params: GetCommandParams) => Promise<{
-    item: T | undefined;
-}>;
-/**
- * Builder for creating DynamoDB get operations.
- * Use this builder when you need to:
- * - Retrieve a single dinosaur by its primary key
- * - Project specific dinosaur attributes
- * - Use consistent reads for critical dinosaur data
- *
- * @example
- * ```typescript
- * // Simple get
- * const result = await new GetBuilder(executor, { pk: 'dinosaur#123', sk: 'profile' })
- *   .execute();
- *
- * // Get with projection and consistent read
- * const result = await new GetBuilder(executor, { pk: 'dinosaur#123', sk: 'profile' })
- *   .select(['species', 'name', 'diet'])
- *   .consistentRead()
- *   .execute();
- * ```
- *
- * @typeParam T - The type of item being retrieved
- */
-declare class GetBuilder<T extends DynamoItem> {
-    private readonly executor;
-    private readonly params;
-    private options;
-    private selectedFields;
-    /**
-     * 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: GetExecutor<T>, key: PrimaryKeyWithoutExpression, tableName: string);
-    /**
-     * Specifies which attributes to return in the get results.
-     * Use this method when you need to:
-     * - Reduce data transfer by selecting specific dinosaur attributes
-     * - Optimize response size for dinosaur records
-     * - Focus on relevant dinosaur characteristics only
-     *
-     * @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: string | string[]): GetBuilder<T>;
-    /**
-     * 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?: boolean): GetBuilder<T>;
-    /**
-     * 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
-     */
-    execute(): Promise<{
-        item: T | undefined;
-    }>;
-}
-
 /**
  * Configuration options for DynamoDB scan operations.
  * Extends the base FilterOptions.
@@ -211,21 +72,12 @@ declare class ScanBuilder<T extends DynamoItem, TConfig extends TableConfig = Ta
     constructor(executor: ScanExecutor<T>);
     /**
      * Creates a deep clone of this ScanBuilder instance.
-     * Use this method when you need to:
-     * - Create scan templates
-     * - Run multiple variations of a scan
-     * - Implement pagination (used internally by paginate())
      *
      * @returns A new ScanBuilder instance with the same configuration
      */
     clone(): ScanBuilder<T, TConfig>;
     /**
      * Executes the scan against DynamoDB.
-     * Use this method when you need to:
-     * - Search across the entire table
-     * - Find items matching specific criteria
-     * - Perform full table analysis
-     * - Generate reports across all data
      *
      * The method returns both the matched items and, if there are more results,
      * a lastEvaluatedKey that can be used with startFrom() to continue the scan.
@@ -348,6 +200,42 @@ declare class Table<TConfig extends TableConfig = TableConfig> {
      * Creates a transaction builder for performing multiple operations atomically
      */
     transactionBuilder(): TransactionBuilder;
+    /**
+     * 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<TEntities extends Record<string, DynamoItem> = Record<string, DynamoItem>>(): BatchBuilder<TEntities>;
     /**
      * Executes a transaction using a callback function
      *
@@ -386,4 +274,4 @@ declare class Table<TConfig extends TableConfig = TableConfig> {
     }>;
 }
 
-export { GetBuilder as G, ScanBuilder as S, Table as T };
+export { ScanBuilder as S, Table as T };