fix(loki): implement deep clone as default clone option (#44)

* remove old shallow clone and just use the new shallow assign as shallow
* move functions from utils and remove the file

Author: Viatorus

packages/loki/spec/generic/cloning.spec.ts

@@ -108,7 +108,27 @@ describe("cloning behavior", () => {
       const cdb = new Loki("cloningEnabled");
       const citems = cdb.addCollection<User>("items", {
         clone: true
-        //, clonemethod: "parse-stringify"
+      });
+
+      citems.insert({name: "mjolnir", owner: "thor", maker: "dwarves"});
+      citems.insert({name: "gungnir", owner: "odin", maker: "elves"});
+      citems.insert({name: "tyrfing", owner: "Svafrlami", maker: "dwarves"});
+      citems.insert({name: "draupnir", owner: "odin", maker: "elves"});
+
+      // just to prove that resultset.data() is not giving the user the actual object reference we keep internally
+      // we will modify the object and see if future requests for that object show the change
+      const mj = citems.find({name: "mjolnir"})[0];
+      mj.maker = "the dwarves";
+
+      const mj2 = citems.find({name: "mjolnir"})[0];
+      expect(mj2.maker).toBe("dwarves");
+    });
+
+    it("works with stringify", () => {
+      const cdb = new Loki("cloningEnabled");
+      const citems = cdb.addCollection<User>("items", {
+        clone: true,
+        cloneMethod: CloneMethod.PARSE_STRINGIFY
       });
 
       citems.insert({name: "mjolnir", owner: "thor", maker: "dwarves"});
@@ -131,7 +151,6 @@ describe("cloning behavior", () => {
       const cdb = new Loki("cloningEnabled");
       const citems = cdb.addCollection<User>("items", {
         clone: true
-        //, clonemethod: "parse-stringify"
       });
 
       citems.insert({name: "mjolnir", owner: "thor", maker: "dwarves"});
@@ -155,7 +174,6 @@ describe("cloning behavior", () => {
       const cdb = new Loki("cloningEnabled");
       const citems = cdb.addCollection<User>("items", {
         clone: true
-        //, clonemethod: "parse-stringify"
       });
 
       citems.insert({name: "mjolnir", owner: "thor", maker: "dwarves"});
@@ -179,7 +197,6 @@ describe("cloning behavior", () => {
       const citems = cdb.addCollection<User>("items", {
         clone: true,
         unique: ["name"]
-        //, clonemethod: "parse-stringify"
       });
 
       citems.insert({name: "mjolnir", owner: "thor", maker: "dwarves"});
@@ -221,7 +238,6 @@ describe("cloning behavior", () => {
       const cdb = new Loki("cloningEnabled");
       const citems = cdb.addCollection<User>("items", {
         clone: true
-        //, clonemethod: "parse-stringify"
       });
 
       citems.insert({name: "mjolnir", owner: "thor", maker: "dwarves"});
@@ -245,7 +261,6 @@ describe("cloning behavior", () => {
       // within resultset.data() options
       const mj = items.chain().find({name: "mjolnir"}).data({
         forceClones: true
-        //,forceCloneMethod: 'parse-stringify'
       })[0];
       mj.maker = "the dwarves";
 

packages/loki/spec/generic/transforms.spec.ts

@@ -155,7 +155,7 @@ describe("transforms", () => {
       expect(items.chain(tx1, {foo: 5}) as any as number).toBe(7);
       // params will cause a recursive shallow clone of objects before substitution
       expect(items.chain(tx2, {minimumAge: 4}) as any as number).toBe(7);
-      
+
       // make sure original transform is unchanged
       expect(tx2[0].type).toEqual("find");
       expect(tx2[0].value.age.$gt).toEqual("[%lktxp]minimumAge");

packages/loki/src/clone.ts

@@ -1,4 +1,63 @@
-export type ANY = any;
+export enum CloneMethod {
+  PARSE_STRINGIFY,
+  DEEP,
+  SHALLOW,
+  SHALLOW_ASSIGN,
+  SHALLOW_RECURSE_OBJECTS,
+}
+
+function add(copy: any, key: any, value: any) {
+  if (copy instanceof Array) {
+    copy.push(value);
+    return copy[copy.length - 1];
+  }
+  else if (copy instanceof Object) {
+    copy[key] = value;
+    return copy[key];
+  }
+}
+
+function walk(target: any, copy: any) {
+  for (let key in target) {
+    let obj = target[key];
+    if (obj instanceof Date) {
+      let value = new Date(obj.getTime());
+      add(copy, key, value);
+    }
+    else if (obj instanceof Function) {
+      let value = obj;
+      add(copy, key, value);
+    }
+    else if (obj instanceof Array) {
+      let value: any[] = [];
+      let last = add(copy, key, value);
+      walk(obj, last);
+    }
+    else if (obj instanceof Object) {
+      let value = {};
+      let last = add(copy, key, value);
+      walk(obj, last);
+    }
+    else {
+      let value = obj;
+      add(copy, key, value);
+    }
+  }
+}
+
+// Deep copy from Simeon Velichkov.
+function deepCopy(target: any) {
+  if (/number|string|boolean/.test(typeof target)) {
+    return target;
+  }
+  if (target instanceof Date) {
+    return new Date(target.getTime());
+  }
+
+  const copy = (target instanceof Array) ? [] : {};
+  walk(target, copy);
+  return copy;
+}
 
 export function clone<T>(data: T, method: CloneMethod = CloneMethod.PARSE_STRINGIFY): T {
   if (data === null || data === undefined) {
@@ -11,19 +70,10 @@ export function clone<T>(data: T, method: CloneMethod = CloneMethod.PARSE_STRING
     case CloneMethod.PARSE_STRINGIFY:
       cloned = JSON.parse(JSON.stringify(data));
       break;
-    case CloneMethod.JQUERY_EXTEND_DEEP:
-      //cloned = jQuery.extend(true, {}, data);
-      // TODO
+    case CloneMethod.DEEP:
+      cloned = deepCopy(data);
       break;
     case CloneMethod.SHALLOW:
-      // more compatible method for older browsers
-      cloned = Object.create(data.constructor.prototype);
-      Object.keys(data).map((i) => {
-        cloned[i] = data[i];
-      });
-      break;
-    case CloneMethod.SHALLOW_ASSIGN:
-      // should be supported by newer environments/browsers
       cloned = Object.create(data.constructor.prototype);
       Object.assign(cloned, data);
       break;
@@ -45,28 +95,3 @@ export function clone<T>(data: T, method: CloneMethod = CloneMethod.PARSE_STRING
 
   return cloned as any as T;
 }
-
-export function cloneObjectArray(objarray: object[], method: CloneMethod) {
-  let i;
-  const result = [];
-
-  if (method === CloneMethod.PARSE_STRINGIFY) {
-    return clone(objarray, method);
-  }
-
-  i = objarray.length - 1;
-
-  for (; i <= 0; i--) {
-    result.push(clone(objarray[i], method));
-  }
-
-  return result;
-}
-
-export enum CloneMethod {
-  PARSE_STRINGIFY,
-  JQUERY_EXTEND_DEEP,
-  SHALLOW,
-  SHALLOW_ASSIGN,
-  SHALLOW_RECURSE_OBJECTS,
-}

packages/loki/src/collection.ts

@@ -2,10 +2,9 @@ import {LokiEventEmitter} from "./event_emitter";
 import {UniqueIndex} from "./unique_index";
 import {Resultset} from "./resultset";
 import {DynamicView} from "./dynamic_view";
-import {clone, CloneMethod} from "./clone";
 import {ltHelper, gtHelper, aeqHelper} from "./helper";
 import {Loki} from "./loki";
-import {copyProperties} from "./utils";
+import {clone, CloneMethod} from "./clone";
 import {Doc, Dict, Query} from "../../common/types";
 import {FullTextSearch} from "../../full-text-search/src/full_text_search";
 import {PLUGINS} from "../../common/plugin";
@@ -172,7 +171,7 @@ export class Collection<E extends object = object> extends LokiEventEmitter {
    * @param {boolean} [options.disableDeltaChangesApi=true] - set to false to enable Delta Changes API (requires Changes API, forces cloning)
    * @param {boolean} [options.clone=false] - specify whether inserts and queries clone to/from user
    * @param {boolean} [options.serializableIndices =true] - converts date values on binary indexed property values are serializable
-   * @param {string} [options.cloneMethod='parse-stringify'] - 'parse-stringify', 'jquery-extend-deep', 'shallow'
+   * @param {string} [options.cloneMethod=CloneMethod.DEEP] - the clone method
    * @param {number} [options.transactional=false] - ?
    * @param {number} options.ttl - ?
    * @param {number} options.ttlInterval - time interval for clearing out 'aged' documents; not set by default.
@@ -239,7 +238,7 @@ export class Collection<E extends object = object> extends LokiEventEmitter {
     this.disableDeltaChangesApi = options.disableDeltaChangesApi !== undefined ? options.disableDeltaChangesApi : true;
 
     // .
-    this.cloneMethod = options.cloneMethod !== undefined ? options.cloneMethod : CloneMethod.PARSE_STRINGIFY;
+    this.cloneMethod = options.cloneMethod !== undefined ? options.cloneMethod : CloneMethod.DEEP;
     if (this.disableChangesApi) {
       this.disableDeltaChangesApi = true;
     }
@@ -359,7 +358,7 @@ export class Collection<E extends object = object> extends LokiEventEmitter {
     coll.asyncListeners = obj.asyncListeners;
     coll.disableChangesApi = obj.disableChangesApi;
     coll.cloneObjects = obj.cloneObjects;
-    coll.cloneMethod = obj.cloneMethod || "parse-stringify";
+    coll.cloneMethod = obj.cloneMethod || CloneMethod.DEEP;
     coll.changes = obj.changes;
 
     coll.dirty = (options && options.retainDirtyFlags === true) ? obj.dirty : false;
@@ -368,7 +367,11 @@ export class Collection<E extends object = object> extends LokiEventEmitter {
       const collOptions = options[coll.name];
 
       if (collOptions.proto) {
-        let inflater = collOptions.inflate || copyProperties;
+        let inflater = collOptions.inflate || ((src: object, dest: object) => {
+          for (let prop in src) {
+            dest[prop] = src[prop];
+          }
+        });
 
         return (data: ANY) => {
           const collObj = new (collOptions.proto)();

packages/loki/src/loki.ts

@@ -260,7 +260,7 @@ export class Loki extends LokiEventEmitter {
    * @param {boolean} [options.asyncListeners=false] - whether listeners are called asynchronously
    * @param {boolean} [options.disableChangesApi=true] - set to false to enable Changes Api
    * @param {boolean} [options.clone=false] - specify whether inserts and queries clone to/from user
-   * @param {string} [options.cloneMethod='parse-stringify'] - 'parse-stringify', 'jquery-extend-deep', 'shallow, 'shallow-assign'
+   * @param {string} [options.cloneMethod=CloneMethod.DEEP] - the clone method
    * @param {int} options.ttlInterval - time interval for clearing out 'aged' documents; not set by default.
    * @returns {Collection} a reference to the collection which was just added
    */

packages/loki/src/resultset.ts

@@ -1,6 +1,5 @@
-import {clone, CloneMethod} from "./clone";
 import {Collection} from "./collection";
-import {resolveTransformParams} from "./utils";
+import {clone, CloneMethod} from "./clone";
 import {ltHelper, gtHelper, aeqHelper, sortHelper} from "./helper";
 import {Doc, Query} from "../../common/types";
 
@@ -17,6 +16,45 @@ export type ANY = any;
 
  */
 
+// used to recursively scan hierarchical transform step object for param substitution
+function resolveTransformObject(subObj: object, params: object, depth: number = 0) {
+  let prop;
+  let pname;
+
+  if (++depth >= 10) return subObj;
+
+  for (prop in subObj) {
+    if (typeof subObj[prop] === "string" && subObj[prop].indexOf("[%lktxp]") === 0) {
+      pname = subObj[prop].substring(8);
+      if (params[pname] !== undefined) {
+        subObj[prop] = params[pname];
+      }
+    } else if (typeof subObj[prop] === "object") {
+      subObj[prop] = resolveTransformObject(subObj[prop], params, depth);
+    }
+  }
+
+  return subObj;
+}
+
+// top level utility to resolve an entire (single) transform (array of steps) for parameter substitution
+function resolveTransformParams(transform: any, params: object) {
+  let idx;
+  let clonedStep;
+  const resolvedTransform = [];
+
+  if (typeof params === "undefined") return transform;
+
+  // iterate all steps in the transform array
+  for (idx = 0; idx < transform.length; idx++) {
+    // clone transform so our scan/replace can operate directly on cloned transform
+    clonedStep = clone(transform[idx], CloneMethod.SHALLOW_RECURSE_OBJECTS);
+    resolvedTransform.push(resolveTransformObject(clonedStep, params));
+  }
+
+  return resolvedTransform;
+}
+
 function containsCheckFn(a: ANY) {
   if (typeof a === "string" || Array.isArray(a)) {
     return (b: ANY) => (a as string).indexOf(b) !== -1;
@@ -1014,10 +1052,10 @@ export class Resultset<E extends object = object> {
       forceCloneMethod = CloneMethod.SHALLOW;
     }
 
-    // if collection has delta changes active, then force clones and use 'parse-stringify' for effective change tracking of nested objects
+    // if collection has delta changes active, then force clones and use CloneMethod.DEEP for effective change tracking of nested objects
     if (!this.collection.disableDeltaChangesApi) {
       forceClones = true;
-      forceCloneMethod = CloneMethod.PARSE_STRINGIFY;
+      forceCloneMethod = CloneMethod.DEEP;
     }
 
     // if this has no filters applied, just return collection.data
@@ -1140,7 +1178,7 @@ export class Resultset<E extends object = object> {
    */
   //eqJoin<T extends object>(joinData: T[] | Resultset<T>, leftJoinKey: string | ((obj: E) => string), rightJoinKey: string | ((obj: T) => string)): Resultset<{ left: E; right: T; }>;
   // eqJoin<T extends object, U extends object>(joinData: T[] | Resultset<T>, leftJoinKey: string | ((obj: E) => string), rightJoinKey: string | ((obj: T) => string), mapFun?: (a: E, b: T) => U, dataOptions?: Resultset.DataOptions): Resultset<U> {
-  eqJoin(joinData: ANY, leftJoinKey: string | Function, rightJoinKey: string | Function, mapFun?: Function, dataOptions?: ANY) : ANY {
+  eqJoin(joinData: ANY, leftJoinKey: string | Function, rightJoinKey: string | Function, mapFun?: Function, dataOptions?: ANY): ANY {
 // eqJoin<T extends object, U extends object>(joinData: T[] | Resultset<T>, leftJoinKey: string | ((obj: E) => string), rightJoinKey: string | ((obj: T) => string), mapFun?: (a: E, b: T) => U, dataOptions?: Resultset.DataOptions): Resultset<U> {
     let leftData = [];
     let leftDataLength;
@@ -1204,7 +1242,7 @@ export class Resultset<E extends object = object> {
    * @param {boolean} dataOptions.forceClones - forcing the return of cloned objects to your map object
    * @param {string} dataOptions.forceCloneMethod - Allows overriding the default or collection specified cloning method.
    */
-  map<U extends object>(mapFun: (obj: E, index: number, array: E[]) => U, dataOptions?: Resultset.DataOptions) : Resultset<U> {
+  map<U extends object>(mapFun: (obj: E, index: number, array: E[]) => U, dataOptions?: Resultset.DataOptions): Resultset<U> {
     let data = this.data(dataOptions).map(mapFun);
     //return return a new resultset with no filters
     this.collection = new Collection("mappedData");