orc-shared 1.1.0-dev.7 → 1.1.0

package/src/hooks/useNotificationRequestState.test.js

@@ -0,0 +1,264 @@
+import Immutable from "immutable";
+import React from "react";
+import useNotificationRequestState from "./useNotificationRequestState";
+import { extractMessages, TestWrapper } from "../utils/testUtils";
+import { requestStateOperations } from "../constants";
+import sharedMessages from "../sharedMessages";
+import sinon from "sinon";
+import { mount } from "enzyme";
+import { resetRequestState } from "../actions/requestState";
+import Snackbar from "@material-ui/core/Snackbar";
+import * as getRequestStateInfo from "../selectors/requestStates";
+
+const messages = extractMessages(sharedMessages);
+
+describe("useNotificationRequestState", () => {
+	let buildRequestState;
+
+	const TestComp = props => {
+		[buildRequestState] = useNotificationRequestState(props);
+		return <div>some content</div>;
+	};
+
+	let state, store, successSpy, errorSpy, dispatchSpy;
+	beforeEach(() => {
+		state = Immutable.fromJS({
+			requestStates: {
+				creates: {},
+				deletes: {},
+				fetches: {},
+				updates: {},
+			},
+		});
+
+		successSpy = sinon.spy().named("success");
+		errorSpy = sinon.spy().named("error");
+		dispatchSpy = sinon.spy().named("dispatch");
+
+		store = {
+			subscribe: () => {},
+			getState: () => state,
+			dispatch: dispatchSpy,
+		};
+	});
+
+	afterEach(() => {
+		successSpy.resetHistory();
+		errorSpy.resetHistory();
+		dispatchSpy.resetHistory();
+	});
+
+	it("buildRequestState builds the expected object", () => {
+		const component = (
+			<TestWrapper provider={{ store }} intlProvider={{ messages }} stylesProvider>
+				<TestComp
+					keys={["key1", "key2"]}
+					operation={requestStateOperations.delete}
+					successMessageId={sharedMessages.delete}
+					successAction={successSpy}
+					errorMessageId={sharedMessages.error}
+					errorAction={errorSpy}
+				/>
+			</TestWrapper>
+		);
+
+		mount(component);
+
+		const obj = buildRequestState();
+		expect(obj, "to equal", {
+			keys: ["key1", "key2"],
+			operation: requestStateOperations.delete,
+		});
+	});
+
+	it("does not dispatch anything for an empty state", () => {
+		const component = (
+			<TestWrapper provider={{ store }} intlProvider={{ messages }} stylesProvider>
+				<TestComp
+					keys={["key1", "key2"]}
+					operation={requestStateOperations.delete}
+					successMessageId={sharedMessages.delete}
+					successAction={successSpy}
+					errorMessageId={sharedMessages.error}
+					errorAction={errorSpy}
+				/>
+			</TestWrapper>
+		);
+
+		mount(component);
+
+		expect(dispatchSpy, "was not called");
+	});
+
+	it("dispatches the success actions", () => {
+		state = state.setIn(
+			["requestStates", "deletes", "key1", "key2", "state"],
+			Immutable.fromJS({
+				inProgress: false,
+				value: true,
+				error: false,
+			}),
+		);
+
+		const component = (
+			<TestWrapper provider={{ store }} intlProvider={{ messages }} stylesProvider>
+				<TestComp
+					keys={["key1", "key2"]}
+					operation={requestStateOperations.delete}
+					successMessageId={sharedMessages.delete}
+					successAction={successSpy}
+					errorMessageId={sharedMessages.error}
+					errorAction={errorSpy}
+				/>
+			</TestWrapper>
+		);
+
+		const mountedComponent = mount(component);
+		const sb = mountedComponent.find(Snackbar);
+
+		const resetAction = resetRequestState(["key1", "key2"], requestStateOperations.delete);
+		expect(dispatchSpy, "to have a call satisfying", { args: [resetAction] });
+		expect(dispatchSpy, "to have a call satisfying", { args: [resetAction] });
+		expect(successSpy, "was called");
+		expect(errorSpy, "was not called");
+		expect(sb.prop("open"), "to equal", true);
+	});
+
+	it("success callback is not called when undefined", () => {
+		state = state.setIn(
+			["requestStates", "deletes", "key1", "key2", "state"],
+			Immutable.fromJS({
+				inProgress: false,
+				value: true,
+				error: false,
+			}),
+		);
+
+		const component = (
+			<TestWrapper provider={{ store }} intlProvider={{ messages }} stylesProvider>
+				<TestComp
+					keys={["key1", "key2"]}
+					operation={requestStateOperations.delete}
+					successMessageId={sharedMessages.delete}
+					errorMessageId={sharedMessages.error}
+					errorAction={errorSpy}
+				/>
+			</TestWrapper>
+		);
+
+		const mountedComponent = mount(component);
+		const sb = mountedComponent.find(Snackbar);
+
+		expect(successSpy, "was not called");
+		expect(sb.prop("open"), "to equal", true);
+	});
+
+	it("dispatches the error actions", () => {
+		state = state.setIn(
+			["requestStates", "deletes", "key1", "key2", "state"],
+			Immutable.fromJS({
+				inProgress: false,
+				value: false,
+				error: true,
+			}),
+		);
+
+		const component = (
+			<TestWrapper provider={{ store }} intlProvider={{ messages }} stylesProvider>
+				<TestComp
+					keys={["key1", "key2"]}
+					operation={requestStateOperations.delete}
+					successMessageId={sharedMessages.delete}
+					successAction={successSpy}
+					errorMessageId={sharedMessages.error}
+					errorAction={errorSpy}
+				/>
+			</TestWrapper>
+		);
+
+		const mountedComponent = mount(component);
+		const sb = mountedComponent.find(Snackbar);
+
+		const resetAction = resetRequestState(["key1", "key2"], requestStateOperations.delete);
+		expect(dispatchSpy, "to have a call satisfying", { args: [resetAction] });
+		expect(dispatchSpy, "to have a call satisfying", { args: [resetAction] });
+		expect(successSpy, "was not called");
+		expect(errorSpy, "was called");
+		expect(sb.prop("open"), "to equal", true);
+	});
+
+	it("dispatches the error actions with a message", () => {
+		const errorPayload = {
+			response: {
+				responseStatus: {
+					message: "some error message",
+				},
+			},
+		};
+
+		const getRequestStateInfoOverride = () => ({
+			inProgress: false,
+			value: false,
+			error: errorSpy.callCount === 0,
+			errorResponse: errorSpy.callCount === 0 ? errorPayload : null,
+		});
+
+		const getRequestStateInfoStub = sinon
+			.stub(getRequestStateInfo, "getRequestStateInfo")
+			.returns(() => getRequestStateInfoOverride());
+
+		const component = (
+			<TestWrapper provider={{ store }} intlProvider={{ messages }} stylesProvider>
+				<TestComp
+					keys={["key1", "key2"]}
+					operation={requestStateOperations.delete}
+					successMessageId={sharedMessages.delete}
+					successAction={successSpy}
+					errorMessageId={sharedMessages.error}
+					errorAction={errorSpy}
+				/>
+			</TestWrapper>
+		);
+
+		const mountedComponent = mount(component);
+		const sb = mountedComponent.find(Snackbar);
+
+		const resetAction = resetRequestState(["key1", "key2"], requestStateOperations.delete);
+		expect(dispatchSpy, "to have a call satisfying", { args: [resetAction] });
+		expect(dispatchSpy, "to have a call satisfying", { args: [resetAction] });
+		expect(successSpy, "was not called");
+		expect(errorSpy, "to have a call satisfying", { args: [errorPayload] });
+		expect(sb.prop("open"), "to equal", true);
+
+		getRequestStateInfoStub.restore();
+	});
+
+	it("error action is not called when undefined", () => {
+		state = state.setIn(
+			["requestStates", "deletes", "key1", "key2", "state"],
+			Immutable.fromJS({
+				inProgress: false,
+				value: false,
+				error: true,
+			}),
+		);
+
+		const component = (
+			<TestWrapper provider={{ store }} intlProvider={{ messages }} stylesProvider>
+				<TestComp
+					keys={["key1", "key2"]}
+					operation={requestStateOperations.delete}
+					successMessageId={sharedMessages.delete}
+					successAction={successSpy}
+					errorMessageId={sharedMessages.error}
+				/>
+			</TestWrapper>
+		);
+
+		const mountedComponent = mount(component);
+		const sb = mountedComponent.find(Snackbar);
+
+		expect(errorSpy, "was not called");
+		expect(sb.prop("open"), "to equal", true);
+	});
+});

