electrodb 2.4.1 → 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 }
@@ -2257,6 +2360,10 @@ export type EntityConfiguration = {
     client?: DocumentClient;
     listeners?: Array<ElectroEventListener>;
     logger?: ElectroEventListener;
+    identifiers?: {
+      entity?: string;
+      version?: string;
+    },
 };
 
 export class Entity<A extends string, F extends string, C extends string, S extends Schema<A,F,C>> {
@@ -2331,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;
@@ -2338,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;
@@ -2374,4 +2590,4 @@ declare function CustomAttributeType<T>(
     ? OpaquePrimitiveTypeName<T>
     : CustomAttributeTypeName<T>;
 
-declare function createSchema<A extends string, F extends string, C extends string, S extends Schema<A,F,C>>(schema: S): S
+declare function createSchema<A extends string, F extends string, C extends string, S extends Schema<A,F,C>>(schema: S): S

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.1",
+  "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",
@@ -37,7 +37,7 @@ let clauses = {
 				return state;
 			}
 			try {
-				const {pk, sk} = state.getCompositeAttributes();
+				const { pk, sk } = state.getCompositeAttributes();
 				return state
 					.setType(QueryTypes.clustered_collection)
 					.setMethod(MethodTypes.query)
@@ -50,6 +50,22 @@ let clauses = {
 						if (sk.length > 1) {
 							state.filterProperties(FilterOperationNames.eq, {...unused, ...composites});
 						}
+					})
+					.whenOptions(({ options, state }) => {
+						if (!options.ignoreOwnership) {
+							state.query.options.expressions.names = {
+								...state.query.options.expressions.names,
+								...state.query.options.identifiers.names,
+							};
+							state.query.options.expressions.values = {
+								...state.query.options.expressions.values,
+								...state.query.options.identifiers.values,
+							};
+							state.query.options.expressions.expression =
+								state.query.options.expressions.expression.length > 1
+									? `(${state.query.options.expressions.expression}) AND ${state.query.options.identifiers.expression}`
+									: `${state.query.options.identifiers.expression}`;
+						}
 					});
 
 			} catch(err) {
@@ -72,7 +88,23 @@ let clauses = {
 					.setType(QueryTypes.collection)
 					.setMethod(MethodTypes.query)
 					.setCollection(collection)
-					.setPK(entity._expectFacets(facets, pk));
+					.setPK(entity._expectFacets(facets, pk))
+					.whenOptions(({ options, state }) => {
+						if (!options.ignoreOwnership) {
+							state.query.options.expressions.names = {
+								...state.query.options.expressions.names,
+								...state.query.options.identifiers.names,
+							};
+							state.query.options.expressions.values = {
+								...state.query.options.expressions.values,
+								...state.query.options.identifiers.values,
+							};
+							state.query.options.expressions.expression =
+								state.query.options.expressions.expression.length > 1
+									? `(${state.query.options.expressions.expression}) AND ${state.query.options.identifiers.expression}`
+									: `${state.query.options.identifiers.expression}`;
+						}
+					});
 			} catch(err) {
 				state.setError(err);
 				return state;
@@ -87,7 +119,13 @@ let clauses = {
 				return state;
 			}
 			try {
-				return state.setMethod(MethodTypes.scan);
+				return state.setMethod(MethodTypes.scan)
+					.whenOptions(({ state, options }) => {
+						if (!options.ignoreOwnership) {
+							state.unsafeApplyFilter(FilterOperationNames.eq, entity.identifiers.entity, entity.getName());
+							state.unsafeApplyFilter(FilterOperationNames.eq, entity.identifiers.version, entity.getVersion());
+						}
+					});
 			} catch(err) {
 				state.setError(err);
 				return state;
@@ -118,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",
@@ -152,7 +198,7 @@ let clauses = {
 				return state;
 			}
 		},
-		children: ["where", "params", "go"],
+		children: ["where", "params", "go", "commit"],
 	},
 	remove: {
 		name: "remove",
@@ -182,7 +228,7 @@ let clauses = {
 				return state;
 			}
 		},
-		children: ["where", "params", "go"],
+		children: ["where", "params", "go", "commit"],
 	},
 	upsert: {
 		name: 'upsert',
@@ -207,7 +253,7 @@ let clauses = {
 				return state;
 			}
 		},
-		children: ["params", "go", "where"],
+		children: ["params", "go", "where", "commit"],
 	},
 	put: {
 		name: "put",
@@ -233,7 +279,7 @@ let clauses = {
 				return state;
 			}
 		},
