Merge branch 'master' into #257-get-rid-of-lodash

# Conflicts:
#	src/mapper/for-type/number.mapper.ts
#	src/mapper/util.ts

Author: michaelwittwer

package-lock.json

@@ -72,21 +72,22 @@
     "prettier": "^1.18.2",
     "reflect-metadata": "^0.1.13",
     "rimraf": "^3.0.0",
-    "semantic-release": "^16.0.0-beta.18",
+    "semantic-release": "^16.0.1",
     "sort-package-json": "^1.22.1",
     "ts-jest": "^24.0.2",
     "ts-node": "^8.3.0",
     "tslint": "^5.19.0",
     "tslint-config-prettier": "^1.18.0",
     "tsutils": "^3.17.1",
-    "typedoc": "^0.15.0",
+    "typedoc": "0.14.0",
     "typedoc-plugin-external-module-name": "^2.1.0",
     "typescript": ">=2.9.1",
     "uuid": "^3.3.2"
   },
   "peerDependencies": {
     "aws-sdk": "^2.401.0",
     "reflect-metadata": "^0.1.12",
+    "tslib": "^1.10.0",
     "uuid": "^3.3.2"
   }
 }

package.json

@@ -19,6 +19,8 @@ import {
   SimpleModel,
 } from '../../test/models'
 import { Form } from '../../test/models/real-world'
+import { updateDynamoEasyConfig } from '../config/update-config.function'
+import { LogLevel } from '../logger/log-level.type'
 import { CollectionProperty } from './impl/collection/collection-property.decorator'
 import { GSIPartitionKey } from './impl/index/gsi-partition-key.decorator'
 import { GSISortKey } from './impl/index/gsi-sort-key.decorator'
@@ -65,7 +67,7 @@ describe('Decorators should add correct metadata', () => {
     })
 
     it('with no properties', () => {
-      expect(modelOptions.properties).toBeUndefined()
+      expect(modelOptions.properties).toEqual([])
     })
   })
 
@@ -317,6 +319,77 @@ describe('Decorators should add correct metadata', () => {
     })
   })
 
