@dhis2/app-service-data 3.2.3 → 3.2.7

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

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.isMetadataPackageInstallation = exports.addOrUpdateConfigurationProperty = exports.isAddOrUpdateSystemOrUserSetting = exports.isInterpretationCommentUpdate = exports.isCommentOnInterpretation = exports.isCreateOrUpdateInterpretation = exports.isCreateFeedbackMessage = exports.isReplyToMessageConversation = void 0;
+exports.isMetadataPackageInstallation = exports.addOrUpdateConfigurationProperty = exports.isAddOrUpdateSystemOrUserSetting = exports.isInterpretationCommentUpdate = exports.isCommentOnInterpretation = exports.isUpdateInterpretation = exports.isCreateInterpretation = exports.isCreateFeedbackMessage = exports.isReplyToMessageConversation = void 0;
 
 /*
  * Requests that expect a "text/plain" Content-Type have been collected by scanning
@@ -28,33 +28,43 @@ exports.isReplyToMessageConversation = isReplyToMessageConversation;
 
 const isCreateFeedbackMessage = (type, {
   resource
-}) => type === 'create' && resource === 'messageConversations/feedback'; // POST or PUT to `interpretations/${objectType}/${id}` (add or update an interpretation)
+}) => type === 'create' && resource === 'messageConversations/feedback'; // POST `interpretations/${objectType}/${id}` (add an interpretation to a visualization)
 
 
 exports.isCreateFeedbackMessage = isCreateFeedbackMessage;
 
-const isCreateOrUpdateInterpretation = (type, {
+const isCreateInterpretation = (type, {
+  resource
+}) => {
+  const pattern = /^interpretations\/(?:reportTable|chart|visualization|map|eventReport|eventChart|dataSetReport)\/[a-zA-Z0-9]{11}$/;
+  return type === 'create' && pattern.test(resource);
+}; // PUT to `interpretations/${id}` (update an interpretation)
+
+
+exports.isCreateInterpretation = isCreateInterpretation;
+
+const isUpdateInterpretation = (type, {
   resource,
   id
 }) => {
-  if (type !== 'create' && type !== 'replace') {
+  if (type !== 'replace') {
     return false;
   }
 
   let resourcePattern;
 
-  if (type === 'replace' && id) {
-    resourcePattern = /^interpretations\/(?:reportTable|chart|visualization|map|eventReport|eventChart|dataSetReport)$/;
+  if (id) {
+    resourcePattern = /^interpretations$/;
     const idPattern = /^[a-zA-Z0-9]{11}$/;
     return resourcePattern.test(resource) && idPattern.test(id);
   }
 
-  resourcePattern = /^interpretations\/(?:reportTable|chart|visualization|map|eventReport|eventChart|dataSetReport)\/[a-zA-Z0-9]{11}$/;
+  resourcePattern = /^interpretations\/[a-zA-Z0-9]{11}$/;
   return resourcePattern.test(resource);
 }; // POST to `interpretations/${id}/comments` (comment on an interpretation)
 
 
-exports.isCreateOrUpdateInterpretation = isCreateOrUpdateInterpretation;
+exports.isUpdateInterpretation = isUpdateInterpretation;
 
 const isCommentOnInterpretation = (type, {
   resource

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

@@ -26,30 +26,58 @@ describe('isCreateFeedbackMessage', () => {
     })).toEqual(false);
   });
 });
-describe('isCreateOrUpdateInterpretation', () => {
+describe('isCreateInterpretation', () => {
   it('returns true for a POST to "interpretations/chart/${id}"', () => {
-    expect((0, _textPlainMatchers.isCreateOrUpdateInterpretation)('create', {
+    expect((0, _textPlainMatchers.isCreateInterpretation)('create', {
       resource: 'interpretations/chart/oXD88WWSQpR'
     })).toEqual(true);
   });
-  it('returns true for a PUT to "interpretations/chart/${id}"', () => {
-    expect((0, _textPlainMatchers.isCreateOrUpdateInterpretation)('replace', {
+  it('returns false for a PUT to "interpretations/chart/${id}"', () => {
+    expect((0, _textPlainMatchers.isCreateInterpretation)('replace', {
       resource: 'interpretations/chart/oXD88WWSQpR'
+    })).toEqual(false);
+  });
+  it('retuns false for PATCH requests with a valid query', () => {
+    expect((0, _textPlainMatchers.isCreateInterpretation)('update', {
+      resource: 'interpretations/chart/oXD88WWSQpR'
+    })).toEqual(false);
+  });
+  it('returns false for a request to a different resource', () => {
+    expect((0, _textPlainMatchers.isCreateInterpretation)('create', {
+      resource: 'interpretations/dummy/oXD88WWSQpR'
+    })).toEqual(false);
+  });
+});
+describe('isUpdateInterpretation', () => {
+  it('returns true for a PUT to "interpretations/${id}"', () => {
+    expect((0, _textPlainMatchers.isUpdateInterpretation)('replace', {
+      resource: 'interpretations/oXD88WWSQpR'
     })).toEqual(true);
   });
   it('returns true for PUT with populated query.id', () => {
-    expect((0, _textPlainMatchers.isCreateOrUpdateInterpretation)('replace', {
-      resource: 'interpretations/chart',
+    expect((0, _textPlainMatchers.isUpdateInterpretation)('replace', {
+      resource: 'interpretations',
       id: 'oXD88WWSQpR'
     })).toEqual(true);
   });
-  it('retuns false for PATCH requests with a valid query', () => {
-    expect((0, _textPlainMatchers.isCreateOrUpdateInterpretation)('update', {
-      resource: 'interpretations/chart/oXD88WWSQpR'
+  it('returns false for a POST to "interpretations/${id}"', () => {
+    expect((0, _textPlainMatchers.isUpdateInterpretation)('create', {
+      resource: 'interpretations/oXD88WWSQpR'
+    })).toEqual(false);
+  });
+  it('returns false for a PATCH to "interpretations/${id}"', () => {
+    expect((0, _textPlainMatchers.isUpdateInterpretation)('update', {
+      resource: 'interpretations/oXD88WWSQpR'
+    })).toEqual(false);
+  });
+  it('returns false for PATCH with populated query.id', () => {
+    expect((0, _textPlainMatchers.isUpdateInterpretation)('update', {
+      resource: 'interpretations',
+      id: 'oXD88WWSQpR'
     })).toEqual(false);
   });
   it('returns false for a request to a different resource', () => {
-    expect((0, _textPlainMatchers.isCreateOrUpdateInterpretation)('create', {
+    expect((0, _textPlainMatchers.isUpdateInterpretation)('create', {
       resource: 'interpretations/dummy/oXD88WWSQpR'
     })).toEqual(false);
   });

package/build/cjs/react/hooks/useDataQuery.js

@@ -96,9 +96,13 @@ const useDataQuery = (query, {
   /**
    * Refetch allows a user to update the variables or just
    * trigger a refetch of the query with the current variables.
+   *
+   * We're using useCallback to make the identity of the function
+   * as stable as possible, so that it won't trigger excessive
+   * rerenders when used for side-effects.
    */
 
