dynoquery 0.1.20 → 0.1.23

package/README.md

@@ -215,6 +215,33 @@ const userToDelete = db.User('john@example.com').draftDelete('METADATA');
 await db.batchWrite([userToDelete]);
 ```
 
+### 5. Transaction Operations
+
+DynoQuery supports `transactWrite` and `transactRead` for atomic operations across multiple items.
+
+```typescript
+// 1. Transaction Write (All operations succeed or all fail)
+const user1 = db.User('john@example.com', 'METADATA');
+user1.name = 'John Doe';
+
+const userToDelete = db.User('olduser@example.com').draftDelete('METADATA');
+
+// You can even set conditions for items in a transaction
+const criticalItem = db.User('admin@example.com', 'METADATA');
+criticalItem.lastLogin = new Date().toISOString();
+criticalItem.setCondition(attr('status').equals('ACTIVE'));
+
+await db.transactWrite([user1, userToDelete, criticalItem]);
+
+// 2. Transaction Read (Read multiple items atomically)
+const userDraft = db.User('john@example.com', 'METADATA');
+const items = await db.transactRead([userDraft]);
+
+if (items[0]) {
+  console.log('Found user:', items[0].name);
+}
+```
+
 ## Optional Configuration Parameters
 
 | Parameter | Type | Default | Description |
@@ -259,6 +286,55 @@ if (token) {
 }
 ```
 
+### Expression Builder (Filters & Conditions)
+
+Use `ExpressionBuilder` to build complex filter and condition expressions in a type-safe way.
+
+```typescript
+import { attr, ExpressionBuilder } from 'dynoquery';
+
+// 1. Filtering in queries
+const builder = attr('age').greaterThan(25).and(attr('status').equals('ACTIVE'));
+const activeUsers = await db.User('some-id').getAll({ filterBuilder: builder });
+
+// 2. Conditional Updates
+const johnMeta = db.User('john@example.com', 'METADATA');
+const condition = attr('version').equals(1);
+
+johnMeta.setCondition(condition);
+johnMeta.name = 'John New Name';
+johnMeta.version = 2;
+
+await johnMeta.save(); // Fails if version is not 1
+
+// 3. Raw Condition Expressions
+await db.User('john@example.com').update({ status: 'INACTIVE' }, [], {
+  ConditionExpression: '#v = :v',
+  ExpressionAttributeNames: { '#v': 'version' },
+  ExpressionAttributeValues: { ':v': 2 }
+});
+
+// Or using Item object
+johnMeta.setCondition(attr('name').exists());
+await johnMeta.save();
+
+// 4. Supported Operators
+// - attr('name').equals('val') / notEquals('val')
+// - .lessThan(val) / lessThanOrEqual(val)
+// - .greaterThan(val) / greaterThanOrEqual(val)
+// - .between(start, end)
+// - .in([val1, val2])
+// - logical: .and(otherBuilder), .or(otherBuilder), ExpressionBuilder.not(builder)
+
+// 4. Supported Functions
+// - attr('field').exists()
+// - attr('field').notExists()
+// - attr('field').type('S')
+// - attr('field').beginsWith('prefix')
+// - attr('field').contains('value')
+// - attr('field').size().greaterThan(5)
+```
+
 ## API Reference
 
 ### DynoQuery
