Merge pull request #121 from shiftcode/#105-transact-get-single-table

#105 transact get single table

Author: michaelwittwer

dynamoDbAbstraction.monopic

@@ -14,6 +14,7 @@ import {
   PutRequest,
   QueryRequest,
   ScanRequest,
+  TransactGetSingleTableRequest,
   UpdateRequest,
 } from './request'
 import { BatchWriteSingleTableRequest } from './request/batchwritesingletable/batch-write-single-table.request'
@@ -77,8 +78,9 @@ describe('dynamo store', () => {
     it('batchWrite', () => expect(store.batchWrite() instanceof BatchWriteSingleTableRequest).toBeTruthy())
     it('scan', () => expect(store.scan() instanceof ScanRequest).toBeTruthy())
     it('query', () => expect(store.query() instanceof QueryRequest).toBeTruthy())
-    it('batchGetItem', () =>
-      expect(store.batchGetItem([{ id: 'id' }]) instanceof BatchGetSingleTableRequest).toBeTruthy())
+    it('batchGet', () => expect(store.batchGet([{ id: 'id' }]) instanceof BatchGetSingleTableRequest).toBeTruthy())
+    it('transactGet', () =>
+      expect(store.transactGet([{ id: 'myId' }]) instanceof TransactGetSingleTableRequest).toBeTruthy())
   })
 
   describe('should enable custom requests', () => {

src/dynamo/create-ket-attributes.function.ts

@@ -13,6 +13,7 @@ import {
   PutRequest,
   QueryRequest,
   ScanRequest,
+  TransactGetSingleTableRequest,
   UpdateRequest,
 } from './request'
 import { BatchWriteSingleTableRequest } from './request/batchwritesingletable/batch-write-single-table.request'
@@ -52,15 +53,6 @@ export class DynamoStore<T> {
     return new DeleteRequest(this.dynamoRx, this.modelClazz, partitionKey, sortKey)
   }
 
-  /**
-   * This is a special implementation of batchWriteItem request, because it only supports one table,
-   * if you wish to write items to multiple tables
-   * create an instance of BatchWriteItemInput and use store.makeRequest with it.
-   */
-  batchWrite(): BatchWriteSingleTableRequest<T> {
-    return new BatchWriteSingleTableRequest<T>(this.dynamoRx, this.modelClazz)
-  }
-
   scan(): ScanRequest<T> {
     return new ScanRequest<T>(this.dynamoRx, this.modelClazz)
   }
@@ -74,10 +66,23 @@ export class DynamoStore<T> {
    * if you wish to retrieve items from multiple tables
    * create an instance of BatchGetItemInput and use store.makeRequest with it.
    */
-  batchGetItem(keys: any[]): BatchGetSingleTableRequest<T> {
+  batchGet(keys: Array<Partial<T>>): BatchGetSingleTableRequest<T> {
     return new BatchGetSingleTableRequest(this.dynamoRx, this.modelClazz, keys)
   }
 
+  /**
+   * This is a special implementation of batchWriteItem request, because it only supports one table,
+   * if you wish to write items to multiple tables
+   * create an instance of BatchWriteItemInput and use store.makeRequest with it.
+   */
+  batchWrite(): BatchWriteSingleTableRequest<T> {
+    return new BatchWriteSingleTableRequest<T>(this.dynamoRx, this.modelClazz)
+  }
+
+  transactGet(keys: Array<Partial<T>>): TransactGetSingleTableRequest<T> {
+    return new TransactGetSingleTableRequest(this.dynamoRx, this.modelClazz, keys)
+  }
+
   makeRequest<Z>(operation: DynamoApiOperations, params?: { [key: string]: any }): Observable<Z> {
     this.logger.debug('request', params)
     return this.dynamoRx.makeRequest(operation, params).pipe(tap(response => this.logger.debug('response', response)))

src/dynamo/create-key-attributes.function.spec.ts

@@ -1,11 +1,11 @@
 import * as DynamoDB from 'aws-sdk/clients/dynamodb'
-import { SimpleWithCompositePartitionKeyModel, SimpleWithPartitionKeyModel } from '../../test/models'
-import { Metadata, metadataForClass } from '../decorator/metadata'
-import { toDb } from '../mapper'
+import { SimpleWithCompositePartitionKeyModel, SimpleWithPartitionKeyModel } from '../../../test/models/index'
+import { Metadata, metadataForClass } from '../../decorator/metadata/index'
+import { toDb } from '../../mapper/index'
 import { createIfNotExistsCondition } from './create-if-not-exists-condition.function'
-import { and } from './expression/logical-operator'
-import { addExpression } from './expression/param-util'
-import { getTableName } from './get-table-name.function'
+import { and } from './logical-operator/index'
+import { addExpression } from './param-util'
+import { getTableName } from '../get-table-name.function'
 
 describe('create ifNotExistsCondition', () => {
   const jsItemSimple: SimpleWithPartitionKeyModel = { id: 'myId-S', age: 20 }

src/dynamo/dynamo-store.spec.ts

@@ -1,7 +1,6 @@
-import { hasSortKey, Metadata } from '../decorator/metadata'
-import { attribute } from './expression/logical-operator'
-import { ConditionExpressionDefinitionFunction } from './expression/type'
-
+import { hasSortKey, Metadata } from '../../decorator/metadata/index'
+import { attribute } from './logical-operator/index'
+import { ConditionExpressionDefinitionFunction } from './type/index'
 
 export function createIfNotExistsCondition<T>(metadata: Metadata<T>): ConditionExpressionDefinitionFunction[] {
   const conditionDefFns: ConditionExpressionDefinitionFunction[] = [

src/dynamo/dynamo-store.ts

@@ -1,13 +1,13 @@
 import * as DynamoDB from 'aws-sdk/clients/dynamodb'
-import { Address, UpdateModel } from '../../test/models'
-import { FormId, FormType, Order, OrderId } from '../../test/models/real-world'
-import { Metadata, metadataForClass } from '../decorator/metadata'
-import { createKeyAttributes } from './create-ket-attributes.function'
-import { and, not, update2 } from './expression/logical-operator'
-import { attribute } from './expression/logical-operator/attribute.function'
-import { update } from './expression/logical-operator/update.function'
-import { addExpression } from './expression/param-util'
-import { getTableName } from './get-table-name.function'
+import { Address, UpdateModel } from '../../../test/models/index'
+import { FormId, FormType, Order, OrderId } from '../../../test/models/real-world/index'
+import { Metadata, metadataForClass } from '../../decorator/metadata/index'
+import { createKeyAttributes } from '../../mapper'
+import { and, not, update2 } from './logical-operator/index'
+import { attribute } from './logical-operator/attribute.function'
+import { update } from './logical-operator/update.function'
+import { addExpression } from './param-util'
+import { getTableName } from '../get-table-name.function'
 import { prepareAndAddUpdateExpressions } from './prepare-and-add-update-expressions.function'
 
 describe('PrepareExpressions function', () => {

src/dynamo/create-if-not-exists-condition.function.spec.ts renamed to src/dynamo/expression/create-if-not-exists-condition.function.spec.ts

@@ -1,11 +1,10 @@
 import * as DynamoDB from 'aws-sdk/clients/dynamodb'
 import { forEach } from 'lodash'
-import { Metadata } from '../decorator/metadata'
-import { Attributes } from '../mapper'
-import { addUpdateExpression } from './expression/param-util'
-import { Expression, UpdateExpressionDefinitionFunction } from './expression/type'
-import { SortedUpdateExpressions } from './request/update/update.request'
-
+import { Metadata } from '../../decorator/metadata/index'
+import { Attributes } from '../../mapper/index'
+import { SortedUpdateExpressions } from '../request/update/update.request'
+import { addUpdateExpression } from './param-util'
+import { Expression, UpdateExpressionDefinitionFunction } from './type/index'
 
 export function prepareAndAddUpdateExpressions(
   metadata: Metadata<any>,

src/dynamo/create-if-not-exists-condition.function.ts renamed to src/dynamo/expression/create-if-not-exists-condition.function.ts

@@ -1,7 +1,7 @@
 import { curry } from 'lodash'
 import { Metadata } from '../../decorator/metadata'
 import { ConditionalParamsHost } from '../operation-params.type'
-import { BaseRequest } from '../request/base.request'
+import { StandardRequest } from '../request/standard.request'
 import { buildFilterExpression } from './condition-expression-builder'
 import { addExpression } from './param-util'
 import { ConditionExpressionDefinitionChain } from './type/condition-expression-definition-chain'
@@ -85,20 +85,20 @@ export function doAddCondition<T, R extends ConditionalParamsHost>(
   return request
 }
 
-export function addPartitionKeyCondition<R extends BaseRequest<any, any>>(
+export function addPartitionKeyCondition<R extends StandardRequest<any, any, any>>(
   keyName: keyof any,
   keyValue: any,
   request: R,
 ): R
 
-export function addPartitionKeyCondition<T, R extends BaseRequest<T, any>>(
+export function addPartitionKeyCondition<T, R extends StandardRequest<T, any, any>>(
   keyName: keyof T,
   keyValue: any,
   request: R,
   metadata: Metadata<T>,
 ): R
 
-export function addPartitionKeyCondition<T, R extends BaseRequest<T, any>>(
+export function addPartitionKeyCondition<T, R extends StandardRequest<T, any, any>>(
   keyName: keyof T,
   keyValue: any,
   request: R,
@@ -121,14 +121,12 @@ export function updateDefinitionFunction<T>(attributePath: keyof T): UpdateExpre
   const f = (operation: UpdateActionDef) => {
     return (...values: any[]): UpdateExpressionDefinitionFunction => {
       const copy = [...values]
-      const curried = curry<
-        string,
+      const curried = curry<string,
         UpdateActionDef,
         any[],
         string[] | undefined,
         Metadata<any> | undefined,
-        UpdateExpression
-      >(buildUpdateExpression)
+        UpdateExpression>(buildUpdateExpression)
 
       return curried(<string>attributePath, operation, copy)
     }