dyno-table 2.2.1 → 2.3.0

package/dist/table-ClST8nkR.d.cts

@@ -1,276 +0,0 @@
-import { G as GetBuilder, B as BatchBuilder, c as BatchWriteOperation } from './batch-builder-BiQDIZ7p.cjs';
-import { ConditionCheckBuilder } from './builders/condition-check-builder.cjs';
-import { DeleteBuilder } from './builders/delete-builder.cjs';
-import { PutBuilder } from './builders/put-builder.cjs';
-import { F as FilterBuilder, b as FilterOptions, Q as QueryBuilder } from './query-builder-D3URwK9k.cjs';
-import { DynamoItem, TableConfig, Index } from './types.cjs';
-import { S as ScanBuilderInterface, R as ResultIterator } from './builder-types-BTVhQSHI.cjs';
-import { TransactionBuilder, TransactionOptions } from './builders/transaction-builder.cjs';
-import { UpdateBuilder } from './builders/update-builder.cjs';
-import { c as PrimaryKeyWithoutExpression, P as PrimaryKey } from './conditions-CcZL0sR2.cjs';
-
-/**
- * Configuration options for DynamoDB scan operations.
- * Extends the base FilterOptions.
- */
-type ScanOptions = FilterOptions;
-/**
- * Function type for executing DynamoDB filter operations.
- * @typeParam T - The type of items being filtered
- */
-type ScanExecutor<T extends DynamoItem> = (options: ScanOptions) => Promise<{
-    items: T[];
-    lastEvaluatedKey?: DynamoItem;
-}>;
-/**
- * Builder for creating DynamoDB scan operations.
- * Use this builder when you need to:
- * - Scan all items in a table
- * - Filter results based on non-key attributes
- * - Scan items on a Secondary Index (GSI)
- * - Implement pagination
- * - Project specific attributes
- *
- * The builder supports:
- * - Type-safe GSI selection
- * - Complex filter conditions
- * - Automatic pagination handling
- * - Consistent reads
- * - Attribute projection
- *
- * @example
- * ```typescript
- * // Simple scan with filtering
- * const result = await new ScanBuilder(executor)
- *   .filter(op => op.eq('status', 'ACTIVE'))
- *   .execute();
- *
- * // Scan with GSI and filtering
- * const result = await new ScanBuilder(executor)
- *   .useIndex('status-index')
- *   .filter(op => op.gt('securityLevel', 8))
- *   .select(['id', 'capacity', 'currentOccupants'])
- *   .limit(10)
- *   .execute();
- *
- * // Scan with pagination
- * const paginator = new ScanBuilder(executor)
- *   .filter(op => op.eq('type', 'INCIDENT'))
- *   .paginate(25);
- *
- * while (paginator.hasNextPage()) {
- *   const page = await paginator.getNextPage();
- *   // Process page.items
- * }
- * ```
- *
- * @typeParam T - The type of items being scanned
- * @typeParam TConfig - The table configuration type for type-safe GSI selection
- */
-declare class ScanBuilder<T extends DynamoItem, TConfig extends TableConfig = TableConfig> extends FilterBuilder<T, TConfig> implements ScanBuilderInterface<T, TConfig> {
-    protected readonly executor: ScanExecutor<T>;
-    constructor(executor: ScanExecutor<T>);
-    /**
-     * Creates a deep clone of this ScanBuilder instance.
-     *
-     * @returns A new ScanBuilder instance with the same configuration
-     */
-    clone(): ScanBuilder<T, TConfig>;
-    private deepCloneFilter;
-    /**
-     * 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
-     */
-    execute(): Promise<ResultIterator<T, TConfig>>;
-}
-
-declare class Table<TConfig extends TableConfig = TableConfig> {
-    private readonly dynamoClient;
-    readonly tableName: string;
-    /**
-     * The column name of the partitionKey for the Table
-     */
-    readonly partitionKey: string;
-    /**
-     * The column name of the sortKey for the Table
-     */
-    readonly sortKey?: string;
-    /**
-     * The Global Secondary Indexes that are configured on this table
-     */
-    readonly gsis: Record<string, Index>;
-    constructor(config: TConfig);
-    protected createKeyForPrimaryIndex(keyCondition: PrimaryKeyWithoutExpression): Record<string, unknown>;
-    /**
-     * 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:
-     *
-     * @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();
-     * ```
-     */
-    create<T extends DynamoItem>(item: T): PutBuilder<T>;
-    get<T extends DynamoItem>(keyCondition: PrimaryKeyWithoutExpression): GetBuilder<T>;
-    /**
-     * Updates an item in the table
-     *
-     * @param item The item to update
-     * @returns A PutBuilder instance for chaining conditions and executing the put operation
-     */
-    put<T extends DynamoItem>(item: T): PutBuilder<T>;
-    /**
-     * Creates a query builder for complex queries
-     * If useIndex is called on the returned QueryBuilder, it will use the GSI configuration
-     */
-    query<T extends DynamoItem>(keyCondition: PrimaryKey): QueryBuilder<T, TConfig>;
-    /**
-     * 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<T extends DynamoItem>(): ScanBuilder<T, TConfig>;
-    delete(keyCondition: PrimaryKeyWithoutExpression): DeleteBuilder;
-    /**
-     * 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<T extends DynamoItem>(keyCondition: PrimaryKeyWithoutExpression): UpdateBuilder<T>;
-    /**
-     * 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
-     *
-     * @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
-     */
-    transaction(callback: (tx: TransactionBuilder) => Promise<void> | void, options?: TransactionOptions): Promise<void>;
-    /**
-     * 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: PrimaryKeyWithoutExpression): ConditionCheckBuilder;
-    /**
-     * 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
-     */
-    batchGet<T extends DynamoItem>(keys: Array<PrimaryKeyWithoutExpression>): Promise<{
-        items: T[];
-        unprocessedKeys: PrimaryKeyWithoutExpression[];
-    }>;
-    /**
-     * 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
-     */
-    batchWrite<T extends DynamoItem>(operations: Array<BatchWriteOperation<T>>): Promise<{
-        unprocessedItems: Array<BatchWriteOperation<T>>;
-    }>;
-}
-
-export { ScanBuilder as S, Table as T };

