first base implementation of decorator and mapper

Author: michaelwittwer

.editorconfig

@@ -6,7 +6,7 @@ end_of_line = lf
 charset = utf-8
 trim_trailing_whitespace = true
 insert_final_newline = true
-max_line_length = 100
+max_line_length = 170
 indent_size = 2
 
 [*.md]

README.md

@@ -9,6 +9,75 @@
 
 A starter project that makes creating a TypeScript library extremely easy.
 
+## Object Mapper
+
+#### Decorators
+Decorators are used to add some metadata to our model classes required by the mapper for some special cases.
+
+This is an experimental feature and requires to set the
+ 
+- "experimentalDecorators": true
+- "emitDecoratorMetadata": true
+
+compiler options.
+Additionally we rely on the reflect-metadata (https://www.npmjs.com/package/reflect-metadata) package for reflection api.
+
+To get started with decorators just add a @Model() Decorator to any ts class. By default this enables the custom mapping functionality
+and will get you started to work with Dynamo DB.
+
+We make heavy usage of compile time informations about our models and the property types.
+ES6 types like Set, Map will be mapped to Object when calling for the type via Reflect.get, so we need some extra info.
+
+Along the way we will probably need some extra features. Here is a list of these:
+
+**Custom TableName**
+@Model({tableName: tableName})
+
+
+#### Types
+The type defines how a value will be mapped. Types can be defined using decorators (for complex types) or we use one of the following methods:
+fromDB  ->  use default for DynamoDB type (see type table)
+toDB    ->  use property value to resolve the type
+
+design:type
+String, Number, Boolean, Undefined, Object
+
+unsupported
+Set, Map, Date, moment.Moment
+
+
+#### Dynamo DB
+
+To map an js object into the attribute map required by dynamodb requests, we implement our very oppinionated custom mapper.
+We use the DynamoDB Document Mapper to map all «default» types to dynamodb attribute values.
+
+There are some custom requirements for these cases:
+
+- MomentJs Dates
+- Use ES6 Map, Set types
+
+Mapper Strategy:
+
+-> To DB
+1) check if we have some property metadata
+      
+      YES                                                      NO
+      
+      isCustomType                                             document client can map (check with typeof propertyValue for additional security)
+      
+      YES                 NO
+      
+      custom mapping      document client can map
+-> From DB
+
+
+## Open Tasks
+Null Values?
+How does DynamoDb treat empty lists, sets or emtpy strings?
+
+## Node Project Template
+
+
 ### Usage
 
 ```bash

attribute-map.type.ts

@@ -0,0 +1,3 @@
+import { AttributeValue } from 'aws-sdk/clients/dynamodb';
+
+export type AttributeMap<T> = {[key in keyof T]: AttributeValue};

package.json

@@ -49,6 +49,7 @@
     }
   },
   "jest": {
+    "testEnvironment": "node",
     "transform": {
       ".(ts|tsx)": "<rootDir>/node_modules/ts-jest/preprocessor.js"
     },
@@ -72,37 +73,44 @@
     }
   },
   "devDependencies": {
-    "@types/jest": "^20.0.0",
-    "@types/node": "^8.0.0",
+    "@types/debug": "^0.0.30",
+    "@types/jest": "^20.0.6",
+    "@types/lodash": "^4.14.71",
+    "@types/node": "^8.0.19",
     "colors": "^1.1.2",
     "commitizen": "^2.9.6",
     "coveralls": "^2.13.1",
-    "cross-env": "^5.0.1",
+    "cross-env": "^5.0.4",
     "cz-conventional-changelog": "^2.0.0",
     "husky": "^0.14.0",
     "jest": "^20.0.4",
-    "lint-staged": "^4.0.0",
+    "lint-staged": "^4.0.3",
     "lodash.camelcase": "^4.3.0",
     "prettier": "^1.4.4",
     "prompt": "^1.0.0",
     "replace-in-file": "^2.5.0",
     "rimraf": "^2.6.1",
-    "rollup": "^0.43.1",
-    "rollup-plugin-commonjs": "^8.0.2",
+    "rollup": "^0.45.2",
+    "rollup-plugin-commonjs": "^8.1.0",
     "rollup-plugin-node-resolve": "^3.0.0",
     "rollup-plugin-sourcemaps": "^0.4.2",
     "semantic-release": "^6.3.6",
-    "ts-jest": "^20.0.6",
+    "ts-jest": "^20.0.10",
     "ts-node": "^3.0.6",
     "tsc-watch": "^1.0.5",
-    "tslint": "^5.4.3",
-    "tslint-config-prettier": "^1.1.0",
+    "tslint": "^5.6.0",
+    "tslint-config-prettier": "^1.3.0",
     "tslint-config-standard": "^6.0.0",
-    "typedoc": "^0.7.1",
+    "typedoc": "^0.8.0",
     "typescript": "^2.3.4",
-    "validate-commit-msg": "^2.12.2"
+    "validate-commit-msg": "^2.14.0"
   },
   "dependencies": {
-    "aws-sdk": "^2.91.0"
+    "aws-sdk": "^2.91.0",
+    "core-js": "^2.5.0",
+    "debug": "^2.6.8",
+    "lodash": "^4.17.4",
+    "moment": "^2.18.1",
+    "reflect-metadata": "^0.1.10"
   }
 }

src/decorators/decorators.ts

@@ -0,0 +1,32 @@
+import "reflect-metadata"
+
+// these reflection keys are built in using the reflect-metadata library
+export const KEY_TYPE = "design:type"
+export const KEY_PARAMETER = "design:paramtypes"
+export const KEY_RETURN_TYPE = "design:returntype"
+
+export const getMetadataType = makeMetadataGetter(KEY_TYPE)
+
+export function makeMetadataGetter(
+  metadataKey: string
+): (target: any, targetKey?: string) => any {
+  return function(target: any, targetKey?: string) {
+    return Reflect.getMetadata(metadataKey, target, targetKey)
+  }
+}
+
+/**
+ * Property index configuration
+ */
+// export interface IModelAttributeIndex {
+//   name: string
+//   unique?: boolean
+//   isSecondaryKey?: boolean
+//   sortKey?: string
+// }
+
+// export function Property(opts: AttributeOptions): PropertyDecorator {
+//   return (target: Object, propertyKey: string | symbol) => {
+//
+//   };
+// }

src/decorators/metadata.ts

@@ -0,0 +1,50 @@
+import { ModelClass } from "../model/model"
+import { ModelMetadata } from "./model-metadata.model"
+import { KEY_MODEL } from "./model.decorator"
+import { PropertyMetadata } from "./property-metadata.model"
+
+export class Metadata<T> {
+  readonly modelOptions: ModelMetadata
+
+  constructor(modelClass: ModelClass<T>) {
+    this.modelOptions = Reflect.getMetadata(KEY_MODEL, modelClass)
+  }
+
+  forProperty(propertyKey: string): PropertyMetadata | undefined {
+    let options: PropertyMetadata | undefined
+
+    if (this.modelOptions.properties) {
+      options = this.modelOptions.properties.find(
+        property => property.key === propertyKey
+      )
+    }
+
+    return options
+  }
+}
+
+export class MetadataHelper {
+  static get<T>(modelClass: ModelClass<T>): Metadata<T> {
+    return new Metadata(modelClass)
+  }
+
+  static forModel<T>(modelClass: ModelClass<T>): ModelMetadata {
+    return Reflect.getMetadata(KEY_MODEL, modelClass)
+  }
+
+  static forProperty<T>(
+    modelClass: ModelClass<T>,
+    propertyKey: keyof T
+  ): PropertyMetadata {
+    let modelOptions = Reflect.getMetadata(KEY_MODEL, modelClass)
+
+    let options: PropertyMetadata | undefined
+    if (modelOptions.properties) {
+      options = modelOptions.properties.find(
+        property => property.key === propertyKey
+      )
+    }
+
+    return options
+  }
+}

src/decorators/model-metadata.model.ts

@@ -0,0 +1,17 @@
+import { PropertyMetadata } from "./property-metadata.model"
+
+export interface ModelData {
+  tableName?: string
+}
+
+/**
+ * Options provided to model
+ * decorator annotation
+ */
+export interface ModelMetadata {
+  clazzName?: string
+  clazz?: any
+  tableName?: string
+  properties?: PropertyMetadata[]
+  transientProperties?: string[]
+}

src/decorators/model.decorator.ts

@@ -0,0 +1,49 @@
+import { kebabCase } from "lodash"
+import { getMetadataType } from "./decorators"
+import { ModelData, ModelMetadata } from "./model-metadata.model"
+import { PropertyMetadata } from "./property-metadata.model"
+import { KEY_PROPERTY } from "./property.decorator"
+// FIXME should be optional dependency
+import moment from "moment"
+
+export const KEY_MODEL = "sc-reflect:model"
+
+export function Model(opts: ModelData = {}): ClassDecorator {
+  return function(constructor: Function) {
+    // Make sure everything is valid
+    const classType = getMetadataType(constructor)
+    const type = constructor as any
+
+    // get all the properties with @Property() annotation
+    const properties: PropertyMetadata[] = Reflect.getOwnMetadata(
+      KEY_PROPERTY,
+      constructor
+    )
+
+    const transientProperties: string[] =
+      properties && properties.length
+        ? properties
+            .filter(property => property.transient === true)
+            .map(property => property.key)
+        : []
+
+    const finalOpts = Object.assign<
+      Partial<ModelMetadata>,
+      Partial<ModelMetadata>,
+      Partial<ModelMetadata>
+    >(
+      {},
+      {
+        clazz: constructor,
+        clazzName: type.name,
+        tableName: kebabCase(type.name),
+        properties,
+        transientProperties
+      },
+      opts
+    )
+
+    console.log(`Decorating: ${finalOpts.clazzName}`, finalOpts)
+    Reflect.defineMetadata(KEY_MODEL, finalOpts, constructor)
+  }
+}

src/decorators/partition-key.decorator.ts

@@ -0,0 +1,9 @@
+import { PropertyMetadata } from "./property-metadata.model"
+import { initOrUpdateProperty, KEY_PROPERTY } from "./property.decorator"
+
+// FIXME check for type of partition key only some scalars are allowed
+export function PartitionKey(): PropertyDecorator {
+  return function(target: Object, propertyKey: string) {
+    initOrUpdateProperty({ partitionKey: true }, target, propertyKey)
+  }
+}

src/decorators/property-data.model.ts

@@ -0,0 +1,4 @@
+export interface PropertyData {
+  // the name of property how it is named in dynamoDb
+  name: string
+}