@dhis2/app-service-data 3.2.7 → 3.2.8

package/build/cjs/__tests__/integration.test.js

@@ -10,8 +10,8 @@ function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return
 
 function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 
-describe('Testing custom data provider and useQuery hook', () => {
-  it('Should render without failing', async () => {
+describe('<DataQuery />', () => {
+  it('should render without failing', async () => {
     const data = {
       answer: 42
     };
@@ -22,18 +22,8 @@ describe('Testing custom data provider and useQuery hook', () => {
       data: data
     }, children);
 
-    const renderFunction = jest.fn(({
-      loading,
-      error,
-      data
-    }) => {
-      if (loading) return 'loading';
-      if (error) return /*#__PURE__*/React.createElement("div", null, "error: ", error.message);
-      return /*#__PURE__*/React.createElement("div", null, "data: ", data && data.answer);
-    });
-    const {
-      getByText
-    } = (0, _react.render)( /*#__PURE__*/React.createElement(_react3.DataQuery, {
+    const renderFunction = jest.fn(() => null);
+    (0, _react.render)( /*#__PURE__*/React.createElement(_react3.DataQuery, {
       query: {
         answer: {
           resource: 'answer'
@@ -42,24 +32,21 @@ describe('Testing custom data provider and useQuery hook', () => {
     }, renderFunction), {
       wrapper
     });
-    expect(getByText(/loading/i)).not.toBeUndefined();
     expect(renderFunction).toHaveBeenCalledTimes(1);
     expect(renderFunction).toHaveBeenLastCalledWith(expect.objectContaining({
       called: true,
       loading: true
     }));
     await (0, _react.waitFor)(() => {
-      getByText(/data: /i);
+      expect(renderFunction).toHaveBeenCalledTimes(2);
+      expect(renderFunction).toHaveBeenLastCalledWith(expect.objectContaining({
+        called: true,
+        loading: false,
+        data
+      }));
     });
-    expect(getByText(/data: /i)).toHaveTextContent("data: ".concat(data.answer));
-    expect(renderFunction).toHaveBeenCalledTimes(2);
-    expect(renderFunction).toHaveBeenLastCalledWith(expect.objectContaining({
-      called: true,
-      loading: false,
-      data
-    }));
   });
-  it('Should render an error', async () => {
+  it('should render an error', async () => {
     const expectedError = new Error('Something went wrong');
     const data = {
       test: () => {
@@ -73,18 +60,8 @@ describe('Testing custom data provider and useQuery hook', () => {
       data: data
     }, children);
 
-    const renderFunction = jest.fn(({
-      loading,
-      error,
-      data
-    }) => {
-      if (loading) return 'loading';
-      if (error) return /*#__PURE__*/React.createElement("div", null, "error: ", error.message);
-      return /*#__PURE__*/React.createElement("div", null, "data: ", data && data.test);
-    });
-    const {
-      getByText
-    } = (0, _react.render)( /*#__PURE__*/React.createElement(_react3.DataQuery, {
+    const renderFunction = jest.fn(() => null);
+    (0, _react.render)( /*#__PURE__*/React.createElement(_react3.DataQuery, {
       query: {
         test: {
           resource: 'test'
@@ -93,21 +70,18 @@ describe('Testing custom data provider and useQuery hook', () => {
     }, renderFunction), {
       wrapper
     });
-    expect(getByText(/loading/i)).not.toBeUndefined();
     expect(renderFunction).toHaveBeenCalledTimes(1);
     expect(renderFunction).toHaveBeenLastCalledWith(expect.objectContaining({
       called: true,
       loading: true
     }));
     await (0, _react.waitFor)(() => {
-      getByText(/error: /i);
+      expect(renderFunction).toHaveBeenCalledTimes(2);
+      expect(renderFunction).toHaveBeenLastCalledWith(expect.objectContaining({
+        called: true,
+        loading: false,
+        error: expectedError
+      }));
     });
-    expect(renderFunction).toHaveBeenCalledTimes(2);
-    expect(getByText(/error: /i)).toHaveTextContent("error: ".concat(expectedError.message));
-    expect(renderFunction).toHaveBeenLastCalledWith(expect.objectContaining({
-      called: true,
-      loading: false,
-      error: expectedError
-    }));
   });
 });

package/build/cjs/__tests__/mutations.test.js

@@ -2,82 +2,73 @@
 
 var _react = require("@testing-library/react");
 
-var _react2 = _interopRequireDefault(require("react"));
+var React = _interopRequireWildcard(require("react"));
 
 var _react3 = require("../react");
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
 
-const mockBackend = {
-  target: jest.fn((type, query) => {
-    expect(query.resource).toBe('target');
-    expect(type).toBe('create');
-    expect(query.data).toMatchObject({
-      question: '?'
-    });
-    return Promise.resolve({
-      answer: 42
-    });
-  })
-};
-describe('Test mutations', () => {
-  it('Should call the mock callback', async () => {
-    let doMutation;
-    const renderFunction = jest.fn(([mutate, {
-      called,
-      loading,
-      error,
-      data
-    }]) => {
-      doMutation = mutate;
-      if (!called) return 'uncalled';
-      if (loading) return 'loading';
-      if (error) return /*#__PURE__*/_react2.default.createElement("div", null, "error: ", error.message);
-      if (data) return /*#__PURE__*/_react2.default.createElement("div", null, "data: ", data.answer);
-    });
-    const testMutation = {
-      resource: 'target',
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+describe('<DataMutation />', () => {
+  it('should render without failing', async () => {
+    const endpointSpy = jest.fn(() => Promise.resolve(42));
+    const mutation = {
+      resource: 'answer',
       type: 'create',
       data: {
         question: '?'
       }
     };
-    const {
-      getByText
-    } = (0, _react.render)( /*#__PURE__*/_react2.default.createElement(_react3.CustomDataProvider, {
-      data: mockBackend
-    }, /*#__PURE__*/_react2.default.createElement(_react3.DataMutation, {
-      mutation: testMutation
-    }, renderFunction)));
-    expect(getByText(/uncalled/i)).not.toBeUndefined();
-    expect(renderFunction).toHaveBeenCalledTimes(1);
-    expect(mockBackend.target).not.toHaveBeenCalled();
-    expect(renderFunction).toHaveBeenLastCalledWith([expect.any(Function), {
+    const data = {
+      answer: endpointSpy
+    };
+
+    const wrapper = ({
+      children
+    }) => /*#__PURE__*/React.createElement(_react3.CustomDataProvider, {
+      data: data
+    }, children);
+
+    const renderSpy = jest.fn(() => null);
+    (0, _react.render)( /*#__PURE__*/React.createElement(_react3.DataMutation, {
+      mutation: mutation
+    }, renderSpy), {
+      wrapper
+    });
+    expect(endpointSpy).toHaveBeenCalledTimes(0);
+    expect(renderSpy).toHaveBeenCalledTimes(1);
+    expect(renderSpy).toHaveBeenLastCalledWith([expect.any(Function), expect.objectContaining({
       called: false,
       loading: false,
       engine: expect.any(Object)
-    }]);
-    expect(doMutation).not.toBeUndefined();
-    (0, _react.act)(() => {
-      doMutation && doMutation();
+    })]);
+    await (0, _react.act)(async () => {
+      const firstRenderSpyCall = renderSpy.mock.calls[0];
+      const firstRenderSpyArgument = firstRenderSpyCall[0];
+      const [mutate] = firstRenderSpyArgument;
+      await mutate();
+    });
+    (0, _react.waitFor)(() => {
+      expect(endpointSpy).toHaveBeenCalledTimes(1);
+      expect(renderSpy).toHaveBeenCalledTimes(2);
+      expect(renderSpy).toHaveBeenLastCalledWith([expect.any(Function), expect.objectContaining({
+        called: true,
+        loading: true,
+        engine: expect.any(Object)
+      })]);
+    });
+    (0, _react.waitFor)(() => {
+      expect(endpointSpy).toHaveBeenCalledTimes(1);
+      expect(renderSpy).toHaveBeenCalledTimes(3);
+      expect(renderSpy).toHaveBeenLastCalledWith([expect.any(Function), expect.objectContaining({
+        called: true,
+        loading: false,
+        data: {
+          answer: 42
+        },
+        engine: expect.any(Object)
+      })]);
     });
-    expect(renderFunction).toHaveBeenCalledTimes(2);
-    expect(renderFunction).toHaveBeenLastCalledWith([doMutation, {
-      called: true,
-      loading: true,
-      engine: expect.any(Object)
-    }]);
-    expect(mockBackend.target).toHaveBeenCalledTimes(1);
-    await (0, _react.waitFor)(() => getByText(/data: /i));
-    expect(renderFunction).toHaveBeenCalledTimes(3);
-    expect(renderFunction).toHaveBeenLastCalledWith([doMutation, {
-      called: true,
-      loading: false,
-      data: {
-        answer: 42
-      },
-      engine: expect.any(Object)
-    }]);
-    expect(getByText(/data: /i)).toHaveTextContent("data: 42");
   });
 });

package/build/cjs/links/RestAPILink/queryToRequestOptions/textPlainMatchers.js

@@ -36,7 +36,7 @@ exports.isCreateFeedbackMessage = isCreateFeedbackMessage;
 const isCreateInterpretation = (type, {
   resource
 }) => {
-  const pattern = /^interpretations\/(?:reportTable|chart|visualization|map|eventReport|eventChart|dataSetReport)\/[a-zA-Z0-9]{11}$/;
+  const pattern = /^interpretations\/(?:reportTable|chart|visualization|map|eventVisualization|eventReport|eventChart|dataSetReport)\/[a-zA-Z0-9]{11}$/;
   return type === 'create' && pattern.test(resource);
 }; // PUT to `interpretations/${id}` (update an interpretation)
 

package/build/cjs/react/hooks/useDataMutation.test.js

@@ -2,79 +2,347 @@
 
 var _reactHooks = require("@testing-library/react-hooks");
 
-var _react = _interopRequireDefault(require("react"));
+var React = _interopRequireWildcard(require("react"));
 
 var _CustomDataProvider = require("../components/CustomDataProvider");
 
+var _useDataEngine = require("./useDataEngine");
+
 var _useDataMutation = require("./useDataMutation");
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-const customData = {
-  answer: 42
-};
-
-const wrapper = ({
-  children
-}) => /*#__PURE__*/_react.default.createElement(_CustomDataProvider.CustomDataProvider, {
-  data: customData
-}, children);
-
-const mutation = {
-  type: 'create',
-  resource: 'answer',
-  data: {
-    answer: 42
-  }
-};
-describe('useDataMustation', () => {
-  const originalError = console.error;
-  afterEach(() => {
-    console.error = originalError;
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+describe('useDataMutation', () => {
+  it('should render without failing', async () => {
+    const mutation = {
+      type: 'create',
+      resource: 'answer',
+      data: {
+        answer: '?'
+      }
+    };
+    const data = {
+      answer: 42
+    };
+
+    const wrapper = ({
+      children
+    }) => /*#__PURE__*/React.createElement(_CustomDataProvider.CustomDataProvider, {
+      data: data
+    }, children);
+
+    const {
+      result,
+      waitFor
+    } = (0, _reactHooks.renderHook)(() => (0, _useDataMutation.useDataMutation)(mutation), {
+      wrapper
+    });
+    const [mutate, beforeMutation] = result.current;
+    expect(beforeMutation).toMatchObject({
+      loading: false,
+      called: false
+    });
+    (0, _reactHooks.act)(() => {
+      mutate();
+    });
+    await waitFor(() => {
+      const [, duringMutation] = result.current;
+      expect(duringMutation).toMatchObject({
+        loading: true,
+        called: true
+      });
+    });
+    await waitFor(() => {
+      const [, afterMutation] = result.current;
+      expect(afterMutation).toMatchObject({
+        loading: false,
+        called: true,
+        data: 42
+      });
+    });
   });
-  it('Should render without failing', async () => {
-    let hookState;
-    console.error = jest.fn();
+  it('should run immediately with lazy: false', async () => {
+    const mutation = {
+      type: 'create',
+      resource: 'answer',
+      data: {
+        answer: '?'
+      }
+    };
+    const data = {
+      answer: 42
+    };
+
+    const wrapper = ({
+      children
+    }) => /*#__PURE__*/React.createElement(_CustomDataProvider.CustomDataProvider, {
+      data: data
+    }, children);
+
+    const {
+      result,
+      waitFor
+    } = (0, _reactHooks.renderHook)(() => (0, _useDataMutation.useDataMutation)(mutation, {
+      lazy: false
+    }), {
+      wrapper
+    });
+    const [, duringMutation] = result.current;
+    expect(duringMutation).toMatchObject({
+      loading: true,
+      called: true
+    });
+    await waitFor(() => {
+      const [, afterMutation] = result.current;
+      expect(afterMutation).toMatchObject({
+        loading: false,
+        called: true,
+        data: 42
+      });
+    });
+  });
+  it('should call onComplete on success', async () => {
+    const onComplete = jest.fn();
+    const mutation = {
+      type: 'create',
+      resource: 'answer',
+      data: {
+        answer: '?'
+      }
+    };
+    const data = {
+      answer: 42
+    };
+
+    const wrapper = ({
+      children
+    }) => /*#__PURE__*/React.createElement(_CustomDataProvider.CustomDataProvider, {
+      data: data
+    }, children);
+
+    const {
+      result,
+      waitFor
+    } = (0, _reactHooks.renderHook)(() => (0, _useDataMutation.useDataMutation)(mutation, {
+      onComplete
+    }), {
+      wrapper
+    });
+    expect(onComplete).toHaveBeenCalledTimes(0);
+    const [mutate] = result.current;
     (0, _reactHooks.act)(() => {
-      hookState = (0, _reactHooks.renderHook)(() => (0, _useDataMutation.useDataMutation)(mutation), {
-        wrapper
+      mutate();
+    });
+    await waitFor(() => {
+      const [, state] = result.current;
+      expect(state).toMatchObject({
+        loading: false,
+        called: true,
+        data: 42
       });
+      expect(onComplete).toHaveBeenCalledTimes(1);
+      expect(onComplete).toHaveBeenLastCalledWith(42);
     });
-    let [mutate, state] = hookState.result.current;
-    expect(state).toMatchObject({
-      called: false,
-      loading: false
+  });
+  it('should call onError on error', async () => {
+    const error = new Error('Something went wrong');
+    const onError = jest.fn();
+    const mutation = {
+      type: 'create',
+      resource: 'answer',
+      data: {
+        answer: 42
+      }
+    };
+    const data = {
+      answer: () => {
+        throw error;
+      }
+    };
+
+    const wrapper = ({
+      children
+    }) => /*#__PURE__*/React.createElement(_CustomDataProvider.CustomDataProvider, {
+      data: data
+    }, children);
+
+    const {
+      result,
+      waitFor
+    } = (0, _reactHooks.renderHook)(() => (0, _useDataMutation.useDataMutation)(mutation, {
+      onError
+    }), {
+      wrapper
     });
+    expect(onError).toHaveBeenCalledTimes(0);
+    const [mutate] = result.current;
     (0, _reactHooks.act)(() => {
       mutate();
     });
-    mutate = hookState.result.current[0];
-    state = hookState.result.current[1];
-    expect(state).toMatchObject({
-      called: true,
-      loading: true
+    await waitFor(() => {
+      const [, state] = result.current;
+      expect(state).toMatchObject({
+        loading: false,
+        called: true,
+        error
+      });
     });
+    expect(onError).toHaveBeenCalledTimes(1);
+    expect(onError).toHaveBeenLastCalledWith(error);
   });
-  it('Should run immediately with lazy: false', async () => {
-    let hookState;
-    console.error = jest.fn();
+  it('should resolve variables', async () => {
+    const mutation = {
+      type: 'update',
+      resource: 'answer',
+      id: ({
+        id
+      }) => id,
+      data: {
+        answer: '?'
+      }
+    };
+    const answerSpy = jest.fn(() => 42);
+    const data = {
+      answer: answerSpy
+    };
+
+    const wrapper = ({
+      children
+    }) => /*#__PURE__*/React.createElement(_CustomDataProvider.CustomDataProvider, {
+      data: data
+    }, children);
+
+    const {
+      result,
+      waitFor
+    } = (0, _reactHooks.renderHook)(() => (0, _useDataMutation.useDataMutation)(mutation, {
+      lazy: false,
+      variables: {
+        id: '1'
+      }
+    }), {
+      wrapper
+    });
+    await waitFor(() => {
+      expect(answerSpy).toHaveBeenLastCalledWith(expect.any(String), expect.objectContaining({
+        id: '1'
+      }), expect.any(Object));
+    });
+    const [mutate] = result.current;
     (0, _reactHooks.act)(() => {
-      hookState = (0, _reactHooks.renderHook)(() => (0, _useDataMutation.useDataMutation)(mutation, {
-        lazy: false
-      }), {
-        wrapper
+      mutate({
+        id: '2'
       });
     });
-    let [, state] = hookState.result.current;
-    expect(state).toMatchObject({
-      called: true,
-      loading: true
+    await waitFor(() => {
+      expect(answerSpy).toHaveBeenLastCalledWith(expect.any(String), expect.objectContaining({
+        id: '2'
+      }), expect.any(Object));
     });
-    await hookState.waitForNextUpdate();
-    state = hookState.result.current[1];
+  });
+  it('should return a reference to the engine', async () => {
+    const mutation = {
+      type: 'create',
+      resource: 'answer',
+      data: {
+        answer: '?'
+      }
+    };
+
+    const wrapper = ({
+      children
+    }) => /*#__PURE__*/React.createElement(_CustomDataProvider.CustomDataProvider, {
+      data: {}
+    }, children);
+
+    const engineHook = (0, _reactHooks.renderHook)(() => (0, _useDataEngine.useDataEngine)(), {
+      wrapper
+    });
+    const mutationHook = (0, _reactHooks.renderHook)(() => (0, _useDataMutation.useDataMutation)(mutation), {
+      wrapper
+    });
+    /**
+     * Ideally we'd check referential equality here with .toBe, but since
+     * both hooks run in a different context that doesn't work.
+     */
+
+    expect(mutationHook.result.current[1].engine).toStrictEqual(engineHook.result.current);
+  });
+  it('should return a stable mutate function', async () => {
+    const mutation = {
+      type: 'create',
+      resource: 'answer',
+      data: {
+        answer: '?'
+      }
+    };
+    const data = {
+      answer: 42
+    };
+
+    const wrapper = ({
+      children
+    }) => /*#__PURE__*/React.createElement(_CustomDataProvider.CustomDataProvider, {
+      data: data
+    }, children);
+
+    const {
+      result
+    } = (0, _reactHooks.renderHook)(() => (0, _useDataMutation.useDataMutation)(mutation), {
+      wrapper
+    });
+    const [firstMutate] = result.current;
+    await (0, _reactHooks.act)(async () => {
+      await firstMutate({
+        variable: 'variable'
+      });
+    });
+    const [secondMutate, state] = result.current;
     expect(state).toMatchObject({
       loading: false,
-      data: 42
+      called: true
+    });
+    expect(firstMutate).toBe(secondMutate);
+  });
+  it('should resolve with the data from mutate on success', async () => {
+    const mutation = {
+      type: 'create',
+      resource: 'answer',
+      data: {
+        answer: '?'
+      }
+    };
+    const data = {
+      answer: 42
+    };
+
+    const wrapper = ({
+      children
+    }) => /*#__PURE__*/React.createElement(_CustomDataProvider.CustomDataProvider, {
+      data: data
+    }, children);
+
+    const {
+      result,
+      waitFor
+    } = (0, _reactHooks.renderHook)(() => (0, _useDataMutation.useDataMutation)(mutation), {
+      wrapper
+    });
+    let mutatePromise;
+    const [mutate] = result.current;
+    (0, _reactHooks.act)(() => {
+      mutatePromise = mutate();
+    });
+    await waitFor(() => {
+      const [, state] = result.current;
+      expect(state).toMatchObject({
+        loading: false,
+        called: true,
+        data: 42
+      });
+      expect(mutatePromise).resolves.toBe(42);
     });
   });
 });

package/build/es/__tests__/integration.test.js

@@ -1,8 +1,8 @@
 import { render, waitFor } from '@testing-library/react';
 import * as React from 'react';
 import { CustomDataProvider, DataQuery } from '../react';
-describe('Testing custom data provider and useQuery hook', () => {
-  it('Should render without failing', async () => {
+describe('<DataQuery />', () => {
+  it('should render without failing', async () => {
     const data = {
       answer: 42
     };
@@ -13,18 +13,8 @@ describe('Testing custom data provider and useQuery hook', () => {
       data: data
     }, children);
 
-    const renderFunction = jest.fn(({
-      loading,
-      error,
-      data
-    }) => {
-      if (loading) return 'loading';
-      if (error) return /*#__PURE__*/React.createElement("div", null, "error: ", error.message);
-      return /*#__PURE__*/React.createElement("div", null, "data: ", data && data.answer);
-    });
-    const {
-      getByText
-    } = render( /*#__PURE__*/React.createElement(DataQuery, {
+    const renderFunction = jest.fn(() => null);
+    render( /*#__PURE__*/React.createElement(DataQuery, {
       query: {
         answer: {
           resource: 'answer'
@@ -33,24 +23,21 @@ describe('Testing custom data provider and useQuery hook', () => {
     }, renderFunction), {
       wrapper
     });
-    expect(getByText(/loading/i)).not.toBeUndefined();
     expect(renderFunction).toHaveBeenCalledTimes(1);
     expect(renderFunction).toHaveBeenLastCalledWith(expect.objectContaining({
       called: true,
       loading: true
     }));
     await waitFor(() => {
-      getByText(/data: /i);
+      expect(renderFunction).toHaveBeenCalledTimes(2);
+      expect(renderFunction).toHaveBeenLastCalledWith(expect.objectContaining({
+        called: true,
+        loading: false,
+        data
+      }));
     });
-    expect(getByText(/data: /i)).toHaveTextContent("data: ".concat(data.answer));
-    expect(renderFunction).toHaveBeenCalledTimes(2);
-    expect(renderFunction).toHaveBeenLastCalledWith(expect.objectContaining({
-      called: true,
-      loading: false,
-      data
-    }));
   });
-  it('Should render an error', async () => {
+  it('should render an error', async () => {
     const expectedError = new Error('Something went wrong');
     const data = {
       test: () => {
@@ -64,18 +51,8 @@ describe('Testing custom data provider and useQuery hook', () => {
       data: data
     }, children);
 
-    const renderFunction = jest.fn(({
-      loading,
-      error,
-      data
-    }) => {
-      if (loading) return 'loading';
-      if (error) return /*#__PURE__*/React.createElement("div", null, "error: ", error.message);
-      return /*#__PURE__*/React.createElement("div", null, "data: ", data && data.test);
-    });
-    const {
-      getByText
-    } = render( /*#__PURE__*/React.createElement(DataQuery, {
+    const renderFunction = jest.fn(() => null);
+    render( /*#__PURE__*/React.createElement(DataQuery, {
       query: {
         test: {
           resource: 'test'
@@ -84,21 +61,18 @@ describe('Testing custom data provider and useQuery hook', () => {
     }, renderFunction), {
       wrapper
     });
-    expect(getByText(/loading/i)).not.toBeUndefined();
     expect(renderFunction).toHaveBeenCalledTimes(1);
     expect(renderFunction).toHaveBeenLastCalledWith(expect.objectContaining({
       called: true,
       loading: true
     }));
     await waitFor(() => {
-      getByText(/error: /i);
+      expect(renderFunction).toHaveBeenCalledTimes(2);
+      expect(renderFunction).toHaveBeenLastCalledWith(expect.objectContaining({
+        called: true,
+        loading: false,
+        error: expectedError
+      }));
     });
-    expect(renderFunction).toHaveBeenCalledTimes(2);
-    expect(getByText(/error: /i)).toHaveTextContent("error: ".concat(expectedError.message));
-    expect(renderFunction).toHaveBeenLastCalledWith(expect.objectContaining({
-      called: true,
-      loading: false,
-      error: expectedError
-    }));
   });
 });

package/build/es/__tests__/mutations.test.js

@@ -1,76 +1,65 @@
-import { render, act, waitFor } from '@testing-library/react';
-import React from 'react';
+import { render, waitFor, act } from '@testing-library/react';
+import * as React from 'react';
 import { CustomDataProvider, DataMutation } from '../react';
-const mockBackend = {
-  target: jest.fn((type, query) => {
-    expect(query.resource).toBe('target');
-    expect(type).toBe('create');
-    expect(query.data).toMatchObject({
-      question: '?'
-    });
-    return Promise.resolve({
-      answer: 42
-    });
-  })
-};
-describe('Test mutations', () => {
-  it('Should call the mock callback', async () => {
-    let doMutation;
-    const renderFunction = jest.fn(([mutate, {
-      called,
-      loading,
-      error,
-      data
-    }]) => {
-      doMutation = mutate;
-      if (!called) return 'uncalled';
-      if (loading) return 'loading';
-      if (error) return /*#__PURE__*/React.createElement("div", null, "error: ", error.message);
-      if (data) return /*#__PURE__*/React.createElement("div", null, "data: ", data.answer);
-    });
-    const testMutation = {
-      resource: 'target',
+describe('<DataMutation />', () => {
+  it('should render without failing', async () => {
+    const endpointSpy = jest.fn(() => Promise.resolve(42));
+    const mutation = {
+      resource: 'answer',
       type: 'create',
       data: {
         question: '?'
       }
     };
-    const {
-      getByText
-    } = render( /*#__PURE__*/React.createElement(CustomDataProvider, {
-      data: mockBackend
-    }, /*#__PURE__*/React.createElement(DataMutation, {
-      mutation: testMutation
-    }, renderFunction)));
-    expect(getByText(/uncalled/i)).not.toBeUndefined();
-    expect(renderFunction).toHaveBeenCalledTimes(1);
-    expect(mockBackend.target).not.toHaveBeenCalled();
-    expect(renderFunction).toHaveBeenLastCalledWith([expect.any(Function), {
+    const data = {
+      answer: endpointSpy
+    };
+
+    const wrapper = ({
+      children
+    }) => /*#__PURE__*/React.createElement(CustomDataProvider, {
+      data: data
+    }, children);
+
+    const renderSpy = jest.fn(() => null);
+    render( /*#__PURE__*/React.createElement(DataMutation, {
+      mutation: mutation
+    }, renderSpy), {
+      wrapper
+    });
+    expect(endpointSpy).toHaveBeenCalledTimes(0);
+    expect(renderSpy).toHaveBeenCalledTimes(1);
+    expect(renderSpy).toHaveBeenLastCalledWith([expect.any(Function), expect.objectContaining({
       called: false,
       loading: false,
       engine: expect.any(Object)
-    }]);
-    expect(doMutation).not.toBeUndefined();
-    act(() => {
-      doMutation && doMutation();
+    })]);
+    await act(async () => {
+      const firstRenderSpyCall = renderSpy.mock.calls[0];
+      const firstRenderSpyArgument = firstRenderSpyCall[0];
+      const [mutate] = firstRenderSpyArgument;
+      await mutate();
+    });
+    waitFor(() => {
+      expect(endpointSpy).toHaveBeenCalledTimes(1);
+      expect(renderSpy).toHaveBeenCalledTimes(2);
+      expect(renderSpy).toHaveBeenLastCalledWith([expect.any(Function), expect.objectContaining({
+        called: true,
+        loading: true,
+        engine: expect.any(Object)
+      })]);
+    });
+    waitFor(() => {
+      expect(endpointSpy).toHaveBeenCalledTimes(1);
+      expect(renderSpy).toHaveBeenCalledTimes(3);
+      expect(renderSpy).toHaveBeenLastCalledWith([expect.any(Function), expect.objectContaining({
+        called: true,
+        loading: false,
+        data: {
+          answer: 42
+        },
+        engine: expect.any(Object)
+      })]);
     });
-    expect(renderFunction).toHaveBeenCalledTimes(2);
-    expect(renderFunction).toHaveBeenLastCalledWith([doMutation, {
-      called: true,
-      loading: true,
-      engine: expect.any(Object)
-    }]);
-    expect(mockBackend.target).toHaveBeenCalledTimes(1);
-    await waitFor(() => getByText(/data: /i));
-    expect(renderFunction).toHaveBeenCalledTimes(3);
-    expect(renderFunction).toHaveBeenLastCalledWith([doMutation, {
-      called: true,
-      loading: false,
-      data: {
-        answer: 42
-      },
-      engine: expect.any(Object)
-    }]);
-    expect(getByText(/data: /i)).toHaveTextContent("data: 42");
   });
 });

package/build/es/links/RestAPILink/queryToRequestOptions/textPlainMatchers.js

@@ -23,7 +23,7 @@ export const isCreateFeedbackMessage = (type, {
 export const isCreateInterpretation = (type, {
   resource
 }) => {
-  const pattern = /^interpretations\/(?:reportTable|chart|visualization|map|eventReport|eventChart|dataSetReport)\/[a-zA-Z0-9]{11}$/;
+  const pattern = /^interpretations\/(?:reportTable|chart|visualization|map|eventVisualization|eventReport|eventChart|dataSetReport)\/[a-zA-Z0-9]{11}$/;
   return type === 'create' && pattern.test(resource);
 }; // PUT to `interpretations/${id}` (update an interpretation)
 

package/build/es/react/hooks/useDataMutation.test.js

@@ -1,72 +1,337 @@
 import { renderHook, act } from '@testing-library/react-hooks';
-import React from 'react';
+import * as React from 'react';
 import { CustomDataProvider } from '../components/CustomDataProvider';
+import { useDataEngine } from './useDataEngine';
 import { useDataMutation } from './useDataMutation';
-const customData = {
-  answer: 42
-};
-
-const wrapper = ({
-  children
-}) => /*#__PURE__*/React.createElement(CustomDataProvider, {
-  data: customData
-}, children);
-
-const mutation = {
-  type: 'create',
-  resource: 'answer',
-  data: {
-    answer: 42
-  }
-};
-describe('useDataMustation', () => {
-  const originalError = console.error;
-  afterEach(() => {
-    console.error = originalError;
+describe('useDataMutation', () => {
+  it('should render without failing', async () => {
+    const mutation = {
+      type: 'create',
+      resource: 'answer',
+      data: {
+        answer: '?'
+      }
+    };
+    const data = {
+      answer: 42
+    };
+
+    const wrapper = ({
+      children
+    }) => /*#__PURE__*/React.createElement(CustomDataProvider, {
+      data: data
+    }, children);
+
+    const {
+      result,
+      waitFor
+    } = renderHook(() => useDataMutation(mutation), {
+      wrapper
+    });
+    const [mutate, beforeMutation] = result.current;
+    expect(beforeMutation).toMatchObject({
+      loading: false,
+      called: false
+    });
+    act(() => {
+      mutate();
+    });
+    await waitFor(() => {
+      const [, duringMutation] = result.current;
+      expect(duringMutation).toMatchObject({
+        loading: true,
+        called: true
+      });
+    });
+    await waitFor(() => {
+      const [, afterMutation] = result.current;
+      expect(afterMutation).toMatchObject({
+        loading: false,
+        called: true,
+        data: 42
+      });
+    });
+  });
+  it('should run immediately with lazy: false', async () => {
+    const mutation = {
+      type: 'create',
+      resource: 'answer',
+      data: {
+        answer: '?'
+      }
+    };
+    const data = {
+      answer: 42
+    };
+
+    const wrapper = ({
+      children
+    }) => /*#__PURE__*/React.createElement(CustomDataProvider, {
+      data: data
+    }, children);
+
+    const {
+      result,
+      waitFor
+    } = renderHook(() => useDataMutation(mutation, {
+      lazy: false
+    }), {
+      wrapper
+    });
+    const [, duringMutation] = result.current;
+    expect(duringMutation).toMatchObject({
+      loading: true,
+      called: true
+    });
+    await waitFor(() => {
+      const [, afterMutation] = result.current;
+      expect(afterMutation).toMatchObject({
+        loading: false,
+        called: true,
+        data: 42
+      });
+    });
   });
-  it('Should render without failing', async () => {
-    let hookState;
-    console.error = jest.fn();
+  it('should call onComplete on success', async () => {
+    const onComplete = jest.fn();
+    const mutation = {
+      type: 'create',
+      resource: 'answer',
+      data: {
+        answer: '?'
+      }
+    };
+    const data = {
+      answer: 42
+    };
+
+    const wrapper = ({
+      children
+    }) => /*#__PURE__*/React.createElement(CustomDataProvider, {
+      data: data
+    }, children);
+
+    const {
+      result,
+      waitFor
+    } = renderHook(() => useDataMutation(mutation, {
+      onComplete
+    }), {
+      wrapper
+    });
+    expect(onComplete).toHaveBeenCalledTimes(0);
+    const [mutate] = result.current;
     act(() => {
-      hookState = renderHook(() => useDataMutation(mutation), {
-        wrapper
+      mutate();
+    });
+    await waitFor(() => {
+      const [, state] = result.current;
+      expect(state).toMatchObject({
+        loading: false,
+        called: true,
+        data: 42
       });
+      expect(onComplete).toHaveBeenCalledTimes(1);
+      expect(onComplete).toHaveBeenLastCalledWith(42);
     });
-    let [mutate, state] = hookState.result.current;
-    expect(state).toMatchObject({
-      called: false,
-      loading: false
+  });
+  it('should call onError on error', async () => {
+    const error = new Error('Something went wrong');
+    const onError = jest.fn();
+    const mutation = {
+      type: 'create',
+      resource: 'answer',
+      data: {
+        answer: 42
+      }
+    };
+    const data = {
+      answer: () => {
+        throw error;
+      }
+    };
+
+    const wrapper = ({
+      children
+    }) => /*#__PURE__*/React.createElement(CustomDataProvider, {
+      data: data
+    }, children);
+
+    const {
+      result,
+      waitFor
+    } = renderHook(() => useDataMutation(mutation, {
+      onError
+    }), {
+      wrapper
     });
+    expect(onError).toHaveBeenCalledTimes(0);
+    const [mutate] = result.current;
     act(() => {
       mutate();
     });
-    mutate = hookState.result.current[0];
-    state = hookState.result.current[1];
-    expect(state).toMatchObject({
-      called: true,
-      loading: true
+    await waitFor(() => {
+      const [, state] = result.current;
+      expect(state).toMatchObject({
+        loading: false,
+        called: true,
+        error
+      });
     });
+    expect(onError).toHaveBeenCalledTimes(1);
+    expect(onError).toHaveBeenLastCalledWith(error);
   });
-  it('Should run immediately with lazy: false', async () => {
-    let hookState;
-    console.error = jest.fn();
+  it('should resolve variables', async () => {
+    const mutation = {
+      type: 'update',
+      resource: 'answer',
+      id: ({
+        id
+      }) => id,
+      data: {
+        answer: '?'
+      }
+    };
+    const answerSpy = jest.fn(() => 42);
+    const data = {
+      answer: answerSpy
+    };
+
+    const wrapper = ({
+      children
+    }) => /*#__PURE__*/React.createElement(CustomDataProvider, {
+      data: data
+    }, children);
+
+    const {
+      result,
+      waitFor
+    } = renderHook(() => useDataMutation(mutation, {
+      lazy: false,
+      variables: {
+        id: '1'
+      }
+    }), {
+      wrapper
+    });
+    await waitFor(() => {
+      expect(answerSpy).toHaveBeenLastCalledWith(expect.any(String), expect.objectContaining({
+        id: '1'
+      }), expect.any(Object));
+    });
+    const [mutate] = result.current;
     act(() => {
-      hookState = renderHook(() => useDataMutation(mutation, {
-        lazy: false
-      }), {
-        wrapper
+      mutate({
+        id: '2'
       });
     });
-    let [, state] = hookState.result.current;
-    expect(state).toMatchObject({
-      called: true,
-      loading: true
+    await waitFor(() => {
+      expect(answerSpy).toHaveBeenLastCalledWith(expect.any(String), expect.objectContaining({
+        id: '2'
+      }), expect.any(Object));
     });
-    await hookState.waitForNextUpdate();
-    state = hookState.result.current[1];
+  });
+  it('should return a reference to the engine', async () => {
+    const mutation = {
+      type: 'create',
+      resource: 'answer',
+      data: {
+        answer: '?'
+      }
+    };
+
+    const wrapper = ({
+      children
+    }) => /*#__PURE__*/React.createElement(CustomDataProvider, {
+      data: {}
+    }, children);
+
+    const engineHook = renderHook(() => useDataEngine(), {
+      wrapper
+    });
+    const mutationHook = renderHook(() => useDataMutation(mutation), {
+      wrapper
+    });
+    /**
+     * Ideally we'd check referential equality here with .toBe, but since
+     * both hooks run in a different context that doesn't work.
+     */
+
+    expect(mutationHook.result.current[1].engine).toStrictEqual(engineHook.result.current);
+  });
+  it('should return a stable mutate function', async () => {
+    const mutation = {
+      type: 'create',
+      resource: 'answer',
+      data: {
+        answer: '?'
+      }
+    };
+    const data = {
+      answer: 42
+    };
+
+    const wrapper = ({
+      children
+    }) => /*#__PURE__*/React.createElement(CustomDataProvider, {
+      data: data
+    }, children);
+
+    const {
+      result
+    } = renderHook(() => useDataMutation(mutation), {
+      wrapper
+    });
+    const [firstMutate] = result.current;
+    await act(async () => {
+      await firstMutate({
+        variable: 'variable'
+      });
+    });
+    const [secondMutate, state] = result.current;
     expect(state).toMatchObject({
       loading: false,
-      data: 42
+      called: true
+    });
+    expect(firstMutate).toBe(secondMutate);
+  });
+  it('should resolve with the data from mutate on success', async () => {
+    const mutation = {
+      type: 'create',
+      resource: 'answer',
+      data: {
+        answer: '?'
+      }
+    };
+    const data = {
+      answer: 42
+    };
+
+    const wrapper = ({
+      children
+    }) => /*#__PURE__*/React.createElement(CustomDataProvider, {
+      data: data
+    }, children);
+
+    const {
+      result,
+      waitFor
+    } = renderHook(() => useDataMutation(mutation), {
+      wrapper
+    });
+    let mutatePromise;
+    const [mutate] = result.current;
+    act(() => {
+      mutatePromise = mutate();
+    });
+    await waitFor(() => {
+      const [, state] = result.current;
+      expect(state).toMatchObject({
+        loading: false,
+        called: true,
+        data: 42
+      });
+      expect(mutatePromise).resolves.toBe(42);
     });
   });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@dhis2/app-service-data",
-    "version": "3.2.7",
+    "version": "3.2.8",
     "main": "./build/cjs/index.js",
     "module": "./build/es/index.js",
     "types": "build/types/index.d.ts",
@@ -22,7 +22,7 @@
         "build/**"
     ],
     "peerDependencies": {
-        "@dhis2/app-service-config": "3.2.7",
+        "@dhis2/app-service-config": "3.2.8",
         "@dhis2/cli-app-scripts": "^7.1.1",
         "prop-types": "^15.7.2",
         "react": "^16.8",