return (dispatch, store) => {
   let normalized = normalize(data.entries, arrayOf(schema));
   // This is for testing only. If no results are returned, Normalizr will 
   // return result: [ undefined ] and entities[entity] = {undefined:{}}.
   if (normalized.result[0] === undefined) {
     normalized.result.length = 0;
     normalized.entities[toCamelCase(name)] = {};
   }
   // Dispatch event for the main data that was gathered on this request.
   // This includes metadata about the collection.
   dispatch(action(FIND, name.toUpperCase(), {
     result: normalized.result,
     items: normalized.entities[toCamelCase(name)],
     meta: {
       count: data.total_entries,
       page: data.page,
       links: data._links
     }
   }));
   
   // Iterate over other objects that were returned (normalized) and 
   // dispatch add actions for them to get them into the store.
   for (let x in normalized.entities) {
     // Exclude main entity
     if (toLoudSnakeCase(x) !== toLoudSnakeCase(name)) {
       // Iterate over each object passed back and dispatch ADD action
       for (let y in normalized.entities[x]) {
         dispatch(action(ADD, toLoudSnakeCase(x), normalized.entities[x][y]));
       }
     }
   }
 }

export const users: Reducer<any> = (state = initialState, action: Action) => {
  switch (action.type) {
    case LOADING_USERS:
    case LOADING_USER:
      return state.set('loading', true);
    case LOADED_USERS:
      const normalizedUsers: IUsers = normalize(action.payload, arrayOf(userSchema));

      return state.withMutations(map => {
        map.set('loading', false);
        map.set('result', List(normalizedUsers.result));
        normalizedUsers.result.forEach((userId: number) => {
          map.setIn(
            ['entities', 'users', userId],
            new UserRecord(normalizedUsers.entities.users[userId])
          );
        });
      });
    case LOADED_USER:
      return state.withMutations(map => {
        map.set('loading', false);
        if (map.get('result').indexOf(action.payload.id) === -1) {
          map.update('result', list => list.push(action.payload.id));
        }
        map.setIn(
          ['entities', 'users', action.payload.id],
          new UserRecord(action.payload)
        );
      });
    case DELETING_USER:
      return state.setIn(['entities', 'users', action.payload.id, 'deleting'], true);
    case DELETED_USER:
      return state.withMutations(map => map
        .deleteIn(['entities', 'users', action.payload])
        .deleteIn(['result', map.get('result').indexOf(action.payload)])
      );
    case ADDING_USER:
      return state.set('adding', true);
    case ADDED_USER:
      return state.withMutations(map => map
        .setIn(['entities', 'users', action.payload.id], new UserRecord(action.payload))
        .update('result', list => list.push(action.payload.id))
        .set('adding', false)
      );
    case PATCHED_USER:
      return state
        .setIn(['entities', 'users', action.payload.id], new UserRecord(action.payload));

    default:
      return state;
  }
};

export const posts: Reducer<any> = (state = initialState, action: Action) => {
  switch (action.type) {
    case LOADING_POSTS:
    case LOADING_POST:
      return state.set('loading', true)
    case LOADED_POSTS:
      const normalizedPosts: IPosts = normalize(action.payload, arrayOf(postSchema))
      return state.withMutations(map => {
        map.set('loading', false)
        map.set('result', List(normalizedPosts.result))
        normalizedPosts.result.forEach((postId: number) => {
          normalizedPosts.entities.posts[postId].user = normalizedPosts.entities.users[normalizedPosts.entities.posts[postId].user]
          map.setIn(
            ['entities', 'posts', postId],
            new PostRecord(normalizedPosts.entities.posts[postId])
          )
        })
      })
    case LOADED_POST:
      return state.withMutations(map => {
        map.set('loading', false)
        if (map.get('result').indexOf(action.payload.id) === -1) {
          map.update('result', list => list.push(action.payload.id))
        }
        map.setIn(
          ['entities', 'posts', action.payload.id],
          new PostRecord(action.payload)
        )
      })
    case DELETING_POST:
      return state.setIn(['entities', 'posts', action.payload.id, 'deleting'], true)
    case DELETED_POST:
      return state.withMutations(map => map
        .deleteIn(['entities', 'posts', action.payload])
        .deleteIn(['result', map.get('result').indexOf(action.payload)])
      )
    case ADDING_POST:
      return state.set('adding', true)
    case ADDED_POST:
      return state.withMutations(map => map
        .setIn(['entities', 'posts', action.payload.id], new PostRecord(action.payload))
        .update('result', list => list.push(action.payload.id))
        .set('adding', false)
      )
    case PATCHED_POST:
      return state
        .setIn(['entities', 'posts', action.payload.id], new PostRecord(action.payload))

    default:
      return state
  }
}

 (res) => normalize(res, arrayOf(peopleSchema))

 .map((res) => this.normalize(res, arrayOf(taskSchema)));

import {Schema, arrayOf} from 'normalizr';
import phone from './phone';


const contact = new Schema('contacts',{
    idAttribute: '_id'
});

contact.define({phones: arrayOf(phone)});

export default contact;

import { normalize, Schema, arrayOf, valuesOf } from "normalizr";
export var article = new Schema("articles");
export var comment = new Schema("comments");
export var user = new Schema("users");
article.define({
	get_comments : arrayOf(comment),
	get_author : user,
});

comment.define({
	get_author : user,
	get_article : article,
});

user.define({
	get_articles : arrayOf(article),
	get_comments : arrayOf(comment),
});

const { Schema, arrayOf } = require('normalizr');

const userSchema = new Schema('users', {
  idAttribute: user => user.id
});

export const Schemas = {
  USER: userSchema,
  ALL_USERS: {
    users: arrayOf(userSchema)
  }
};

 .map((res) => this.normalize(res, arrayOf(storySchema)));

 .map((res) => this.normalize(res, arrayOf(projectSchema)));