style(tslint): reformat code

Author: michaelwittwer

src/dynamo/dynamo-store.ts

@@ -18,10 +18,14 @@ import {
 import { BatchWriteSingleTableRequest } from './request/batchwritesingletable/batch-write-single-table.request'
 
 export class DynamoStore<T> {
-  private readonly logger: Logger
-  private readonly dynamoRx: DynamoRx
+
+  get dynamoDb(): DynamoDB {
+    return this.dynamoRx.dynamoDb
+  }
 
   readonly tableName: string
+  private readonly logger: Logger
+  private readonly dynamoRx: DynamoRx
 
   constructor(
     private modelClazz: ModelConstructor<T>,
@@ -32,10 +36,6 @@ export class DynamoStore<T> {
     this.logger.debug('instance created')
   }
 
-  get dynamoDb(): DynamoDB {
-    return this.dynamoRx.dynamoDb
-  }
-
   put(item: T): PutRequest<T> {
     return new PutRequest(this.dynamoRx, this.modelClazz, item)
   }

src/dynamo/request/batchgetsingletable/batch-get-single-table.request.ts

@@ -17,13 +17,13 @@ const DEFAULT_TIME_SLOT = 1000
 
 // TODO add support for indexes
 export class BatchGetSingleTableRequest<T> {
-  private readonly logger: Logger
   readonly dynamoRx: DynamoRx
   readonly params: BatchGetItemInput
   readonly modelClazz: ModelConstructor<T>
   readonly tableName: string
 
   readonly metadata: Metadata<T>
+  private readonly logger: Logger
 
   constructor(dynamoRx: DynamoRx, modelClazz: ModelConstructor<T>, keys: Array<Partial<T>>) {
     this.logger = createLogger('dynamo.request.BatchGetSingleTableRequest', modelClazz)
@@ -59,6 +59,25 @@ export class BatchGetSingleTableRequest<T> {
     return this
   }
 
+  execNoMap(backoffTimer = randomExponentialBackoffTimer, throttleTimeSlot = DEFAULT_TIME_SLOT): Observable<DynamoDB.BatchGetItemOutput> {
+    return this.fetch(backoffTimer, throttleTimeSlot)
+  }
+
+  execFullResponse(backoffTimer = randomExponentialBackoffTimer, throttleTimeSlot = DEFAULT_TIME_SLOT): Observable<BatchGetSingleTableResponse<T>> {
+    return this.fetch(backoffTimer, throttleTimeSlot).pipe(
+      map(this.mapResponse),
+      tap(response => this.logger.debug('mapped items', response.Items)),
+    )
+  }
+
+  exec(backoffTimer = randomExponentialBackoffTimer, throttleTimeSlot = DEFAULT_TIME_SLOT): Observable<T[]> {
+    return this.fetch(backoffTimer, throttleTimeSlot).pipe(
+      map(this.mapResponse),
+      map(r => r.Items),
+      tap(items => this.logger.debug('mapped items', items)),
+    )
+  }
+
   private mapResponse = (response: DynamoDB.BatchGetItemOutput) => {
     let items: T[] = []
     if (response.Responses && Object.keys(response.Responses).length && response.Responses[this.tableName]) {
@@ -82,23 +101,4 @@ export class BatchGetSingleTableRequest<T> {
       )
   }
 
-  execNoMap(backoffTimer = randomExponentialBackoffTimer, throttleTimeSlot = DEFAULT_TIME_SLOT): Observable<DynamoDB.BatchGetItemOutput> {
-    return this.fetch(backoffTimer, throttleTimeSlot)
-  }
-
-  execFullResponse(backoffTimer = randomExponentialBackoffTimer, throttleTimeSlot = DEFAULT_TIME_SLOT): Observable<BatchGetSingleTableResponse<T>> {
-    return this.fetch(backoffTimer, throttleTimeSlot).pipe(
-      map(this.mapResponse),
-      tap(response => this.logger.debug('mapped items', response.Items)),
-    )
-  }
-
-  exec(backoffTimer = randomExponentialBackoffTimer, throttleTimeSlot = DEFAULT_TIME_SLOT): Observable<T[]> {
-    return this.fetch(backoffTimer, throttleTimeSlot).pipe(
-      map(this.mapResponse),
-      map(r => r.Items),
-      tap(items => this.logger.debug('mapped items', items)),
-    )
-  }
-
 }

src/dynamo/request/batchwritesingletable/batch-write-single-table.request.ts

@@ -13,7 +13,6 @@ import { BatchWriteSingleTableResponse } from './batch-write-single-table.respon
 const MAX_BATCH_WRITE_ITEMS = 25
 
 export class BatchWriteSingleTableRequest<T> {
-  private readonly logger: Logger
 
   private get toKey(): (item: T) => Attributes {
     if (!this.keyFn) {
@@ -22,12 +21,13 @@ export class BatchWriteSingleTableRequest<T> {
     return this.keyFn
   }
 
-  private keyFn: any
-
   readonly dynamoRx: DynamoRx
   readonly modelClazz: ModelConstructor<T>
   readonly tableName: string
   readonly itemsToProcess: WriteRequests
+  private readonly logger: Logger
+
+  private keyFn: any
 
   constructor(dynamoRx: DynamoRx, modelClazz: ModelConstructor<T>) {
     this.logger = createLogger('dynamo.request.BatchWriteSingleTableRequest', modelClazz)
@@ -56,6 +56,34 @@ export class BatchWriteSingleTableRequest<T> {
     return this
   }
 
+  // fixme backoff time is resetted for every request.. :/
+  /**
+   *
+   * @param backoffTimer generator for how much timeSlots should be waited before requesting next batch. only used when capacity was exceeded. default randomExponentialBackoffTimer
+   * @param throttleTimeSlot defines how long one timeSlot is for throttling, default 1 second
+   */
+  exec(backoffTimer = randomExponentialBackoffTimer, throttleTimeSlot = 1000): Observable<void> {
+    this.logger.debug('starting batchWriteItem')
+    const rBoT = backoffTimer()
+    return this.execNextBatch().pipe(
+      mergeMap((r: BatchWriteSingleTableResponse) => {
+        if (r.capacityExceeded) {
+          const backoffTime = rBoT.next().value * throttleTimeSlot
+          this.logger.info(`wait ${backoffTime} ms until next request`, { backoffTime })
+          return of(r).pipe(delay(backoffTime))
+        }
+        return of(r)
+      }),
+      mergeMap((r: BatchWriteSingleTableResponse) => {
+        if (r.remainingItems > 0) {
+          return this.exec()
+        } else {
+          return of()
+        }
+      }),
+    )
+  }
+
   private execNextBatch(): Observable<BatchWriteSingleTableResponse> {
     const batch = this.itemsToProcess.splice(0, MAX_BATCH_WRITE_ITEMS)
     const batchWriteItemInput: BatchWriteItemInput = {
@@ -86,32 +114,4 @@ export class BatchWriteSingleTableRequest<T> {
       }),
     )
   }
-
-  // fixme backoff time is resetted for every request.. :/
-  /**
-   *
-   * @param backoffTimer generator for how much timeSlots should be waited before requesting next batch. only used when capacity was exceeded. default randomExponentialBackoffTimer
-   * @param throttleTimeSlot defines how long one timeSlot is for throttling, default 1 second
-   */
-  exec(backoffTimer = randomExponentialBackoffTimer, throttleTimeSlot = 1000): Observable<void> {
-    this.logger.debug('starting batchWriteItem')
-    const rBoT = backoffTimer()
-    return this.execNextBatch().pipe(
-      mergeMap((r: BatchWriteSingleTableResponse) => {
-        if (r.capacityExceeded) {
-          const backoffTime = rBoT.next().value * throttleTimeSlot
-          this.logger.info(`wait ${backoffTime} ms until next request`, { backoffTime })
-          return of(r).pipe(delay(backoffTime))
-        }
-        return of(r)
-      }),
-      mergeMap((r: BatchWriteSingleTableResponse) => {
-        if (r.remainingItems > 0) {
-          return this.exec()
-        } else {
-          return of()
-        }
-      }),
-    )
-  }
 }

src/dynamo/request/get/get.request.ts

@@ -13,8 +13,8 @@ import { BaseRequest } from '../base.request'
 import { GetResponse } from './get.response'
 
 export class GetRequest<T> extends BaseRequest<T, any> {
-  private readonly logger: Logger
   readonly params: DynamoDB.GetItemInput
+  private readonly logger: Logger
 
   constructor(dynamoRx: DynamoRx, modelClazz: ModelConstructor<T>, partitionKey: any, sortKey?: any) {
     super(dynamoRx, modelClazz)

src/dynamo/request/query/query.request.ts

@@ -18,13 +18,6 @@ export class QueryRequest<T> extends Request<T, QueryRequest<T>, QueryInput, Que
     this.logger = createLogger('dynamo.request.QueryRequest', modelClazz)
   }
 
-  private mapFromDb = (queryResponse: QueryOutput) => {
-    const response: QueryResponse<T> = <any>{ ...queryResponse }
-    response.Items = (queryResponse.Items || []).map(item => fromDb(<Attributes<T>>item, this.modelClazz))
-
-    return response
-  }
-
   wherePartitionKey(partitionKeyValue: any): QueryRequest<T> {
     let partitionKey: keyof T
     if (this.params.IndexName) {
@@ -136,4 +129,11 @@ export class QueryRequest<T> extends Request<T, QueryRequest<T>, QueryInput, Que
     )
   }
 
+  private mapFromDb = (queryResponse: QueryOutput) => {
+    const response: QueryResponse<T> = <any>{ ...queryResponse }
+    response.Items = (queryResponse.Items || []).map(item => fromDb(<Attributes<T>>item, this.modelClazz))
+
+    return response
+  }
+
 }

src/dynamo/request/scan/scan.request.ts

@@ -16,14 +16,6 @@ export class ScanRequest<T> extends Request<T, ScanRequest<T>, ScanInput, ScanRe
     this.logger = createLogger('dynamo.request.ScanRequest', modelClazz)
   }
 
-  private mapFromDb = (output: ScanOutput) => {
-    const response: ScanResponse<T> = <any>{ ...output }
-    if (output.Items) {
-      response.Items = output.Items.map(item => fromDb(<Attributes<T>>item, this.modelClazz))
-    }
-    return response
-  }
-
   execNoMap(): Observable<ScanOutput> {
     this.logger.debug('request (noMap)', this.params)
     return this.dynamoRx.scan(this.params)
@@ -77,4 +69,12 @@ export class ScanRequest<T> extends Request<T, ScanRequest<T>, ScanInput, ScanRe
     )
   }
 
+  private mapFromDb = (output: ScanOutput) => {
+    const response: ScanResponse<T> = <any>{ ...output }
+    if (output.Items) {
+      response.Items = output.Items.map(item => fromDb(<Attributes<T>>item, this.modelClazz))
+    }
+    return response
+  }
+
 }

src/dynamo/transactwrite/transact-write.request.ts

@@ -6,8 +6,8 @@ import { TransactOperation } from './transact-operation.type'
 
 
 export class TransactWriteRequest {
-  private readonly dynamoRx: DynamoRx
   readonly params: DynamoDB.TransactWriteItemsInput
+  private readonly dynamoRx: DynamoRx
 
   constructor() {
     this.dynamoRx = new DynamoRx()

tslint.yml

@@ -11,12 +11,12 @@ rules:
     true,
     {
       order: [
-        "public-instance-field",
-        "private-instance-field",
         "public-static-field",
         "private-static-field",
-        "instance-field",
-        "static-method",
+        "public-instance-field",
+        "private-instance-field",
+        "public-static-method",
+        "private-static-method",
         "constructor",
         "public-instance-method",
         "private-instance-method",