electrodb 2.4.2 → 2.5.0

package/index.d.ts

@@ -1,6 +1,9 @@
-
+import {ScanCommandInput, GetCommandInput, QueryCommandInput, DeleteCommandInput, BatchWriteCommandInput, UpdateCommandInput, UpdateCommand, PutCommandInput, BatchGetCommandInput, TransactWriteCommandInput, TransactGetCommandInput} from '@aws-sdk/lib-dynamodb';
 export type DocumentClientMethod = (parameters: any) => {promise: () => Promise<any>};
 
+type TransactGetItem = Extract<Required<TransactGetCommandInput['TransactItems']>, Array<any>>[number];
+type TransactWriteItem = Extract<Required<TransactWriteCommandInput['TransactItems']>, Array<any>>[number];
+
 export type DocumentClient = {
     get: DocumentClientMethod;
     put: DocumentClientMethod;
@@ -712,12 +715,89 @@ export interface RecordsActionOptions<A extends string,
     where: WhereClause<A,F,C,S,Item<A,F,C,S,S["attributes"]>,RecordsActionOptions<A,F,C,S,Items,IndexCompositeAttributes>>;
 }
 
+export type TransactionItemCode = 'None' | 'ConditionalCheckFailed' | 'ItemCollectionSizeLimitExceeded' | 'TransactionConflict' | 'ProvisionedThroughputExceeded' | 'ThrottlingError' | 'ValidationError';
+
+export type TransactionItem<T> = {
+    item: null | T;
+    rejected: boolean;
+    code: TransactionItemCode;
+    message?: string | undefined;
+};
+
+type CommittedTransactionResult<T, Params> =
+    & Params
+    & { [TransactionSymbol]: T };
+
 export interface SingleRecordOperationOptions<A extends string, F extends string, C extends string, S extends Schema<A,F,C>, ResponseType> {
     go: GoGetTerminal<A,F,C,S, ResponseType>;
     params: ParamTerminal<A,F,C,S,ResponseType>;
     where: WhereClause<A,F,C,S,Item<A,F,C,S,S["attributes"]>,SingleRecordOperationOptions<A,F,C,S,ResponseType>>;
 }
 
