Merge pull request #32 from osmanmesutozcan/remove-class-transformer-internal

remove class transformer

Author: osmanmesutozcan

package.json

@@ -1,7 +1,8 @@
 {
   "name": "@xanthous/dgraph-orm",
-  "version": "0.3.3",
+  "version": "0.4.0",
   "description": "dgraph ORM in TypeScript",
+  "types": "dist/index.d.ts",
   "main": "dist/index.js",
   "author": "Xanthous Tech Developers <hi@x-tech.io>",
   "contributors": [
@@ -58,7 +59,6 @@
     "@types/debug": "^4.1.5",
     "@types/n3": "^1.1.1",
     "@xanthous/n3": "^1.3.5",
-    "class-transformer": "^0.2.3",
     "class-validator": "^0.10.2",
     "debug": "^4.1.1",
     "dgraph-js": "^2.0.2",

src/decorator/predicate.ts

@@ -1,5 +1,3 @@
-import { Exclude } from 'class-transformer';
-
 import { MetadataStorage } from '../metadata/storage';
 import { Constructor } from '../utils/class';
 
@@ -16,9 +14,6 @@ export function Predicate(options: Predicate.IOptions): PropertyDecorator {
       name = `${target.constructor.name}.${propertyName}`;
     }
 
-    // Exclude the predicates to prevent class-transformer from doing unnecessary stuff..
-    Exclude()(target, name);
-
     MetadataStorage.Instance.addPredicateMetadata({
       facet: options.facet,
       count: options.count !== undefined ? options.count : true,

src/decorator/property.ts

@@ -1,5 +1,3 @@
-import { Expose } from 'class-transformer';
-
 import { MetadataStorage } from '../metadata/storage';
 import { PropertyType, PropertyTypeUtils } from '../types/property';
 
@@ -58,17 +56,13 @@ export function Property(options: Property.IOptions = {}): PropertyDecorator {
       name = `${target.constructor.name}.${propertyName}`;
     }
 
-    // When we load data into the class, we will have a new property
-    // defined as the auto-generated name, we need to make sure property with predicate
-    // decorator returns the correct value.
-    Expose({ name, toClassOnly: true })(target, propertyName);
-
     MetadataStorage.Instance.addPropertyMetadata({
       type,
       name,
       isArray,
       target,
-      propertyName
+      propertyName,
+      default: options.default
     });
   };
 }
@@ -93,6 +87,11 @@ export namespace Property {
      * property lets user to reuse a global predicate between different nodes.
      */
     name?: string;
+
+    /**
+     * Default value to fallback to.
+     */
+    default?: number | boolean | string;
   }
 }
 

src/decorator/uid.ts

@@ -1,4 +1,3 @@
-import { Expose } from 'class-transformer';
 import { MetadataStorage } from '../metadata/storage';
 
 /**
@@ -9,7 +8,6 @@ import { MetadataStorage } from '../metadata/storage';
 export function Uid() {
   return function(target: Object, propertyName: string): void {
     // Expose the uid json property to class.
-    Expose({ name: 'uid', toClassOnly: true })(target, propertyName);
     MetadataStorage.Instance.addUidMetadata({ target, propertyName });
   };
 }

src/metadata/property.ts

@@ -36,6 +36,11 @@ export namespace PropertyMetadata {
      * Is the predicate an array type.
      */
     isArray: boolean;
+
+    /**
+     * Default value for the predicate.
+     */
+    default?: any;
   }
 }
 

src/transaction/diff-tracker.ts