-		children: ["params", "go"],
+		children: ["params", "go", "commit"],
 	},
 	batchPut: {
 		name: "batchPut",
@@ -269,7 +315,7 @@ let clauses = {
 				return state;
 			}
 		},
-		children: ["params", "go"],
+		children: ["params", "go", "commit"],
 	},
 	patch: {
 		name: "patch",
@@ -298,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",
@@ -321,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",
@@ -351,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",
@@ -368,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",
@@ -385,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",
@@ -405,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",
@@ -422,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",
@@ -439,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",
@@ -456,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",
@@ -478,10 +524,13 @@ let clauses = {
 						if (sk.length > 1) {
 							state.filterProperties(FilterOperationNames.eq, {...unused, ...composites});
 						}
-						if (state.query.options.indexType === IndexTypes.clustered && Object.keys(composites).length < sk.length) {
-							state.unsafeApplyFilter(FilterOperationNames.eq, entity.identifiers.entity, entity.getName())
-								.unsafeApplyFilter(FilterOperationNames.eq, entity.identifiers.version, entity.getVersion());
-						}
+
+						state.whenOptions(({ options, state }) => {
+							if (state.query.options.indexType === IndexTypes.clustered && Object.keys(composites).length < sk.length && !options.ignoreOwnership) {
+								state.unsafeApplyFilter(FilterOperationNames.eq, entity.identifiers.entity, entity.getName())
+									.unsafeApplyFilter(FilterOperationNames.eq, entity.identifiers.version, entity.getVersion());
+							}
+						});
 					});
 			} catch(err) {
 				state.setError(err);
@@ -621,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 = {}) {
@@ -632,20 +710,29 @@ 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 ],
+					context: { operation: options._isTransaction ? MethodTypes.transactWrite : undefined }
+				});
+				state.applyWithOptions(normalizedOptions);
 				let results;
 				switch (method) {
-					case MethodTypes.query:
-						results = entity._queryParams(state, options);
+					case MethodTypes.query: {
+						results = entity._queryParams(state, normalizedOptions);
 						break;
-					case MethodTypes.batchWrite:
-						results = entity._batchWriteParams(state, options);
-						break
-					case MethodTypes.batchGet:
-						results = entity._batchGetParams(state, options);
+					}
+					case MethodTypes.batchWrite: {
+						results = entity._batchWriteParams(state, normalizedOptions);
 						break;
-					default:
-						results = entity._params(state, options);
+					}
+					case MethodTypes.batchGet: {
+						results = entity._batchGetParams(state, normalizedOptions);
+						break;
+					}
+					default: {
+						results = entity._params(state, normalizedOptions);
 						break;
+					}
 				}
 
 				if (method === MethodTypes.update && results.ExpressionAttributeValues && Object.keys(results.ExpressionAttributeValues).length === 0) {
@@ -653,6 +740,14 @@ let clauses = {
 					// todo: change the getValues() method to return undefined in this case (would potentially require a more generous refactor)
 					delete results.ExpressionAttributeValues;
 				}
+
+				if (options._returnOptions) {
+					return {
+						params: results,
+						options: normalizedOptions,
+					}
+				}
+
 				return results;
 			} catch(err) {
 				throw err;
@@ -671,9 +766,8 @@ let clauses = {
 					throw new e.ElectroError(e.ErrorCodes.NoClientDefined, "No client defined on model");
 				}
 				options.terminalOperation = TerminalOperation.go;
-				let params = clauses.params.action(entity, state, options);
-				let {config} = entity._applyParameterOptions({}, state.getOptions(), options);
-				return entity.go(state.getMethod(), params, config);
+				const paramResults = clauses.params.action(entity, state, { ...options, _returnOptions: true });
+				return entity.go(state.getMethod(), paramResults.params, paramResults.options);
 			} catch(err) {
 				return Promise.reject(err);
 			}
@@ -718,6 +812,7 @@ class ChainState {
 			options,
 		};
 		this.subStates = [];
+		this.applyAfterOptions = [];
 		this.hasSortKey = hasSortKey;
 		this.prev = null;
 		this.self = null;
@@ -911,6 +1006,18 @@ class ChainState {
 		this.query.put.data = {...this.query.put.data, ...data};
 		return this;
 	}
+
+	whenOptions(fn) {
+		if (v.isFunction(fn)) {
+			this.applyAfterOptions.push((options) => {
+				fn({ options, state: this });
+			});
+		}
+	}
+
+	applyWithOptions(options = {}) {
+		this.applyAfterOptions.forEach((fn) => fn(options));
+	}
 }
 
 module.exports = {