Added recursive dependencies support for denormalize method

src/__tests__/__snapshots__/index.test.js.snap

@@ -33,6 +33,39 @@ Object {
 }
 `;
 
+exports[`denormalize denormalizes recursive dependencies 1`] = `
+Object {
+  "id": 1,
+  "title": "Weekly report",
+  "user": Object {
+    "id": 1,
+    "reports": Array [
+      1,
+    ],
+    "role": "manager",
+  },
+}
+`;
+
+exports[`denormalize denormalizes recursive dependencies with custom idAttribute 1`] = `
+Object {
+  "title": "Weekly report",
+  "user": Object {
+    "id": 1,
+    "reports": Array [
+      1,
+      Object {
+        "title": "Monthly report",
+        "user": 1,
+        "uuid": 2,
+      },
+    ],
+    "role": "manager",
+  },
+  "uuid": 1,
+}
+`;
+
 exports[`normalize can use fully custom entity classes 1`] = `
 Object {
   "entities": Object {

src/__tests__/index.test.js

@@ -206,4 +206,69 @@ describe('denormalize', () => {
     });
     expect(() => denormalize('123', article, entities)).not.toThrow();
   });
+
+  it('denormalizes recursive dependencies', () => {
+    const user = new schema.Entity('users');
+    const report = new schema.Entity('reports');
+
+    user.define({
+      reports: [ report ]
+    });
+    report.define({
+      user: user
+    });
+
+    const entities = {
+      reports: {
+        1: {
+          id: 1,
+          title: 'Weekly report',
+          user: 1
+        }
+      },
+      users: {
+        1: {
+          id: 1,
+          role: 'manager',
+          reports: [ 1 ]
+        }
+      }
+    };
+    expect(denormalize('1', report, entities)).toMatchSnapshot();
+  });
+
+  it('denormalizes recursive dependencies with custom idAttribute', () => {
+    const user = new schema.Entity('users');
+    const report = new schema.Entity('reports', {}, { idAttribute: 'uuid' });
+
+    user.define({
+      reports: [ report ]
+    });
+    report.define({
+      user: user
+    });
+
+    const entities = {
+      reports: {
+        1: {
+          uuid: 1,
+          title: 'Weekly report',
+          user: 1
+        },
+        2: {
+          uuid: 2,
+          title: 'Monthly report',
+          user: 1
+        }
+      },
+      users: {
+        1: {
+          id: 1,
+          role: 'manager',
+          reports: [ 1, 2 ]
+        }
+      }
+    };
+    expect(denormalize('1', report, entities)).toMatchSnapshot();
+  });
 });

src/index.js

@@ -55,22 +55,23 @@ export const normalize = (input, schema) => {
   return { entities, result };
 };
 