@@ -19,10 +19,9 @@ export class DiffTracker {
    * Attaching a tracker on a property will make that property enumerable.
    */
   public trackProperty(target: Object, propertyName: string, diffKey?: string): Object {
-    this.ensureInstance(target, propertyName, diffKey || propertyName);
-
     const initialValue = Reflect.get(target, propertyName);
     if (initialValue !== undefined) {
+      this.ensureInstance(target, propertyName, diffKey || propertyName);
       this._instances.get(target)![propertyName].set(initialValue);
     }
 
@@ -33,9 +32,11 @@ export class DiffTracker {
       configurable: true,
       enumerable: true,
       set: function(value: any) {
+        tracker.ensureInstance(target, propertyName, diffKey || propertyName);
         tracker._instances.get(target)![propertyName].set(value);
       },
       get: function() {
+        tracker.ensureInstance(target, propertyName, diffKey || propertyName);
         return tracker._instances.get(target)![propertyName].get();
       }
     });

src/transaction/mutation-builder.ts

@@ -11,6 +11,7 @@ import quad = DataFactory.quad;
 import namedNode = DataFactory.namedNode;
 import literal = DataFactory.literal;
 import variable = DataFactory.variable;
+import { DiffValue } from './diff-tracker';
 
 /**
  * Dgraph type prefix to add on the new nodes.
@@ -132,24 +133,29 @@ export class MutationBuilder {
     }
 
     const quads: Quad[] = [];
-    const changes = this.diff.properties.getSets(target);
-    if (changes.length > 0) {
-      changes.forEach(c => {
-        const propertyMetadata = metadata.find(pm => pm.args.propertyName === c.key || pm.args.name === c.key);
+    const changes = this.diff.properties.getSets(target).reduce((acc, c) => {
+      acc.set(c.key, c);
+      return acc;
+    }, new Map<string, DiffValue<any>>());
 
-        if (!propertyMetadata) {
-          return;
-        }
+    metadata.forEach(pm => {
+      const change = changes.get(pm.args.propertyName) || changes.get(pm.args.name);
+
+      if (!change && !pm.args.default) {
+        return;
+      }
 
-        quads.push(
-          DataFactory.quad(
-            targetNode,
-            DataFactory.namedNode(c.key),
-            DataFactory.literal(c.get(), PropertyTypeUtils.getLiteralTypeNamedNode(propertyMetadata.args.type))
+      quads.push(
+        DataFactory.quad(
+          targetNode,
+          DataFactory.namedNode(change ? change.key : pm.args.name),
+          DataFactory.literal(
+            change ? change.get() : pm.args.default,
+            PropertyTypeUtils.getLiteralTypeNamedNode(pm.args.type)
           )
-        );
-      });
-    }
+        )
+      );
+    });
 
     return quads;
   }

src/transaction/transaction.ts

@@ -1,19 +1,19 @@
 import { Quad } from 'n3';
 import uniqid from 'uniqid';
-import { plainToClass } from 'class-transformer';
+
+import { DiffTracker } from './diff-tracker';
+import { FacetStorage } from './facet-storage';
+import { PredicateImpl } from './predicate-impl';
+import { MutationBuilder } from './mutation-builder';
 
 import { IPredicate } from '..';
 import { MetadataStorage } from '../metadata/storage';
 import { PredicateMetadata } from '../metadata/predicate';
 import { INode, IPlainPredicates } from '../types/data';
 import { Constructor } from '../utils/class';
 import { IObjectLiteral } from '../utils/type';
-
-import { DiffTracker } from './diff-tracker';
-import { FacetStorage } from './facet-storage';
-import { PredicateImpl } from './predicate-impl';
-import { MutationBuilder } from './mutation-builder';
 import { IterableWeakMap } from '../utils/iterator';
+import { transformer } from '../utils/transformer';
 
 /**
  * Create an environment for a mapped tree.
@@ -143,10 +143,7 @@ export class Transaction<T extends Object, V> implements ITransaction<T> {
       }
 
       // Build the entry class
-      const ins: T = plainToClass(cls, pln, {
-        enableCircularCheck: true,
-        strategy: 'exposeAll'
-      });
+      const ins: T = transformer(cls, pln);
 
       // Keep reference to the instance so in case of circular we can simply get it from storage and complete the circle.
       storage.set(pln, ins);
@@ -271,7 +268,7 @@ export class Transaction<T extends Object, V> implements ITransaction<T> {
             return acc;
           }, {});
 
-          const facetInstance = plainToClass(facet!, plain);
+          const facetInstance = Object.assign(new facet!(), plain);
           FacetStorage.attach(propertyName, instance, children[Number(idx)], facetInstance);
 
           // Track each facet property in facet instance and reset it..
@@ -335,7 +332,7 @@ export interface ITransaction<T> {
   /**
    * Initialize a node object from data.
    */
-  nodeFor<N extends Object, V extends Object>(nodeCls: Constructor<N>, data: V): N;
+  nodeFor<N extends Object, V extends Object>(nodeCls: Constructor<N>, data: V & { uid?: string }): N;
 
   /**
    * Get set nQuads for transaction.

src/utils/class.ts

@@ -1,14 +1,4 @@
-import { Transform } from 'class-transformer';
-
 /**
  * A class constructor accepting arbitrary arguments.
  */
 export type Constructor<T = {}> = new (...args: any[]) => T;
-
-/**
- * Default Value Transform Decorator, need to use with `@Expose`
- * @param defaultValue default value to provide
- */
-export function DefaultValue(defaultValue: any): PropertyDecorator {
-  return Transform((value: any) => value || defaultValue, { toClassOnly: true });
-}

src/utils/transformer.ts

@@ -0,0 +1,25 @@
+import { Constructor } from './class';
+import { IObjectLiteral } from './type';
+import { MetadataStorage } from '../metadata/storage';
+
+export function transformer<T>(cls: Constructor<T>, plain: IObjectLiteral<T>): T {
+  const className = cls.name;
+  const instance = new cls();
+  Object.assign(instance, plain);
+
+  const properties = MetadataStorage.Instance.properties.get(className);
+  if (properties) {
+    for (const property of properties) {
+      (instance as any)[property.args.propertyName] = plain[property.args.name];
+    }
+  }
+
+  const uids = MetadataStorage.Instance.uids.get(className);
+  if (uids && uids.length > 0) {
+    for (const uid of uids) {
+      (instance as any)[uid.args.propertyName] = plain['uid'];
+    }
+  }
+
+  return instance;
+}