@@ -270,15 +346,17 @@ if (token) {
 - `scan(params)`: Low-level ScanCommand wrapper.
 - `batchWrite(items)`: Batch persists multiple `Item` objects.
 - `batchRead(items)`: Batch fetches multiple `Item` or `IndexQuery` objects.
+- `transactWrite(items)`: Performs atomic write operations (Put/Delete) for up to 100 items.
+- `transactRead(items)`: Performs atomic read operations (Get) for up to 100 items.
 - `[ModelName](id, skValue?)`: Returns a `Partition` instance for the given ID. If `skValue` is provided, returns an `Item` object directly.
 - `findBy[IndexName](id, skValue?)`: Returns an `IndexQuery` instance.
 
 ### Partition
 - `get(skValue)`: Fetches data for a specific Sort Key value (returns a Promise).
-- `getAll(options?)`: Fetches items in the partition. Options: `{ limit, exclusiveStartKey }`.
-- `create(skValue, data, indices?)`: Creates an item. `indices` is an array of `IndexQuery` for GSI population.
-- `update(skValue, data)`: Partial update of an item.
-- `delete(skValue)`: Deletes an item.
+- `getAll(options?)`: Fetches items in the partition. Options: `{ limit, exclusiveStartKey, filterBuilder, FilterExpression, ExpressionAttributeNames, ExpressionAttributeValues }`.
+- `create(skValue, data, indices?, options?)`: Creates an item. `options`: `{ conditionBuilder, ConditionExpression, ExpressionAttributeNames, ExpressionAttributeValues }`.
+- `update(skValue, data, indices?, options?)`: Partial update of an item. `options`: `{ conditionBuilder, ConditionExpression, ExpressionAttributeNames, ExpressionAttributeValues }`.
+- `delete(skValue, options?)`: Deletes an item. `options`: `{ conditionBuilder, ConditionExpression, ExpressionAttributeNames, ExpressionAttributeValues }`.
 - `draft(skValue, data?)`: Returns an `Item` object initialized with `data` (optional).
 - `draftDelete(skValue)`: Returns an `Item` object marked for deletion (for use with `batchWrite`).
 - `deleteAll()`: Deletes all items in the partition.
@@ -286,14 +364,16 @@ if (token) {
 
 ### IndexQuery
 - `get(skValue?)`: Get a single item from the index.
-- `getAll(options?)`: Query index. Options: `{ limit, scanIndexForward, exclusiveStartKey, skValue }`.
+- `getAll(options?)`: Query index. Options: `{ limit, scanIndexForward, exclusiveStartKey, skValue, filterBuilder, FilterExpression, ExpressionAttributeNames, ExpressionAttributeValues }`.
 - `getLastEvaluatedKey()`: Returns the pagination token from the last `getAll()`.
 
 ### Item (returned by Partition.get or draft)
-- `create(data?, indices?)`: Persists the item as a new record with the provided data. Supports GSI indices.
-- `update(data, indices?)`: Partial update of the item. Supports GSI indices.
-- `save()`: Persists the current state of the item (alias for update of all properties). Uses indices attached via `setIndex()`.
-- `setIndex(indices)`: Attaches one or more `IndexQuery` objects to the item for use with `save()` or `create()`.
+- `create(data?, indices?)`: Persists the item as a new record with the provided data. Supports GSI indices and internal `conditionBuilder`.
+- `update(data, indices?)`: Partial update of the item. Supports GSI indices and internal `conditionBuilder`.
+- `save()`: Persists the current state of the item. Uses indices attached via `setIndex()` and internal `conditionBuilder`.
+- `setIndex(indices)`: Attaches one or more `IndexQuery` objects to the item.
+- `setFilter(builder)`: Sets a filter expression builder for the item.
+- `setCondition(builder)`: Sets a condition for the item using an `ExpressionBuilder`.
 
 ## License
 

package/dist/expression-builder.d.ts

@@ -0,0 +1,41 @@
+export type Operand = string | number | ExpressionBuilder;
+export declare class ExpressionBuilder {
+    private parts;
+    private attributeNames;
+    private attributeValues;
+    private valueCounter;
+    private nameCounter;
+    constructor();
+    static field(name: string): ExpressionBuilder;
+    static value(val: any): ExpressionBuilder;
+    where(field: string, operator: string, value: any): ExpressionBuilder;
+    equals(value: any): ExpressionBuilder;
+    notEquals(value: any): ExpressionBuilder;
+    lessThan(value: any): ExpressionBuilder;
+    lessThanOrEqual(value: any): ExpressionBuilder;
+    greaterThan(value: any): ExpressionBuilder;
+    greaterThanOrEqual(value: any): ExpressionBuilder;
+    between(start: any, end: any): ExpressionBuilder;
+    in(values: any[]): ExpressionBuilder;
+    exists(): ExpressionBuilder;
+    notExists(): ExpressionBuilder;
+    type(type: string): ExpressionBuilder;
+    attributeExists(path: string): ExpressionBuilder;
+    attributeNotExists(path: string): ExpressionBuilder;
+    attributeType(path: string, type: string): ExpressionBuilder;
+    beginsWith(pathOrSubstr: string, substr?: string): ExpressionBuilder;
+    contains(pathOrValue: string, value?: any): ExpressionBuilder;
+    size(path?: string): ExpressionBuilder;
+    and(other: ExpressionBuilder): ExpressionBuilder;
+    or(other: ExpressionBuilder): ExpressionBuilder;
+    static not(condition: ExpressionBuilder): ExpressionBuilder;
+    build(attributeNames?: Record<string, string>, attributeValues?: Record<string, any>, counters?: {
+        name: number;
+        value: number;
+    }): {
+        expression: string;
+        attributeNames: Record<string, string>;
+        attributeValues: Record<string, any>;
+    };
+}
+export declare function attr(name: string): ExpressionBuilder;

package/dist/expression-builder.js

@@ -0,0 +1,248 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExpressionBuilder = void 0;
+exports.attr = attr;
+class ExpressionBuilder {
+    constructor() {
+        this.parts = [];
+        this.attributeNames = {};
+        this.attributeValues = {};
+        this.valueCounter = 0;
+        this.nameCounter = 0;
+    }
+    static field(name) {
+        const builder = new ExpressionBuilder();
+        builder.parts.push({ type: 'field', name });
+        return builder;
+    }
+    static value(val) {
+        const builder = new ExpressionBuilder();
+        builder.parts.push({ type: 'value', value: val });
+        return builder;
+    }
+    where(field, operator, value) {
+        this.parts.push({ type: 'condition', field, operator, value });
+        return this;
+    }
+    equals(value) {
+        this.parts.push({ type: 'operator', operator: '=', value });
+        return this;
+    }
+    notEquals(value) {
+        this.parts.push({ type: 'operator', operator: '<>', value });
+        return this;
+    }
+    lessThan(value) {
+        this.parts.push({ type: 'operator', operator: '<', value });
+        return this;
+    }
+    lessThanOrEqual(value) {
+        this.parts.push({ type: 'operator', operator: '<=', value });
+        return this;
+    }
+    greaterThan(value) {
+        this.parts.push({ type: 'operator', operator: '>', value });
+        return this;
+    }
+    greaterThanOrEqual(value) {
+        this.parts.push({ type: 'operator', operator: '>=', value });
+        return this;
+    }
+    between(start, end) {
+        this.parts.push({ type: 'between', start, end });
+        return this;
+    }
+    in(values) {
+        this.parts.push({ type: 'in', values });
+        return this;
+    }
+    exists() {
+        const last = this.parts.pop();
+        if (last && last.type === 'field') {
+            this.parts.push({ type: 'function', name: 'attribute_exists', args: [last] });
+        }
+        return this;
+    }
+    notExists() {
+        const last = this.parts.pop();
+        if (last && last.type === 'field') {
+            this.parts.push({ type: 'function', name: 'attribute_not_exists', args: [last] });
+        }
+        return this;
+    }
+    type(type) {
+        const last = this.parts.pop();
+        if (last && last.type === 'field') {
+            this.parts.push({ type: 'function', name: 'attribute_type', args: [last, { type: 'value', value: type }] });
+        }
+        return this;
+    }
+    attributeExists(path) {
+        this.parts.push({ type: 'function', name: 'attribute_exists', args: [{ type: 'field', name: path }] });
+        return this;
+    }
+    attributeNotExists(path) {
+        this.parts.push({ type: 'function', name: 'attribute_not_exists', args: [{ type: 'field', name: path }] });
+        return this;
+    }
+    attributeType(path, type) {
+        this.parts.push({ type: 'function', name: 'attribute_type', args: [{ type: 'field', name: path }, { type: 'value', value: type }] });
+        return this;
+    }
+    beginsWith(pathOrSubstr, substr) {
+        if (substr !== undefined) {
+            // Legacy static-like call: builder.beginsWith('field', 'prefix')
+            this.parts.push({ type: 'function', name: 'begins_with', args: [{ type: 'field', name: pathOrSubstr }, { type: 'value', value: substr }] });
+        }
+        else {
+            // Fluent call: attr('field').beginsWith('prefix')
+            const last = this.parts.pop();
+            if (last && last.type === 'field') {
+                this.parts.push({ type: 'function', name: 'begins_with', args: [last, { type: 'value', value: pathOrSubstr }] });
+            }
+        }
+        return this;
+    }
+    contains(pathOrValue, value) {
+        if (value !== undefined) {
+            // Legacy static-like call: builder.contains('field', 'value')
+            this.parts.push({ type: 'function', name: 'contains', args: [{ type: 'field', name: pathOrValue }, { type: 'value', value }] });
+        }
+        else {
+            // Fluent call: attr('field').contains('value')
+            const last = this.parts.pop();
+            if (last && last.type === 'field') {
+                this.parts.push({ type: 'function', name: 'contains', args: [last, { type: 'value', value: pathOrValue }] });
+            }
+        }
+        return this;
+    }
+    size(path) {
+        if (path) {
+            // Legacy: builder.size('field')
+            const builder = new ExpressionBuilder();
+            builder.parts.push({ type: 'function', name: 'size', args: [{ type: 'field', name: path }] });
+            return builder;
+        }
+        else {
+            // Fluent: attr('field').size()
+            const last = this.parts.pop();
+            if (last && last.type === 'field') {
+                this.parts.push({ type: 'function', name: 'size', args: [last] });
+            }
+            return this;
+        }
+    }
+    and(other) {
+        const newBuilder = new ExpressionBuilder();
+        newBuilder.parts.push({ type: 'group', builder: this });
+        newBuilder.parts.push({ type: 'logical', operator: 'AND' });
+        newBuilder.parts.push({ type: 'group', builder: other });
+        return newBuilder;
+    }
+    or(other) {
+        const newBuilder = new ExpressionBuilder();
+        newBuilder.parts.push({ type: 'group', builder: this });
+        newBuilder.parts.push({ type: 'logical', operator: 'OR' });
+        newBuilder.parts.push({ type: 'group', builder: other });
+        return newBuilder;
+    }
+    static not(condition) {
+        const builder = new ExpressionBuilder();
+        builder.parts.push({ type: 'logical', operator: 'NOT' });
+        builder.parts.push({ type: 'group', builder: condition });
+        return builder;
+    }
+    build(attributeNames = {}, attributeValues = {}, counters = { name: 0, value: 0 }) {
+        let expressionParts = [];
+        for (const part of this.parts) {
+            switch (part.type) {
+                case 'field': {
+                    const namePlaceholder = `#n${counters.name++}`;
+                    attributeNames[namePlaceholder] = part.name;
+                    expressionParts.push(namePlaceholder);
+                    break;
+                }
+                case 'value': {
+                    const valuePlaceholder = `:v${counters.value++}`;
+                    attributeValues[valuePlaceholder] = part.value;
+                    expressionParts.push(valuePlaceholder);
+                    break;
+                }
+                case 'condition': {
+                    const namePlaceholder = `#n${counters.name++}`;
+                    attributeNames[namePlaceholder] = part.field;
+                    const valuePlaceholder = `:v${counters.value++}`;
+                    attributeValues[valuePlaceholder] = part.value;
+                    expressionParts.push(`${namePlaceholder} ${part.operator} ${valuePlaceholder}`);
+                    break;
+                }
+                case 'operator': {
+                    const valuePlaceholder = `:v${counters.value++}`;
+                    attributeValues[valuePlaceholder] = part.value;
+                    const last = expressionParts.pop();
+                    expressionParts.push(`${last} ${part.operator} ${valuePlaceholder}`);
+                    break;
+                }
+                case 'between': {
+                    const startPlaceholder = `:v${counters.value++}`;
+                    attributeValues[startPlaceholder] = part.start;
+                    const endPlaceholder = `:v${counters.value++}`;
+                    attributeValues[endPlaceholder] = part.end;
+                    const last = expressionParts.pop();
+                    expressionParts.push(`${last} BETWEEN ${startPlaceholder} AND ${endPlaceholder}`);
+                    break;
+                }
+                case 'in': {
+                    const placeholders = part.values.map((v) => {
+                        const vp = `:v${counters.value++}`;
+                        attributeValues[vp] = v;
+                        return vp;
+                    });
+                    const last = expressionParts.pop();
+                    expressionParts.push(`${last} IN (${placeholders.join(', ')})`);
+                    break;
+                }
+                case 'function': {
+                    const args = part.args.map((arg) => {
+                        if (arg.type === 'field') {
+                            const np = `#n${counters.name++}`;
+                            attributeNames[np] = arg.name;
+                            return np;
+                        }
+                        else if (arg.type === 'value') {
+                            const vp = `:v${counters.value++}`;
+                            attributeValues[vp] = arg.value;
+                            return vp;
+                        }
+                        else if (arg instanceof ExpressionBuilder) {
+                            const sub = arg.build(attributeNames, attributeValues, counters);
+                            return sub.expression;
+                        }
+                        return arg;
+                    });
+                    expressionParts.push(`${part.name}(${args.join(', ')})`);
+                    break;
+                }
+                case 'logical': {
+                    expressionParts.push(part.operator);
+                    break;
+                }
+                case 'group': {
+                    const sub = part.builder.build(attributeNames, attributeValues, counters);
+                    expressionParts.push(`(${sub.expression})`);
+                    break;
+                }
+            }
+        }
+        return {
+            expression: expressionParts.join(' '),
+            attributeNames,
+            attributeValues
+        };
+    }
+}
+exports.ExpressionBuilder = ExpressionBuilder;
+function attr(name) {
+    return ExpressionBuilder.field(name);
+}

package/dist/index-query.d.ts

@@ -1,4 +1,5 @@
 import { DynoQuery } from "./index";
+import { ExpressionBuilder } from "./expression-builder";
 export interface IndexQueryConfig {
     tableName?: string;
     indexName: string;
@@ -23,9 +24,10 @@ export declare class IndexQuery {
         scanIndexForward?: boolean;
         exclusiveStartKey?: any;
         skValue?: string;
-        filterExpression?: string;
-        expressionAttributeNames?: Record<string, string>;
-        expressionAttributeValues?: Record<string, any>;
+        filterBuilder?: ExpressionBuilder;
+        FilterExpression?: string;
+        ExpressionAttributeNames?: Record<string, string>;
+        ExpressionAttributeValues?: Record<string, any>;
     }): Promise<T[]>;
     get<T = any>(skValue?: string): Promise<T | null>;
     getPkValue(): string;

package/dist/index-query.js

@@ -34,18 +34,25 @@ class IndexQuery {
         return __awaiter(this, void 0, void 0, function* () {
             const finalSkValue = (options === null || options === void 0 ? void 0 : options.skValue) || this.skValue;
             let keyCondition = "#pk = :pk";
-            const expressionAttributeNames = Object.assign({ "#pk": this.pkName }, options === null || options === void 0 ? void 0 : options.expressionAttributeNames);
-            const expressionAttributeValues = Object.assign({ ":pk": this.pkValue }, options === null || options === void 0 ? void 0 : options.expressionAttributeValues);
+            let expressionAttributeNames = Object.assign({ "#pk": this.pkName }, options === null || options === void 0 ? void 0 : options.ExpressionAttributeNames);
+            let expressionAttributeValues = Object.assign({ ":pk": this.pkValue }, options === null || options === void 0 ? void 0 : options.ExpressionAttributeValues);
             if (finalSkValue) {
                 keyCondition += " AND begins_with(#sk, :sk)";
                 expressionAttributeNames["#sk"] = this.skName;
                 expressionAttributeValues[":sk"] = finalSkValue;
             }
+            let filterExpression = options === null || options === void 0 ? void 0 : options.FilterExpression;
+            if (options === null || options === void 0 ? void 0 : options.filterBuilder) {
+                const { expression, attributeNames, attributeValues } = options.filterBuilder.build();
+                filterExpression = expression;
+                expressionAttributeNames = Object.assign(Object.assign({}, expressionAttributeNames), attributeNames);
+                expressionAttributeValues = Object.assign(Object.assign({}, expressionAttributeValues), attributeValues);
+            }
             const response = yield this.db.query({
                 TableName: this.tableName,
                 IndexName: this.indexName,
                 KeyConditionExpression: keyCondition,
-                FilterExpression: options === null || options === void 0 ? void 0 : options.filterExpression,
+                FilterExpression: filterExpression,
                 ExpressionAttributeNames: expressionAttributeNames,
                 ExpressionAttributeValues: expressionAttributeValues,
                 Limit: options === null || options === void 0 ? void 0 : options.limit,

package/dist/index.d.ts

@@ -1,6 +1,8 @@
 import { PutCommandInput, GetCommandInput, UpdateCommandInput, DeleteCommandInput, QueryCommandInput, ScanCommandInput } from "@aws-sdk/lib-dynamodb";
 import { Item } from "./partition";
 import { IndexQuery } from "./index-query";
+import { ExpressionBuilder, attr } from "./expression-builder";
+export { ExpressionBuilder, attr };
 export interface DynoQueryConfig {
     tableName?: string;
     pkName?: string;
@@ -65,6 +67,14 @@ export declare class DynoQuery {
      * Batch get items from the table.
      */
     batchRead(items: (Item | IndexQuery)[]): Promise<any[]>;
+    /**
+     * Transact write items to the table.
+     */
+    transactWrite(items: Item[]): Promise<Item[]>;
+    /**
+     * Transact get items from the table.
+     */
+    transactRead(items: (Item | IndexQuery)[]): Promise<any[]>;
     /**
      * Maps a raw DynamoDB item to a Model Item if it matches a registered model.
      */

package/dist/index.js

@@ -34,11 +34,14 @@ var __rest = (this && this.__rest) || function (s, e) {
     return t;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Item = exports.DynoQuery = void 0;
+exports.Item = exports.DynoQuery = exports.attr = exports.ExpressionBuilder = void 0;
 const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
 const lib_dynamodb_1 = require("@aws-sdk/lib-dynamodb");
 const partition_1 = require("./partition");
 const index_query_1 = require("./index-query");
+const expression_builder_1 = require("./expression-builder");
+Object.defineProperty(exports, "ExpressionBuilder", { enumerable: true, get: function () { return expression_builder_1.ExpressionBuilder; } });
+Object.defineProperty(exports, "attr", { enumerable: true, get: function () { return expression_builder_1.attr; } });
 class DynoQuery {
     constructor(config = {}) {
         this.registeredModels = {};
@@ -178,14 +181,7 @@ class DynoQuery {
                     });
                 }
                 else {
-                    const dataToSave = {};
-                    for (const key in item) {
-                        if (Object.prototype.hasOwnProperty.call(item, key) &&
-                            !["_indices", "_partition", "_skValue", "_toBeDeleted"].includes(key) &&
-                            typeof item[key] !== "function") {
-                            dataToSave[key] = item[key];
-                        }
-                    }
+                    const dataToSave = item.getData();
                     // Ensure PK and SK are in the data
                     dataToSave[this.pkName] = partition.getPkValue();
                     dataToSave[this.skName] = skValue;
@@ -271,6 +267,116 @@ class DynoQuery {
             return allItems;
         });
     }
+    /**
+     * Transact write items to the table.
+     */
+    transactWrite(items) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Chunk items into 100
+            for (let i = 0; i < items.length; i += 100) {
+                const chunk = items.slice(i, i + 100);
+                const transactItems = chunk.map((item) => {
+                    const partition = item.getPartition();
+                    const tableName = partition.getTableName();
+                    const skValue = item.getSkValue();
+                    const pkValue = partition.getPkValue();
+                    const conditionBuilder = item.getConditionBuilder();
+                    if (item.toBeDeleted()) {
+                        const deleteItem = {
+                            Key: {
+                                [this.pkName]: pkValue,
+                                [this.skName]: skValue,
+                            },
+                            TableName: tableName,
+                        };
+                        if (conditionBuilder) {
+                            const { expression, attributeNames, attributeValues } = conditionBuilder.build();
+                            deleteItem.ConditionExpression = expression;
+                            deleteItem.ExpressionAttributeNames = attributeNames;
+                            deleteItem.ExpressionAttributeValues = attributeValues;
+                        }
+                        return {
+                            Delete: deleteItem,
+                        };
+                    }
+                    else {
+                        const dataToSave = item.getData();
+                        // Ensure PK and SK are in the data
+                        dataToSave[this.pkName] = pkValue;
+                        dataToSave[this.skName] = skValue;
+                        const putItem = {
+                            Item: dataToSave,
+                            TableName: tableName,
+                        };
+                        if (conditionBuilder) {
+                            const { expression, attributeNames, attributeValues } = conditionBuilder.build();
+                            putItem.ConditionExpression = expression;
+                            putItem.ExpressionAttributeNames = attributeNames;
+                            putItem.ExpressionAttributeValues = attributeValues;
+                        }
+                        return {
+                            Put: putItem,
+                        };
+                    }
+                });
+                yield this.docClient.send(new lib_dynamodb_1.TransactWriteCommand({
+                    TransactItems: transactItems,
+                }));
+            }
+            return items;
+        });
+    }
+    /**
+     * Transact get items from the table.
+     */
+    transactRead(items) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const allItems = [];
+            // Chunk items into 100
+            for (let i = 0; i < items.length; i += 100) {
+                const chunk = items.slice(i, i + 100);
+                const transactItems = chunk.map((item) => {
+                    let tableName;
+                    let pkValue;
+                    let skValue;
+                    if (item instanceof index_query_1.IndexQuery) {
+                        tableName = item.tableName;
+                        pkValue = item.getPkValue();
+                        skValue = item.getSkValue() || "";
+                    }
+                    else {
+                        const partition = item.getPartition();
+                        tableName = partition.getTableName();
+                        pkValue = partition.getPkValue();
+                        skValue = item.getSkValue();
+                    }
+                    return {
+                        Get: {
+                            TableName: tableName,
+                            Key: {
+                                [this.pkName]: pkValue,
+                                [this.skName]: skValue,
+                            },
+                        },
+                    };
+                });
+                const response = yield this.docClient.send(new lib_dynamodb_1.TransactGetCommand({
+                    TransactItems: transactItems,
+                }));
+                if (response.Responses) {
+                    response.Responses.forEach((res) => {
+                        if (res.Item) {
+                            allItems.push(this.mapItemToModelItem(res.Item));
+                        }
+                        else {
+                            allItems.push(null);
+                        }
+                    });
+                }
+            }
+            return allItems;
+        });
+    }
     /**
      * Maps a raw DynamoDB item to a Model Item if it matches a registered model.
      */

package/dist/partition.d.ts

@@ -1,5 +1,6 @@
 import { DynoQuery } from "./index";
 import { IndexQuery } from "./index-query";
+import { ExpressionBuilder } from "./expression-builder";
 export interface PartitionConfig {
     tableName?: string;
     pk?: string;
@@ -11,6 +12,8 @@ export declare class Item {
     private _partition;
     private _skValue;
     private _toBeDeleted;
+    private _filterBuilder?;
+    private _conditionBuilder?;
     constructor(partition: Partition, skValue: string, data: any);
 }
 export declare class Partition {
@@ -30,14 +33,20 @@ export declare class Partition {
     getAll<T = any>(options?: {
         limit?: number;
         exclusiveStartKey?: any;
-        filterExpression?: string;
-        expressionAttributeNames?: Record<string, string>;
-        expressionAttributeValues?: Record<string, any>;
+        filterBuilder?: ExpressionBuilder;
+        FilterExpression?: string;
+        ExpressionAttributeNames?: Record<string, string>;
+        ExpressionAttributeValues?: Record<string, any>;
     }): Promise<T[]>;
     /**
      * Create an item in this partition.
      */
-    create<T = any>(skValue: string, data: T, indices?: IndexQuery[]): Promise<T>;
+    create<T = any>(skValue: string, data: T, indices?: IndexQuery[], options?: {
+        conditionBuilder?: ExpressionBuilder;
+        ConditionExpression?: string;
+        ExpressionAttributeNames?: Record<string, string>;
+        ExpressionAttributeValues?: Record<string, any>;
+    }): Promise<T>;
     /**
      * Internal method to get raw data for a specific SK.
      */
@@ -45,11 +54,21 @@ export declare class Partition {
     /**
      * Update an existing item in this partition.
      */
-    update<T = any>(skValue: string, data: Partial<T>, indices?: IndexQuery[]): Promise<T>;
+    update<T = any>(skValue: string, data: Partial<T>, indices?: IndexQuery[], options?: {
+        conditionBuilder?: ExpressionBuilder;
+        ConditionExpression?: string;
+        ExpressionAttributeNames?: Record<string, string>;
+        ExpressionAttributeValues?: Record<string, any>;
+    }): Promise<T>;
     /**
      * Delete an item by its SK within this partition.
      */
-    delete(skValue: string): Promise<void>;
+    delete(skValue: string, options?: {
+        conditionBuilder?: ExpressionBuilder;
+        ConditionExpression?: string;
+        ExpressionAttributeNames?: Record<string, string>;
+        ExpressionAttributeValues?: Record<string, any>;
+    }): Promise<void>;
     /**
      * Get data for a specific SK and return it wrapped in a Item object.
      */

package/dist/partition.js

@@ -20,31 +20,67 @@ class Item {
         const self = this;
         return new Proxy(this, {
             get(target, prop, receiver) {
-                if (prop === "save") {
+                if (prop === "getData") {
                     return () => {
-                        const dataToSave = {};
+                        const data = {};
                         for (const key in target) {
                             if (Object.prototype.hasOwnProperty.call(target, key) &&
-                                !["_indices", "_partition", "_skValue", "_toBeDeleted"].includes(key) &&
+                                ![
+                                    "_indices",
+                                    "_partition",
+                                    "_skValue",
+                                    "_toBeDeleted",
+                                    "_filterBuilder",
+                                    "_conditionBuilder",
+                                ].includes(key) &&
                                 typeof target[key] !== "function") {
-                                dataToSave[key] = target[key];
+                                data[key] = target[key];
                             }
                         }
-                        return partition.update(skValue, dataToSave, self._indices);
+                        return data;
+                    };
+                }
+                if (prop === "save") {
+                    return () => {
+                        return partition.update(skValue, receiver.getData(), self._indices, {
+                            conditionBuilder: self._conditionBuilder,
+                        });
                     };
                 }
                 if (prop === "create") {
                     return (data, indices) => {
                         const dataToSave = data || {};
                         const finalIndices = indices || self._indices;
-                        return partition.create(skValue, dataToSave, finalIndices);
+                        return partition.create(skValue, dataToSave, finalIndices, {
+                            conditionBuilder: self._conditionBuilder,
+                        });
                     };
                 }
                 if (prop === "update") {
                     return (data, indices) => {
-                        return partition.update(skValue, data, indices);
+                        return partition.update(skValue, data, indices, {
+                            conditionBuilder: self._conditionBuilder,
+                        });
+                    };
+                }
+                if (prop === "setFilter") {
+                    return (builder) => {
+                        self._filterBuilder = builder;
+                        return receiver;
+                    };
+                }
+                if (prop === "setCondition") {
+                    return (builder) => {
+                        self._conditionBuilder = builder;
+                        return receiver;
                     };
                 }
+                if (prop === "getFilterBuilder") {
+                    return () => self._filterBuilder;
+                }
+                if (prop === "getConditionBuilder") {
+                    return () => self._conditionBuilder;
+                }
                 if (prop === "setIndex") {
                     return (indexObj) => {
                         if (Array.isArray(indexObj)) {
@@ -118,12 +154,21 @@ class Partition {
      */
     getAll(options) {
         return __awaiter(this, void 0, void 0, function* () {
+            let filterExpression = options === null || options === void 0 ? void 0 : options.FilterExpression;
+            let expressionAttributeNames = Object.assign({ "#pk": this.pkName }, options === null || options === void 0 ? void 0 : options.ExpressionAttributeNames);
+            let expressionAttributeValues = Object.assign({ ":pk": this.pkValue }, options === null || options === void 0 ? void 0 : options.ExpressionAttributeValues);
+            if (options === null || options === void 0 ? void 0 : options.filterBuilder) {
+                const { expression, attributeNames, attributeValues } = options.filterBuilder.build();
+                filterExpression = expression;
+                expressionAttributeNames = Object.assign(Object.assign({}, expressionAttributeNames), attributeNames);
+                expressionAttributeValues = Object.assign(Object.assign({}, expressionAttributeValues), attributeValues);
+            }
             const response = yield this.db.query({
                 TableName: this.tableName,
                 KeyConditionExpression: "#pk = :pk",
-                FilterExpression: options === null || options === void 0 ? void 0 : options.filterExpression,
-                ExpressionAttributeNames: Object.assign({ "#pk": this.pkName }, options === null || options === void 0 ? void 0 : options.expressionAttributeNames),
-                ExpressionAttributeValues: Object.assign({ ":pk": this.pkValue }, options === null || options === void 0 ? void 0 : options.expressionAttributeValues),
+                FilterExpression: filterExpression,
+                ExpressionAttributeNames: expressionAttributeNames,
+                ExpressionAttributeValues: expressionAttributeValues,
                 Limit: options === null || options === void 0 ? void 0 : options.limit,
                 ExclusiveStartKey: options === null || options === void 0 ? void 0 : options.exclusiveStartKey,
             });
@@ -143,7 +188,7 @@ class Partition {
     /**
      * Create an item in this partition.
      */
-    create(skValue, data, indices) {
+    create(skValue, data, indices, options) {
         return __awaiter(this, void 0, void 0, function* () {
             const item = Object.assign({ [this.pkName]: this.pkValue, [this.skName]: skValue }, data);
             if (indices) {
@@ -154,10 +199,22 @@ class Partition {
                     }
                 });
             }
-            yield this.db.create({
+            const createParams = {
                 TableName: this.tableName,
                 Item: item,
-            });
+            };
+            if (options === null || options === void 0 ? void 0 : options.conditionBuilder) {
+                const { expression, attributeNames, attributeValues } = options.conditionBuilder.build();
+                createParams.ConditionExpression = expression;
+                createParams.ExpressionAttributeNames = Object.assign(Object.assign({}, createParams.ExpressionAttributeNames), attributeNames);
+                createParams.ExpressionAttributeValues = Object.assign(Object.assign({}, createParams.ExpressionAttributeValues), attributeValues);
+            }
+            if (options === null || options === void 0 ? void 0 : options.ConditionExpression) {
+                createParams.ConditionExpression = options.ConditionExpression;
+                createParams.ExpressionAttributeNames = Object.assign(Object.assign({}, createParams.ExpressionAttributeNames), options.ExpressionAttributeNames);
+                createParams.ExpressionAttributeValues = Object.assign(Object.assign({}, createParams.ExpressionAttributeValues), options.ExpressionAttributeValues);
+            }
+            yield this.db.create(createParams);
             this.cache[skValue] = item;
             return new Item(this, skValue, item);
         });
@@ -190,25 +247,37 @@ class Partition {
     /**
      * Update an existing item in this partition.
      */
-    update(skValue, data, indices) {
+    update(skValue, data, indices, options) {
         return __awaiter(this, void 0, void 0, function* () {
             const current = (yield this._getRaw(skValue)) || {};
             const updated = Object.assign(Object.assign({}, current), data);
-            return yield this.create(skValue, updated, indices);
+            return yield this.create(skValue, updated, indices, options);
         });
     }
     /**
      * Delete an item by its SK within this partition.
      */
-    delete(skValue) {
+    delete(skValue, options) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.db.delete({
+            const deleteParams = {
                 TableName: this.tableName,
                 Key: {
                     [this.pkName]: this.pkValue,
                     [this.skName]: skValue,
                 },
-            });
+            };
+            if (options === null || options === void 0 ? void 0 : options.conditionBuilder) {
+                const { expression, attributeNames, attributeValues } = options.conditionBuilder.build();
+                deleteParams.ConditionExpression = expression;
+                deleteParams.ExpressionAttributeNames = Object.assign(Object.assign({}, deleteParams.ExpressionAttributeNames), attributeNames);
+                deleteParams.ExpressionAttributeValues = Object.assign(Object.assign({}, deleteParams.ExpressionAttributeValues), attributeValues);
+            }
+            if (options === null || options === void 0 ? void 0 : options.ConditionExpression) {
+                deleteParams.ConditionExpression = options.ConditionExpression;
+                deleteParams.ExpressionAttributeNames = Object.assign(Object.assign({}, deleteParams.ExpressionAttributeNames), options.ExpressionAttributeNames);
+                deleteParams.ExpressionAttributeValues = Object.assign(Object.assign({}, deleteParams.ExpressionAttributeValues), options.ExpressionAttributeValues);
+            }
+            yield this.db.delete(deleteParams);
             delete this.cache[skValue];
         });
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dynoquery",
-  "version": "0.1.20",
+  "version": "0.1.23",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/devspikejs/dynoquery.git"