Fix multiple operation for embedded object while serializing

Author: slaveofcode

blueprint/functions/normalize.js

@@ -3,7 +3,12 @@
 const { keys, forEach } = require('lodash');
 const { isArray } = require('../../types/detector');
 const { isTypeObject } = require('../utils');
-const { resolveEmbededObj, parseEmbedValue, initiateTypeHandler, handleUnknownProperties } = require('./utils');
+const {
+  resolveEmbededObj,
+  parseEmbedValue,
+  initiateTypeHandler,
+  handleUnknownProperties
+} = require('./utils');
 
 const normalizeValue = function (valuesToNormalize, onValidation = false) {
   if (this.isArray && !isArray(valuesToNormalize)) {
@@ -108,7 +113,10 @@ const normalizeValue = function (valuesToNormalize, onValidation = false) {
         doValidation: onValidation
       });
       if (isAllowUnknownProperties) {
-        Object.assign(normalizedResult, handleUnknownProperties(v, this.schema));
+        Object.assign(
+          normalizedResult,
+          handleUnknownProperties(v, this.schema)
+        );
       }
       return [errorDetails, normalizedResult];
     });

blueprint/functions/serialize.js

@@ -1,15 +1,31 @@
 'use strict';
 
 const { includes, forEach } = require('lodash');
-const { resolveEmbededObj, parseEmbedValue, initiateTypeHandler, handleUnknownProperties } = require('./utils');
+const {
+  resolveEmbededObj,
+  parseEmbedValue,
+  initiateTypeHandler,
+  handleUnknownProperties
+} = require('./utils');
 
-const serializeValue = function (valuesToSerialize, onValidation = false) {
+const serializeValue = function (
+  valuesToSerialize,
+  onValidation = false,
+  opts = { isSelfCall: false }
+) {
   let serialized = this.isArray ? [] : {};
-  const [
-    isError,
-    errorDetails,
-    normalizedValues
-  ] = this.normalize(valuesToSerialize, { doValidation: onValidation });
+
+  let isError = false;
+  let errorDetails = [];
+  let normalizedValues = {};
+  if (!opts.isSelfCall) {
+    [isError, errorDetails, normalizedValues] = this.normalize(
+      valuesToSerialize,
+      { doValidation: onValidation }
+    );
+  } else {
+    normalizedValues = valuesToSerialize;
+  }
 
   const isAllowUnknownProperties = this.options.allowUnknownProperties;
 
@@ -21,7 +37,11 @@ const serializeValue = function (valuesToSerialize, onValidation = false) {
       const embedObj = resolveEmbededObj(typeHandler);
       if (embedObj !== null) {
         if (!embedObj.isHideOnSerialization()) {
-          const serializedResult = parseEmbedValue('serialize', embedObj, normalizedValues[key]);
+          const serializedResult = parseEmbedValue(
+            'serialize',
+            embedObj,
+            normalizedValues[key]
+          );
           const serializeTo = embedObj.getSerializeName();
           if (serializeTo !== null) {
             serialized[serializeTo] = serializedResult;

blueprint/functions/utils.js

@@ -22,9 +22,11 @@ const initiateTypeHandler = typehandler => {
  * @param {embedCls} embeddedObject
  */
 const resolveEmbededObj = obj =>
-  (isFunction(obj.embed) && obj.embed() instanceof BlueprintEmbedClass
+  isFunction(obj.embed) && obj.embed() instanceof BlueprintEmbedClass
     ? obj.embed()
-    : obj instanceof BlueprintEmbedClass ? obj : null);
+    : obj instanceof BlueprintEmbedClass
+      ? obj
+      : null;
 
 const handleUnknownProperties = (params, objToExclude) => {
   const registeredKeys = keys(objToExclude);
@@ -61,7 +63,9 @@ const parseEmbedValue = (clsMethodName, embedObj, valueToParse) => {
     } else {
       // calling normalize/serialize/deserialize function on parent blueprint obj
       const [fail, , parsedValues] = embedInstance[clsMethodName](
-        valueToParse
+        valueToParse,
+        false,
+        { isSelfCall: true }
       );
 
       // applying embed object options

package-lock.json

@@ -0,0 +1,95 @@
+'use strict';
+
+/* eslint-disable */
+
+const blueprint = require("../blueprint");
+const types = require("../types");
+
+test("Should be executed once for transform function in embed", () => {
+  const expSchema = blueprint.object({
+    id: types.transform(id => {
+      return "abc" + id;
+    })
+  });
+
+  const expSchema2 = blueprint.object({
+    emb: expSchema
+  });
+
+  const res = expSchema2({
+    emb: {
+      id: 123
+    }
+  });
+
+  expect(res.emb.id).toEqual("abc123");
+});
+
+test("Should be executed once for transform function in embed in serialization", () => {
+  const expSchema = blueprint.object({
+    id: types.transform(id => {
+      return "abc" + id;
+    })
+  });
+
+  const expSchema2 = blueprint.object({
+    emb: expSchema
+  });
+
+  const expSchema3 = blueprint.array({
+    emb: expSchema
+  });
+
+  const res = expSchema2.serialize({
+    emb: {
+      id: 123
+    }
+  });
+
+  const res2 = expSchema3.serialize([
+    {
+      emb: {
+        id: 456
+      }
+    }
+  ]);
+
+  expect(res.emb.id).toEqual("abc123");
+  expect(res2[0].emb.id).toEqual("abc456");
+});
+
+test("Should be executed once for transform function in embed in deserialization", () => {
+  const expSchema = blueprint.object({
+    id: types.transform(
+      id => {
+        return "abc" + id;
+      },
+      { deserialize: { from: "number" } }
+    )
+  });
+
+  const expSchema2 = blueprint.object({
+    emb: expSchema
+  });
+
+  const expSchema3 = blueprint.array({
+    emb: expSchema
+  });
+
+  const res = expSchema2.deserialize({
+    emb: {
+      number: 123
+    }
+  });
+
+  const res2 = expSchema3.deserialize([
+    {
+      emb: {
+        number: 456
+      }
+    }
+  ]);
+
+  expect(res.emb.id).toEqual("abc123");
+  expect(res2[0].emb.id).toEqual("abc456");
+});