+  describe('multiple property decorators', () => {
+    const REVERSE_INDEX = 'reverse-index'
+    const OTHER_INDEX = 'other-index'
+    const LSI_1 = 'lsi-1'
+    const LSI_2 = 'lsi-2'
+
+    @Model()
+    class ABC {
+      @PartitionKey()
+      @Property({ name: 'pk' })
+      @GSISortKey(REVERSE_INDEX)
+      id: string
+
+      @SortKey()
+      @Property({ name: 'sk' })
+      @GSIPartitionKey(REVERSE_INDEX)
+      @GSISortKey(OTHER_INDEX)
+      timestamp: number
+
+      @GSIPartitionKey(OTHER_INDEX)
+      @LSISortKey(LSI_1)
+      @LSISortKey(LSI_2)
+      otherId: string
+    }
+
+    let metaData: Metadata<ABC>
+
+    beforeEach(() => (metaData = metadataForModel(ABC)))
+
+    it('PartitionKey & Property & GSISortKey should combine the data', () => {
+      const propData = metaData.forProperty('id')
+      expect(propData).toEqual({
+        key: { type: 'HASH' },
+        name: 'id',
+        nameDb: 'pk',
+        typeInfo: { type: String },
+        keyForGSI: { [REVERSE_INDEX]: 'RANGE' },
+      })
+    })
+    it('SortKey & Property & GSIPartitionKey & GSISortKey should combine the data', () => {
+      const propData = metaData.forProperty('timestamp')
+      expect(propData).toEqual({
+        key: { type: 'RANGE' },
+        name: 'timestamp',
+        nameDb: 'sk',
+        typeInfo: { type: Number },
+        keyForGSI: { [REVERSE_INDEX]: 'HASH', [OTHER_INDEX]: 'RANGE' },
+      })
+    })
+    it('GSIPartitionKey & multiple LSISortkey should combine the data', () => {
+      const propData = metaData.forProperty('otherId')
+      expect(propData).toBeDefined()
+      expect(propData!.name).toEqual('otherId')
+      expect(propData!.nameDb).toEqual('otherId')
+      expect(propData!.typeInfo).toEqual({ type: String })
+      expect(propData!.keyForGSI).toEqual({ [OTHER_INDEX]: 'HASH' })
+      expect(propData!.sortKeyForLSI).toContain(LSI_1)
+      expect(propData!.sortKeyForLSI).toContain(LSI_2)
+    })
+    it('correctly defines the indexes', () => {
+      const reverseIndex = metaData.getIndex(REVERSE_INDEX)
+      const otherIndex = metaData.getIndex(OTHER_INDEX)
+      const lsi1 = metaData.getIndex(LSI_1)
+      const lsi2 = metaData.getIndex(LSI_2)
+      expect(reverseIndex).toEqual({ partitionKey: 'sk', sortKey: 'pk' })
+      expect(otherIndex).toEqual({ partitionKey: 'otherId', sortKey: 'sk' })
+      expect(lsi1).toEqual({ partitionKey: 'pk', sortKey: 'otherId' })
+      expect(lsi2).toEqual({ partitionKey: 'pk', sortKey: 'otherId' })
+    })
+  })
+
   describe('enum (no Enum decorator)', () => {
     let metadata: Metadata<ModelWithEnum>
 
@@ -544,17 +617,43 @@ describe('Decorators should add correct metadata', () => {
   })
 
   describe('should throw when more than one partitionKey was defined in a model', () => {
-    expect(() => {
+    it('does so', () => {
+      expect(() => {
+        @Model()
+        class InvalidModel {
+          @PartitionKey()
+          partKeyA: string
+
+          @PartitionKey()
+          partKeyB: string
+        }
+
+        return new InvalidModel()
+      }).toThrow()
+    })
+  })
+
+  describe('decorate property multiple times identically', () => {
+    let logReceiver: jest.Mock
+
+    beforeEach(() => {
+      logReceiver = jest.fn()
+      updateDynamoEasyConfig({ logReceiver })
+    })
+
+    it('should not throw but warn, if the PartitionKey is two times annotated', () => {
       @Model()
-      class InvalidModel {
+      class NotCoolButOkModel {
         @PartitionKey()
-        partKeyA: string
-
         @PartitionKey()
-        partKeyB: string
+        doppeltGemoppelt: string
       }
 
-      return new InvalidModel()
-    }).toThrow()
+      const propertyMetaData = metadataForModel(NotCoolButOkModel).forProperty('doppeltGemoppelt')
+      expect(propertyMetaData).toBeDefined()
+      expect(propertyMetaData!.key).toEqual({ type: 'HASH' })
+      expect(logReceiver).toBeCalledTimes(1)
+      expect(logReceiver.mock.calls[0][0].level).toBe(LogLevel.WARNING)
+    })
   })
 })

src/decorator/decorators.spec.ts

@@ -36,6 +36,7 @@ export function initOrUpdateIndex(indexType: IndexType, indexData: IndexData, ta
         indexData,
       )
       break
+    // `default` is actually unnecessary - but could only be removed by cast or nonNullAssertion of `propertyMetadata`
     default:
       throw new Error(`unsupported index type ${indexType}`)
   }

src/decorator/impl/index/util.ts

@@ -1,10 +1,13 @@
 /**
  * @module decorators
  */
+import { createOptModelLogger } from '../../../logger/logger'
 import { PropertyMetadata } from '../../metadata/property-metadata.model'
 import { initOrUpdateProperty } from '../property/init-or-update-property.function'
 import { KEY_PROPERTY } from '../property/key-property.const'
 
