feat(dataStore): add validation for table name

Author: michaelwittwer

README.md

@@ -1,6 +1,6 @@
 # Dynamo-Easy
 [![Travis](https://img.shields.io/travis/shiftcode/dynamo-easy.svg)](https://travis-ci.org/shiftcode/dynamo-easy)
-[![Coverage Status](https://img.shields.io/coveralls/jekyll/jekyll.svg)](https://coveralls.io/github/shiftcode/dynamo-easy)
+[![Coverage Status](https://img.shields.io/coveralls/jekyll/jekyll.svg)](https://coveralls.io/github/shiftcode/dynamo-easy?branch=master)
 [![Dev Dependencies](https://img.shields.io/david/expressjs/express.svg)](https://david-dm.org/michaelwittwer/dynamo-easy?type=dev)
 [![Greenkeeper badge](https://badges.greenkeeper.io/alexjoverm/typescript-library-starter.svg)](https://greenkeeper.io/)
 [![styled with prettier](https://img.shields.io/badge/styled_with-prettier-ff69b4.svg)](https://github.com/prettier/prettier)
@@ -11,7 +11,7 @@ to define some metadata for your models. You don't need to care about the mappin
 
 Checkout the full technical api documentation [here](https://shiftcode.github.io/dynamo-easy/).
 
-Built with :heart: by the crew from [shiftcode](https://www.shiftcode.ch).
+Built with :heart: by [shiftcode](https://www.shiftcode.ch).
 
 # Get Started
 ```

src/decorator/impl/model/model-data.model.ts

@@ -1,3 +1,5 @@
+import { TableNameResolver } from '../../../dynamo/table-name-resolver.type'
+
 export interface ModelData {
   tableName?: string
 }

src/decorator/impl/model/model.decorator.ts

@@ -1,24 +1,13 @@
 import { kebabCase } from 'lodash'
 import { ModelMetadata } from '../../metadata/model-metadata.model'
 import { PropertyMetadata } from '../../metadata/property-metadata.model'
-// FIXME should be optional dependency
 import { getMetadataType } from '../../util'
 import { SecondaryIndex } from '../index/secondary-index'
 import { KEY_PROPERTY } from '../property/property.decorator'
 import { ModelData } from './model-data.model'
 
 export const KEY_MODEL = 'sc-reflect:model'
 
-/*
- * FIXME add validation for tableName
- * Table names and index names must be between 3 and 255 characters long, and can contain only the following characters:
-a-z
-A-Z
-0-9
-_ (underscore)
-- (dash)
-. (dot)
- */
 export function Model(opts: ModelData = {}): ClassDecorator {
   // tslint:disable-next-line:ban-types
   return (constructor: Function) => {
@@ -27,7 +16,6 @@ export function Model(opts: ModelData = {}): ClassDecorator {
     const classType = getMetadataType(constructor)
     const type = constructor as any
 
-    // FIXME would better typing help with something
     // get all the properties with @Property() annotation
     const properties: Array<PropertyMetadata<any>> = Reflect.getOwnMetadata(KEY_PROPERTY, constructor)
 

src/dynamo/dynamo-store.spec.ts

@@ -0,0 +1,37 @@
+import { Model } from '../decorator/impl/model/model.decorator'
+import { DynamoStore } from './dynamo-store'
+
+// tslint:disable-next-line:max-classes-per-file
+@Model()
+class DynamoStoreModel {}
+
+// tslint:disable-next-line:max-classes-per-file
+@Model({ tableName: 'myTableName' })
+class DynamoStoreModel2 {}
+
+describe('dynamo store', () => {
+  it('correct table name (default)', () => {
+    const dynamoStore = new DynamoStore(DynamoStoreModel)
+
+    expect(dynamoStore.tableName).toBe('dynamo-store-models')
+  })
+
+  it('correct table name ()', () => {
+    const dynamoStore = new DynamoStore(DynamoStoreModel2)
+
+    expect(dynamoStore.tableName).toBe('myTableName')
+  })
+
+  it('correct table name ()', () => {
+    const dynamoStore = new DynamoStore(DynamoStoreModel2, tableName => `${tableName}-with-special-thing`)
+
+    expect(dynamoStore.tableName).toBe('myTableName-with-special-thing')
+  })
+
+  it('throw error because table name is invalid', () => {
+    expect(() => {
+      // tslint:disable-next-line:no-unused-expression
+      new DynamoStore(DynamoStoreModel2, tableName => `${tableName}$`)
+    }).toThrowError()
+  })
+})

src/dynamo/dynamo-store.ts

@@ -17,6 +17,9 @@ import { SessionValidityEnsurer } from './session-validity-ensurer.type'
 import { TableNameResolver } from './table-name-resolver.type'
 
 export class DynamoStore<T> {
+  /* http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Limits.html#limits-naming-rules */
+  private static REGEX_TABLE_NAME = /^[a-zA-Z0-9_\-.]{3,255}$/
+
   private readonly dynamoRx: DynamoRx
   private readonly mapper: Mapper
 
@@ -28,7 +31,14 @@ export class DynamoStore<T> {
     sessionValidityEnsurer: SessionValidityEnsurer = DEFAULT_SESSION_VALIDITY_ENSURER
   ) {
     this.dynamoRx = new DynamoRx(sessionValidityEnsurer)
-    this.tableName = tableNameResolver(MetadataHelper.get(this.modelClazz).modelOptions.tableName)
+    const tableName = tableNameResolver(MetadataHelper.get(this.modelClazz).modelOptions.tableName)
+    if (!DynamoStore.REGEX_TABLE_NAME.test(tableName)) {
+      throw new Error(
+        'make sure the table name only contains these characters «a-z A-Z 0-9 - _ .» and is between 3 and 255 characters long'
+      )
+    }
+
+    this.tableName = tableName
   }
 
   get dynamoDb(): DynamoDB {
@@ -111,12 +121,6 @@ export class DynamoStore<T> {
     })
   }
 
-  // private findBySingleKey(partitionKeyValue: any): Observable<T[]> {
-  //   return this.query()
-  //     .wherePartitionKey(partitionKeyValue)
-  //     .exec()
-  // }
-
   private createBaseParams(): { TableName: string } {
     const params: { TableName: string } = {
       TableName: this.tableName,

src/dynamo/request/put/put.request.spec.ts

@@ -0,0 +1,28 @@
+import { PutItemInput } from 'aws-sdk/clients/dynamodb'
+import { getTableName } from '../../../../test/helper/get-table-name.function'
+import { SimpleWithIdModel } from '../../../../test/models/simple-with-id.model'
+import { PutRequest } from './put.request'
+
+describe('put request', () => {
+  describe('if exists condition', () => {
+    it('simple', () => {
+      const item: SimpleWithIdModel = { id: 'myId', age: 45 }
+      const request = new PutRequest(null, SimpleWithIdModel, getTableName(SimpleWithIdModel), item)
+      request.ifNotExists()
+
+      expect((<PutItemInput>request.params).ConditionExpression).toBe('attribute_not_exists (#id)')
+      expect((<PutItemInput>request.params).ExpressionAttributeNames).toEqual({ '#id': 'id' })
+      expect((<PutItemInput>request.params).ExpressionAttributeValues).toBeUndefined()
+    })
+
+    it('predicate', () => {
+      const item: SimpleWithIdModel = { id: 'myId', age: 45 }
+      const request = new PutRequest(null, SimpleWithIdModel, getTableName(SimpleWithIdModel), item)
+      request.ifNotExists(25 + 20 === 40)
+
+      expect((<PutItemInput>request.params).ConditionExpression).toBeUndefined()
+      expect((<PutItemInput>request.params).ExpressionAttributeNames).toBeUndefined()
+      expect((<PutItemInput>request.params).ExpressionAttributeValues).toBeUndefined()
+    })
+  })
+})

src/mapper/for-type/date.mapper.spec.ts

@@ -0,0 +1,40 @@
+import { AttributeValue } from 'aws-sdk/clients/dynamodb'
+import { DateMapper } from './date.mapper'
+
+describe('date mapper', () => {
+  let dateMapper: DateMapper
+
+  beforeEach(() => {
+    dateMapper = new DateMapper()
+  })
+
+  describe('to db', () => {
+    it('simple', () => {
+      const now = new Date()
+      const toDb: AttributeValue = dateMapper.toDb(now)
+
+      expect(toDb).toEqual({ N: `${now.getTime()}` })
+    })
+
+    it('throws', () => {
+      expect(() => {
+        dateMapper.toDb(<any>'noDate')
+      }).toThrowError()
+    })
+  })
+
+  describe('from db', () => {
+    xit('simple', () => {
+      const now = new Date()
+      const fromDb = dateMapper.fromDb({ N: `${now.getTime()}` })
+
+      expect(fromDb).toEqual(now)
+    })
+
+    it('throws', () => {
+      expect(() => {
+        dateMapper.fromDb({ S: <any>'noDate' })
+      }).toThrowError()
+    })
+  })
+})

src/mapper/for-type/date.mapper.ts

@@ -12,7 +12,7 @@ export class DateMapper implements MapperForType<Date> {
 
   toDb(modelValue: Date): AttributeValue {
     if (modelValue && modelValue instanceof Date) {
-      return { N: modelValue.getTime().toString() }
+      return { N: `${modelValue.getTime()}` }
     } else {
       throw new Error('the given model value must be an instance of Date')
     }