package/src/hooks/useRequestState.js

@@ -0,0 +1,57 @@
+import useSelectorAndUnwrap from "./useSelectorAndUnwrap";
+import { getRequestStateInfo } from "../selectors/requestStates";
+import { useEffect } from "react";
+import { useDispatch } from "react-redux";
+import { resetRequestState } from "../actions/requestState";
+
+/*
+    This hook is used to handle custom action after deletes and updates requests. We can add additional operation if required.
+    We have a reducer scanning every request for a special payload (meta.requestState).
+    If this payload is detected we set some flags (inProgress, value, error) depending on the request type (_REQUEST, _SUCCESS, _FAILURE):
+        * inProgress: set to true while the request is executing
+        * value: set to false when starting the request and to true when the request has been executed successfully
+        * error: set to false when starting the request and to true when the request has not been executed successfully
+
+    This hook returns a method used to build a requestState object that is used in the meta data property of the dispatched action.
+    The expected format for the action is as follow:
+    {
+        type: 'some type',
+        ... // other properties
+        meta: {
+            requestState: {
+                keys: [],
+                operation: requestStateOperations.delete
+            }
+        }
+    }
+*/
+
+const useRequestState = ({ keys, operation, successAction, errorAction }) => {
+	const { inProgress, value, error, errorResponse } = useSelectorAndUnwrap(getRequestStateInfo(operation, keys));
+	const dispatch = useDispatch();
+
+	useEffect(() => {
+		if (value && !inProgress && !error) {
+			dispatch(resetRequestState(keys, operation));
+			if (successAction) {
+				successAction();
+			}
+		} else if (!value && !inProgress && error) {
+			dispatch(resetRequestState(keys, operation));
+			if (errorAction) {
+				errorAction(errorResponse);
+			}
+		}
+	}, [dispatch, keys, operation, successAction, errorAction, errorResponse, inProgress, value, error]);
+
+	const buildRequestState = () => {
+		return {
+			keys,
+			operation,
+		};
+	};
+
+	return [buildRequestState];
+};
+
+export default useRequestState;