+const logger = createOptModelLogger('@PartitionKey')
+
 export function PartitionKey(): PropertyDecorator {
   return (target: any, propertyKey: string | symbol) => {
     if (typeof propertyKey === 'string') {
@@ -14,9 +17,11 @@ export function PartitionKey(): PropertyDecorator {
         const existingPartitionKeys = properties.filter(property => property.key && property.key.type === 'HASH')
         if (existingPartitionKeys.length) {
           if (properties.find(property => property.name === propertyKey)) {
-            // just ignore this and go on, somehow the partition key gets defined
-            // tslint:disable-next-line:no-console
-            console.warn(`this is the second execution to define the partitionKey for property ${propertyKey}`)
+            // just ignore this and go on, somehow the partition key gets defined two times
+            logger.warn(
+              `this is the second execution to define the partitionKey for property ${propertyKey}`,
+              target.constructor,
+            )
           } else {
             throw new Error(
               'only one partition key is allowed per model, if you want to define key for indexes use one of these decorators: ' +

src/decorator/impl/key/partition-key.decorator.ts

@@ -0,0 +1,17 @@
+/**
+ * @module decorators
+ */
+
+/**
+ * @hidden
+ */
+export const modelErrors = {
+  gsiMultiplePk: (indexName: string, propDbName: string) =>
+    `there is already a partition key defined for global secondary index ${indexName} (property name: ${propDbName})`,
+  gsiMultipleSk: (indexName: string, propDbName: string) =>
+    `there is already a sort key defined for global secondary index ${indexName} (property name: ${propDbName})`,
+  lsiMultipleSk: (indexName: string, propDbName: string) =>
+    `only one sort key can be defined for the same local secondary index, ${propDbName} is already defined as sort key for index ${indexName}`,
+  lsiRequiresPk: (indexName: string, propDbName: string) =>
+    `the  local secondary index ${indexName} requires the partition key to be defined`,
+}

src/decorator/impl/model/errors.const.ts

@@ -0,0 +1,70 @@
+// tslint:disable:max-classes-per-file
+import { GSIPartitionKey } from '../index/gsi-partition-key.decorator'
+import { GSISortKey } from '../index/gsi-sort-key.decorator'
+import { LSISortKey } from '../index/lsi-sort-key.decorator'
+import { PartitionKey } from '../key/partition-key.decorator'
+import { modelErrors } from './errors.const'
+import { Model } from './model.decorator'
+
+const IX_NAME = 'anIndexName'
+
+describe('@model decorator', () => {
+  describe('getGlobalSecondaryIndexes', () => {
+    // throws on applying decorator
+
+    it('throws when defining multiple partitionKeys for same gsi', () => {
+      expect(() => {
+        // @ts-ignore
+        @Model()
+        class FailModel {
+          @GSIPartitionKey(IX_NAME)
+          pk1: string
+          @GSIPartitionKey(IX_NAME)
+          pk2: string
+          @GSISortKey(IX_NAME)
+          sk1: string
+        }
+      }).toThrow(modelErrors.gsiMultiplePk(IX_NAME, 'pk2'))
+    })
+    it('throws when defining multiple sortKeys for same gsi', () => {
+      expect(() => {
+        // @ts-ignore
+        @Model()
+        class FailModel {
+          @GSIPartitionKey(IX_NAME)
+          pk1: string
+          @GSISortKey(IX_NAME)
+          sk1: string
+          @GSISortKey(IX_NAME)
+          sk2: string
+        }
+      }).toThrow(modelErrors.gsiMultipleSk(IX_NAME, 'sk2'))
+    })
+  })
+  describe('getLocalSecondaryIndexes', () => {
+    it('throws when defining LSI sortKey but no PartitionKey', () => {
+      expect(() => {
+        // @ts-ignore
+        @Model()
+        class FailModel {
+          @LSISortKey(IX_NAME)
+          sk1: string
+        }
+      }).toThrow(modelErrors.lsiRequiresPk(IX_NAME, 'sk1'))
+    })
+    it('throws when defining multiple sortKeys for same lsi', () => {
+      expect(() => {
+        // @ts-ignore
+        @Model()
+        class FailModel {
+          @PartitionKey()
+          pk1: string
+          @LSISortKey(IX_NAME)
+          sk1: string
+          @LSISortKey(IX_NAME)
+          sk2: string
+        }
+      }).toThrow(modelErrors.lsiMultipleSk(IX_NAME, 'sk2'))
+    })
+  })
+})