-  const refetch = newVariables => {
+  const refetch = (0, _react.useCallback)(newVariables => {
     /**
      * If there are no updates that will trigger an automatic refetch
      * we'll need to call react-query's refetch directly
@@ -112,10 +116,6 @@ const useDataQuery = (query, {
       }) => data);
     }
 
-    if (!enabled) {
-      setEnabled(true);
-    }
-
     if (newVariables) {
       // Use cached hash if it exists
       const currentHash = variablesHash.current || (0, _stableVariablesHash.stableVariablesHash)(variables);
@@ -125,8 +125,11 @@ const useDataQuery = (query, {
       const mergedHash = (0, _stableVariablesHash.stableVariablesHash)(mergedVariables);
       const identical = currentHash === mergedHash;
 
-      if (identical) {
-        // If the variables are identical we'll need to trigger the refetch manually
+      if (identical && enabled) {
+        /**
+         * If the variables are identical and the query is enabled
+         * we'll need to trigger the refetch manually
+         */
         return queryRefetch({
           cancelRefetch: true,
           throwOnError: false
@@ -137,6 +140,11 @@ const useDataQuery = (query, {
         variablesHash.current = mergedHash;
         setVariables(mergedVariables);
       }
+    } // Enable the query after the variables have been set to prevent extra request
+
+
+    if (!enabled) {
+      setEnabled(true);
     } // This promise does not currently reject on errors
 
 
@@ -145,13 +153,12 @@ const useDataQuery = (query, {
         resolve(data);
       };
     });
-  };
+  }, [enabled, queryRefetch, variables]);
   /**
    * react-query returns null or an error, but we return undefined
    * or an error, so this ensures consistency with the other types.
    */
 
-
   const ourError = error || undefined;
   return {
     engine,

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

@@ -507,6 +507,149 @@ describe('useDataQuery', () => {
     });
   });
   describe('return values: refetch', () => {
+    it('Should only trigger a single request when refetch is called on a lazy query with new variables', async () => {
+      const spy = jest.fn((type, query) => {
+        if (query.id === '1') {
+          return 42;
+        }
+
+        return 0;
+      });
+      const data = {
+        answer: spy
+      };
+      const query = {
+        x: {
+          resource: 'answer',
+          id: ({
+            id
+          }) => id
+        }
+      };
+
+      const wrapper = ({
+        children
+      }) => /*#__PURE__*/React.createElement(_CustomDataProvider.CustomDataProvider, {
+        data: data
+      }, children);
+
+      const {
+        result,
+        waitFor
+      } = (0, _reactHooks.renderHook)(() => (0, _useDataQuery.useDataQuery)(query, {
+        lazy: true
+      }), {
+        wrapper
+      });
+      expect(spy).not.toHaveBeenCalled();
+      (0, _reactHooks.act)(() => {
+        result.current.refetch({
+          id: '1'
+        });
+      });
+      await waitFor(() => {
+        expect(result.current).toMatchObject({
+          loading: false,
+          called: true,
+          data: {
+            x: 42
+          }
+        });
+      });
+      expect(spy).toHaveBeenCalledTimes(1);
+    });
+    it('Should only trigger a single request when refetch is called on a lazy query with identical variables', async () => {
+      const spy = jest.fn((type, query) => {
+        if (query.id === '1') {
+          return 42;
+        }
+
+        return 0;
+      });
+      const data = {
+        answer: spy
+      };
+      const query = {
+        x: {
+          resource: 'answer',
+          id: ({
+            id
+          }) => id
+        }
+      };
+
+      const wrapper = ({
+        children
+      }) => /*#__PURE__*/React.createElement(_CustomDataProvider.CustomDataProvider, {
+        data: data
+      }, children);
+
+      const {
+        result,
+        waitFor
+      } = (0, _reactHooks.renderHook)(() => (0, _useDataQuery.useDataQuery)(query, {
+        lazy: true,
+        variables: {
+          id: '1'
+        }
+      }), {
+        wrapper
+      });
+      expect(spy).not.toHaveBeenCalled();
+      (0, _reactHooks.act)(() => {
+        result.current.refetch({
+          id: '1'
+        });
+      });
+      await waitFor(() => {
+        expect(result.current).toMatchObject({
+          loading: false,
+          called: true,
+          data: {
+            x: 42
+          }
+        });
+      });
+      expect(spy).toHaveBeenCalledTimes(1);
+    });
+    it('Should have a stable identity if the variables have not changed', async () => {
+      const data = {
+        answer: () => 42
+      };
+      const query = {
+        x: {
+          resource: 'answer'
+        }
+      };
+
+      const wrapper = ({
+        children
+      }) => /*#__PURE__*/React.createElement(_CustomDataProvider.CustomDataProvider, {
+        data: data
+      }, children);
+
+      const {
+        result,
+        waitForNextUpdate,
+        rerender
+      } = (0, _reactHooks.renderHook)(() => (0, _useDataQuery.useDataQuery)(query), {
+        wrapper
+      });
+      const firstRefetch = result.current.refetch;
+      await waitForNextUpdate();
+      (0, _reactHooks.act)(() => {
+        result.current.refetch();
+        /**
+         * FIXME: https://github.com/tannerlinsley/react-query/issues/2481
+         * This forced rerender is not necessary in the app, just when testing.
+         * It is unclear why.
+         */
+
+        rerender();
+      });
+      await waitForNextUpdate();
+      expect(result.current.refetch).toBe(firstRefetch);
+    });
     it('Should return stale data and set loading to true on refetch', async () => {
       const answers = [42, 43];
       const mockSpy = jest.fn(() => Promise.resolve(answers.shift()));

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

@@ -18,25 +18,32 @@ export const isReplyToMessageConversation = (type, {
 
 export const isCreateFeedbackMessage = (type, {
   resource
-}) => type === 'create' && resource === 'messageConversations/feedback'; // POST or PUT to `interpretations/${objectType}/${id}` (add or update an interpretation)
+}) => type === 'create' && resource === 'messageConversations/feedback'; // POST `interpretations/${objectType}/${id}` (add an interpretation to a visualization)
 
-export const isCreateOrUpdateInterpretation = (type, {
+export const isCreateInterpretation = (type, {
+  resource
+}) => {
+  const pattern = /^interpretations\/(?:reportTable|chart|visualization|map|eventReport|eventChart|dataSetReport)\/[a-zA-Z0-9]{11}$/;
+  return type === 'create' && pattern.test(resource);
+}; // PUT to `interpretations/${id}` (update an interpretation)
+
+export const isUpdateInterpretation = (type, {
   resource,
   id
 }) => {
-  if (type !== 'create' && type !== 'replace') {
+  if (type !== 'replace') {
     return false;
   }
 
   let resourcePattern;
 
-  if (type === 'replace' && id) {
-    resourcePattern = /^interpretations\/(?:reportTable|chart|visualization|map|eventReport|eventChart|dataSetReport)$/;
+  if (id) {
+    resourcePattern = /^interpretations$/;
     const idPattern = /^[a-zA-Z0-9]{11}$/;
     return resourcePattern.test(resource) && idPattern.test(id);
   }
 
-  resourcePattern = /^interpretations\/(?:reportTable|chart|visualization|map|eventReport|eventChart|dataSetReport)\/[a-zA-Z0-9]{11}$/;
+  resourcePattern = /^interpretations\/[a-zA-Z0-9]{11}$/;
   return resourcePattern.test(resource);
 }; // POST to `interpretations/${id}/comments` (comment on an interpretation)
 

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

@@ -1,4 +1,4 @@
-import { isReplyToMessageConversation, isCreateFeedbackMessage, isCreateOrUpdateInterpretation, isCommentOnInterpretation, isInterpretationCommentUpdate, isAddOrUpdateSystemOrUserSetting, addOrUpdateConfigurationProperty, isMetadataPackageInstallation } from './textPlainMatchers';
+import { isReplyToMessageConversation, isCreateFeedbackMessage, isCreateInterpretation, isUpdateInterpretation, isCommentOnInterpretation, isInterpretationCommentUpdate, isAddOrUpdateSystemOrUserSetting, addOrUpdateConfigurationProperty, isMetadataPackageInstallation } from './textPlainMatchers';
 describe('isReplyToMessageConversation', () => {
   it('retuns true for POST to `messageConversations/${id}`', () => {
     expect(isReplyToMessageConversation('create', {
@@ -23,30 +23,58 @@ describe('isCreateFeedbackMessage', () => {
     })).toEqual(false);
   });
 });
-describe('isCreateOrUpdateInterpretation', () => {
+describe('isCreateInterpretation', () => {
   it('returns true for a POST to "interpretations/chart/${id}"', () => {
-    expect(isCreateOrUpdateInterpretation('create', {
+    expect(isCreateInterpretation('create', {
       resource: 'interpretations/chart/oXD88WWSQpR'
     })).toEqual(true);
   });
-  it('returns true for a PUT to "interpretations/chart/${id}"', () => {
-    expect(isCreateOrUpdateInterpretation('replace', {
+  it('returns false for a PUT to "interpretations/chart/${id}"', () => {
+    expect(isCreateInterpretation('replace', {
       resource: 'interpretations/chart/oXD88WWSQpR'
+    })).toEqual(false);
+  });
+  it('retuns false for PATCH requests with a valid query', () => {
+    expect(isCreateInterpretation('update', {
+      resource: 'interpretations/chart/oXD88WWSQpR'
+    })).toEqual(false);
+  });
+  it('returns false for a request to a different resource', () => {
+    expect(isCreateInterpretation('create', {
+      resource: 'interpretations/dummy/oXD88WWSQpR'
+    })).toEqual(false);
+  });
+});
+describe('isUpdateInterpretation', () => {
+  it('returns true for a PUT to "interpretations/${id}"', () => {
+    expect(isUpdateInterpretation('replace', {
+      resource: 'interpretations/oXD88WWSQpR'
     })).toEqual(true);
   });
   it('returns true for PUT with populated query.id', () => {
-    expect(isCreateOrUpdateInterpretation('replace', {
-      resource: 'interpretations/chart',
+    expect(isUpdateInterpretation('replace', {
+      resource: 'interpretations',
       id: 'oXD88WWSQpR'
     })).toEqual(true);
   });
-  it('retuns false for PATCH requests with a valid query', () => {
-    expect(isCreateOrUpdateInterpretation('update', {
-      resource: 'interpretations/chart/oXD88WWSQpR'
+  it('returns false for a POST to "interpretations/${id}"', () => {
+    expect(isUpdateInterpretation('create', {
+      resource: 'interpretations/oXD88WWSQpR'
+    })).toEqual(false);
+  });
+  it('returns false for a PATCH to "interpretations/${id}"', () => {
+    expect(isUpdateInterpretation('update', {
+      resource: 'interpretations/oXD88WWSQpR'
+    })).toEqual(false);
+  });
+  it('returns false for PATCH with populated query.id', () => {
+    expect(isUpdateInterpretation('update', {
+      resource: 'interpretations',
+      id: 'oXD88WWSQpR'
     })).toEqual(false);
   });
   it('returns false for a request to a different resource', () => {
-    expect(isCreateOrUpdateInterpretation('create', {
+    expect(isUpdateInterpretation('create', {
       resource: 'interpretations/dummy/oXD88WWSQpR'
     })).toEqual(false);
   });

package/build/es/react/hooks/useDataQuery.js

@@ -1,4 +1,4 @@
-import { useState, useRef } from 'react';
+import { useState, useRef, useCallback } from 'react';
 import { useQuery, setLogger } from 'react-query';
 import { stableVariablesHash } from './stableVariablesHash';
 import { useDataEngine } from './useDataEngine';
@@ -84,9 +84,13 @@ export const useDataQuery = (query, {
   /**
    * Refetch allows a user to update the variables or just
    * trigger a refetch of the query with the current variables.
+   *
+   * We're using useCallback to make the identity of the function
+   * as stable as possible, so that it won't trigger excessive
+   * rerenders when used for side-effects.
    */
 
-  const refetch = newVariables => {
+  const refetch = useCallback(newVariables => {
     /**
      * If there are no updates that will trigger an automatic refetch
      * we'll need to call react-query's refetch directly
@@ -100,10 +104,6 @@ export const useDataQuery = (query, {
       }) => data);
     }
 
-    if (!enabled) {
-      setEnabled(true);
-    }
-
     if (newVariables) {
       // Use cached hash if it exists
       const currentHash = variablesHash.current || stableVariablesHash(variables);
@@ -113,8 +113,11 @@ export const useDataQuery = (query, {
       const mergedHash = stableVariablesHash(mergedVariables);
       const identical = currentHash === mergedHash;
 
-      if (identical) {
-        // If the variables are identical we'll need to trigger the refetch manually
+      if (identical && enabled) {
+        /**
+         * If the variables are identical and the query is enabled
+         * we'll need to trigger the refetch manually
+         */
         return queryRefetch({
           cancelRefetch: true,
           throwOnError: false
@@ -125,6 +128,11 @@ export const useDataQuery = (query, {
         variablesHash.current = mergedHash;
         setVariables(mergedVariables);
       }
+    } // Enable the query after the variables have been set to prevent extra request
+
+
+    if (!enabled) {
+      setEnabled(true);
     } // This promise does not currently reject on errors
 
 
@@ -133,13 +141,12 @@ export const useDataQuery = (query, {
         resolve(data);
       };
     });
-  };
+  }, [enabled, queryRefetch, variables]);
   /**
    * react-query returns null or an error, but we return undefined
    * or an error, so this ensures consistency with the other types.
    */
 
-
   const ourError = error || undefined;
   return {
     engine,

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

@@ -497,6 +497,149 @@ describe('useDataQuery', () => {
     });
   });
   describe('return values: refetch', () => {
+    it('Should only trigger a single request when refetch is called on a lazy query with new variables', async () => {
+      const spy = jest.fn((type, query) => {
+        if (query.id === '1') {
+          return 42;
+        }
+
+        return 0;
+      });
+      const data = {
+        answer: spy
+      };
+      const query = {
+        x: {
+          resource: 'answer',
+          id: ({
+            id
+          }) => id
+        }
+      };
+
+      const wrapper = ({
+        children
+      }) => /*#__PURE__*/React.createElement(CustomDataProvider, {
+        data: data
+      }, children);
+
+      const {
+        result,
+        waitFor
+      } = renderHook(() => useDataQuery(query, {
+        lazy: true
+      }), {
+        wrapper
+      });
+      expect(spy).not.toHaveBeenCalled();
+      act(() => {
+        result.current.refetch({
+          id: '1'
+        });
+      });
+      await waitFor(() => {
+        expect(result.current).toMatchObject({
+          loading: false,
+          called: true,
+          data: {
+            x: 42
+          }
+        });
+      });
+      expect(spy).toHaveBeenCalledTimes(1);
+    });
+    it('Should only trigger a single request when refetch is called on a lazy query with identical variables', async () => {
+      const spy = jest.fn((type, query) => {
+        if (query.id === '1') {
+          return 42;
+        }
+
+        return 0;
+      });
+      const data = {
+        answer: spy
+      };
+      const query = {
+        x: {
+          resource: 'answer',
+          id: ({
+            id
+          }) => id
+        }
+      };
+
+      const wrapper = ({
+        children
+      }) => /*#__PURE__*/React.createElement(CustomDataProvider, {
+        data: data
+      }, children);
+
+      const {
+        result,
+        waitFor
+      } = renderHook(() => useDataQuery(query, {
+        lazy: true,
+        variables: {
+          id: '1'
+        }
+      }), {
+        wrapper
+      });
+      expect(spy).not.toHaveBeenCalled();
+      act(() => {
+        result.current.refetch({
+          id: '1'
+        });
+      });
+      await waitFor(() => {
+        expect(result.current).toMatchObject({
+          loading: false,
+          called: true,
+          data: {
+            x: 42
+          }
+        });
+      });
+      expect(spy).toHaveBeenCalledTimes(1);
+    });
+    it('Should have a stable identity if the variables have not changed', async () => {
+      const data = {
+        answer: () => 42
+      };
+      const query = {
+        x: {
+          resource: 'answer'
+        }
+      };
+
+      const wrapper = ({
+        children
+      }) => /*#__PURE__*/React.createElement(CustomDataProvider, {
+        data: data
+      }, children);
+
+      const {
+        result,
+        waitForNextUpdate,
+        rerender
+      } = renderHook(() => useDataQuery(query), {
+        wrapper
+      });
+      const firstRefetch = result.current.refetch;
+      await waitForNextUpdate();
+      act(() => {
+        result.current.refetch();
+        /**
+         * FIXME: https://github.com/tannerlinsley/react-query/issues/2481
+         * This forced rerender is not necessary in the app, just when testing.
+         * It is unclear why.
+         */
+
+        rerender();
+      });
+      await waitForNextUpdate();
+      expect(result.current.refetch).toBe(firstRefetch);
+    });
     it('Should return stale data and set loading to true on refetch', async () => {
       const answers = [42, 43];
       const mockSpy = jest.fn(() => Promise.resolve(answers.shift()));

package/build/types/links/RestAPILink/queryToRequestOptions/textPlainMatchers.d.ts

@@ -1,7 +1,8 @@
 import { ResolvedResourceQuery, FetchType } from '../../../engine';
 export declare const isReplyToMessageConversation: (type: FetchType, { resource }: ResolvedResourceQuery) => boolean;
 export declare const isCreateFeedbackMessage: (type: FetchType, { resource }: ResolvedResourceQuery) => boolean;
-export declare const isCreateOrUpdateInterpretation: (type: FetchType, { resource, id }: ResolvedResourceQuery) => boolean;
+export declare const isCreateInterpretation: (type: FetchType, { resource }: ResolvedResourceQuery) => boolean;
+export declare const isUpdateInterpretation: (type: FetchType, { resource, id }: ResolvedResourceQuery) => boolean;
 export declare const isCommentOnInterpretation: (type: FetchType, { resource }: ResolvedResourceQuery) => boolean;
 export declare const isInterpretationCommentUpdate: (type: FetchType, { resource, id }: ResolvedResourceQuery) => boolean;
 export declare const isAddOrUpdateSystemOrUserSetting: (type: FetchType, { resource }: ResolvedResourceQuery) => boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@dhis2/app-service-data",
-    "version": "3.2.3",
+    "version": "3.2.7",
     "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.3",
+        "@dhis2/app-service-config": "3.2.7",
         "@dhis2/cli-app-scripts": "^7.1.1",
         "prop-types": "^15.7.2",
         "react": "^16.8",