feat(loki): chained/transform map op now accepts 'dataOptions' for clone/removeMeta (#34)

(from techfort/LokiJS#618)

Author: Viatorus

packages/loki/spec/generic/transforms.spec.js

@@ -199,5 +199,103 @@ describe("transforms", () => {
 
     });
   });
+  describe("eqJoin step with dataOptions works", function () {
+    it("works", () => {
+      const db1 = new loki("testJoins");
+
+      const directors = db1.addCollection("directors");
+      const films = db1.addCollection("films");
+
+      directors.insert([
+        {name: "Martin Scorsese", directorId: 1},
+        {name: "Francis Ford Coppola", directorId: 2},
+        {name: "Steven Spielberg", directorId: 3},
+        {name: "Quentin Tarantino", directorId: 4}
+      ]);
+
+      films.insert([
+        {title: "Taxi", filmId: 1, directorId: 1},
+        {title: "Raging Bull", filmId: 2, directorId: 1},
+        {title: "The Godfather", filmId: 3, directorId: 2},
+        {title: "Jaws", filmId: 4, directorId: 3},
+        {title: "ET", filmId: 5, directorId: 3},
+        {title: "Raiders of the Lost Ark", filmId: 6, directorId: 3}
+      ]);
+
+      // Since our collection options do not specify cloning, this is only safe
+      // because we have cloned internal objects with dataOptions before modifying them.
+      function fdmap(left, right) {
+        // PhantomJS does not support es6 Object.assign
+        //left = Object.assign(left, right);
+        Object.keys(right).forEach((key) => {
+          left[key] = right[key];
+        });
+        return left;
+      }
+
+      // The 'joinData' in this instance is a Collection which we will call
+      //   data() on with the specified (optional) dataOptions on.
+      //   It could also be a resultset or data array.
+      // Our left side resultset which this transform is executed on will also
+      //   call data() with specified (optional) dataOptions.
+      films.addTransform("filmdirect", [
+        {
+          type: "eqJoin",
+          joinData: directors,
+          leftJoinKey: "directorId",
+          rightJoinKey: "directorId",
+          mapFun: fdmap,
+          dataOptions: {removeMeta: true}
+        }
+      ]);
+
+      // Although we removed all meta, the eqjoin inserts the resulting objects
+      // into a new volatile collection which would adds its own meta and loki.
+      // We don't care about these useless volatile data so grab results without it.
+      const results = films.chain("filmdirect").data({removeMeta: true});
+
+      expect(results.length).toEqual(6);
+      expect(results[0].title).toEqual("Taxi");
+      expect(results[0].name).toEqual("Martin Scorsese");
+      expect(results[5].title).toEqual("Raiders of the Lost Ark");
+      expect(results[5].name).toEqual("Steven Spielberg");
+      results.forEach((obj) => {
+        expect(Object.keys(obj).length).toEqual(4);
+      });
+    });
+  });
 
+  describe("map step with dataOptions works", function () {
+    it("works", () => {
+      const db1 = new loki("testJoins");
+
+      const c1 = db1.addCollection("c1");
+      c1.insert([{a: 1, b: 9}, {a: 2, b: 8}, {a: 3, b: 7}, {a: 4, b: 6}]);
+
+      // only safe because our 'removeMeta' option will clone objects passed in
+      function graftMap(obj) {
+        obj.c = obj.b - obj.a;
+        return obj;
+      }
+
+      const tx = [{
+        type: "map",
+        value: graftMap,
+        dataOptions: {removeMeta: true}
+      }];
+
+      const results = c1.chain(tx).data({removeMeta: true});
+
+      expect(results.length).toEqual(4);
+      expect(results[0].a).toEqual(1);
+      expect(results[0].b).toEqual(9);
+      expect(results[0].c).toEqual(8);
+      expect(results[3].a).toEqual(4);
+      expect(results[3].b).toEqual(6);
+      expect(results[3].c).toEqual(2);
+      results.forEach((obj) => {
+        expect(Object.keys(obj).length).toEqual(3);
+      });
+    });
+  });
 });

packages/loki/src/resultset.js

@@ -442,7 +442,7 @@ export class Resultset {
           rs = rs.offset(step.value);
           break; // offset makes copy so update reference
         case "map":
-          rs = rs.map(step.value);
+          rs = rs.map(step.value, step.dataOptions);
           break;
         case "eqJoin":
           rs = rs.eqJoin(step.joinData, step.leftJoinKey, step.rightJoinKey, step.mapFun, step.dataOptions);
@@ -1129,7 +1129,10 @@ export class Resultset {
    * @param {(string|function)} leftJoinKey - Property name in this result set to join on or a function to produce a value to join on
    * @param {(string|function)} rightJoinKey - Property name in the joinData to join on or a function to produce a value to join on
    * @param {function} [mapFun=] - a function that receives each matching pair and maps them into output objects - function(left,right){return joinedObject}
-   * @param {object} dataOptions - optional options to apply to data() calls for left and right sides
+   * @param {object} [dataOptions=] - optional options to apply to data() calls for left and right sides
+   * @param {boolean} dataOptions.removeMeta - allows removing meta before calling mapFun
+   * @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.
    * @returns {Resultset} A resultset with data in the format [{left: leftObj, right: rightObj}]
    */
   eqJoin(joinData, leftJoinKey, rightJoinKey, mapFun, dataOptions) {
@@ -1187,8 +1190,16 @@ export class Resultset {
     return this;
   }
 
-  map(mapFun) {
-    let data = this.data().map(mapFun);
+  /**
+   * Applies a map function into a new collection for further chaining.
+   * @param {function} mapFun - javascript map function
+   * @param {object} [dataOptions=] - options to data() before input to your map function
+   * @param {boolean} dataOptions.removeMeta - allows removing meta before calling mapFun
+   * @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(mapFun, dataOptions) {
+    let data = this.data(dataOptions).map(mapFun);
     //return return a new resultset with no filters
     this.collection = new Collection("mappedData");
     this.collection.insert(data);