+type GoGetTerminalTransaction<A extends string, F extends string, C extends string, S extends Schema<A,F,C>, ResponseItem, Params> = <Options extends TransactGetQueryOptions<keyof ResponseItem>>(options?: Options) =>
+    Options extends GoQueryTerminalOptions<infer Attr>
+        ? CommittedTransactionResult<{
+            [Name in keyof ResponseItem as Name extends Attr
+                ? Name
+                : never]: ResponseItem[Name]
+        }, Params>
+        : CommittedTransactionResult<ResponseItem, Params>
+
+type GoSingleTerminalTransaction<A extends string, F extends string, C extends string, S extends Schema<A,F,C>, ResponseItem, Params> = <Options extends TransactWriteQueryOptions>(options?: Options) =>
+    CommittedTransactionResult<ResponseItem, Params>
+
+export interface SingleRecordOperationOptionsTransaction<A extends string, F extends string, C extends string, S extends Schema<A,F,C>, ResponseType, Params> {
+    commit: GoSingleTerminalTransaction<A,F,C,S, ResponseType, Params>;
+    where: WhereClause<A,F,C,S,Item<A,F,C,S,S["attributes"]>,SingleRecordOperationOptionsTransaction<A,F,C,S,ResponseType, Params>>;
+}
+
+export interface GetOperationOptionsTransaction<A extends string, F extends string, C extends string, S extends Schema<A,F,C>, ResponseType, Params> {
+    commit: GoGetTerminalTransaction<A,F,C,S, ResponseType, Params>;
+}
+
+export type DeleteRecordOperationGoTransaction<ResponseType, Options = TransactWriteQueryOptions> = <T = ResponseType>(options?: Options) => CommittedTransactionResult<T, TransactWriteItem>;
+
+export interface DeleteRecordOperationOptionsTransaction<A extends string, F extends string, C extends string, S extends Schema<A,F,C>, ResponseType> {
+    commit: DeleteRecordOperationGoTransaction<ResponseType, TransactWriteQueryOptions>;
+    where: WhereClause<A,F,C,S,Item<A,F,C,S,S["attributes"]>,DeleteRecordOperationOptionsTransaction<A,F,C,S,ResponseType>>;
+}
+
+export type PutRecordGoTransaction<ResponseType, Options = TransactWriteQueryOptions> = <T = ResponseType>(options?: Options) => CommittedTransactionResult<T, TransactWriteItem>;
+
+export interface PutRecordOperationOptionsTransaction<A extends string, F extends string, C extends string, S extends Schema<A,F,C>, ResponseType> {
+    commit: PutRecordGoTransaction<ResponseType, TransactWriteQueryOptions>;
+    where: WhereClause<A, F, C, S, Item<A, F, C, S, S["attributes"]>, PutRecordOperationOptionsTransaction<A, F, C, S, ResponseType>>;
+}
+
+export interface UpsertRecordOperationOptionsTransaction<A extends string, F extends string, C extends string, S extends Schema<A,F,C>, ResponseType> {
+    commit: PutRecordGoTransaction<ResponseType, TransactWriteQueryOptions>;
+    where: WhereClause<A, F, C, S, Item<A, F, C, S, S["attributes"]>, UpsertRecordOperationOptionsTransaction<A, F, C, S, ResponseType>>;
+}
+
+export type UpdateRecordGoTransaction<ResponseType> = <T = ResponseType, Options extends TransactWriteQueryOptions = TransactWriteQueryOptions>(options?: Options) => CommittedTransactionResult<Partial<T>, TransactWriteItem>
+
+export interface SetRecordActionOptionsTransaction<A extends string, F extends string, C extends string, S extends Schema<A,F,C>, SetAttr,IndexCompositeAttributes,TableItem> {
+    commit: UpdateRecordGoTransaction<TableItem>;
+    params: ParamRecord<UpdateQueryParams>;
+    set: SetRecordTransaction<A,F,C,S, SetItem<A,F,C,S>,IndexCompositeAttributes,TableItem>;
+    remove: RemoveRecordTransaction<A,F,C,S, Array<keyof SetItem<A,F,C,S>>,IndexCompositeAttributes,TableItem>;
+    add: SetRecordTransaction<A,F,C,S, AddItem<A,F,C,S>,IndexCompositeAttributes,TableItem>;
+    subtract: SetRecordTransaction<A,F,C,S, SubtractItem<A,F,C,S>,IndexCompositeAttributes,TableItem>;
+    append: SetRecordTransaction<A,F,C,S, AppendItem<A,F,C,S>,IndexCompositeAttributes,TableItem>;
+    delete: SetRecordTransaction<A,F,C,S, DeleteItem<A,F,C,S>,IndexCompositeAttributes,TableItem>;
+    data: DataUpdateMethodRecordTransaction<A,F,C,S, Item<A,F,C,S,S["attributes"]>,IndexCompositeAttributes,TableItem>;
+    where: WhereClause<A,F,C,S, Item<A,F,C,S,S["attributes"]>,SetRecordActionOptionsTransaction<A,F,C,S,SetAttr,IndexCompositeAttributes,TableItem>>;
+}
+
+export type RemoveRecordTransaction<A extends string, F extends string, C extends string, S extends Schema<A,F,C>, RemoveAttr, IndexCompositeAttributes, TableItem> = (properties: RemoveAttr) =>
+    SetRecordActionOptionsTransaction<A,F,C,S, RemoveAttr, IndexCompositeAttributes, TableItem>;
+
+export type SetRecordTransaction<A extends string, F extends string, C extends string, S extends Schema<A,F,C>, SetAttr, IndexCompositeAttributes, TableItem> = (properties: SetAttr) =>
+    SetRecordActionOptionsTransaction<A,F,C,S, SetAttr, IndexCompositeAttributes, TableItem>;
+
+export type DataUpdateMethodRecordTransaction<A extends string, F extends string, C extends string, S extends Schema<A,F,C>, SetAttr, IndexCompositeAttributes, TableItem> =
+    DataUpdateMethod<A,F,C,S, UpdateData<A,F,C,S>, SetRecordActionOptionsTransaction<A,F,C,S, SetAttr, IndexCompositeAttributes, TableItem>>
+
 export interface BatchGetRecordOperationOptions<A extends string, F extends string, C extends string, S extends Schema<A,F,C>, ResponseType> {
     go: GoBatchGetTerminal<A,F,C,S,ResponseType>
     params: ParamTerminal<A,F,C,S,ResponseType>;
@@ -915,6 +995,28 @@ interface GoQueryTerminalOptions<Attributes> {
     order?: 'asc' | 'desc';
 }
 
+interface TransactWriteQueryOptions {
+    data?: 'raw' | 'includeKeys' | 'attributes';
+    table?: string;
+    params?: object;
+    originalErr?: boolean;
+    ignoreOwnership?: boolean;
+    listeners?: Array<ElectroEventListener>;
+    logger?: ElectroEventListener;
+    response?: 'all_old';
+}
+
+interface TransactGetQueryOptions<Attributes> {
+    data?: 'raw' | 'includeKeys' | 'attributes';
+    table?: string;
+    params?: object;
+    originalErr?: boolean;
+    ignoreOwnership?: boolean;
+    attributes?: ReadonlyArray<Attributes>;
+    listeners?: Array<ElectroEventListener>;
+    logger?: ElectroEventListener;
+}
+
 export interface ParamTerminalOptions<Attributes> {
     table?: string;
     limit?: number;
@@ -2151,6 +2253,7 @@ export declare const WhereSymbol: unique symbol;
 export declare const UpdateDataSymbol: unique symbol;
 export declare const CustomAttributeSymbol: unique symbol;
 export declare const OpaquePrimitiveSymbol: unique symbol;
+export declare const TransactionSymbol: unique symbol;
 
 export type WhereAttributeSymbol<T extends any> =
         { [WhereSymbol]: void }
@@ -2335,6 +2438,80 @@ export class Entity<A extends string, F extends string, C extends string, S exte
     client: any;
 }
 
+
+export class TransactWriteEntity<A extends string, F extends string, C extends string, S extends Schema<A,F,C>> {
+    readonly schema: S;
+    constructor(schema: S);
+
+    check(key: AllTableIndexCompositeAttributes<A,F,C,S>): SingleRecordOperationOptionsTransaction<A,F,C,S, ResponseItem<A,F,C,S>, TransactWriteItem>;
+    delete(key: AllTableIndexCompositeAttributes<A,F,C,S>): DeleteRecordOperationOptionsTransaction<A,F,C,S, ResponseItem<A,F,C,S>>;
+    remove(key: AllTableIndexCompositeAttributes<A,F,C,S>): DeleteRecordOperationOptionsTransaction<A,F,C,S, ResponseItem<A,F,C,S>>
+    put(record: PutItem<A,F,C,S>): PutRecordOperationOptionsTransaction<A,F,C,S, ResponseItem<A,F,C,S>>;
+    create(record: PutItem<A,F,C,S>): PutRecordOperationOptionsTransaction<A,F,C,S, ResponseItem<A,F,C,S>>
+    upsert(record: PutItem<A,F,C,S>): UpsertRecordOperationOptionsTransaction<A,F,C,S, ResponseItem<A,F,C,S>>;
+    update(key: AllTableIndexCompositeAttributes<A,F,C,S>): {
+        set: SetRecordTransaction<A,F,C,S, SetItem<A,F,C,S>, TableIndexCompositeAttributes<A,F,C,S>, ResponseItem<A,F,C,S>>;
+        remove: RemoveRecordTransaction<A,F,C,S, RemoveItem<A,F,C,S>, TableIndexCompositeAttributes<A,F,C,S>, ResponseItem<A,F,C,S>>;
+        add: SetRecordTransaction<A,F,C,S, AddItem<A,F,C,S>, TableIndexCompositeAttributes<A,F,C,S>, ResponseItem<A,F,C,S>>;
+        subtract: SetRecordTransaction<A,F,C,S, SubtractItem<A,F,C,S>, TableIndexCompositeAttributes<A,F,C,S>, ResponseItem<A,F,C,S>>;
+        append: SetRecordTransaction<A,F,C,S, AppendItem<A,F,C,S>, TableIndexCompositeAttributes<A,F,C,S>, ResponseItem<A,F,C,S>>;
+        delete: SetRecordTransaction<A,F,C,S, DeleteItem<A,F,C,S>, TableIndexCompositeAttributes<A,F,C,S>, ResponseItem<A,F,C,S>>;
+        data: DataUpdateMethodRecordTransaction<A,F,C,S, Item<A,F,C,S,S["attributes"]>, TableIndexCompositeAttributes<A,F,C,S>, ResponseItem<A,F,C,S>>;
+    };
+    patch(key: AllTableIndexCompositeAttributes<A,F,C,S>): {
+        set: SetRecordTransaction<A,F,C,S, SetItem<A,F,C,S>, TableIndexCompositeAttributes<A,F,C,S>, ResponseItem<A,F,C,S>>;
+        remove: RemoveRecordTransaction<A,F,C,S, RemoveItem<A,F,C,S>, TableIndexCompositeAttributes<A,F,C,S>, ResponseItem<A,F,C,S>>;
+        add: SetRecordTransaction<A,F,C,S, AddItem<A,F,C,S>, TableIndexCompositeAttributes<A,F,C,S>, ResponseItem<A,F,C,S>>;
+        subtract: SetRecordTransaction<A,F,C,S, SubtractItem<A,F,C,S>, TableIndexCompositeAttributes<A,F,C,S>, ResponseItem<A,F,C,S>>;
+        append: SetRecordTransaction<A,F,C,S, AppendItem<A,F,C,S>, TableIndexCompositeAttributes<A,F,C,S>, ResponseItem<A,F,C,S>>;
+        delete: SetRecordTransaction<A,F,C,S, DeleteItem<A,F,C,S>, TableIndexCompositeAttributes<A,F,C,S>, ResponseItem<A,F,C,S>>;
+        data: DataUpdateMethodRecordTransaction<A,F,C,S, Item<A,F,C,S,S["attributes"]>, TableIndexCompositeAttributes<A,F,C,S>, ResponseItem<A,F,C,S>>;
+    };
+}
+
+export class TransactGetEntity<A extends string, F extends string, C extends string, S extends Schema<A,F,C>> {
+    readonly schema: S;
+    constructor(schema: S);
+
+    get(key: AllTableIndexCompositeAttributes<A,F,C,S>): GetOperationOptionsTransaction<A,F,C,S, ResponseItem<A,F,C,S>, TransactGetItem>;
+}
+
+type TransactWriteFunctionOptions = {
+    token?: string;
+};
+
+type TransactGetFunctionOptions = {};
+
+type TransactWriteExtractedType<T extends readonly any[], A extends readonly any[] = []> =
+    T extends [infer F, ...infer R] ?
+        F extends CommittedTransactionResult<infer V, TransactWriteItem>
+            ? TransactWriteExtractedType<R, [...A, TransactionItem<V>]>
+            : never
+    : A;
+
+type TransactGetExtractedType<T extends readonly any[], A extends readonly any[] = []> =
+    T extends [infer F, ...infer R] ?
+        F extends CommittedTransactionResult<infer V, TransactGetItem>
+            ? TransactWriteExtractedType<R, [...A, TransactionItem<V>]>
+            : never
+        : A
+
+type TransactWriteEntities<E extends {[name: string]: Entity<any, any, any, any>}> = {
+    [EntityName in keyof E]: E[EntityName] extends Entity<infer A, infer F, infer C, infer S>
+        ? TransactWriteEntity<A,F,C,S>
+        : never;
+}
+
+type TransactGetEntities<E extends {[name: string]: Entity<any, any, any, any>}> = {
+    [EntityName in keyof E]: E[EntityName] extends Entity<infer A, infer F, infer C, infer S>
+        ? TransactGetEntity<A,F,C,S>
+        : never;
+}
+
+type TransactWriteFunction<E extends {[name: string]: Entity<any, any, any, any>}, T, R extends ReadonlyArray<CommittedTransactionResult<T, TransactWriteItem>> > = (entities: TransactWriteEntities<E>) => [...R];
+
+type TransactGetFunction<E extends {[name: string]: Entity<any, any, any, any>}, T, R extends ReadonlyArray<CommittedTransactionResult<T, TransactGetItem>> > = (entities: TransactGetEntities<E>) => [...R];
+
 export type ServiceConfiguration = {
     table?: string;
     client?: DocumentClient;
@@ -2342,11 +2519,46 @@ export type ServiceConfiguration = {
     logger?: ElectroEventListener;
 };
 
+declare function createWriteTransaction<E extends {[name: string]: Entity<any, any, any, any>}, T, R extends ReadonlyArray<CommittedTransactionResult<T, TransactWriteItem>>>(entities: E, fn: TransactWriteFunction<E,T,R>): {
+    go: (options?: TransactWriteFunctionOptions) => Promise<{
+        canceled: boolean;
+        data: TransactWriteExtractedType<R>
+    }>;
+    params: <O extends TransactWriteFunctionOptions = TransactWriteFunctionOptions>(options?: O) => TransactWriteCommandInput
+}
+
+declare function createGetTransaction<E extends {[name: string]: Entity<any, any, any, any>},T, R extends ReadonlyArray<CommittedTransactionResult<T, TransactGetItem>>>(entities: E, fn: TransactGetFunction<E,T,R>): {
+    go: (options?: TransactGetFunctionOptions) => Promise<{
+        canceled: boolean;
+        data: TransactGetExtractedType<R>
+    }>;
+    params: <O extends TransactGetFunctionOptions = TransactGetFunctionOptions>(options?: O) => TransactGetCommandInput
+};
+
 export class Service<E extends {[name: string]: Entity<any, any, any, any>}> {
     entities: E;
     collections:
         ClusteredCollectionQueries<E, ClusteredCollectionAssociations<E>>
         & IsolatedCollectionQueries<E, IsolatedCollectionAssociations<E>>
+
+    transaction: {
+        write: <T, R extends ReadonlyArray<CommittedTransactionResult<T, TransactWriteItem>>>(fn: TransactWriteFunction<E,T,R>) => {
+            go: (options?: TransactWriteFunctionOptions) => Promise<{
+                canceled: boolean;
+                data: TransactWriteExtractedType<R>
+            }>;
+            params: <O extends TransactWriteFunctionOptions = TransactWriteFunctionOptions>(options?: O) => TransactWriteCommandInput
+        };
+
+        get: <T, R extends ReadonlyArray<CommittedTransactionResult<T, TransactGetItem>>>(fn: TransactGetFunction<E,T,R>) => {
+            go: (options?: TransactGetFunctionOptions) => Promise<{
+                canceled: boolean;
+                data: TransactGetExtractedType<R>
+            }>;
+            params: <O extends TransactGetFunctionOptions = TransactGetFunctionOptions>(options?: O) => TransactGetCommandInput
+        };
+    }
+
     constructor(entities: E, config?: ServiceConfiguration);
 
     setTableName(tableName: string): void;

package/index.js

@@ -1,5 +1,6 @@
 const { Entity } = require("./src/entity");
 const { Service } = require("./src/service");
+const { createGetTransaction, createWriteTransaction } = require('./src/transaction');
 const { createCustomAttribute, CustomAttributeType, createSchema } = require('./src/schema');
 const { ElectroError, ElectroValidationError, ElectroUserValidationError, ElectroAttributeValidationError } = require('./src/errors');
 
@@ -11,4 +12,6 @@ module.exports = {
     CustomAttributeType,
     createCustomAttribute,
     ElectroValidationError,
+    createGetTransaction,
+    createWriteTransaction,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "electrodb",
-  "version": "2.4.2",
+  "version": "2.5.0",
   "description": "A library to more easily create and interact with multiple entities and heretical relationships in dynamodb",
   "main": "index.js",
   "scripts": {

package/src/clauses.js

@@ -1,4 +1,4 @@
-const { QueryTypes, MethodTypes, ItemOperations, ExpressionTypes, TableIndex, TerminalOperation, KeyTypes, IndexTypes } = require("./types");
+const { QueryTypes, MethodTypes, ItemOperations, ExpressionTypes, TransactionCommitSymbol, TransactionOperations, TerminalOperation, KeyTypes, IndexTypes } = require("./types");
 const {AttributeOperationProxy, UpdateOperations, FilterOperationNames} = require("./operations");
 const {UpdateExpression} = require("./update");
 const {FilterExpression} = require("./where");
@@ -28,7 +28,7 @@ function batchAction(action, type, entity, state, payload) {
 let clauses = {
 	index: {
 		name: "index",
-		children: ["get", "delete", "update", "query", "upsert", "put", "scan", "collection", "clusteredCollection", "create", "remove", "patch", "batchPut", "batchDelete", "batchGet"],
+		children: ["check", "get", "delete", "update", "query", "upsert", "put", "scan", "collection", "clusteredCollection", "create", "remove", "patch", "batchPut", "batchDelete", "batchGet"],
 	},
 	clusteredCollection: {
 		name: "clusteredCollection",
@@ -156,7 +156,15 @@ let clauses = {
 				return state;
 			}
 		},
-		children: ["params", "go"],
+		children: ["params", "go", "commit"],
+	},
+	check: {
+		name: 'check',
+		action(...params) {
+			return clauses.get.action(...params)
+				.setMethod(MethodTypes.check);
+		},
+		children: ["commit"],
 	},
 	batchGet: {
 		name: "batchGet",
@@ -190,7 +198,7 @@ let clauses = {
 				return state;
 			}
 		},
-		children: ["where", "params", "go"],
+		children: ["where", "params", "go", "commit"],
 	},
 	remove: {
 		name: "remove",
@@ -220,7 +228,7 @@ let clauses = {
 				return state;
 			}
 		},
-		children: ["where", "params", "go"],
+		children: ["where", "params", "go", "commit"],
 	},
 	upsert: {
 		name: 'upsert',
@@ -245,7 +253,7 @@ let clauses = {
 				return state;
 			}
 		},
-		children: ["params", "go", "where"],
+		children: ["params", "go", "where", "commit"],
 	},
 	put: {
 		name: "put",
@@ -271,7 +279,7 @@ let clauses = {
 				return state;
 			}
 		},
-		children: ["params", "go"],
+		children: ["params", "go", "commit"],
 	},
 	batchPut: {
 		name: "batchPut",
@@ -307,7 +315,7 @@ let clauses = {
 				return state;
 			}
 		},
-		children: ["params", "go"],
+		children: ["params", "go", "commit"],
 	},
 	patch: {
 		name: "patch",
@@ -336,7 +344,7 @@ let clauses = {
 				return state;
 			}
 		},
-		children: ["set", "append","updateRemove", "updateDelete", "add", "subtract", "data"],
+		children: ["set", "append","updateRemove", "updateDelete", "add", "subtract", "data", "commit"],
 	},
 	update: {
 		name: "update",
@@ -359,7 +367,7 @@ let clauses = {
 				return state;
 			}
 		},
