feat(typings): better typing

- update jest config to match new config schema
- add new type MetadataWithSortKey to be used with the guard function hasSortKey on metadata
- make Attributes generic
- update typings for request-expression-builder
- add type Omit for convenience

Author: michaelwittwer

jest.config.js

@@ -2,7 +2,7 @@ module.exports = {
   testEnvironment: "node",
   globals: {
     "ts-jest": {
-      tsConfigFile: "./tsconfig.jest.json"
+      tsConfig: "./tsconfig.jest.json"
     }
   },
   transform: {

package-lock.json

@@ -1,9 +1,19 @@
 import { ModelConstructor } from '../../model/model-constructor'
+import { Omit } from '../../model/omit.type'
 import { SecondaryIndex } from '../impl/index/secondary-index'
 import { KEY_MODEL } from '../impl/model/model.decorator'
 import { ModelMetadata } from './model-metadata.model'
 import { PropertyMetadata } from './property-metadata.model'
 
+export type MetadataWithSortKey<T> = Omit<Metadata<T>, 'getSortKey'> & { getSortKey: (indexName?: string) => keyof T }
+
+/**
+ * Checks if given metadata returns a sort key when calling metadata.getSortKey
+ */
+export function hasSortKey<T>(metadata: Metadata<T>): metadata is MetadataWithSortKey<T> {
+  return metadata.getSortKey() !== null
+}
+
 export class Metadata<T> {
   readonly modelOptions: ModelMetadata<T>
 
@@ -28,7 +38,7 @@ export class Metadata<T> {
    * @returns {Array<PropertyMetadata<any>>} Returns all the properties property the @PartitionKeyUUID decorator is present, returns an empty array by default
    */
   getKeysWithUUID(): Array<PropertyMetadata<any>> {
-    return this.filterBy(p => !!(p.key && p.key.uuid), [])
+    return filterBy(this.modelOptions, p => !!(p.key && p.key.uuid), [])
   }
 
   /**
@@ -46,7 +56,7 @@ export class Metadata<T> {
         throw new Error(`there is no index defined for name ${indexName}`)
       }
     } else {
-      const property = this.filterByFirst(p => !!(p.key && p.key.type === 'HASH'))
+      const property = filterByFirst(this.modelOptions, p => !!(p.key && p.key.type === 'HASH'))
 
       if (property) {
         return property.name
@@ -74,7 +84,7 @@ export class Metadata<T> {
         throw new Error(`there is no index defined for name ${indexName}`)
       }
     } else {
-      const property = this.filterByFirst(p => !!(p.key && p.key.type === 'RANGE'))
+      const property = filterByFirst(this.modelOptions, p => !!(p.key && p.key.type === 'RANGE'))
       return property ? property.name : null
     }
   }
@@ -103,23 +113,27 @@ export class Metadata<T> {
 
     return null
   }
+}
 
-  private filterBy<R>(
-    predicate: (property: PropertyMetadata<any>) => boolean,
-    defaultValue: R,
-  ): Array<PropertyMetadata<any>> | R {
-    if (this.modelOptions && this.modelOptions.properties) {
-      const properties = this.modelOptions.properties.filter(predicate)
-      if (properties && properties.length) {
-        return properties
-      }
+function filterBy<T, R>(
+  modelOptions: ModelMetadata<T>,
+  predicate: (property: PropertyMetadata<any>) => boolean,
+  defaultValue: R,
+): Array<PropertyMetadata<any>> | R {
+  if (modelOptions && modelOptions.properties) {
+    const properties = modelOptions.properties.filter(predicate)
+    if (properties && properties.length) {
+      return properties
     }
-
-    return defaultValue
   }
 
-  private filterByFirst(predicate: (property: PropertyMetadata<T>) => boolean): PropertyMetadata<T> | null {
-    const properties = this.filterBy(predicate, null)
-    return properties && properties.length ? properties[0] : null
-  }
+  return defaultValue
+}
+
+function filterByFirst<T>(
+  modelOptions: ModelMetadata<T>,
+  predicate: (property: PropertyMetadata<T>) => boolean,
+): PropertyMetadata<T> | null {
+  const properties = filterBy(modelOptions, predicate, null)
+  return properties && properties.length ? properties[0] : null
 }

src/decorator/metadata/metadata.ts

@@ -2,6 +2,7 @@ import { BatchGetItemInput } from 'aws-sdk/clients/dynamodb'
 import { isObject, isString } from 'lodash'
 import { Observable } from 'rxjs'
 import { map } from 'rxjs/operators'
+import { hasSortKey } from '../../decorator/metadata'
 import { metadataForClass } from '../../decorator/metadata/metadata-helper'
 import { fromDb, toDbOne } from '../../mapper'
 import { Attributes } from '../../mapper/type/attribute.type'
@@ -49,16 +50,16 @@ export class BatchGetRequest {
 
     // loop over all the keys
     keys.forEach(key => {
-      const idOb: Attributes = {}
+      const idOb: Attributes<T> = <any>{}
 
       if (isString(key)) {
         // got a simple primary key
         const value = toDbOne(key)
         if (value === null) {
           throw Error('please provide an actual value for partition key')
         }
-        // FIXME: should work  without cast - because keyof T must be a string or symbol (error exists since update to  2.9.x -> check in a later version, there are some open issues)
-        idOb[<string>metadata.getPartitionKey()] = value
+
+        idOb[metadata.getPartitionKey()] = value
       } else if (isObject(key) && key.partitionKey !== undefined && key.partitionKey !== null) {
         // got a composite primary key
 
@@ -67,15 +68,17 @@ export class BatchGetRequest {
         if (mappedPartitionKey === null) {
           throw Error('please provide an actual value for partition key')
         }
-        idOb[<string>metadata.getPartitionKey()] = mappedPartitionKey
+        idOb[metadata.getPartitionKey()] = mappedPartitionKey
 
         // sort key
         const mappedSortKey = toDbOne(key.sortKey)
         if (mappedSortKey === null) {
           throw Error('please provide an actual value for partition key')
         }
 
-        idOb[<string>metadata.getSortKey()] = mappedSortKey
+        if (hasSortKey(metadata)) {
+          idOb[metadata.getSortKey()] = mappedSortKey
+        }
       } else {
         throw new Error('a key must either be a string or a PrimaryKey')
       }

src/dynamo/batchget/batch-get.request.ts

@@ -88,7 +88,7 @@ export function buildFilterExpression(
   // check if provided values are valid for given operator
   validateValues(operator, values)
 
-  // load property metadat if model metadata was provided
+  // load property metadata if model metadata was provided
   let propertyMetadata: PropertyMetadata<any> | undefined
   if (metadata) {
     propertyMetadata = metadata.forProperty(attributePath)
@@ -150,7 +150,7 @@ function buildInConditionExpression(
   existingValueNames: string[] | undefined,
   propertyMetadata: PropertyMetadata<any> | undefined,
 ): Expression {
-  const attributeValues: Attributes = (<any[]>values[0])
+  const attributeValues: Attributes<any> = (<any[]>values[0])
     .map(value => toDbOne(value, propertyMetadata))
     .reduce(
       (result, mappedValue: Attribute | null, index: number) => {
@@ -159,7 +159,7 @@ function buildInConditionExpression(
         }
         return result
       },
-      <Attributes>{},
+      <Attributes<any>>{},
     )
 
   const inStatement = (<any[]>values[0]).map((value: any, index: number) => `${valuePlaceholder}_${index}`).join(', ')
@@ -180,7 +180,7 @@ function buildBetweenConditionExpression(
   existingValueNames: string[] | undefined,
   propertyMetadata: PropertyMetadata<any> | undefined,
 ): Expression {
-  const attributes: Attributes = {}
+  const attributes: Attributes<any> = {}
   const mappedValue1 = toDbOne(values[0], propertyMetadata)
   const mappedValue2 = toDbOne(values[1], propertyMetadata)
 
@@ -224,7 +224,7 @@ function buildDefaultConditionExpression(
     statement = [namePlaceholder, operator, valuePlaceholder].join(' ')
   }
 
-  const attributes: Attributes = {}
+  const attributes: Attributes<any> = {}
   if (hasValue) {
     let attribute: Attribute | null
     switch (operator) {

src/dynamo/expression/condition-expression-builder.ts

@@ -13,7 +13,7 @@ export function resolveAttributeValueNameConflicts(
   expression: Expression,
   params: QueryInput | ScanInput | UpdateItemInput,
 ): Expression {
-  let attributeValues: Attributes = {}
+  let attributeValues: Attributes<any> = {}
   let statement: string = expression.statement
 
   if (params.ExpressionAttributeValues) {

src/dynamo/expression/functions/resolve-attribute-value-name-conflicts.function.ts

@@ -25,44 +25,55 @@ import { buildUpdateExpression } from './update-expression-builder'
 /**
  * Adds a condition to the given query.
  */
-export function addCondition<T extends BaseRequest<any, any>>(
+export function addCondition<R extends BaseRequest<any, any>>(
   expressionType: ExpressionType,
   attributePath: string,
-  request: T,
+  request: R,
   metadata?: Metadata<any>,
-): RequestConditionFunction<T> {
+): RequestConditionFunction<R> {
   const f = (operator: ConditionOperator) => {
-    return (...values: any[]): T => {
+    return (...values: any[]): R => {
       return doAddCondition(expressionType, attributePath, request, metadata, operator, ...values)
     }
   }
 
-  return createConditionFunctions<RequestConditionFunction<T>>(f)
+  return createConditionFunctions<RequestConditionFunction<R>>(f)
 }
 
-export function addSortKeyCondition<T extends BaseRequest<any, any>>(
-  keyName: string,
-  request: T,
-  metadata?: Metadata<any>,
-): RequestSortKeyConditionFunction<T> {
+export function addSortKeyCondition<R extends BaseRequest<any, any>>(
+  keyName: keyof any,
+  request: R,
+): RequestSortKeyConditionFunction<R>
+
+export function addSortKeyCondition<T, R extends BaseRequest<T, any>>(
+  keyName: keyof T,
+  request: R,
+  metadata: Metadata<T>,
+): RequestSortKeyConditionFunction<R>
+
+export function addSortKeyCondition<T, R extends BaseRequest<T, any>>(
+  keyName: keyof T,
+  request: R,
+  metadata?: Metadata<T>,
+): RequestSortKeyConditionFunction<R> {
   const f = (operator: ConditionOperator) => {
-    return (...values: any[]): T => {
-      return doAddCondition('KeyConditionExpression', keyName, request, metadata, operator, ...values)
+    return (...values: any[]): R => {
+      return doAddCondition('KeyConditionExpression', <string>keyName, request, metadata, operator, ...values)
     }
   }
 
   // only a subset of available operators are supported for sort keys
   return createConditionFunctions(f, '=', '<=', '<', '>', '>=', 'begins_with', 'BETWEEN')
 }
 
-export function doAddCondition<T extends BaseRequest<any, any>>(
+export function doAddCondition<T, R extends BaseRequest<T, any>>(
   expressionType: ExpressionType,
   attributePath: string,
-  request: T,
-  metadata: Metadata<any> | undefined,
+  request: R,
+  metadata: Metadata<T> | undefined,
   operator: ConditionOperator,
   ...values: any[]
-): T {
+): R {
   const copy = [...values]
   const existingValueKeys = request.params.ExpressionAttributeValues
     ? Object.keys(request.params.ExpressionAttributeValues)
@@ -73,13 +84,30 @@ export function doAddCondition<T extends BaseRequest<any, any>>(
   return request
 }
 
-export function addPartitionKeyCondition<T extends BaseRequest<any, any>>(
-  keyName: string,
+export function addPartitionKeyCondition<R extends BaseRequest<any, any>>(
+  keyName: keyof any,
   keyValue: any,
-  request: T,
-  metadata?: Metadata<any>,
-): T {
-  return addSortKeyCondition(keyName, request, metadata).equals(keyValue)
+  request: R,
+): R
+
+export function addPartitionKeyCondition<T, R extends BaseRequest<T, any>>(
+  keyName: keyof T,
+  keyValue: any,
+  request: R,
+  metadata: Metadata<T>,
+): R
+
+export function addPartitionKeyCondition<T, R extends BaseRequest<T, any>>(
+  keyName: keyof T,
+  keyValue: any,
+  request: R,
+  metadata?: Metadata<T>,
+): R {
+  if (metadata) {
+    return addSortKeyCondition(keyName, request, metadata).equals(keyValue)
+  } else {
+    return addSortKeyCondition(keyName, request).equals(keyValue)
+  }
 }
 
 export function updateDefinitionFunction(attributePath: string): UpdateExpressionDefinitionChain

src/dynamo/expression/request-expression-builder.ts

@@ -2,6 +2,6 @@ import { Attributes } from '../../../mapper/type/attribute.type'
 
 export interface Expression {
   attributeNames: { [key: string]: string }
-  attributeValues: Attributes
+  attributeValues: Attributes<any>
   statement: string
 }

src/dynamo/expression/type/expression.type.ts

@@ -133,7 +133,7 @@ function buildDefaultExpression(
 
   const hasValue = !isNoValueAction(operator.action)
 
-  const attributes: Attributes = {}
+  const attributes: Attributes<any> = {}
   if (hasValue) {
     const attribute: Attribute | null = toDbOne(values[0], propertyMetadata)
 

src/dynamo/expression/update-expression-builder.ts

@@ -20,7 +20,7 @@ export abstract class BaseRequest<
   readonly params: I
   readonly modelClazz: ModelConstructor<T>
 
-  private metadata: Metadata<T>
+  readonly metadata: Metadata<T>
 
   constructor(dynamoRx: DynamoRx, modelClazz: ModelConstructor<T>, tableName: string) {
     this.dynamoRx = dynamoRx
@@ -33,14 +33,7 @@ export abstract class BaseRequest<
     this.params = <I>{
       TableName: tableName,
     }
-  }
-
-  get metaData(): Metadata<T> {
-    if (!this.metadata) {
-      this.metadata = metadataForClass(this.modelClazz)
-    }
-
-    return this.metadata
+    this.metadata = metadataForClass(this.modelClazz)
   }
 
   abstract execFullResponse(): Observable<any>