package/src/hooks/useRequestState.test.js

@@ -0,0 +1,217 @@
+import Immutable from "immutable";
+import React from "react";
+import useRequestState from "./useRequestState";
+import { extractMessages, TestWrapper } from "../utils/testUtils";
+import { requestStateOperations } from "../constants";
+import sharedMessages from "../sharedMessages";
+import sinon from "sinon";
+import { mount } from "enzyme";
+import { resetRequestState } from "../actions/requestState";
+
+const messages = extractMessages(sharedMessages);
+
+describe("useRequestState", () => {
+	let buildRequestState;
+
+	const TestComp = props => {
+		[buildRequestState] = useRequestState(props);
+		return <div>some content</div>;
+	};
+
+	let state, store, successSpy, errorSpy, dispatchSpy;
+	beforeEach(() => {
+		state = Immutable.fromJS({
+			requestStates: {
+				deletes: {},
+				updates: {},
+			},
+		});
+
+		successSpy = sinon.spy().named("success");
+		errorSpy = sinon.spy().named("error");
+		dispatchSpy = sinon.spy().named("dispatch");
+
+		store = {
+			subscribe: () => {},
+			getState: () => state,
+			dispatch: dispatchSpy,
+		};
+	});
+
+	afterEach(() => {
+		successSpy.resetHistory();
+		errorSpy.resetHistory();
+		dispatchSpy.resetHistory();
+	});
+
+	it("buildRequestState builds the expected object", () => {
+		const component = (
+			<TestWrapper provider={{ store }} intlProvider={{ messages }} stylesProvider>
+				<TestComp
+					keys={["key1", "key2"]}
+					operation={requestStateOperations.delete}
+					successAction={successSpy}
+					errorAction={errorSpy}
+				/>
+			</TestWrapper>
+		);
+
+		mount(component);
+
+		const obj = buildRequestState();
+		expect(obj, "to equal", {
+			keys: ["key1", "key2"],
+			operation: requestStateOperations.delete,
+		});
+	});
+
+	it("does not dispatch anything for an empty state", () => {
+		const component = (
+			<TestWrapper provider={{ store }} intlProvider={{ messages }} stylesProvider>
+				<TestComp
+					keys={["key1", "key2"]}
+					operation={requestStateOperations.delete}
+					successAction={successSpy}
+					errorAction={errorSpy}
+				/>
+			</TestWrapper>
+		);
+
+		mount(component);
+
+		expect(dispatchSpy, "was not called");
+	});
+
+	it("dispatches the success actions", () => {
+		state = state.setIn(
+			["requestStates", "deletes", "key1", "key2", "state"],
+			Immutable.fromJS({
+				inProgress: false,
+				value: true,
+				error: false,
+			}),
+		);
+
+		const component = (
+			<TestWrapper provider={{ store }} intlProvider={{ messages }} stylesProvider>
+				<TestComp
+					keys={["key1", "key2"]}
+					operation={requestStateOperations.delete}
+					successAction={successSpy}
+					errorAction={errorSpy}
+				/>
+			</TestWrapper>
+		);
+
+		mount(component);
+
+		const resetAction = resetRequestState(["key1", "key2"], requestStateOperations.delete);
+		expect(dispatchSpy, "to have a call satisfying", { args: [resetAction] });
+		expect(dispatchSpy, "to have a call satisfying", { args: [resetAction] });
+		expect(successSpy, "was called");
+		expect(errorSpy, "was not called");
+	});
+
+	it("success callback is not called when undefined", () => {
+		state = state.setIn(
+			["requestStates", "deletes", "key1", "key2", "state"],
+			Immutable.fromJS({
+				inProgress: false,
+				value: true,
+				error: false,
+			}),
+		);
+
+		const component = (
+			<TestWrapper provider={{ store }} intlProvider={{ messages }} stylesProvider>
+				<TestComp keys={["key1", "key2"]} operation={requestStateOperations.delete} errorAction={errorSpy} />
+			</TestWrapper>
+		);
+
+		mount(component);
+
+		expect(successSpy, "was not called");
+	});
+
+	it("dispatches the error actions", () => {
+		state = state.setIn(
+			["requestStates", "deletes", "key1", "key2", "state"],
+			Immutable.fromJS({
+				inProgress: false,
+				value: false,
+				error: true,
+			}),
+		);
+
+		const component = (
+			<TestWrapper provider={{ store }} intlProvider={{ messages }} stylesProvider>
+				<TestComp
+					keys={["key1", "key2"]}
+					operation={requestStateOperations.delete}
+					successAction={successSpy}
+					errorAction={errorSpy}
+				/>
+			</TestWrapper>
+		);
+
+		mount(component);
+
+		const resetAction = resetRequestState(["key1", "key2"], requestStateOperations.delete);
+		expect(dispatchSpy, "to have a call satisfying", { args: [resetAction] });
+		expect(dispatchSpy, "to have a call satisfying", { args: [resetAction] });
+		expect(successSpy, "was not called");
+		expect(errorSpy, "was called");
+	});
+
+	it("dispatches the error actions with a message", () => {
+		state = state.setIn(
+			["requestStates", "deletes", "key1", "key2", "state"],
+			Immutable.fromJS({
+				inProgress: false,
+				value: false,
+				error: true,
+				errorResponse: "some error message",
+			}),
+		);
+
+		const component = (
+			<TestWrapper provider={{ store }} intlProvider={{ messages }} stylesProvider>
+				<TestComp
+					keys={["key1", "key2"]}
+					operation={requestStateOperations.delete}
+					successAction={successSpy}
+					errorAction={errorSpy}
+				/>
+			</TestWrapper>
+		);
+
+		mount(component);
+
+		const resetAction = resetRequestState(["key1", "key2"], requestStateOperations.delete);
+		expect(dispatchSpy, "to have a call satisfying", { args: [resetAction] });
+		expect(dispatchSpy, "to have a call satisfying", { args: [resetAction] });
+		expect(successSpy, "was not called");
+		expect(errorSpy, "to have a call satisfying", { args: ["some error message"] });
+	});
+
+	it("error action is not called when undefined", () => {
+		state = state.setIn(
+			["requestStates", "deletes", "key1", "key2", "state"],
+			Immutable.fromJS({
+				inProgress: false,
+				value: false,
+				error: true,
+			}),
+		);
+
+		const component = (
+			<TestWrapper provider={{ store }} intlProvider={{ messages }} stylesProvider>
+				<TestComp keys={["key1", "key2"]} operation={requestStateOperations.delete} successAction={successSpy} />
+			</TestWrapper>
+		);
+
+		mount(component);
+
+		expect(errorSpy, "was not called");
+	});
+});