package/dist/table-vE3cGoDy.d.ts

@@ -1,276 +0,0 @@
-import { G as GetBuilder, B as BatchBuilder, c as BatchWriteOperation } from './batch-builder-CNsLS6sR.js';
-import { ConditionCheckBuilder } from './builders/condition-check-builder.js';
-import { DeleteBuilder } from './builders/delete-builder.js';
-import { PutBuilder } from './builders/put-builder.js';
-import { F as FilterBuilder, b as FilterOptions, Q as QueryBuilder } from './query-builder-cfEkU0_w.js';
-import { DynamoItem, TableConfig, Index } from './types.js';
-import { S as ScanBuilderInterface, R as ResultIterator } from './builder-types-CzuLR4Th.js';
-import { TransactionBuilder, TransactionOptions } from './builders/transaction-builder.js';
-import { UpdateBuilder } from './builders/update-builder.js';
-import { c as PrimaryKeyWithoutExpression, P as PrimaryKey } from './conditions-D_w7vVYG.js';
-
-/**
- * Configuration options for DynamoDB scan operations.
- * Extends the base FilterOptions.
- */
-type ScanOptions = FilterOptions;
-/**
- * Function type for executing DynamoDB filter operations.
- * @typeParam T - The type of items being filtered
- */
-type ScanExecutor<T extends DynamoItem> = (options: ScanOptions) => Promise<{
-    items: T[];
-    lastEvaluatedKey?: DynamoItem;
-}>;
-/**
- * Builder for creating DynamoDB scan operations.
- * Use this builder when you need to:
- * - Scan all items in a table
- * - Filter results based on non-key attributes
- * - Scan items on a Secondary Index (GSI)
- * - Implement pagination
- * - Project specific attributes
- *
- * The builder supports:
- * - Type-safe GSI selection
- * - Complex filter conditions
- * - Automatic pagination handling
- * - Consistent reads
- * - Attribute projection
- *
- * @example
- * ```typescript
- * // Simple scan with filtering
- * const result = await new ScanBuilder(executor)
- *   .filter(op => op.eq('status', 'ACTIVE'))
- *   .execute();
- *
- * // Scan with GSI and filtering
- * const result = await new ScanBuilder(executor)
- *   .useIndex('status-index')
- *   .filter(op => op.gt('securityLevel', 8))
- *   .select(['id', 'capacity', 'currentOccupants'])
- *   .limit(10)
- *   .execute();
- *
- * // Scan with pagination
- * const paginator = new ScanBuilder(executor)
- *   .filter(op => op.eq('type', 'INCIDENT'))
- *   .paginate(25);
- *
- * while (paginator.hasNextPage()) {
- *   const page = await paginator.getNextPage();
- *   // Process page.items
- * }
- * ```
- *
- * @typeParam T - The type of items being scanned
- * @typeParam TConfig - The table configuration type for type-safe GSI selection
- */
-declare class ScanBuilder<T extends DynamoItem, TConfig extends TableConfig = TableConfig> extends FilterBuilder<T, TConfig> implements ScanBuilderInterface<T, TConfig> {
-    protected readonly executor: ScanExecutor<T>;
-    constructor(executor: ScanExecutor<T>);
-    /**
-     * Creates a deep clone of this ScanBuilder instance.
-     *
-     * @returns A new ScanBuilder instance with the same configuration
-     */
-    clone(): ScanBuilder<T, TConfig>;
-    private deepCloneFilter;
-    /**
-     * 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
-     */
-    execute(): Promise<ResultIterator<T, TConfig>>;
-}
-
-declare class Table<TConfig extends TableConfig = TableConfig> {
-    private readonly dynamoClient;
-    readonly tableName: string;
-    /**
-     * The column name of the partitionKey for the Table
-     */
-    readonly partitionKey: string;
-    /**
-     * The column name of the sortKey for the Table
-     */
-    readonly sortKey?: string;
-    /**
-     * The Global Secondary Indexes that are configured on this table
-     */
-    readonly gsis: Record<string, Index>;
-    constructor(config: TConfig);
-    protected createKeyForPrimaryIndex(keyCondition: PrimaryKeyWithoutExpression): Record<string, unknown>;
-    /**
-     * 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:
-     *
-     * @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();
-     * ```
-     */
-    create<T extends DynamoItem>(item: T): PutBuilder<T>;
-    get<T extends DynamoItem>(keyCondition: PrimaryKeyWithoutExpression): GetBuilder<T>;
-    /**
-     * Updates an item in the table
-     *
-     * @param item The item to update
-     * @returns A PutBuilder instance for chaining conditions and executing the put operation
-     */
-    put<T extends DynamoItem>(item: T): PutBuilder<T>;
-    /**
-     * Creates a query builder for complex queries
-     * If useIndex is called on the returned QueryBuilder, it will use the GSI configuration
-     */
-    query<T extends DynamoItem>(keyCondition: PrimaryKey): QueryBuilder<T, TConfig>;
-    /**
-     * 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<T extends DynamoItem>(): ScanBuilder<T, TConfig>;
-    delete(keyCondition: PrimaryKeyWithoutExpression): DeleteBuilder;
-    /**
-     * 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<T extends DynamoItem>(keyCondition: PrimaryKeyWithoutExpression): UpdateBuilder<T>;
-    /**
-     * 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
-     *
-     * @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
-     */
-    transaction(callback: (tx: TransactionBuilder) => Promise<void> | void, options?: TransactionOptions): Promise<void>;
-    /**
-     * 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: PrimaryKeyWithoutExpression): ConditionCheckBuilder;
-    /**
-     * 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
-     */
-    batchGet<T extends DynamoItem>(keys: Array<PrimaryKeyWithoutExpression>): Promise<{
-        items: T[];
-        unprocessedKeys: PrimaryKeyWithoutExpression[];
-    }>;
-    /**
-     * 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
-     */
-    batchWrite<T extends DynamoItem>(operations: Array<BatchWriteOperation<T>>): Promise<{
-        unprocessedItems: Array<BatchWriteOperation<T>>;
-    }>;
-}
-
-export { ScanBuilder as S, Table as T };