@dhis2/app-service-data 3.3.0 → 3.4.2

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

@@ -13,6 +13,7 @@ const useStaticInput = (staticValue, {
 } = {}) => {
   const originalValue = (0, _react.useRef)(staticValue);
   const [value, setValue] = (0, _react.useState)(() => originalValue.current);
+  (0, _react.useDebugValue)(value, debugValue => "".concat(name, ": ").concat(JSON.stringify(debugValue)));
   (0, _react.useEffect)(() => {
     if (warn && originalValue.current !== staticValue) {
       console.warn("The ".concat(name, " should be static, don't create it within the render loop!"));

package/build/es/engine/helpers/getMutationFetchType.test.js

@@ -11,6 +11,11 @@ describe('getMutationFetchType', () => {
       resource: 'test',
       id: 'id'
     })).toBe('delete');
+    expect(getMutationFetchType({
+      type: 'json-patch',
+      resource: 'test',
+      data: {}
+    })).toBe('json-patch');
   });
   it('should return `replace` for non-partial `update`', () => {
     expect(getMutationFetchType({

package/build/es/engine/helpers/validate.js

@@ -1,6 +1,6 @@
 import { InvalidQueryError } from '../types/InvalidQueryError';
 const validQueryKeys = ['resource', 'id', 'params', 'data'];
-const validTypes = ['read', 'create', 'update', 'replace', 'delete'];
+const validTypes = ['read', 'create', 'update', 'replace', 'delete', 'json-patch'];
 export const getResourceQueryErrors = (type, query) => {
   if (!validTypes.includes(type)) {
     return ["Unknown query or mutation type ".concat(type)];
@@ -32,6 +32,10 @@ export const getResourceQueryErrors = (type, query) => {
     errors.push("Mutation type 'delete' does not support property 'data'");
   }
 
+  if (type === 'json-patch' && !Array.isArray(query.data)) {
+    errors.push("Mutation type 'json-patch' requires property 'data' to be of type Array");
+  }
+
   const invalidKeys = Object.keys(query).filter(k => !validQueryKeys.includes(k));
   invalidKeys.forEach(k => {
     errors.push("Property ".concat(k, " is not supported"));

package/build/es/engine/helpers/validate.test.js

@@ -73,6 +73,14 @@ describe('query validation', () => {
       expect(errors).toHaveLength(1);
       expect(errors).toMatchInlineSnapshot("\n                Array [\n                  \"Mutation type 'delete' does not support property 'data'\",\n                ]\n            ");
     });
+    it('should fail if query is json-patch mutation with non-array data prop', () => {
+      const errors = getResourceQueryErrors('json-patch', {
+        resource: 'metadata',
+        data: {}
+      });
+      expect(errors).toHaveLength(1);
+      expect(errors).toMatchInlineSnapshot("\n                Array [\n                  \"Mutation type 'json-patch' requires property 'data' to be of type Array\",\n                ]\n            ");
+    });
     it('should fail if unrecognized keys are passed to query', () => {
       const errors = getResourceQueryErrors('update', {
         resource: 'indicators',

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

@@ -25,6 +25,10 @@ export const requestContentType = (type, query) => {
     return null;
   }
 
+  if (type === 'json-patch') {
+    return 'application/json-patch+json';
+  }
+
   if (resourceExpectsTextPlain(type, query)) {
     return 'text/plain';
   }
@@ -58,7 +62,7 @@ export const requestBodyForContentType = (contentType, {
     return undefined;
   }
 
-  if (contentType === 'application/json') {
+  if (contentType === 'application/json' || contentType === 'application/json-patch+json') {
     return JSON.stringify(data);
   }
 

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

@@ -6,6 +6,12 @@ describe('requestContentType', () => {
       data: 'test'
     })).toEqual('application/json');
   });
+  it('returns "application/json-patch+json" when the fetch type is "json-patch"', () => {
+    expect(requestContentType('json-patch', {
+      resource: 'test',
+      data: 'test'
+    })).toEqual('application/json-patch+json');
+  });
   it('returns "multipart/form-data" for a specific resource that expects it', () => {
     expect(requestContentType('create', {
       resource: 'fileResources',

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

@@ -9,6 +9,7 @@ const getMethod = type => {
       return 'GET';
 
     case 'update':
+    case 'json-patch':
       return 'PATCH';
 
     case 'replace':
@@ -16,6 +17,9 @@ const getMethod = type => {
 
     case 'delete':
       return 'DELETE';
+
+    default:
+      throw new Error("Unknown type ".concat(type));
   }
 };
 

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

@@ -26,6 +26,16 @@ describe('queryToRequestOptions', () => {
     });
     expect(options).toMatchInlineSnapshot("\n            Object {\n              \"body\": \"{\\\"answer\\\":42,\\\"foo\\\":\\\"bar\\\"}\",\n              \"headers\": Object {\n                \"Content-Type\": \"application/json\",\n              },\n              \"method\": \"PATCH\",\n              \"signal\": undefined,\n            }\n        ");
   });
+  it('should return a valid Fetch option object for json-patch request', () => {
+    const options = queryToRequestOptions('json-patch', {
+      resource: 'test',
+      data: {
+        answer: 42,
+        foo: 'bar'
+      }
+    });
+    expect(options).toMatchInlineSnapshot("\n            Object {\n              \"body\": \"{\\\"answer\\\":42,\\\"foo\\\":\\\"bar\\\"}\",\n              \"headers\": Object {\n                \"Content-Type\": \"application/json-patch+json\",\n              },\n              \"method\": \"PATCH\",\n              \"signal\": undefined,\n            }\n        ");
+  });
   it('should return a valid Fetch option object for replace request', () => {
     const options = queryToRequestOptions('replace', {
       resource: 'test',

package/build/es/links/RestAPILink/queryToResourcePath.js

@@ -55,13 +55,26 @@ const isAction = resource => resource.startsWith(actionPrefix);
 
 const makeActionPath = resource => joinPath('dhis-web-commons', "".concat(resource.substr(actionPrefix.length), ".action"));
 
-export const queryToResourcePath = (apiPath, query, type) => {
+const skipApiVersion = (resource, config) => {
+  if (resource === 'tracker') {
+    var _config$serverVersion, _config$serverVersion2;
+
+    if (!((_config$serverVersion = config.serverVersion) !== null && _config$serverVersion !== void 0 && _config$serverVersion.minor) || ((_config$serverVersion2 = config.serverVersion) === null || _config$serverVersion2 === void 0 ? void 0 : _config$serverVersion2.minor) < 38) {
+      return true;
+    }
+  }
+
+  return false;
+};
+
+export const queryToResourcePath = (link, query, type) => {
   const {
     resource,
     id,
     params = {}
   } = query;
-  const base = isAction(resource) ? makeActionPath(resource) : joinPath(apiPath, resource, id);
+  const apiBase = skipApiVersion(resource, link.config) ? link.unversionedApiPath : link.versionedApiPath;
+  const base = isAction(resource) ? makeActionPath(resource) : joinPath(apiBase, resource, id);
   validateResourceQuery(query, type);
 
   if (Object.keys(params).length) {

package/build/es/links/RestAPILink/queryToResourcePath.test.js

@@ -1,5 +1,19 @@
+import { RestAPILink } from '../RestAPILink';
 import { queryToResourcePath } from './queryToResourcePath';
-const apiPath = '<api>';
+
+const createLink = config => new RestAPILink(config);
+
+const defaultConfig = {
+  basePath: '<base>',
+  apiVersion: '37',
+  serverVersion: {
+    major: 2,
+    minor: 37,
+    patch: 11
+  }
+};
+const link = createLink(defaultConfig);
+const apiPath = link.versionedApiPath;
 const actionPrefix = "dhis-web-commons/";
 const actionPostfix = '.action';
 describe('queryToResourcePath', () => {
@@ -8,7 +22,7 @@ describe('queryToResourcePath', () => {
       const query = {
         resource: 'action::test'
       };
-      expect(queryToResourcePath(apiPath, query)).toBe("".concat(actionPrefix, "test").concat(actionPostfix));
+      expect(queryToResourcePath(link, query, 'read')).toBe("".concat(actionPrefix, "test").concat(actionPostfix));
     });
     it('should return action URL with a simple querystring if query parameters are passed', () => {
       const query = {
@@ -17,7 +31,7 @@ describe('queryToResourcePath', () => {
           key: 'value'
         }
       };
-      expect(queryToResourcePath(apiPath, query)).toBe("".concat(actionPrefix, "test").concat(actionPostfix, "?key=value"));
+      expect(queryToResourcePath(link, query, 'read')).toBe("".concat(actionPrefix, "test").concat(actionPostfix, "?key=value"));
     });
   });
   describe('resource with dot', () => {
@@ -25,14 +39,14 @@ describe('queryToResourcePath', () => {
       const query = {
         resource: 'svg.pdf'
       };
-      expect(queryToResourcePath(apiPath, query)).toBe("".concat(apiPath, "/svg.pdf"));
+      expect(queryToResourcePath(link, query, 'read')).toBe("".concat(apiPath, "/svg.pdf"));
     });
   });
   it('should return resource url with no querystring if not query parameters are passed', () => {
     const query = {
       resource: 'test'
     };
-    expect(queryToResourcePath(apiPath, query)).toBe("".concat(apiPath, "/test"));
+    expect(queryToResourcePath(link, query, 'read')).toBe("".concat(apiPath, "/test"));
   });
   it('should return resource url and singular parameter separated by ?', () => {
     const query = {
@@ -41,7 +55,7 @@ describe('queryToResourcePath', () => {
         key: 'value'
       }
     };
-    expect(queryToResourcePath(apiPath, query)).toBe("".concat(apiPath, "/test?key=value"));
+    expect(queryToResourcePath(link, query, 'read')).toBe("".concat(apiPath, "/test?key=value"));
   });
   it('should return resource url and multiple parameters separated by ? and &', () => {
     const query = {
@@ -51,7 +65,7 @@ describe('queryToResourcePath', () => {
         param: 'value2'
       }
     };
-    expect(queryToResourcePath(apiPath, query)).toBe("".concat(apiPath, "/test?key=value&param=value2"));
+    expect(queryToResourcePath(link, query, 'read')).toBe("".concat(apiPath, "/test?key=value&param=value2"));
   });
   it('should url encode special characters in query keys', () => {
     const query = {
@@ -60,7 +74,7 @@ describe('queryToResourcePath', () => {
         'key=42&val': 'value'
       }
     };
-    expect(queryToResourcePath(apiPath, query)).toBe("".concat(apiPath, "/test?key%3D42%26val=value"));
+    expect(queryToResourcePath(link, query, 'read')).toBe("".concat(apiPath, "/test?key%3D42%26val=value"));
   });
   it('should url encode special characters in string parameters', () => {
     const query = {
@@ -70,7 +84,7 @@ describe('queryToResourcePath', () => {
         param: 'value2&& 53'
       }
     };
-    expect(queryToResourcePath(apiPath, query)).toBe("".concat(apiPath, "/test?key=value%3F%3D42&param=value2%26%26%2053"));
+    expect(queryToResourcePath(link, query, 'read')).toBe("".concat(apiPath, "/test?key=value%3F%3D42&param=value2%26%26%2053"));
   });
   it('should support numeric (integer and float) parameters', () => {
     const query = {
@@ -80,7 +94,7 @@ describe('queryToResourcePath', () => {
         param: 193.75
       }
     };
-    expect(queryToResourcePath(apiPath, query)).toBe("".concat(apiPath, "/test?key=42&param=193.75"));
+    expect(queryToResourcePath(link, query, 'read')).toBe("".concat(apiPath, "/test?key=42&param=193.75"));
   });
   it('should support boolean parameters', () => {
     const query = {
@@ -90,7 +104,7 @@ describe('queryToResourcePath', () => {
         someflag: true
       }
     };
-    expect(queryToResourcePath(apiPath, query)).toBe("".concat(apiPath, "/test?key=42&someflag=true"));
+    expect(queryToResourcePath(link, query, 'read')).toBe("".concat(apiPath, "/test?key=42&someflag=true"));
   });
   it('should join array parameters with commas', () => {
     const query = {
@@ -99,7 +113,7 @@ describe('queryToResourcePath', () => {
         key: ['asdf', 123]
       }
     };
-    expect(queryToResourcePath(apiPath, query)).toBe("".concat(apiPath, "/test?key=asdf,123"));
+    expect(queryToResourcePath(link, query, 'read')).toBe("".concat(apiPath, "/test?key=asdf,123"));
   });
   it('should include multiple filter parameters when array of filters provided', () => {
     const query = {
@@ -108,7 +122,7 @@ describe('queryToResourcePath', () => {
         filter: ['asdf', 123]
       }
     };
-    expect(queryToResourcePath(apiPath, query)).toBe("".concat(apiPath, "/test?filter=asdf&filter=123"));
+    expect(queryToResourcePath(link, query, 'read')).toBe("".concat(apiPath, "/test?filter=asdf&filter=123"));
   });
   it('should NOT YET support name-aliased parameters', () => {
     const query = {
@@ -119,7 +133,7 @@ describe('queryToResourcePath', () => {
         }
       }
     };
-    expect(() => queryToResourcePath(apiPath, query)).toThrow();
+    expect(() => queryToResourcePath(link, query, 'read')).toThrow();
   });
   it('should throw if passed something crazy like a function', () => {
     const query = {
@@ -128,6 +142,25 @@ describe('queryToResourcePath', () => {
         key: a => a
       }
     };
-    expect(() => queryToResourcePath(apiPath, query)).toThrow();
+    expect(() => queryToResourcePath(link, query, 'read')).toThrow();
+  });
+  it('should return an unversioned endpoint for the new tracker importer (in version 2.37)', () => {
+    const query = {
+      resource: 'tracker'
+    };
+    expect(queryToResourcePath(link, query, 'read')).toBe("".concat(link.unversionedApiPath, "/tracker"));
+  });
+  it('should return a VERSIONED endpoint for the new tracker importer (in version 2.38)', () => {
+    const query = {
+      resource: 'tracker'
+    };
+    const v38config = { ...defaultConfig,
+      serverVersion: {
+        major: 2,
+        minor: 38,
+        patch: 0
+      }
+    };
+    expect(queryToResourcePath(createLink(v38config), query, 'read')).toBe("".concat(link.versionedApiPath, "/tracker"));
   });
 });

package/build/es/links/RestAPILink.js

@@ -5,29 +5,26 @@ import { joinPath } from './RestAPILink/path';
 import { queryToRequestOptions } from './RestAPILink/queryToRequestOptions';
 import { queryToResourcePath } from './RestAPILink/queryToResourcePath';
 export class RestAPILink {
-  constructor({
-    baseUrl,
-    apiVersion
-  }) {
-    _defineProperty(this, "apiPath", void 0);
+  constructor(config) {
+    _defineProperty(this, "config", void 0);
 
-    _defineProperty(this, "baseUrl", void 0);
+    _defineProperty(this, "versionedApiPath", void 0);
 
-    _defineProperty(this, "apiVersion", void 0);
+    _defineProperty(this, "unversionedApiPath", void 0);
 
-    this.baseUrl = baseUrl;
-    this.apiVersion = apiVersion;
-    this.apiPath = joinPath('api', String(apiVersion));
+    this.config = config;
+    this.versionedApiPath = joinPath('api', String(config.apiVersion));
+    this.unversionedApiPath = joinPath('api');
   }
 
   fetch(path, options) {
-    return fetchData(joinPath(this.baseUrl, path), options);
+    return fetchData(joinPath(this.config.baseUrl, path), options);
   }
 
   executeResourceQuery(type, query, {
     signal
   }) {
-    return this.fetch(queryToResourcePath(this.apiPath, query, type), queryToRequestOptions(type, query, signal));
+    return this.fetch(queryToResourcePath(this, query, type), queryToRequestOptions(type, query, signal));
   }
 
 }

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

@@ -0,0 +1,23 @@
+import { stableVariablesHash } from './stableVariablesHash';
+export const mergeAndCompareVariables = (previousVariables, newVariables, previousHash) => {
+  if (!newVariables) {
+    return {
+      identical: true,
+      mergedVariablesHash: previousHash,
+      mergedVariables: previousVariables
+    };
+  } // Use cached hash if it exists
+
+
+  const currentHash = previousHash || stableVariablesHash(previousVariables);
+  const mergedVariables = { ...previousVariables,
+    ...newVariables
+  };
+  const mergedVariablesHash = stableVariablesHash(mergedVariables);
+  const identical = currentHash === mergedVariablesHash;
+  return {
+    identical,
+    mergedVariablesHash,
+    mergedVariables
+  };
+};

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

@@ -0,0 +1,53 @@
+import { mergeAndCompareVariables } from './mergeAndCompareVariables';
+import { stableVariablesHash } from './stableVariablesHash';
+jest.mock('./stableVariablesHash', () => ({
+  stableVariablesHash: object => JSON.stringify(object)
+}));
+const testVariables = {
+  question: 'What do you get when you multiply six by nine?',
+  answer: 42
+};
+const testHash = stableVariablesHash(testVariables);
+describe('mergeAndCompareVariables', () => {
+  it('Should return previous variables and hash when no new variables are provided', () => {
+    expect(mergeAndCompareVariables(testVariables, undefined, undefined)).toMatchObject({
+      identical: true,
+      mergedVariables: testVariables,
+      mergedVariablesHash: undefined
+    });
+  });
+  it('Should return identical: true when merged variables are identical to old variables (without prev hash)', () => {
+    const newVariables = {
+      answer: testVariables.answer
+    };
+    expect(mergeAndCompareVariables(testVariables, newVariables, undefined)).toMatchObject({
+      identical: true,
+      mergedVariables: testVariables,
+      mergedVariablesHash: testHash
+    });
+  });
+  it('Should return identical: false with incorrect previous hash', () => {
+    const incorrectPreviousHash = 'IAmAHash';
+    const newVariables = {
+      answer: 42
+    };
+    expect(mergeAndCompareVariables(testVariables, newVariables, incorrectPreviousHash)).toMatchObject({
+      identical: false,
+      mergedVariables: testVariables,
+      mergedVariablesHash: testHash
+    });
+  });
+  it('Should return identical: false when merged variables are different than old variables', () => {
+    const newVariables = {
+      answer: 43
+    };
+    const expectedMergedVariables = { ...testVariables,
+      ...newVariables
+    };
+    expect(mergeAndCompareVariables(testVariables, newVariables, testHash)).toMatchObject({
+      identical: false,
+      mergedVariables: expectedMergedVariables,
+      mergedVariablesHash: stableVariablesHash(expectedMergedVariables)
+    });
+  });
+});

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

@@ -1,6 +1,6 @@
-import { useState, useRef, useCallback } from 'react';
+import { useState, useRef, useCallback, useDebugValue } from 'react';
 import { useQuery, setLogger } from 'react-query';
-import { stableVariablesHash } from './stableVariablesHash';
+import { mergeAndCompareVariables } from './mergeAndCompareVariables';
 import { useDataEngine } from './useDataEngine';
 import { useStaticInput } from './useStaticInput';
 
@@ -23,24 +23,35 @@ export const useDataQuery = (query, {
   variables: initialVariables = {},
   lazy: initialLazy = false
 } = {}) => {
-  const variablesHash = useRef(null);
-  const [variables, setVariables] = useState(initialVariables);
-  const [enabled, setEnabled] = useState(!initialLazy);
   const [staticQuery] = useStaticInput(query, {
     warn: true,
     name: 'query'
   });
+  const [variablesUpdateCount, setVariablesUpdateCount] = useState(0);
+  const queryState = useRef({
+    variables: initialVariables,
+    variablesHash: undefined,
+    enabled: !initialLazy,
+    refetchCallback: undefined
+  });
   /**
-   * User callbacks and refetch handling
+   * Display current query state and refetch count in React DevTools
    */
 
-  const refetchCallback = useRef(null);
+  useDebugValue({
+    variablesUpdateCount,
+    enabled: queryState.current.enabled,
+    variables: queryState.current.variables
+  }, debugValue => JSON.stringify(debugValue));
+  /**
+   * User callbacks and refetch handling
+   */
 
   const onSuccess = data => {
-    if (refetchCallback.current) {
-      refetchCallback.current(data);
-      refetchCallback.current = null;
-    }
+    var _queryState$current$r, _queryState$current;
+
+    (_queryState$current$r = (_queryState$current = queryState.current).refetchCallback) === null || _queryState$current$r === void 0 ? void 0 : _queryState$current$r.call(_queryState$current, data);
+    queryState.current.refetchCallback = undefined;
 
     if (userOnSuccess) {
       userOnSuccess(data);
@@ -49,9 +60,7 @@ export const useDataQuery = (query, {
 
   const onError = error => {
     // If we'd want to reject on errors we'd call the cb with the error here
-    if (refetchCallback.current) {
-      refetchCallback.current = null;
-    }
+    queryState.current.refetchCallback = undefined;
 
     if (userOnError) {
       userOnError(error);
@@ -63,10 +72,10 @@ export const useDataQuery = (query, {
 
 
   const engine = useDataEngine();
-  const queryKey = [staticQuery, variables];
+  const queryKey = [staticQuery, queryState.current.variables];
 
   const queryFn = () => engine.query(staticQuery, {
-    variables
+    variables: queryState.current.variables
   });
 
   const {
@@ -77,7 +86,7 @@ export const useDataQuery = (query, {
     data,
     refetch: queryRefetch
   } = useQuery(queryKey, queryFn, {
-    enabled,
+    enabled: queryState.current.enabled,
     onSuccess,
     onError
   });
@@ -91,11 +100,17 @@ export const useDataQuery = (query, {
    */
 
   const refetch = useCallback(newVariables => {
+    const {
+      identical,
+      mergedVariables,
+      mergedVariablesHash
+    } = mergeAndCompareVariables(queryState.current.variables, newVariables, queryState.current.variablesHash);
     /**
      * If there are no updates that will trigger an automatic refetch
      * we'll need to call react-query's refetch directly
      */
-    if (enabled && !newVariables) {
+
+    if (queryState.current.enabled && identical) {
       return queryRefetch({
         cancelRefetch: true,
         throwOnError: false
@@ -104,44 +119,19 @@ export const useDataQuery = (query, {
       }) => data);
     }
 
-    if (newVariables) {
-      // Use cached hash if it exists
-      const currentHash = variablesHash.current || stableVariablesHash(variables);
-      const mergedVariables = { ...variables,
-        ...newVariables
-      };
-      const mergedHash = stableVariablesHash(mergedVariables);
-      const identical = currentHash === mergedHash;
-
-      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
-        }).then(({
-          data
-        }) => data);
-      } else {
-        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
-
-
-    return new Promise(resolve => {
-      refetchCallback.current = data => {
+    queryState.current.variables = mergedVariables;
+    queryState.current.variablesHash = mergedVariablesHash;
+    queryState.current.enabled = true; // This promise does not currently reject on errors
+
+    const refetchPromise = new Promise(resolve => {
+      queryState.current.refetchCallback = data => {
         resolve(data);
       };
-    });
-  }, [enabled, queryRefetch, variables]);
+    }); // Trigger a react-query refetch by incrementing variablesUpdateCount state
+
+    setVariablesUpdateCount(prevCount => prevCount + 1);
+    return refetchPromise;
+  }, [queryRefetch]);
   /**
    * react-query returns null or an error, but we return undefined
    * or an error, so this ensures consistency with the other types.

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

@@ -497,6 +497,65 @@ describe('useDataQuery', () => {
     });
   });
   describe('return values: refetch', () => {
+    it('Should be stable if the query variables change', async () => {
+      let count = 0;
+      const spy = jest.fn(() => {
+        count++;
+        return count;
+      });
+      const data = {
+        answer: spy
+      };
+      const query = {
+        x: {
+          resource: 'answer'
+        }
+      };
+
+      const wrapper = ({
+        children
+      }) => /*#__PURE__*/React.createElement(CustomDataProvider, {
+        data: data
+      }, children);
+
+      const {
+        result,
+        waitFor
+      } = renderHook(() => useDataQuery(query, {
+        lazy: true
+      }), {
+        wrapper
+      });
+      expect(spy).not.toHaveBeenCalled();
+      const initialRefetch = result.current.refetch;
+      act(() => {
+        initialRefetch();
+      });
+      await waitFor(() => {
+        expect(result.current).toMatchObject({
+          loading: false,
+          called: true,
+          data: {
+            x: 1
+          }
+        });
+      });
+      expect(spy).toHaveBeenCalledTimes(1);
+      act(() => {
+        initialRefetch();
+      });
+      await waitFor(() => {
+        expect(result.current).toMatchObject({
+          loading: false,
+          called: true,
+          data: {
+            x: 2
+          }
+        });
+      });
+      expect(spy).toHaveBeenCalledTimes(2);
+      expect(initialRefetch).toBe(result.current.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') {