-		children: ["data", "set", "append", "add", "updateRemove", "updateDelete", "go", "params", "subtract"],
+		children: ["data", "set", "append", "add", "updateRemove", "updateDelete", "go", "params", "subtract", "commit"],
 	},
 	data: {
 		name: "data",
@@ -389,7 +397,7 @@ let clauses = {
 				return state;
 			}
 		},
-		children: ["data", "set", "append", "add", "updateRemove", "updateDelete", "go", "params", "subtract"],
+		children: ["data", "set", "append", "add", "updateRemove", "updateDelete", "go", "params", "subtract", "commit"],
 	},
 	set: {
 		name: "set",
@@ -406,7 +414,7 @@ let clauses = {
 				return state;
 			}
 		},
-		children: ["data", "set", "append", "add", "updateRemove", "updateDelete", "go", "params", "subtract"],
+		children: ["data", "set", "append", "add", "updateRemove", "updateDelete", "go", "params", "subtract", "commit"],
 	},
 	append: {
 		name: "append",
@@ -423,7 +431,7 @@ let clauses = {
 				return state;
 			}
 		},
-		children: ["data", "set", "append", "add", "updateRemove", "updateDelete", "go", "params", "subtract"],
+		children: ["data", "set", "append", "add", "updateRemove", "updateDelete", "go", "params", "subtract", "commit"],
 	},
 	updateRemove: {
 		name: "remove",
@@ -443,7 +451,7 @@ let clauses = {
 				return state;
 			}
 		},
