refactor(decorator): keep ModelMetadata properties and indexes defined

Author: mumenthalers

src/decorator/decorators.spec.ts

@@ -65,7 +65,7 @@ describe('Decorators should add correct metadata', () => {
     })
 
     it('with no properties', () => {
-      expect(modelOptions.properties).toBeUndefined()
+      expect(modelOptions.properties).toEqual([])
     })
   })
 

src/decorator/impl/index/util.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/model/errors.const.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/model.decorator.ts

@@ -7,6 +7,7 @@ import { ModelMetadata } from '../../metadata/model-metadata.model'
 import { PropertyMetadata } from '../../metadata/property-metadata.model'
 import { SecondaryIndex } from '../index/secondary-index'
 import { KEY_PROPERTY } from '../property/key-property.const'
+import { modelErrors } from './errors.const'
 import { KEY_MODEL } from './key-model.const'
 import { ModelData } from './model-data.model'
 
@@ -21,27 +22,26 @@ export function Model(opts: ModelData = {}): ClassDecorator {
     // get all the properties with @Property() annotation (or @PartitionKey(),...)
     // if given class has own properties, all inherited properties are already set and we can get the properties with 'getOwnMetadata'.
     // otherwise when the given class does not have own properties, there's no 'ownMetadata' but we need to get them from the class it extends with 'getMetadata'
-    const properties: Array<PropertyMetadata<any>> = Reflect.hasOwnMetadata(KEY_PROPERTY, constructor)
-      ? Reflect.getOwnMetadata(KEY_PROPERTY, constructor)
-      : Reflect.getMetadata(KEY_PROPERTY, constructor)
+    const properties: Array<PropertyMetadata<any>> =
+      (Reflect.hasOwnMetadata(KEY_PROPERTY, constructor)
+        ? Reflect.getOwnMetadata(KEY_PROPERTY, constructor)
+        : Reflect.getMetadata(KEY_PROPERTY, constructor)) || []
 
     // get partition key
-    const partitionKeys = properties
-      ? properties.filter(property => property.key && property.key.type === 'HASH')
-      : null
-    const partitionKeyName: string | null = partitionKeys && partitionKeys.length ? partitionKeys[0].nameDb : null
+    const partitionKeys = properties.filter(property => property.key && property.key.type === 'HASH')
+
+    const partitionKeyName: string | null = partitionKeys.length ? partitionKeys[0].nameDb : null
 
     /*
      * get the local and global secondary indexes
      */
-    const globalSecondaryIndexes: any = getGlobalSecondaryIndexes(properties) || []
-    const localSecondaryIndexes: any = getLocalSecondaryIndexes(partitionKeyName, properties) || []
+    const globalSecondaryIndexes: any = getGlobalSecondaryIndexes(properties)
+    const localSecondaryIndexes: any = getLocalSecondaryIndexes(partitionKeyName, properties)
     const indexes: Map<string, SecondaryIndex<any>> = new Map([...globalSecondaryIndexes, ...localSecondaryIndexes])
 
-    const transientProperties =
-      properties && properties.length
-        ? properties.filter(property => property.transient === true).map(property => property.name)
-        : []
+    const transientProperties = properties.length
+      ? properties.filter(property => property.transient === true).map(property => property.name)
+      : []
 
     const metaData: ModelMetadata<any> = {
       clazz: constructor,
@@ -77,46 +77,36 @@ function testForLSI<T>(property: PropertyMetadata<T>): property is PropertyMetad
 /**
  * @hidden
  */
-function getGlobalSecondaryIndexes(properties: Array<PropertyMetadata<any>>): Map<string, SecondaryIndex<any>> | null {
-  if (properties && properties.length) {
-    return properties.filter(testForGSI).reduce((map, property): Map<string, SecondaryIndex<any>> => {
-      let gsi: SecondaryIndex<any>
-      Object.keys(property.keyForGSI).forEach(indexName => {
-        if (map.has(indexName)) {
-          gsi = map.get(indexName)
-        } else {
-          gsi = <SecondaryIndex<any>>{}
-        }
-
-        switch (property.keyForGSI[indexName]) {
-          case 'HASH':
-            if (gsi.partitionKey) {
-              throw new Error(
-                `there is already a partition key defined for global secondary index ${indexName} (property name: ${property.nameDb})`,
-              )
-            }
-
-            gsi.partitionKey = property.nameDb
-            break
-          case 'RANGE':
-            if (gsi.sortKey) {
-              throw new Error(
-                `there is already a sort key defined for global secondary index ${indexName} (property name: ${property.nameDb})`,
-              )
-            }
-
-            gsi.sortKey = property.nameDb
-            break
-        }
-
-        map.set(indexName, gsi)
-      })
-
-      return map
-    }, new Map())
-  } else {
-    return null
-  }
+function getGlobalSecondaryIndexes(properties: Array<PropertyMetadata<any>>): Map<string, SecondaryIndex<any>> {
+  return properties.filter(testForGSI).reduce((map, property): Map<string, SecondaryIndex<any>> => {
+    let gsi: SecondaryIndex<any>
+    Object.keys(property.keyForGSI).forEach(indexName => {
+      if (map.has(indexName)) {
+        gsi = map.get(indexName)
+      } else {
+        gsi = <SecondaryIndex<any>>{}
+      }
+
+      switch (property.keyForGSI[indexName]) {
+        case 'HASH':
+          if (gsi.partitionKey) {
+            throw new Error(modelErrors.gsiMultiplePk(indexName, property.nameDb))
+          }
+          gsi.partitionKey = property.nameDb
+          break
+        case 'RANGE':
+          if (gsi.sortKey) {
+            throw new Error(modelErrors.gsiMultipleSk(indexName, property.nameDb))
+          }
+          gsi.sortKey = property.nameDb
+          break
+      }
+
+      map.set(indexName, gsi)
+    })
+
+    return map
+  }, new Map())
 }
 
 /**
@@ -125,35 +115,27 @@ function getGlobalSecondaryIndexes(properties: Array<PropertyMetadata<any>>): Ma
 function getLocalSecondaryIndexes(
   basePartitionKey: string | null,
   properties: Array<PropertyMetadata<any>>,
-): Map<string, SecondaryIndex<any>> | null {
-  if (properties && properties.length) {
-    return properties.filter(testForLSI).reduce((map, property): Map<string, SecondaryIndex<any>> => {
-      let lsi: SecondaryIndex<any>
-
-      property.sortKeyForLSI.forEach(indexName => {
-        if (map.has(indexName)) {
-          throw new Error(
-            `only one sort key can be defined for the same local secondary index, ${property.nameDb} is already defined as sort key for index ${indexName}`,
-          )
-        }
-
-        if (!basePartitionKey) {
-          throw new Error(
-            'a local secondary index requires the partition key to be defined, use the @PartitionKey decorator',
-          )
-        }
-
-        lsi = {
-          partitionKey: basePartitionKey,
-          sortKey: property.nameDb,
-        }
-
-        map.set(indexName, lsi)
-      })
-
-      return map
-    }, new Map())
-  } else {
-    return null
-  }
+): Map<string, SecondaryIndex<any>> {
+  return properties.filter(testForLSI).reduce((map, property): Map<string, SecondaryIndex<any>> => {
+    let lsi: SecondaryIndex<any>
+
+    property.sortKeyForLSI.forEach(indexName => {
+      if (map.has(indexName)) {
+        throw new Error(modelErrors.lsiMultipleSk(indexName, property.nameDb))
+      }
+
+      if (!basePartitionKey) {
+        throw new Error(modelErrors.lsiRequiresPk(indexName, property.nameDb))
+      }
+
+      lsi = {
+        partitionKey: basePartitionKey,
+        sortKey: property.nameDb,
+      }
+
+      map.set(indexName, lsi)
+    })
+
+    return map
+  }, new Map())
 }

src/decorator/metadata/metadata.ts

@@ -32,19 +32,15 @@ export class Metadata<T> {
     modelOpts: ModelMetadata<M>,
     propertyName: keyof M,
   ): PropertyMetadata<M> | undefined {
-    return (
-      (modelOpts.properties &&
-        modelOpts.properties.find(property => property.name === propertyName || property.nameDb === propertyName)) ||
-      undefined
-    )
+    return modelOpts.properties.find(property => property.name === propertyName || property.nameDb === propertyName)
   }
 
   constructor(modelConstructor: ModelConstructor<T>) {
     this.modelOptions = Reflect.getMetadata(KEY_MODEL, modelConstructor)
   }
 
   forProperty(propertyKey: keyof T | string): PropertyMetadata<T> | undefined {
-    if (!this.modelOptions.properties) {
+    if (this.modelOptions.properties.length === 0) {
       return
     }
     if (typeof propertyKey === 'string' && NESTED_ATTR_PATH_REGEX.test(<string>propertyKey)) {
@@ -90,7 +86,11 @@ export class Metadata<T> {
     if (indexName) {
       const index = this.getIndex(indexName)
       if (index) {
-        return index.partitionKey
+        if (index.partitionKey) {
+          return index.partitionKey
+        } else {
+          throw new Error('the index exists but no partition key for it was defined. use @GSIPartitionKey(indexName)')
+        }
       } else {
         throw new Error(`there is no index defined for name ${indexName}`)
       }
@@ -133,24 +133,15 @@ export class Metadata<T> {
    * @returns {SecondaryIndex[]} Returns all the secondary indexes if exists or an empty array if none is defined
    */
   getIndexes(): Array<SecondaryIndex<T>> {
-    if (this.modelOptions.indexes && this.modelOptions.indexes.size) {
-      return Array.from(this.modelOptions.indexes.values())
-    } else {
-      return []
-    }
+    return Array.from(this.modelOptions.indexes.values())
   }
 
   /**
    * @param {string} indexName
    * @returns {SecondaryIndex} Returns the index if one with given name exists, null otherwise
    */
   getIndex(indexName: string): SecondaryIndex<T> | null {
-    if (this.modelOptions.indexes) {
-      const index = this.modelOptions.indexes.get(indexName)
-      return index ? index : null
-    }
-
-    return null
+    return this.modelOptions.indexes.get(indexName) || null
   }
 }
 
@@ -162,9 +153,9 @@ function filterBy<T, R>(
   predicate: (property: PropertyMetadata<any>) => boolean,
   defaultValue: R,
 ): Array<PropertyMetadata<any>> | R {
-  if (modelOptions && modelOptions.properties) {
+  if (modelOptions) {
     const properties = modelOptions.properties.filter(predicate)
-    if (properties && properties.length) {
+    if (properties.length) {
       return properties
     }
   }

src/decorator/metadata/model-metadata.model.ts

@@ -11,9 +11,9 @@ export interface ModelMetadata<T> {
   clazzName: string
   clazz: any
   tableName: string
-  properties?: Array<PropertyMetadata<T>>
+  properties: Array<PropertyMetadata<T>>
   transientProperties?: Array<string | number | symbol>
 
   // local and global secondary indexes maps the name to the index definition (partition and optional sort key depending on index type)
-  indexes?: Map<string, SecondaryIndex<T>>
+  indexes: Map<string, SecondaryIndex<T>>
 }

src/decorator/util.ts

@@ -27,12 +27,6 @@ export const getMetadataType = makeMetadataGetter<ModelConstructor<any>>(KEY_TYP
 /**
  * @hidden
  */
-export function makeMetadataGetter<T>(metadataKey: string): (target: any, targetKey?: string) => T {
-  return (target: any, targetKey?: string) => {
-    if (targetKey) {
-      return Reflect.getMetadata(metadataKey, target, targetKey)
-    } else {
-      return Reflect.getMetadata(metadataKey, target)
-    }
-  }
+export function makeMetadataGetter<T>(metadataKey: string): (target: any, targetKey: string) => T {
+  return (target: any, targetKey: string) => Reflect.getMetadata(metadataKey, target, targetKey)
 }

src/mapper/mapper.ts

@@ -170,8 +170,8 @@ function testForKey<T>(p: PropertyMetadata<T>): p is PropertyMetadata<T> & { key
 export function createToKeyFn<T>(modelConstructor: ModelConstructor<T>): (item: Partial<T>) => Attributes<T> {
   const metadata = metadataForModel(modelConstructor)
   const properties = metadata.modelOptions.properties
-  if (!properties) {
-    throw new Error('metadata properties is not defined')
+  if (!properties.length) {
+    throw new Error('no properties defined on metadata')
   }
 
   const keyProperties = properties.filter(testForKey)

test/helper/get-meta-data-property.function.ts

@@ -4,5 +4,5 @@ export function getMetaDataProperty<T, K extends keyof T>(
   modelOptions: ModelMetadata<T>,
   propertyKey: K,
 ): PropertyMetadata<T[K]> | undefined {
-  return <any>(modelOptions.properties || []).find(property => property.name === propertyKey)
+  return <any>modelOptions.properties.find(property => property.name === propertyKey)
 }