package/src/reducers/metadata.js

@@ -18,11 +18,19 @@ import {
 	INCREMENT_CUSTOMER_LOOKUPS_PAGE,
 	REFRESH_PAGED_CUSTOMER_LOOKUPS,
 	SET_PAGED_CUSTOMER_LOOKUPS_CURRENT_INFO,
+	SAVE_ORDER_LOOKUP_SUCCESS,
+	SAVE_CUSTOMER_LOOKUP_SUCCESS,
+	CREATE_PROFILE_DEFINITION_SUCCESS,
+	ADD_ORDER_LOOKUP_SUCCESS,
+	ADD_CUSTOMER_LOOKUP_SUCCESS,
+	UPDATE_PROFILE_DEFINITION_SUCCESS,
+	GET_ORDER_LOOKUP_SUCCESS,
+	GET_CUSTOMER_LOOKUP_SUCCESS,
 } from "../actions/metadata";
 
-export const ORDER_LOOKUP_MODULE_NAME = "order";
-export const CUSTOMER_LOOKUP_MODULE_NAME = "customer";
-export const PRODUCT_LOOKUP_MODULE_NAME = "product";
+export const ORDER_MODULE_NAME = "order";
+export const CUSTOMER_MODULE_NAME = "customer";
+export const PRODUCT_MODULE_NAME = "product";
 
 const arrayToIndex = (items, keyField) =>
 	items.reduce((index, item) => {
@@ -57,7 +65,7 @@ const lookupReducerHelper = {
 	incrementPage: (moduleName, state, action) => {
 		return state.setIn(["lookups", moduleName, "nextPageToLoad"], action.pageToLoad);
 	},
-	getPagedLookups: (moduleName, state, action) => {
+	getPagedLookups: (moduleName, state) => {
 		const page = state.getIn(["lookups", moduleName, "nextPageToLoad"]) ?? 1;
 		const index = state.getIn(["lookups", moduleName, "index"]);
 		const [...keys] = index.keys();
@@ -95,48 +103,100 @@ const lookupReducerHelper = {
 const metadataReducer = (state = initialState, action) => {
 	switch (action.type) {
 		case INCREMENT_ORDER_LOOKUPS_PAGE: {
-			return lookupReducerHelper.incrementPage(ORDER_LOOKUP_MODULE_NAME, state, action);
+			return lookupReducerHelper.incrementPage(ORDER_MODULE_NAME, state, action);
 		}
 		case REFRESH_PAGED_ORDER_LOOKUPS: {
-			return lookupReducerHelper.getPagedLookups(ORDER_LOOKUP_MODULE_NAME, state, action);
+			return lookupReducerHelper.getPagedLookups(ORDER_MODULE_NAME, state);
 		}
 		case SET_PAGED_ORDER_LOOKUPS_CURRENT_INFO: {
-			return lookupReducerHelper.setPagedCurrentInfo(ORDER_LOOKUP_MODULE_NAME, state, action);
+			return lookupReducerHelper.setPagedCurrentInfo(ORDER_MODULE_NAME, state, action);
 		}
 		case GET_ORDER_LOOKUPS_SUCCESS: {
-			return lookupReducerHelper.getLookupsQuerySuccess(ORDER_LOOKUP_MODULE_NAME, state, action);
+			return lookupReducerHelper.getLookupsQuerySuccess(ORDER_MODULE_NAME, state, action);
 		}
 		case INCREMENT_CUSTOMER_LOOKUPS_PAGE: {
-			return lookupReducerHelper.incrementPage(CUSTOMER_LOOKUP_MODULE_NAME, state, action);
+			return lookupReducerHelper.incrementPage(CUSTOMER_MODULE_NAME, state, action);
 		}
 		case REFRESH_PAGED_CUSTOMER_LOOKUPS: {
-			return lookupReducerHelper.getPagedLookups(CUSTOMER_LOOKUP_MODULE_NAME, state, action);
+			return lookupReducerHelper.getPagedLookups(CUSTOMER_MODULE_NAME, state);
 		}
 		case SET_PAGED_CUSTOMER_LOOKUPS_CURRENT_INFO: {
-			return lookupReducerHelper.setPagedCurrentInfo(CUSTOMER_LOOKUP_MODULE_NAME, state, action);
+			return lookupReducerHelper.setPagedCurrentInfo(CUSTOMER_MODULE_NAME, state, action);
 		}
 		case GET_CUSTOMER_LOOKUPS_SUCCESS: {
-			return lookupReducerHelper.getLookupsQuerySuccess(CUSTOMER_LOOKUP_MODULE_NAME, state, action);
+			return lookupReducerHelper.getLookupsQuerySuccess(CUSTOMER_MODULE_NAME, state, action);
 		}
 		case GET_PRODUCT_LOOKUPS_SUCCESS: {
-			return lookupReducerHelper.getLookupsQuerySuccess(PRODUCT_LOOKUP_MODULE_NAME, state, action);
+			return lookupReducerHelper.getLookupsQuerySuccess(PRODUCT_MODULE_NAME, state, action);
 		}
 		case GET_CUSTOMER_DEFINITIONS_SUCCESS: {
 			const normalizedDefinitons = normalize(action.payload, definitionsListSchema);
-			return state.setIn(["definitions", "customer"], Immutable.fromJS(normalizedDefinitons.entities.definitions));
+			return state.setIn(
+				["definitions", CUSTOMER_MODULE_NAME],
+				Immutable.fromJS(normalizedDefinitons.entities.definitions),
+			);
 		}
 		case GET_ORDER_DEFINITIONS_SUCCESS: {
 			const normalizedDefinitons = normalize(action.payload, definitionsListSchema);
-			return state.setIn(["definitions", "order"], Immutable.fromJS(normalizedDefinitons.entities.definitions));
+			return state.setIn(
+				["definitions", ORDER_MODULE_NAME],
+				Immutable.fromJS(normalizedDefinitons.entities.definitions),
+			);
 		}
 		case GET_PRODUCT_DEFINITIONS_SUCCESS: {
 			const normalizedDefinitons = normalize(action.payload, productDefinitionsListSchema);
-			return state.setIn(["definitions", "product"], Immutable.fromJS(normalizedDefinitons.entities.definitions));
+			return state.setIn(
+				["definitions", PRODUCT_MODULE_NAME],
+				Immutable.fromJS(normalizedDefinitons.entities.definitions),
+			);
 		}
 		case GET_PROFILE_ATTRIBUTE_GROUPS_SUCCESS: {
 			const normalizedData = normalize(action.payload?.profileAttributeGroups, profileAttributeGroupsListSchema);
 			return state.set("profileAttributeGroups", Immutable.fromJS(normalizedData.entities.metadata));
 		}
+		case SAVE_ORDER_LOOKUP_SUCCESS:
+		case GET_ORDER_LOOKUP_SUCCESS:
+			return state.setIn(
+				["lookups", ORDER_MODULE_NAME, "index", action.payload.lookupName],
+				Immutable.fromJS(action.payload),
+			);
+
+		case ADD_ORDER_LOOKUP_SUCCESS: {
+			state = state.setIn(
+				["lookups", ORDER_MODULE_NAME, "index", action.payload.lookupName],
+				Immutable.fromJS(action.payload),
+			);
+
+			return lookupReducerHelper.getPagedLookups(ORDER_MODULE_NAME, state);
+		}
+
+		case SAVE_CUSTOMER_LOOKUP_SUCCESS:
+		case GET_CUSTOMER_LOOKUP_SUCCESS:
+			return state.setIn(
+				["lookups", CUSTOMER_MODULE_NAME, "index", action.payload.lookupName],
+				Immutable.fromJS(action.payload),
+			);
+
+		case ADD_CUSTOMER_LOOKUP_SUCCESS: {
+			state = state.setIn(
+				["lookups", CUSTOMER_MODULE_NAME, "index", action.payload.lookupName],
+				Immutable.fromJS(action.payload),
+			);
+
+			return lookupReducerHelper.getPagedLookups(CUSTOMER_MODULE_NAME, state);
+		}
+
+		case CREATE_PROFILE_DEFINITION_SUCCESS:
+			return state.setIn(
+				["definitions", CUSTOMER_MODULE_NAME, action.payload.entityTypeName],
+				Immutable.fromJS(action.payload),
+			);
+
+		case UPDATE_PROFILE_DEFINITION_SUCCESS:
+			return state.setIn(
+				["definitions", CUSTOMER_MODULE_NAME, action.payload.entityTypeName],
+				Immutable.fromJS(action.payload),
+			);
 		default:
 			return state;
 	}