-		children: ["data", "set", "append", "add", "updateRemove", "updateDelete", "go", "params", "subtract"],
+		children: ["data", "set", "append", "add", "updateRemove", "updateDelete", "go", "params", "subtract", "commit"],
 	},
 	updateDelete: {
 		name: "delete",
@@ -460,7 +468,7 @@ let clauses = {
 				return state;
 			}
 		},
-		children: ["data", "set", "append", "add", "updateRemove", "updateDelete", "go", "params", "subtract"],
+		children: ["data", "set", "append", "add", "updateRemove", "updateDelete", "go", "params", "subtract", "commit"],
 	},
 	add: {
 		name: "add",
@@ -477,7 +485,7 @@ let clauses = {
 				return state;
 			}
 		},
-		children: ["data", "set", "append", "add", "updateRemove", "updateDelete", "go", "params", "subtract"],
+		children: ["data", "set", "append", "add", "updateRemove", "updateDelete", "go", "params", "subtract", "commit"],
 	},
 	subtract: {
 		name: "subtract",
@@ -494,7 +502,7 @@ let clauses = {
 				return state;
 			}
 		},
-		children: ["data", "set", "append", "add", "updateRemove", "updateDelete", "go", "params", "subtract"],
+		children: ["data", "set", "append", "add", "updateRemove", "updateDelete", "go", "params", "subtract", "commit"],
 	},
 	query: {
 		name: "query",
@@ -662,6 +670,35 @@ let clauses = {
 		},
 		children: ["go", "params"],
 	},