-const unvisit = (input, schema, entities) => {
-  if (typeof schema === 'object' && (!schema.normalize || typeof schema.normalize !== 'function')) {
+const unvisit = (input, schema, entities, visitedEntities) => {
+  if (typeof schema === 'object' && (!schema.denormalize || typeof schema.denormalize !== 'function')) {
     let method = ObjectUtils.denormalize;
     if (Array.isArray(schema)) {
       method = ArrayUtils.denormalize;
     }
-    return method(schema, input, unvisit, entities);
+    return method(schema, input, unvisit, entities, visitedEntities);
   }
 
-  return schema.denormalize(input, unvisit, entities);
+  return schema.denormalize(input, unvisit, entities, visitedEntities);
 };
 
 export const denormalize = (input, schema, entities) => {
   if (!input) {
     return input;
   }
 
-  return unvisit(input, schema, entities);
+  const visitedEntities = {};
+  return unvisit(input, schema, entities, visitedEntities);
 };

src/schemas/Array.js

@@ -21,9 +21,9 @@ export const normalize = (schema, input, parent, key, visit, addEntity) => {
   return values.map((value, index) => visit(value, parent, key, schema, addEntity));
 };
 
-export const denormalize = (schema, input, unvisit, entities) => {
+export const denormalize = (schema, input, unvisit, entities, visitedEntities) => {
   schema = validateSchema(schema);
-  return input.map((entityOrId) => unvisit(entityOrId, schema, entities));
+  return input.map((entityOrId) => unvisit(entityOrId, schema, entities, visitedEntities));
 };
 
 export default class ArraySchema extends PolymorphicSchema {
@@ -34,7 +34,7 @@ export default class ArraySchema extends PolymorphicSchema {
       .filter((value) => value !== undefined && value !== null);
   }
 
-  denormalize(input, unvisit, entities) {
-    return input.map((value) => this.denormalizeValue(value, unvisit, entities));
+  denormalize(input, unvisit, entities, visitedEntities) {
+    return input.map((value) => this.denormalizeValue(value, unvisit, entities, visitedEntities));
   }
 }

src/schemas/Entity.js

@@ -1,3 +1,5 @@
+import { denormalize } from './Object';
+
 export default class EntitySchema {
   constructor(key, definition = {}, options = {}) {
     if (!key || typeof key !== 'string') {
@@ -51,16 +53,19 @@ export default class EntitySchema {
     return this.getId(input, parent, key);
   }
 
-  denormalize(entityOrId, unvisit, entities) {
+  denormalize(entityOrId, unvisit, entities, visitedEntities) {
     const entity = typeof entityOrId === 'object' ? entityOrId : entities[this.key][entityOrId];
-    const entityCopy = { ...entity };
-    Object.keys(this.schema).forEach((key) => {
-      if (entityCopy.hasOwnProperty(key)) {
-        const schema = this.schema[key];
-        entityCopy[key] = unvisit(entityCopy[key], schema, entities);
-      }
-    });
 
-    return entityCopy;
+    if (!visitedEntities[this.key]) {
+      visitedEntities[this.key] = {};
+    }
+
+    const id = this.getId(entity);
+    if (visitedEntities[this.key][id]) {
+      return id;
+    }
+    visitedEntities[this.key][id] = true;
+
+    return denormalize(this.schema, entity, unvisit, entities, visitedEntities);
   }
 }

src/schemas/Object.js

@@ -12,12 +12,11 @@ export const normalize = (schema, input, parent, key, visit, addEntity) => {
   return object;
 };
 
-export const denormalize = (schema, input, unvisit, entities) => {
+export const denormalize = (schema, input, unvisit, entities, visitedEntities) => {
   const object = { ...input };
   Object.keys(schema).forEach((key) => {
-    const localSchema = schema[key];
     if (object[key]) {
-      object[key] = unvisit(object[key], localSchema, entities);
+      object[key] = unvisit(object[key], schema[key], entities, visitedEntities);
     }
   });
   return object;

src/schemas/Polymorphic.js

@@ -40,11 +40,11 @@ export default class PolymorphicSchema {
       { id: normalizedValue, schema: this.getSchemaAttribute(value, parent, key) };
   }
 
-  denormalizeValue(value, unvisit, entities) {
+  denormalizeValue(value, unvisit, entities, visitedEntities) {
     if (!this.isSingleSchema && !value.schema) {
       return value;
     }
     const schema = this.isSingleSchema ? this.schema : this.schema[value.schema];
-    return unvisit(value.id || value, schema, entities);
+    return unvisit(value.id || value, schema, entities, visitedEntities);
   }
 }

src/schemas/Union.js

@@ -12,7 +12,7 @@ export default class UnionSchema extends PolymorphicSchema {
     return this.normalizeValue(input, parent, key, visit, addEntity);
   }
 
-  denormalize(input, unvisit, entities) {
-    return this.denormalizeValue(input, unvisit, entities);
+  denormalize(input, unvisit, entities, visitedEntities) {
+    return this.denormalizeValue(input, unvisit, entities, visitedEntities);
   }
 }

src/schemas/Values.js

@@ -11,12 +11,12 @@ export default class ValuesSchema extends PolymorphicSchema {
     }, {});
   }
 
-  denormalize(input, unvisit, entities) {
+  denormalize(input, unvisit, entities, visitedEntities) {
     return Object.keys(input).reduce((output, key) => {
       const entityOrId = input[key];
       return {
         ...output,
-        [key]: this.denormalizeValue(entityOrId, unvisit, entities)
+        [key]: this.denormalizeValue(entityOrId, unvisit, entities, visitedEntities)
       };
     }, {});
   }