+	commit: {
+		name: 'commit',
+		action(entity, state, options) {
+			if (state.getError() !== null) {
+				throw state.error;
+			}
+
+			const results = clauses.params.action(entity, state, {
+				...options,
+				_returnOptions: true,
+				_isTransaction: true,
+			});
+
+			const method = TransactionOperations[state.query.method];
+			if (!method) {
+				throw new Error('Invalid commit method');
+			}
+
+			return {
+				[method]: results.params,
+				[TransactionCommitSymbol]: () => {
+					return {
+						entity,
+					}
+				},
+			}
+		},
+		children: [],
+	},
 	params: {
 		name: "params",
 		action(entity, state, options = {}) {
@@ -673,7 +710,10 @@ let clauses = {
 					throw new e.ElectroError(e.ErrorCodes.MissingTable, `Table name not defined. Table names must be either defined on the model, instance configuration, or as a query option.`);
 				}
 				const method = state.getMethod();
-				const normalizedOptions = entity._normalizeExecutionOptions({ provided: [ state.getOptions(), state.query.options, options ] });
+				const normalizedOptions = entity._normalizeExecutionOptions({
+					provided: [ state.getOptions(), state.query.options, options ],
+					context: { operation: options._isTransaction ? MethodTypes.transactWrite : undefined }
+				});
 				state.applyWithOptions(normalizedOptions);
 				let results;
 				switch (method) {

package/src/client.js

@@ -1,12 +1,13 @@
 const lib = require('@aws-sdk/lib-dynamodb')
+const util = require('@aws-sdk/lib-dynamodb/dist-cjs/commands/utils')
 const { isFunction } = require('./validations');
 const { ElectroError, ErrorCodes } = require('./errors');
-
 const DocumentClientVersions = {
     v2: 'v2',
     v3: 'v3',
     electro: 'electro',
 };
+const unmarshallOutput = util.unmarshallOutput || ((val) => val);
 
 const v3Methods = ['send'];
 const v2Methods = ['get', 'put', 'update', 'delete', 'batchWrite', 'batchGet', 'scan', 'query', 'createSet', 'transactWrite', 'transactGet'];
@@ -15,6 +16,99 @@ const supportedClientVersions = {
     [DocumentClientVersions.v3]: v3Methods,
 }
 
+class DocumentClientV2Wrapper {
+    static init(client) {
+        return new DocumentClientV2Wrapper(client, lib);
+    }
+
+    constructor(client, lib) {
+        this.client = client;
+        this.lib = lib;
+        this.__v = 'v2';
+    }
+
+    get(params) {
+        return this.client.get(params);
+    }
+
+    put(params) {
+        return this.client.put(params);
+    }
+
+    update(params) {
+        return this.client.update(params);
+    }
+
+    delete(params) {
+        return this.client.delete(params);
+    }
+
+    batchWrite(params) {
+        return this.client.batchWrite(params);
+    }
+
+    batchGet(params) {
+        return this.client.batchGet(params);
+    }
+
+    scan(params) {
+        return this.client.scan(params);
+    }
+
+    query(params) {
+        return this.client.query(params);
+    }
+
+    _transact(transactionRequest) {
+        let cancellationReasons;
+        transactionRequest.on('extractError', (response) => {
+            try {
+                cancellationReasons = JSON.parse(response.httpResponse.body.toString()).CancellationReasons;
+            } catch (err) {}
+        });
+
+        return {
+            async promise() {
+                return transactionRequest.promise()
+                    .catch((err) => {
+                        if (err) {
+                            if (Array.isArray(cancellationReasons)) {
+                                return {
+                                    canceled: cancellationReasons
+                                        .map(reason => {
+                                            if (reason.Item) {
+                                                return unmarshallOutput(reason, [{ key: "Item" }]);
+                                            }
+                                            return reason;
+                                        })
+                                };
+                            }
+                            throw err;
+                        }
+                    });
+            }
+        }
+    }
+
+    transactWrite(params) {
+        const transactionRequest = this.client.transactWrite(params);
+        return this._transact(transactionRequest);
+    }
+
+    transactGet(params) {
+        const transactionRequest = this.client.transactGet(params);
+        return this._transact(transactionRequest);
+    }
+
+    createSet(value, ...rest) {
+        if (Array.isArray(value)) {
+            return this.client.createSet(value, ...rest);
+        } else {
+            return this.client.createSet([value], ...rest);
+        }
+    }
+}
+
 class DocumentClientV3Wrapper {
     static init(client) {
         return new DocumentClientV3Wrapper(client, lib);
@@ -23,6 +117,7 @@ class DocumentClientV3Wrapper {
     constructor(client, lib) {
         this.client = client;
         this.lib = lib;
+        this.__v = 'v3';
     }
 
     promiseWrap(fn) {
@@ -81,16 +176,49 @@ class DocumentClientV3Wrapper {
             return this.client.send(command);
         });
     }
+
     transactWrite(params) {
         return this.promiseWrap(async () => {
             const command = new this.lib.TransactWriteCommand(params);
-            return this.client.send(command);
+            return this.client.send(command)
+                .then((result) => {
+                    return result;
+                })
+                .catch(err => {
+                    if (err.CancellationReasons) {
+                        return {
+                            canceled: err.CancellationReasons.map(reason => {
+                                if (reason.Item) {
+                                    return unmarshallOutput(reason, [{ key: "Item" }]);
+                                }
+                                return reason;
+                            })
+                        }
+                    }
+                    throw err;
+                });
         });
     }
     transactGet(params) {
         return this.promiseWrap(async () => {
             const command = new this.lib.TransactGetCommand(params);
-            return this.client.send(command);
+            return this.client.send(command)
+                .then((result) => {
+                    return result;
+                })
+                .catch(err => {
+                    if (err.CancellationReasons) {
+                        return {
+                            canceled: err.CancellationReasons.map(reason => {
+                                if (reason.Item) {
+                                    return unmarshallOutput(reason, [{ key: "Item" }]);
+                                }
+                                return reason;
+                            })
+                        }
+                    }
+                    throw err;
+                });
         });
     }
     createSet(value) {
@@ -103,7 +231,9 @@ class DocumentClientV3Wrapper {
 }
 
 function identifyClientVersion(client = {}) {
-    if (client instanceof DocumentClientV3Wrapper) return DocumentClientVersions.electro;
+    if (client instanceof DocumentClientV3Wrapper || client instanceof DocumentClientV2Wrapper) {
+        return DocumentClientVersions.electro;
+    }
     for (const [version, methods] of Object.entries(supportedClientVersions)) {
         const hasMethods = methods.every(method => {
             return method in client && isFunction(client[method]);
@@ -121,6 +251,7 @@ function normalizeClient(client) {
         case DocumentClientVersions.v3:
             return DocumentClientV3Wrapper.init(client);
         case DocumentClientVersions.v2:
+            return DocumentClientV2Wrapper.init(client);
         case DocumentClientVersions.electro:
             return client;
         default:
@@ -136,6 +267,7 @@ function normalizeConfig(config = {}) {
 }
 
 module.exports = {
+    util,
     v2Methods,
     v3Methods,
     normalizeClient,
@@ -144,4 +276,5 @@ module.exports = {
     DocumentClientVersions,
     supportedClientVersions,
     DocumentClientV3Wrapper,
+    DocumentClientV2Wrapper,
 };

package/src/entity.js

@@ -24,6 +24,7 @@ const { AllPages,
 	IndexTypes,
 	PartialComparisons,
 	MethodTypeTranslation,
+	TransactionCommitSymbol,
 } = require("./types");
 const { FilterFactory } = require("./filters");
 const { FilterOperations } = require("./operations");
@@ -35,6 +36,7 @@ const c = require('./client');
 const u = require("./util");
 const e = require("./errors");
 const { validate } = require("jsonschema");
+const v = require('./validations');
 
 class Entity {
 	constructor(model, config = {}) {
@@ -229,6 +231,10 @@ class Entity {
 		return validations.model(model);
 	}
 
+	check(compositeAttributes = {}) {
+		return this._makeChain(TableIndex, this._clausesWithFilters, clauses.index).check(compositeAttributes);
+	}
+
 	get(facets = {}) {
 		let index = TableIndex;
 		if (Array.isArray(facets)) {
@@ -285,6 +291,16 @@ class Entity {
 		return this._makeChain(index, this._clausesWithFilters, clauses.index, options).remove(facets);
 	}
 
+	async transactWrite(parameters, config) {
+		let response = await this._exec(MethodTypes.transactWrite, parameters, config);
+		return response;
+	}
+
+	async transactGet(parameters, config) {
+		let response = await this._exec(MethodTypes.transactGet, parameters, config);
+		return response;
+	}
+
 	async go(method, parameters = {}, config = {}) {
 		let stackTrace;
 		if (!config.originalErr) {
@@ -486,7 +502,7 @@ class Entity {
 			case FormatToReturnValues.all_old:
 			case FormatToReturnValues.updated_new:
 			case FormatToReturnValues.updated_old:
-				return this.formatResponse(response, config);
+				return this.formatResponse(response, TableIndex, config);
 			case FormatToReturnValues.default:
 			default:
 				return this._formatDefaultResponse(method, parameters.IndexName, parameters, config, response);
@@ -883,7 +899,7 @@ class Entity {
 		return pager
 	}
 
-	_normalizeExecutionOptions({ provided = [] } = {}) {
+	_normalizeExecutionOptions({ provided = [], context = {} } = {}) {
 		let config = {
 			includeKeys: false,
 			originalErr: false,
@@ -931,7 +947,11 @@ class Entity {
 					throw new e.ElectroError(e.ErrorCodes.InvalidOptions, `Invalid value for query option "format" provided: "${option.format}". Allowed values include ${u.commaSeparatedString(Object.keys(ReturnValues))}.`);
 				}
 				config.response = format;
-				config.params.ReturnValues = FormatToReturnValues[format];
+				if (context.operation === MethodTypes.transactWrite) {
+					config.params.ReturnValuesOnConditionCheckFailure = FormatToReturnValues[format];
+				} else {
+					config.params.ReturnValues = FormatToReturnValues[format];
+				}
 			}
 
 			if (option.formatCursor) {
@@ -1125,6 +1145,7 @@ class Entity {
 		let consolidatedQueryFacets = this._consolidateQueryFacets(keys.sk);
 		let params = {};
 		switch (method) {
+			case MethodTypes.check:
 			case MethodTypes.get:
 			case MethodTypes.delete:
 			case MethodTypes.remove:
@@ -1392,7 +1413,7 @@ class Entity {
 		});
 		let Key = this._makeParameterKey(index, keys.pk, ...keys.sk);
 		let TableName = this.getTableName();
-		return {Key, TableName};
+		return { Key, TableName };
 	}
 
 	_removeAttributes(item, keys) {
@@ -3134,7 +3155,49 @@ class Entity {
 	}
 }
 
+function getEntityIdentifiers(entities) {
+	let identifiers = [];
+	for (let alias of Object.keys(entities)) {
+		let entity = entities[alias];
+		let name = entity.model.entity;
+		let version = entity.model.version;
+		identifiers.push({
+			name,
+			alias,
+			version,
+			entity,
+			nameField: entity.identifiers.entity,
+			versionField: entity.identifiers.version
+		});
+	}
+	return identifiers;
+}
+
+function matchToEntityAlias({ paramItem, identifiers, record } = {}) {
+	let entity;
+	let entityAlias;
+
+	if (paramItem && v.isFunction(paramItem[TransactionCommitSymbol])) {
+		const committed = paramItem[TransactionCommitSymbol]();
+		entity = committed.entity;
+	}
+
+	for (let {name, version, nameField, versionField, alias} of identifiers) {
+		if (entity && entity.model.entity === name && entity.model.version === version) {
+			entityAlias = alias;
+			break;
+		} else if (record[nameField] !== undefined && record[nameField] === name && record[versionField] !== undefined && record[versionField] === version) {
+			entityAlias = alias;
+			break;
+		}
+	}
+
+	return entityAlias;
+}
+
 module.exports = {
 	Entity,
 	clauses,
+	getEntityIdentifiers,
+	matchToEntityAlias,
 };

package/src/filters.js

@@ -76,7 +76,7 @@ class FilterFactory {
 		let filterParents = Object.entries(injected)
 			.filter(clause => {
 				let [name, { children }] = clause;
-				return children.includes("go");
+				return children.find(child => ['go', 'commit'].includes(child));
 			})
 			.map(([name]) => name);
 		let modelFilters = Object.keys(filters);
@@ -86,7 +86,7 @@ class FilterFactory {
 			injected[name] = {
 				name: name,
 				action: this.buildClause(filter),
-				children: ["params", "go", "filter", ...modelFilters],
+				children: ["params", "go", "commit", "filter", ...modelFilters],
 			};
 		}
 		filterChildren.push("filter");
@@ -95,7 +95,7 @@ class FilterFactory {
 			action: (entity, state, fn) => {
 				return this.buildClause(fn)(entity, state);
 			},
-			children: ["params", "go", "filter", ...modelFilters],
+			children: ["params", "go", "commit", "filter", ...modelFilters],
 		};
 		for (let parent of filterParents) {
 			injected[parent] = { ...injected[parent] };

package/src/service.js

@@ -1,14 +1,15 @@
-const { Entity } = require("./entity");
+const { Entity, getEntityIdentifiers, matchToEntityAlias } = require("./entity");
 const { clauses } = require("./clauses");
-const { KeyCasing, ServiceVersions, Pager, ElectroInstance, ElectroInstanceTypes, ModelVersions, IndexTypes } = require("./types");
+const { TableIndex, TransactionMethods, KeyCasing, ServiceVersions, Pager, ElectroInstance, ElectroInstanceTypes, ModelVersions, IndexTypes } = require("./types");
 const { FilterFactory } = require("./filters");
 const { FilterOperations } = require("./operations");
 const { WhereFactory } = require("./where");
-const { getInstanceType, getModelVersion, applyBetaModelOverrides } = require("./util");
 const v = require("./validations");
 const c = require('./client');
 const e = require("./errors");
 const u = require("./util");
+const txn = require("./transaction");
+const { getInstanceType, getModelVersion, applyBetaModelOverrides } = require("./util");
 
 const ConstructorTypes = {
 	beta: "beta",
@@ -68,6 +69,22 @@ class Service {
 		this.compositeAttributes = {};
 		this.collections = {};
 		this.identifiers = {};
+		this.transaction = {
+			get: (fn) => {
+				return txn.createTransaction({
+					fn,
+					getEntities: () => this.entities,
+					method: TransactionMethods.transactGet,
+				});
+			},
+			write: (fn) => {
+				return txn.createTransaction({
+					fn,
+					getEntities: () => this.entities,
+					method: TransactionMethods.transactWrite,
+				});
+			}
+		};
 		this._instance = ElectroInstance.service;
 		this._instanceType = ElectroInstanceTypes.service;
 	}
@@ -94,6 +111,22 @@ class Service {
 		this.compositeAttributes = {};
 		this.collections = {};
 		this.identifiers = {};
+		this.transaction = {
+			get: (fn) => {
+				return txn.createTransaction({
+					fn,
+					getEntities: () => this.entities,
+					method: TransactionMethods.transactGet,
+				});
+			},
+			write: (fn) => {
+				return txn.createTransaction({
+					fn,
+					getEntities: () => this.entities,
+					method: TransactionMethods.transactWrite,
+				});
+			}
+		};
 		this._instance = ElectroInstance.service;
 		this._instanceType = ElectroInstanceTypes.service;
 	}
@@ -270,53 +303,39 @@ class Service {
 		}
 	}
 
-	_getEntityIdentifiers(entities) {
-		let identifiers = [];
-		for (let alias of Object.keys(entities)) {
-			let entity = entities[alias];
-			let name = entity.model.entity;
-			let version = entity.model.version;
-			identifiers.push({
-				name,
-				alias,
-				version,
-				entity,
-				nameField: entity.identifiers.entity,
-				versionField: entity.identifiers.version
-			});
-		}
-		return identifiers;
-	}
-
-	cleanseRetrievedData(collection = "", entities, data = {}, config = {}) {
+	cleanseRetrievedData(index = TableIndex, entities, data = {}, config = {}) {
 		if (config.raw) {
 			return data;
 		}
+		const identifiers = getEntityIdentifiers(entities);
+
 		data.Items = data.Items || [];
-		let index = this.collectionSchema[collection].index;
-		let results = {};
-		let identifiers = this._getEntityIdentifiers(entities);
+
+		const results = {};
 		for (let {alias} of identifiers) {
 			results[alias] = [];
 		}
-		for (let record of data.Items) {
-			let entityAlias;
-			for (let {name, version, nameField, versionField, alias} of identifiers) {
-				if (record[nameField] !== undefined && record[nameField] === name && record[versionField] !== undefined && record[versionField] === version) {
-					entityAlias = alias;
-					break;
-				}
+
+		for (let i = 0; i < data.Items.length; i++) {
+			const record = data.Items[i];
+
+			if (!record) {
+				continue;
 			}
+
+			const entityAlias = matchToEntityAlias({identifiers, record});
+
 			if (!entityAlias) {
 				continue;
 			}
 			// pager=false because we don't want the entity trying to parse the lastEvaluatedKey
-			let items = this.collectionSchema[collection].entities[entityAlias].formatResponse({Item: record}, index, {
+			let formatted = entities[entityAlias].formatResponse({Item: record}, index, {
 				...config,
 				pager: false,
 				parse: undefined
 			});
-			results[entityAlias].push(items.data);
+
+			results[entityAlias].push(formatted.data);
 		}
 		return results;
 	}
@@ -364,7 +383,7 @@ class Service {
 		name = "",
 		initialClauses = {},
 	}, facets = {}) {
-		const { entities, attributes, identifiers, indexType } = this.collectionSchema[name];
+		const { entities, attributes, identifiers, indexType, index } = this.collectionSchema[name];
 		const compositeAttributes = this.compositeAttributes[name];
 		const allEntities = Object.values(entities);
 		const entity = allEntities[0];
@@ -381,7 +400,10 @@ class Service {
 		let options = {
 			// expressions, // DynamoDB doesnt return what I expect it would when provided with these entity filters
 			parse: (options, data) => {
-				return this.cleanseRetrievedData(name, entities, data, options);
+				if (options.raw) {
+					return data;
+				}
+				return this.cleanseRetrievedData(index, entities, data, options);
 			},
 			formatCursor: {
 				serialize: (key) => {
@@ -735,4 +757,6 @@ class Service {
 	}
 }
 
-module.exports = { Service };
+module.exports = {
+	Service,
+};

package/src/transaction.js

@@ -0,0 +1,179 @@
+const { TableIndex, TransactionMethods } = require('./types');
+const { getEntityIdentifiers, matchToEntityAlias } = require('./entity');
+
+function cleanseCanceledData(index = TableIndex, entities, data = {}, config = {}) {
+    if (config.raw) {
+        return data;
+    }
+    const identifiers = getEntityIdentifiers(entities);
+    const canceled = data.canceled || [];
+    const paramItems = config._paramItems || [];
+    const results = [];
+    for (let i = 0; i < canceled.length; i++) {
+        const { Item, Code, Message } = canceled[i] || {};
+        const paramItem = paramItems[i];
+        const code = Code || 'None';
+        const rejected = code !== 'None';
+        const result = {
+            rejected,
+            code,
+            message: Message,
+        }
+
+        if (Item) {
+            const entityAlias = matchToEntityAlias({
+                record: Item,
+                paramItem,
+                identifiers
+            });
+            result.item = entities[entityAlias].formatResponse({Item}, index, {
+                ...config,
+                pager: false,
+                parse: undefined,
+            }).data;
+        } else {
+            result.item = null;
+        }
+
+        results.push(result);
+    }
+
+    return results;
+}
+
+function cleanseTransactionData(index = TableIndex, entities, data = {}, config = {}) {
+    if (config.raw) {
+        return data;
+    }
+    const identifiers = getEntityIdentifiers(entities);
+    data.Items = data.Items || [];
+    const paramItems = config._paramItems || [];
+    const results = [];
+    for (let i = 0; i < data.Items.length; i++) {
+        const record = data.Items[i];
+        if (!record) {
+            results.push(null);
+            continue;
+        }
+
+        const paramItem = paramItems[i];
+        const entityAlias = matchToEntityAlias({paramItem, identifiers, record});
+        if (!entityAlias) {
+            continue;
+        }
+
+        // pager=false because we don't want the entity trying to parse the lastEvaluatedKey
+        let formatted = entities[entityAlias].formatResponse({ Item: record }, index, {
+            ...config,
+            pager: false,
+            parse: undefined
+        });
+
+        results.push(formatted.data);
+    }
+
+    return results.map(item => ({
+        rejected: false,
+        item,
+    }));
+}
+
+function createTransaction(options) {
+    const { fn, method, getEntities } = options;
+    const operations = {
+        params: (options = {}) => {
+            const paramItems = fn(getEntities());
+            const params = {
+                TransactItems: paramItems,
+            };
+
+            if (typeof options.token === 'string' && options.token.length) {
+                params['ClientRequestToken'] = options.token;
+            }
+            if (options._returnParamItems) {
+                return { params, paramItems };
+            }
+            return params;
+        },
+        go: async (options) => {
+            const driver = Object.values(getEntities())[0];
+
+            if (!driver) {
+                throw new Error('At least one entity must exist to perform a transaction');
+            }
+
+            const { params, paramItems } = operations.params({
+                ...options,
+                _returnParamItems: true
+            });
+
+            let canceled = false;
+            if (paramItems.length === 0) {
+                return {
+                    canceled,
+                    data: [],
+                }
+            }
+
+            const response = await driver.go(method, params, {
+                ...options,
+                parse: (options, data) => {
+                    if (options.raw) {
+                        return data;
+                    } else if (data.canceled) {
+                        canceled = true;
+                        return cleanseCanceledData(TableIndex, getEntities(), data, {
+                            ...options,
+                            _isTransaction: true,
+                            _paramItems: paramItems,
+                        });
+                    } else if (data.Responses) {
+                        return cleanseTransactionData(TableIndex, getEntities(), {
+                            Items: data.Responses.map(response => response.Item)
+                        }, {
+                            ...options,
+                            _isTransaction: true,
+                            _paramItems: paramItems,
+                        });
+                    } else {
+                        return new Array(paramItems ? paramItems.length : 0).fill({
+                            item: null,
+                            code: 'None',
+                            rejected: false,
+                            message: undefined,
+                        });
+                    }
+                }
+            });
+
+            return {
+                ...response,
+                canceled,
+            }
+        }
+    }
+
+    return operations;
+}
+
+function createWriteTransaction(entities, fn) {
+    return createTransaction({
+        fn,
+        method: TransactionMethods.transactWrite,
+        getEntities: () => entities,
+    });
+}
+
+function createGetTransaction(entities, fn) {
+    return createTransaction({
+        fn,
+        method: TransactionMethods.transactGet,
+        getEntities: () => entities,
+    });
+}
+
+module.exports = {
+    createTransaction,
+    createWriteTransaction,
+    createGetTransaction,
+}

package/src/types.js

@@ -23,6 +23,7 @@ const QueryTypes = {
 };
 
 const MethodTypes = {
+	check: "check",
 	put: "put",
 	get: "get",
 	query: "query",
@@ -35,8 +36,27 @@ const MethodTypes = {
 	batchGet: "batchGet",
 	batchWrite: "batchWrite",
 	upsert: "upsert",
+	transactWrite: "transactWrite",
+	transactGet: "transactGet",
 };
 
+const TransactionMethods = {
+	transactWrite: MethodTypes.transactWrite,
+	transactGet: MethodTypes.transactGet,
+}
+
+const TransactionOperations = {
+	[MethodTypes.get]: "Get",
+	[MethodTypes.check]: "ConditionCheck",
+	[MethodTypes.put]: "Put",
+	[MethodTypes.create]: "Put",
+	[MethodTypes.upsert]: "Update",
+	[MethodTypes.update]: "Update",
+	[MethodTypes.patch]: "Update",
+	[MethodTypes.remove]: "Delete",
+	[MethodTypes.delete]: "Delete",
+}
+
 const MethodTypeTranslation = {
 	put: "put",
 	get: "get",
@@ -50,6 +70,8 @@ const MethodTypeTranslation = {
 	batchGet: "batchGet",
 	batchWrite: "batchWrite",
 	upsert: "update",
+	transactWrite: 'transactWrite',
+	transactGet: 'transactGet',
 }
 
 const IndexTypes = {
@@ -198,6 +220,7 @@ const ItemOperations = {
 };
 
 const AttributeProxySymbol = Symbol("attribute_proxy");
+const TransactionCommitSymbol = Symbol('transaction_commit');
 
 const BuilderTypes = {
 	update: "update",
@@ -325,4 +348,7 @@ module.exports = {
 	AllPages,
 	ResultOrderOption,
 	ResultOrderParam,
+	TransactionCommitSymbol,
+	TransactionOperations,
+	TransactionMethods,
 };

package/src/where.js

@@ -76,6 +76,7 @@ class WhereFactory {
 		case MethodTypes.remove:
 		case MethodTypes.upsert:
 		case MethodTypes.get:
+		case MethodTypes.check:
 			return ExpressionTypes.ConditionExpression
 		default:
 			return ExpressionTypes.FilterExpression
@@ -108,7 +109,7 @@ class WhereFactory {
 		let filterParents = Object.entries(injected)
 			.filter(clause => {
 				let [name, { children }] = clause;
-				return children.includes("go");
+				return children.find(child => ['go', 'commit'].includes(child));
 			})
 			.map(([name]) => name);
 		let modelFilters = Object.keys(filters);
@@ -118,7 +119,7 @@ class WhereFactory {
 			injected[name] = {
 				name,
 				action: this.buildClause(filter),
-				children: ["params", "go", "where", ...modelFilters],
+				children: ["params", "go", "commit", "where", ...modelFilters],
 			};
 		}
 		filterChildren.push("where");
@@ -127,7 +128,7 @@ class WhereFactory {
 			action: (entity, state, fn) => {
 				return this.buildClause(fn)(entity, state);
 			},
-			children: ["params", "go", "where", ...modelFilters],
+			children: ["params", "go", "commit", "where", ...modelFilters],
 		};
 		for (let parent of filterParents) {
 			injected[parent] = { ...injected[parent] };

package/notes

@@ -1,8 +0,0 @@
-- add hydrate option to query
-- add hydrate option to collection
-- implement hydrate on entity query
-- implement hydrate on collection query
-- add index property to signify only keys are present
-    - skip for match/find
-    - do not apply automatic filters on queries
-- validate