@gravity-ui/data-source 0.8.2 → 0.9.1-alpha.0

package/build/esm/react-query/__tests__/subscriptions.test.js

@@ -1,1176 +0,0 @@
-import _regeneratorRuntime from "@babel/runtime/helpers/regeneratorRuntime";
-import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
-import React from 'react';
-import { useMutation } from '@tanstack/react-query';
-import { renderHook, waitFor } from '@testing-library/react';
-import { ClientDataManager } from '../ClientDataManager';
-import { DataSourceProvider } from '../DataSourceProvider';
-import { jsx as _jsx } from "react/jsx-runtime";
-describe('subscriptions', function () {
-  var dataManager;
-  beforeEach(function () {
-    dataManager = new ClientDataManager({
-      defaultOptions: {
-        queries: {
-          retry: false
-        },
-        mutations: {
-          retry: false
-        }
-      },
-      normalizerConfig: {
-        devLogging: false
-      }
-    });
-  });
-  afterEach(function () {
-    var _dataManager$queryNor;
-    (_dataManager$queryNor = dataManager.queryNormalizer) === null || _dataManager$queryNor === void 0 || _dataManager$queryNor.unsubscribe();
-    dataManager.queryClient.clear();
-  });
-  describe('QueryCache subscription', function () {
-    it('should add query to normalizer when added to QueryCache', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2() {
-      var normalized;
-      return _regeneratorRuntime().wrap(function _callee2$(_context2) {
-        while (1) switch (_context2.prev = _context2.next) {
-          case 0:
-            expect(dataManager.queryNormalizer).toBeDefined();
-            dataManager.queryNormalizer.subscribe();
-
-            // Add query with normalize: true option
-            _context2.next = 4;
-            return dataManager.queryClient.fetchQuery({
-              queryKey: ['users'],
-              queryFn: function () {
-                var _queryFn = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
-                  return _regeneratorRuntime().wrap(function _callee$(_context) {
-                    while (1) switch (_context.prev = _context.next) {
-                      case 0:
-                        return _context.abrupt("return", [{
-                          id: '1',
-                          name: 'User 1'
-                        }]);
-                      case 1:
-                      case "end":
-                        return _context.stop();
-                    }
-                  }, _callee);
-                }));
-                function queryFn() {
-                  return _queryFn.apply(this, arguments);
-                }
-                return queryFn;
-              }(),
-              normalize: true
-            });
-          case 4:
-            normalized = dataManager.queryNormalizer.getNormalizedData();
-            expect(normalized.objects['@@1']).toBeDefined();
-          case 6:
-          case "end":
-            return _context2.stop();
-        }
-      }, _callee2);
-    })));
-    it('should update query in normalizer on update', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee5() {
-      var queryKey, normalizedBefore, objectCountBefore, normalizedAfter;
-      return _regeneratorRuntime().wrap(function _callee5$(_context5) {
-        while (1) switch (_context5.prev = _context5.next) {
-          case 0:
-            expect(dataManager.queryNormalizer).toBeDefined();
-            dataManager.queryNormalizer.subscribe();
-            queryKey = ['users']; // Initial data with normalize: true
-            _context5.next = 5;
-            return dataManager.queryClient.fetchQuery({
-              queryKey: queryKey,
-              queryFn: function () {
-                var _queryFn2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee3() {
-                  return _regeneratorRuntime().wrap(function _callee3$(_context3) {
-                    while (1) switch (_context3.prev = _context3.next) {
-                      case 0:
-                        return _context3.abrupt("return", [{
-                          id: '1',
-                          name: 'Old'
-                        }]);
-                      case 1:
-                      case "end":
-                        return _context3.stop();
-                    }
-                  }, _callee3);
-                }));
-                function queryFn() {
-                  return _queryFn2.apply(this, arguments);
-                }
-                return queryFn;
-              }(),
-              normalize: true
-            });
-          case 5:
-            normalizedBefore = dataManager.queryNormalizer.getNormalizedData();
-            objectCountBefore = Object.keys(normalizedBefore.objects).length; // Update data
-            _context5.next = 9;
-            return dataManager.queryClient.fetchQuery({
-              queryKey: queryKey,
-              queryFn: function () {
-                var _queryFn3 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee4() {
-                  return _regeneratorRuntime().wrap(function _callee4$(_context4) {
-                    while (1) switch (_context4.prev = _context4.next) {
-                      case 0:
-                        return _context4.abrupt("return", [{
-                          id: '1',
-                          name: 'New'
-                        }]);
-                      case 1:
-                      case "end":
-                        return _context4.stop();
-                    }
-                  }, _callee4);
-                }));
-                function queryFn() {
-                  return _queryFn3.apply(this, arguments);
-                }
-                return queryFn;
-              }(),
-              normalize: true
-            });
-          case 9:
-            // Verify that normalized data was updated
-            normalizedAfter = dataManager.queryNormalizer.getNormalizedData();
-            expect(Object.keys(normalizedAfter.objects).length).toBe(objectCountBefore);
-            expect(normalizedAfter.queries[JSON.stringify(queryKey)]).toBeDefined();
-          case 12:
-          case "end":
-            return _context5.stop();
-        }
-      }, _callee5);
-    })));
-    it('should remove query from normalizer when removed from QueryCache', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee7() {
-      var queryKey, normalized;
-      return _regeneratorRuntime().wrap(function _callee7$(_context7) {
-        while (1) switch (_context7.prev = _context7.next) {
-          case 0:
-            expect(dataManager.queryNormalizer).toBeDefined();
-            dataManager.queryNormalizer.subscribe();
-            queryKey = ['users']; // Add query
-            _context7.next = 5;
-            return dataManager.queryClient.fetchQuery({
-              queryKey: queryKey,
-              queryFn: function () {
-                var _queryFn4 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee6() {
-                  return _regeneratorRuntime().wrap(function _callee6$(_context6) {
-                    while (1) switch (_context6.prev = _context6.next) {
-                      case 0:
-                        return _context6.abrupt("return", [{
-                          id: '1',
-                          name: 'User 1'
-                        }]);
-                      case 1:
-                      case "end":
-                        return _context6.stop();
-                    }
-                  }, _callee6);
-                }));
-                function queryFn() {
-                  return _queryFn4.apply(this, arguments);
-                }
-                return queryFn;
-              }(),
-              normalize: true
-            });
-          case 5:
-            // Remove query
-            dataManager.queryClient.removeQueries({
-              queryKey: queryKey
-            });
-
-            // Give time to process event
-            _context7.next = 8;
-            return new Promise(function (resolve) {
-              return setTimeout(resolve, 10);
-            });
-          case 8:
-            normalized = dataManager.queryNormalizer.getNormalizedData(); // Query should be removed from queries
-            expect(normalized.queries[JSON.stringify(queryKey)]).toBeUndefined();
-          case 10:
-          case "end":
-            return _context7.stop();
-        }
-      }, _callee7);
-    })));
-    it('should support meta configuration for queries', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee8() {
-      var normalized;
-      return _regeneratorRuntime().wrap(function _callee8$(_context8) {
-        while (1) switch (_context8.prev = _context8.next) {
-          case 0:
-            expect(dataManager.queryNormalizer).toBeDefined();
-            dataManager.queryNormalizer.subscribe();
-
-            // Check that we can use meta for configuration
-            // Real check for disabling via meta is already tested in integration tests
-            normalized = dataManager.queryNormalizer.getNormalizedData();
-            expect(normalized).toBeDefined();
-            expect(normalized.objects).toBeDefined();
-            expect(normalized.queries).toBeDefined();
-          case 6:
-          case "end":
-            return _context8.stop();
-        }
-      }, _callee8);
-    })));
-    it('should unsubscribe correctly', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee10() {
-      var normalized;
-      return _regeneratorRuntime().wrap(function _callee10$(_context10) {
-        while (1) switch (_context10.prev = _context10.next) {
-          case 0:
-            expect(dataManager.queryNormalizer).toBeDefined();
-            dataManager.queryNormalizer.subscribe();
-            dataManager.queryNormalizer.unsubscribe();
-
-            // After unsubscribing, adding query should not affect normalizer
-            _context10.next = 5;
-            return dataManager.queryClient.fetchQuery({
-              queryKey: ['users'],
-              queryFn: function () {
-                var _queryFn5 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee9() {
-                  return _regeneratorRuntime().wrap(function _callee9$(_context9) {
-                    while (1) switch (_context9.prev = _context9.next) {
-                      case 0:
-                        return _context9.abrupt("return", [{
-                          id: '1',
-                          name: 'User 1'
-                        }]);
-                      case 1:
-                      case "end":
-                        return _context9.stop();
-                    }
-                  }, _callee9);
-                }));
-                function queryFn() {
-                  return _queryFn5.apply(this, arguments);
-                }
-                return queryFn;
-              }(),
-              normalize: true
-            });
-          case 5:
-            normalized = dataManager.queryNormalizer.getNormalizedData();
-            expect(Object.keys(normalized.objects)).toHaveLength(0);
-          case 7:
-          case "end":
-            return _context10.stop();
-        }
-      }, _callee10);
-    })));
-    it('should allow multiple unsubscribe calls', function () {
-      expect(dataManager.queryNormalizer).toBeDefined();
-      dataManager.queryNormalizer.subscribe();
-      dataManager.queryNormalizer.unsubscribe();
-
-      // Repeated call should not throw error
-      expect(function () {
-        return dataManager.queryNormalizer.unsubscribe();
-      }).not.toThrow();
-    });
-  });
-  describe('MutationCache subscription', function () {
-    var dataManagerWithOptimistic;
-    beforeEach(function () {
-      dataManagerWithOptimistic = new ClientDataManager({
-        defaultOptions: {
-          queries: {
-            retry: false
-          },
-          mutations: {
-            retry: false
-          }
-        },
-        normalizerConfig: {
-          devLogging: false,
-          optimistic: {
-            autoCalculateRollback: true
-          }
-        }
-      });
-    });
-    afterEach(function () {
-      var _dataManagerWithOptim;
-      (_dataManagerWithOptim = dataManagerWithOptimistic.queryNormalizer) === null || _dataManagerWithOptim === void 0 || _dataManagerWithOptim.unsubscribe();
-      dataManagerWithOptimistic.queryClient.clear();
-    });
-    it('should update queries on successful mutation', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee13() {
-      var queryKey, wrapper, _renderHook, mutationResult, data;
-      return _regeneratorRuntime().wrap(function _callee13$(_context13) {
-        while (1) switch (_context13.prev = _context13.next) {
-          case 0:
-            expect(dataManagerWithOptimistic.queryNormalizer).toBeDefined();
-            dataManagerWithOptimistic.queryNormalizer.subscribe();
-            queryKey = ['users']; // Initial data
-            _context13.next = 5;
-            return dataManagerWithOptimistic.queryClient.fetchQuery({
-              queryKey: queryKey,
-              queryFn: function () {
-                var _queryFn6 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee11() {
-                  return _regeneratorRuntime().wrap(function _callee11$(_context11) {
-                    while (1) switch (_context11.prev = _context11.next) {
-                      case 0:
-                        return _context11.abrupt("return", [{
-                          id: '1',
-                          name: 'Old'
-                        }]);
-                      case 1:
-                      case "end":
-                        return _context11.stop();
-                    }
-                  }, _callee11);
-                }));
-                function queryFn() {
-                  return _queryFn6.apply(this, arguments);
-                }
-                return queryFn;
-              }(),
-              normalize: true
-            });
-          case 5:
-            // Create wrapper for hooks
-            wrapper = function wrapper(_ref7) {
-              var children = _ref7.children;
-              return /*#__PURE__*/_jsx(DataSourceProvider, {
-                dataManager: dataManagerWithOptimistic,
-                children: children
-              });
-            }; // Mutation via useMutation
-            _renderHook = renderHook(function () {
-              return useMutation({
-                mutationFn: function () {
-                  var _mutationFn = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee12() {
-                    return _regeneratorRuntime().wrap(function _callee12$(_context12) {
-                      while (1) switch (_context12.prev = _context12.next) {
-                        case 0:
-                          return _context12.abrupt("return", {
-                            id: '1',
-                            name: 'New'
-                          });
-                        case 1:
-                        case "end":
-                          return _context12.stop();
-                      }
-                    }, _callee12);
-                  }));
-                  function mutationFn() {
-                    return _mutationFn.apply(this, arguments);
-                  }
-                  return mutationFn;
-                }(),
-                normalize: true,
-                optimistic: true
-              });
-            }, {
-              wrapper: wrapper
-            }), mutationResult = _renderHook.result;
-            mutationResult.current.mutate(undefined);
-            _context13.next = 10;
-            return waitFor(function () {
-              return expect(mutationResult.current.isSuccess).toBe(true);
-            });
-          case 10:
-            data = dataManagerWithOptimistic.queryClient.getQueryData(queryKey);
-            expect(data[0].name).toBe('New');
-          case 12:
-          case "end":
-            return _context13.stop();
-        }
-      }, _callee13);
-    })));
-    it('should apply optimistic updates', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee16() {
-      var queryKey, wrapper, _renderHook2, mutationResult, dataFinal;
-      return _regeneratorRuntime().wrap(function _callee16$(_context16) {
-        while (1) switch (_context16.prev = _context16.next) {
-          case 0:
-            expect(dataManagerWithOptimistic.queryNormalizer).toBeDefined();
-            dataManagerWithOptimistic.queryNormalizer.subscribe();
-            queryKey = ['users']; // Initial data
-            _context16.next = 5;
-            return dataManagerWithOptimistic.queryClient.fetchQuery({
-              queryKey: queryKey,
-              queryFn: function () {
-                var _queryFn7 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee14() {
-                  return _regeneratorRuntime().wrap(function _callee14$(_context14) {
-                    while (1) switch (_context14.prev = _context14.next) {
-                      case 0:
-                        return _context14.abrupt("return", [{
-                          id: '1',
-                          name: 'Original'
-                        }]);
-                      case 1:
-                      case "end":
-                        return _context14.stop();
-                    }
-                  }, _callee14);
-                }));
-                function queryFn() {
-                  return _queryFn7.apply(this, arguments);
-                }
-                return queryFn;
-              }(),
-              normalize: true
-            });
-          case 5:
-            wrapper = function wrapper(_ref9) {
-              var children = _ref9.children;
-              return /*#__PURE__*/_jsx(DataSourceProvider, {
-                dataManager: dataManagerWithOptimistic,
-                children: children
-              });
-            }; // Mutation with optimistic data
-            _renderHook2 = renderHook(function () {
-              return useMutation({
-                mutationFn: function () {
-                  var _mutationFn2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee15() {
-                    return _regeneratorRuntime().wrap(function _callee15$(_context15) {
-                      while (1) switch (_context15.prev = _context15.next) {
-                        case 0:
-                          _context15.next = 2;
-                          return new Promise(function (resolve) {
-                            return setTimeout(resolve, 50);
-                          });
-                        case 2:
-                          return _context15.abrupt("return", {
-                            id: '1',
-                            name: 'Final'
-                          });
-                        case 3:
-                        case "end":
-                          return _context15.stop();
-                      }
-                    }, _callee15);
-                  }));
-                  function mutationFn() {
-                    return _mutationFn2.apply(this, arguments);
-                  }
-                  return mutationFn;
-                }(),
-                onMutate: function onMutate() {
-                  return {
-                    optimisticData: {
-                      id: '1',
-                      name: 'Optimistic'
-                    }
-                  };
-                },
-                normalize: true,
-                optimistic: true
-              });
-            }, {
-              wrapper: wrapper
-            }), mutationResult = _renderHook2.result;
-            mutationResult.current.mutate(undefined);
-
-            // Check optimistic data
-            _context16.next = 10;
-            return waitFor(function () {
-              var data = dataManagerWithOptimistic.queryClient.getQueryData(queryKey);
-              expect(data[0].name).toBe('Optimistic');
-            });
-          case 10:
-            _context16.next = 12;
-            return waitFor(function () {
-              return expect(mutationResult.current.isSuccess).toBe(true);
-            });
-          case 12:
-            dataFinal = dataManagerWithOptimistic.queryClient.getQueryData(queryKey);
-            expect(dataFinal[0].name).toBe('Final');
-          case 14:
-          case "end":
-            return _context16.stop();
-        }
-      }, _callee16);
-    })));
-    it('should automatically calculate rollbackData', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee19() {
-      var queryKey, wrapper, _renderHook3, mutationResult, data;
-      return _regeneratorRuntime().wrap(function _callee19$(_context19) {
-        while (1) switch (_context19.prev = _context19.next) {
-          case 0:
-            expect(dataManagerWithOptimistic.queryNormalizer).toBeDefined();
-            dataManagerWithOptimistic.queryNormalizer.subscribe();
-            queryKey = ['users']; // Initial data
-            _context19.next = 5;
-            return dataManagerWithOptimistic.queryClient.fetchQuery({
-              queryKey: queryKey,
-              queryFn: function () {
-                var _queryFn8 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee17() {
-                  return _regeneratorRuntime().wrap(function _callee17$(_context17) {
-                    while (1) switch (_context17.prev = _context17.next) {
-                      case 0:
-                        return _context17.abrupt("return", [{
-                          id: '1',
-                          name: 'Original'
-                        }]);
-                      case 1:
-                      case "end":
-                        return _context17.stop();
-                    }
-                  }, _callee17);
-                }));
-                function queryFn() {
-                  return _queryFn8.apply(this, arguments);
-                }
-                return queryFn;
-              }(),
-              normalize: true
-            });
-          case 5:
-            wrapper = function wrapper(_ref11) {
-              var children = _ref11.children;
-              return /*#__PURE__*/_jsx(DataSourceProvider, {
-                dataManager: dataManagerWithOptimistic,
-                children: children
-              });
-            }; // Mutation with optimistic data that will fail
-            _renderHook3 = renderHook(function () {
-              return useMutation({
-                mutationFn: function () {
-                  var _mutationFn3 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee18() {
-                    return _regeneratorRuntime().wrap(function _callee18$(_context18) {
-                      while (1) switch (_context18.prev = _context18.next) {
-                        case 0:
-                          _context18.next = 2;
-                          return new Promise(function (resolve) {
-                            return setTimeout(resolve, 50);
-                          });
-                        case 2:
-                          throw new Error('Mutation failed');
-                        case 3:
-                        case "end":
-                          return _context18.stop();
-                      }
-                    }, _callee18);
-                  }));
-                  function mutationFn() {
-                    return _mutationFn3.apply(this, arguments);
-                  }
-                  return mutationFn;
-                }(),
-                onMutate: function onMutate() {
-                  return {
-                    optimisticData: {
-                      id: '1',
-                      name: 'Optimistic'
-                    }
-                  };
-                },
-                normalize: true,
-                optimistic: true
-              });
-            }, {
-              wrapper: wrapper
-            }), mutationResult = _renderHook3.result;
-            mutationResult.current.mutate(undefined);
-            _context19.next = 10;
-            return waitFor(function () {
-              return expect(mutationResult.current.isError).toBe(true);
-            });
-          case 10:
-            // Data should be rolled back to original
-            data = dataManagerWithOptimistic.queryClient.getQueryData(queryKey);
-            expect(data[0].name).toBe('Original');
-          case 12:
-          case "end":
-            return _context19.stop();
-        }
-      }, _callee19);
-    })));
-    it('should rollback changes on mutation error', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee22() {
-      var queryKey, wrapper, _renderHook4, mutationResult, data;
-      return _regeneratorRuntime().wrap(function _callee22$(_context22) {
-        while (1) switch (_context22.prev = _context22.next) {
-          case 0:
-            expect(dataManagerWithOptimistic.queryNormalizer).toBeDefined();
-            dataManagerWithOptimistic.queryNormalizer.subscribe();
-            queryKey = ['users']; // Initial data
-            _context22.next = 5;
-            return dataManagerWithOptimistic.queryClient.fetchQuery({
-              queryKey: queryKey,
-              queryFn: function () {
-                var _queryFn9 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee20() {
-                  return _regeneratorRuntime().wrap(function _callee20$(_context20) {
-                    while (1) switch (_context20.prev = _context20.next) {
-                      case 0:
-                        return _context20.abrupt("return", [{
-                          id: '1',
-                          name: 'Original'
-                        }]);
-                      case 1:
-                      case "end":
-                        return _context20.stop();
-                    }
-                  }, _callee20);
-                }));
-                function queryFn() {
-                  return _queryFn9.apply(this, arguments);
-                }
-                return queryFn;
-              }(),
-              normalize: true
-            });
-          case 5:
-            wrapper = function wrapper(_ref13) {
-              var children = _ref13.children;
-              return /*#__PURE__*/_jsx(DataSourceProvider, {
-                dataManager: dataManagerWithOptimistic,
-                children: children
-              });
-            }; // Mutation with error
-            _renderHook4 = renderHook(function () {
-              return useMutation({
-                mutationFn: function () {
-                  var _mutationFn4 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee21() {
-                    return _regeneratorRuntime().wrap(function _callee21$(_context21) {
-                      while (1) switch (_context21.prev = _context21.next) {
-                        case 0:
-                          _context21.next = 2;
-                          return new Promise(function (resolve) {
-                            return setTimeout(resolve, 50);
-                          });
-                        case 2:
-                          throw new Error('Failed');
-                        case 3:
-                        case "end":
-                          return _context21.stop();
-                      }
-                    }, _callee21);
-                  }));
-                  function mutationFn() {
-                    return _mutationFn4.apply(this, arguments);
-                  }
-                  return mutationFn;
-                }(),
-                onMutate: function onMutate() {
-                  return {
-                    optimisticData: {
-                      id: '1',
-                      name: 'Optimistic'
-                    }
-                  };
-                },
-                normalize: true,
-                optimistic: true
-              });
-            }, {
-              wrapper: wrapper
-            }), mutationResult = _renderHook4.result;
-            mutationResult.current.mutate(undefined);
-            _context22.next = 10;
-            return waitFor(function () {
-              return expect(mutationResult.current.isError).toBe(true);
-            });
-          case 10:
-            data = dataManagerWithOptimistic.queryClient.getQueryData(queryKey);
-            expect(data[0].name).toBe('Original');
-          case 12:
-          case "end":
-            return _context22.stop();
-        }
-      }, _callee22);
-    })));
-    it('should ignore mutations with normalize: false', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee24() {
-      var dmNoNormalize, queryKey, wrapper, _renderHook5, mutationResult, data;
-      return _regeneratorRuntime().wrap(function _callee24$(_context24) {
-        while (1) switch (_context24.prev = _context24.next) {
-          case 0:
-            dmNoNormalize = new ClientDataManager({
-              defaultOptions: {
-                queries: {
-                  retry: false
-                },
-                mutations: {
-                  retry: false
-                }
-              },
-              normalizerConfig: {
-                devLogging: false
-              }
-            });
-            expect(dmNoNormalize.queryNormalizer).toBeDefined();
-            queryKey = ['users'];
-            dmNoNormalize.queryClient.setQueryData(queryKey, [{
-              id: '1',
-              name: 'Original'
-            }]);
-            wrapper = function wrapper(_ref15) {
-              var children = _ref15.children;
-              return /*#__PURE__*/_jsx(DataSourceProvider, {
-                dataManager: dmNoNormalize,
-                children: children
-              });
-            }; // Mutation should not update data automatically (no normalize option)
-            _renderHook5 = renderHook(function () {
-              return useMutation({
-                mutationFn: function () {
-                  var _mutationFn5 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee23() {
-                    return _regeneratorRuntime().wrap(function _callee23$(_context23) {
-                      while (1) switch (_context23.prev = _context23.next) {
-                        case 0:
-                          return _context23.abrupt("return", {
-                            id: '1',
-                            name: 'New'
-                          });
-                        case 1:
-                        case "end":
-                          return _context23.stop();
-                      }
-                    }, _callee23);
-                  }));
-                  function mutationFn() {
-                    return _mutationFn5.apply(this, arguments);
-                  }
-                  return mutationFn;
-                }()
-              });
-            }, {
-              wrapper: wrapper
-            }), mutationResult = _renderHook5.result;
-            mutationResult.current.mutate(undefined);
-            _context24.next = 9;
-            return waitFor(function () {
-              return expect(mutationResult.current.isSuccess).toBe(true);
-            });
-          case 9:
-            data = dmNoNormalize.queryClient.getQueryData(queryKey);
-            expect(data[0].name).toBe('Original'); // Not changed
-          case 11:
-          case "end":
-            return _context24.stop();
-        }
-      }, _callee24);
-    })));
-    it('should support devLogging for optimistic updates', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee27() {
-      var dmWithLogging, consoleSpy, queryKey, wrapper, _renderHook6, mutationResult;
-      return _regeneratorRuntime().wrap(function _callee27$(_context27) {
-        while (1) switch (_context27.prev = _context27.next) {
-          case 0:
-            dmWithLogging = new ClientDataManager({
-              defaultOptions: {
-                queries: {
-                  retry: false
-                },
-                mutations: {
-                  retry: false
-                }
-              },
-              normalizerConfig: {
-                devLogging: false,
-                optimistic: {
-                  autoCalculateRollback: true,
-                  devLogging: true
-                }
-              }
-            });
-            expect(dmWithLogging.queryNormalizer).toBeDefined();
-            consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-            dmWithLogging.queryNormalizer.subscribe();
-            queryKey = ['users'];
-            _context27.next = 7;
-            return dmWithLogging.queryClient.fetchQuery({
-              queryKey: queryKey,
-              queryFn: function () {
-                var _queryFn10 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee25() {
-                  return _regeneratorRuntime().wrap(function _callee25$(_context25) {
-                    while (1) switch (_context25.prev = _context25.next) {
-                      case 0:
-                        return _context25.abrupt("return", [{
-                          id: '1',
-                          name: 'Original'
-                        }]);
-                      case 1:
-                      case "end":
-                        return _context25.stop();
-                    }
-                  }, _callee25);
-                }));
-                function queryFn() {
-                  return _queryFn10.apply(this, arguments);
-                }
-                return queryFn;
-              }(),
-              normalize: true
-            });
-          case 7:
-            wrapper = function wrapper(_ref17) {
-              var children = _ref17.children;
-              return /*#__PURE__*/_jsx(DataSourceProvider, {
-                dataManager: dmWithLogging,
-                children: children
-              });
-            };
-            _renderHook6 = renderHook(function () {
-              return useMutation({
-                mutationFn: function () {
-                  var _mutationFn6 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee26() {
-                    return _regeneratorRuntime().wrap(function _callee26$(_context26) {
-                      while (1) switch (_context26.prev = _context26.next) {
-                        case 0:
-                          _context26.next = 2;
-                          return new Promise(function (resolve) {
-                            return setTimeout(resolve, 50);
-                          });
-                        case 2:
-                          throw new Error('Failed');
-                        case 3:
-                        case "end":
-                          return _context26.stop();
-                      }
-                    }, _callee26);
-                  }));
-                  function mutationFn() {
-                    return _mutationFn6.apply(this, arguments);
-                  }
-                  return mutationFn;
-                }(),
-                onMutate: function onMutate() {
-                  return {
-                    optimisticData: {
-                      id: '1',
-                      name: 'Optimistic'
-                    }
-                  };
-                },
-                normalize: true,
-                optimistic: true
-              });
-            }, {
-              wrapper: wrapper
-            }), mutationResult = _renderHook6.result;
-            mutationResult.current.mutate(undefined);
-            _context27.next = 12;
-            return waitFor(function () {
-              return expect(mutationResult.current.isError).toBe(true);
-            });
-          case 12:
-            // Verify that logging was called
-            expect(consoleSpy).toHaveBeenCalledWith('[OptimisticUpdate] Auto-calculated rollbackData:', expect.any(Object));
-            expect(consoleSpy).toHaveBeenCalledWith('[OptimisticUpdate] Rolling back changes');
-            consoleSpy.mockRestore();
-          case 15:
-          case "end":
-            return _context27.stop();
-        }
-      }, _callee27);
-    })));
-    it('should support manual rollbackData', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee30() {
-      var dmNoAutoRollback, queryKey, wrapper, _renderHook7, mutationResult, data;
-      return _regeneratorRuntime().wrap(function _callee30$(_context30) {
-        while (1) switch (_context30.prev = _context30.next) {
-          case 0:
-            dmNoAutoRollback = new ClientDataManager({
-              defaultOptions: {
-                queries: {
-                  retry: false
-                },
-                mutations: {
-                  retry: false
-                }
-              },
-              normalizerConfig: {
-                devLogging: false,
-                optimistic: {
-                  autoCalculateRollback: false
-                }
-              }
-            });
-            expect(dmNoAutoRollback.queryNormalizer).toBeDefined();
-            dmNoAutoRollback.queryNormalizer.subscribe();
-            queryKey = ['users'];
-            _context30.next = 6;
-            return dmNoAutoRollback.queryClient.fetchQuery({
-              queryKey: queryKey,
-              queryFn: function () {
-                var _queryFn11 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee28() {
-                  return _regeneratorRuntime().wrap(function _callee28$(_context28) {
-                    while (1) switch (_context28.prev = _context28.next) {
-                      case 0:
-                        return _context28.abrupt("return", [{
-                          id: '1',
-                          name: 'Original'
-                        }]);
-                      case 1:
-                      case "end":
-                        return _context28.stop();
-                    }
-                  }, _callee28);
-                }));
-                function queryFn() {
-                  return _queryFn11.apply(this, arguments);
-                }
-                return queryFn;
-              }(),
-              normalize: true
-            });
-          case 6:
-            wrapper = function wrapper(_ref19) {
-              var children = _ref19.children;
-              return /*#__PURE__*/_jsx(DataSourceProvider, {
-                dataManager: dmNoAutoRollback,
-                children: children
-              });
-            };
-            _renderHook7 = renderHook(function () {
-              return useMutation({
-                mutationFn: function () {
-                  var _mutationFn7 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee29() {
-                    return _regeneratorRuntime().wrap(function _callee29$(_context29) {
-                      while (1) switch (_context29.prev = _context29.next) {
-                        case 0:
-                          _context29.next = 2;
-                          return new Promise(function (resolve) {
-                            return setTimeout(resolve, 50);
-                          });
-                        case 2:
-                          throw new Error('Failed');
-                        case 3:
-                        case "end":
-                          return _context29.stop();
-                      }
-                    }, _callee29);
-                  }));
-                  function mutationFn() {
-                    return _mutationFn7.apply(this, arguments);
-                  }
-                  return mutationFn;
-                }(),
-                onMutate: function onMutate() {
-                  return {
-                    optimisticData: {
-                      id: '1',
-                      name: 'Optimistic'
-                    },
-                    rollbackData: {
-                      id: '1',
-                      name: 'Manual Rollback'
-                    }
-                  };
-                },
-                normalize: true,
-                optimistic: true
-              });
-            }, {
-              wrapper: wrapper
-            }), mutationResult = _renderHook7.result;
-            mutationResult.current.mutate(undefined);
-            _context30.next = 11;
-            return waitFor(function () {
-              return expect(mutationResult.current.isError).toBe(true);
-            });
-          case 11:
-            data = dmNoAutoRollback.queryClient.getQueryData(queryKey);
-            expect(data[0].name).toBe('Manual Rollback');
-            dmNoAutoRollback.queryNormalizer.unsubscribe();
-            dmNoAutoRollback.queryClient.clear();
-          case 15:
-          case "end":
-            return _context30.stop();
-        }
-      }, _callee30);
-    })));
-    it('should invalidate queries when invalidate option is enabled', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee33() {
-      var dmWithInvalidate, queryKey, invalidateSpy, wrapper, _renderHook8, mutationResult;
-      return _regeneratorRuntime().wrap(function _callee33$(_context33) {
-        while (1) switch (_context33.prev = _context33.next) {
-          case 0:
-            dmWithInvalidate = new ClientDataManager({
-              defaultOptions: {
-                queries: {
-                  retry: false
-                },
-                mutations: {
-                  retry: false
-                }
-              },
-              normalizerConfig: {
-                devLogging: false,
-                invalidate: true
-              }
-            });
-            expect(dmWithInvalidate.queryNormalizer).toBeDefined();
-            dmWithInvalidate.queryNormalizer.subscribe();
-            queryKey = ['users']; // Initial data
-            _context33.next = 6;
-            return dmWithInvalidate.queryClient.fetchQuery({
-              queryKey: queryKey,
-              queryFn: function () {
-                var _queryFn12 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee31() {
-                  return _regeneratorRuntime().wrap(function _callee31$(_context31) {
-                    while (1) switch (_context31.prev = _context31.next) {
-                      case 0:
-                        return _context31.abrupt("return", [{
-                          id: '1',
-                          name: 'Original'
-                        }]);
-                      case 1:
-                      case "end":
-                        return _context31.stop();
-                    }
-                  }, _callee31);
-                }));
-                function queryFn() {
-                  return _queryFn12.apply(this, arguments);
-                }
-                return queryFn;
-              }()
-            });
-          case 6:
-            // Spy on invalidateQueries
-            invalidateSpy = jest.spyOn(dmWithInvalidate.queryClient, 'invalidateQueries');
-            wrapper = function wrapper(_ref21) {
-              var children = _ref21.children;
-              return /*#__PURE__*/_jsx(DataSourceProvider, {
-                dataManager: dmWithInvalidate,
-                children: children
-              });
-            };
-            _renderHook8 = renderHook(function () {
-              return useMutation({
-                mutationFn: function () {
-                  var _mutationFn8 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee32() {
-                    return _regeneratorRuntime().wrap(function _callee32$(_context32) {
-                      while (1) switch (_context32.prev = _context32.next) {
-                        case 0:
-                          return _context32.abrupt("return", {
-                            id: '1',
-                            name: 'Updated'
-                          });
-                        case 1:
-                        case "end":
-                          return _context32.stop();
-                      }
-                    }, _callee32);
-                  }));
-                  function mutationFn() {
-                    return _mutationFn8.apply(this, arguments);
-                  }
-                  return mutationFn;
-                }(),
-                normalize: true
-              });
-            }, {
-              wrapper: wrapper
-            }), mutationResult = _renderHook8.result;
-            mutationResult.current.mutate(undefined);
-            _context33.next = 12;
-            return waitFor(function () {
-              return expect(mutationResult.current.isSuccess).toBe(true);
-            });
-          case 12:
-            // Verify that invalidateQueries was called
-            expect(invalidateSpy).toHaveBeenCalled();
-            invalidateSpy.mockRestore();
-            dmWithInvalidate.queryNormalizer.unsubscribe();
-            dmWithInvalidate.queryClient.clear();
-          case 16:
-          case "end":
-            return _context33.stop();
-        }
-      }, _callee33);
-    })));
-    it('should not invalidate queries when invalidate: false is set on mutation', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee36() {
-      var dmWithInvalidate, queryKey, invalidateSpy, wrapper, _renderHook9, mutationResult;
-      return _regeneratorRuntime().wrap(function _callee36$(_context36) {
-        while (1) switch (_context36.prev = _context36.next) {
-          case 0:
-            dmWithInvalidate = new ClientDataManager({
-              defaultOptions: {
-                queries: {
-                  retry: false
-                },
-                mutations: {
-                  retry: false
-                }
-              },
-              normalizerConfig: {
-                devLogging: false,
-                invalidate: true // Globally enabled
-              }
-            });
-            expect(dmWithInvalidate.queryNormalizer).toBeDefined();
-            dmWithInvalidate.queryNormalizer.subscribe();
-            queryKey = ['users'];
-            _context36.next = 6;
-            return dmWithInvalidate.queryClient.fetchQuery({
-              queryKey: queryKey,
-              queryFn: function () {
-                var _queryFn13 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee34() {
-                  return _regeneratorRuntime().wrap(function _callee34$(_context34) {
-                    while (1) switch (_context34.prev = _context34.next) {
-                      case 0:
-                        return _context34.abrupt("return", [{
-                          id: '1',
-                          name: 'Original'
-                        }]);
-                      case 1:
-                      case "end":
-                        return _context34.stop();
-                    }
-                  }, _callee34);
-                }));
-                function queryFn() {
-                  return _queryFn13.apply(this, arguments);
-                }
-                return queryFn;
-              }()
-            });
-          case 6:
-            invalidateSpy = jest.spyOn(dmWithInvalidate.queryClient, 'invalidateQueries');
-            wrapper = function wrapper(_ref23) {
-              var children = _ref23.children;
-              return /*#__PURE__*/_jsx(DataSourceProvider, {
-                dataManager: dmWithInvalidate,
-                children: children
-              });
-            };
-            _renderHook9 = renderHook(function () {
-              return useMutation({
-                mutationFn: function () {
-                  var _mutationFn9 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee35() {
-                    return _regeneratorRuntime().wrap(function _callee35$(_context35) {
-                      while (1) switch (_context35.prev = _context35.next) {
-                        case 0:
-                          return _context35.abrupt("return", {
-                            id: '1',
-                            name: 'Updated'
-                          });
-                        case 1:
-                        case "end":
-                          return _context35.stop();
-                      }
-                    }, _callee35);
-                  }));
-                  function mutationFn() {
-                    return _mutationFn9.apply(this, arguments);
-                  }
-                  return mutationFn;
-                }(),
-                normalize: true,
-                invalidate: false // Disable for this mutation
-              });
-            }, {
-              wrapper: wrapper
-            }), mutationResult = _renderHook9.result;
-            mutationResult.current.mutate(undefined);
-            _context36.next = 12;
-            return waitFor(function () {
-              return expect(mutationResult.current.isSuccess).toBe(true);
-            });
-          case 12:
-            // Verify that invalidateQueries was NOT called
-            expect(invalidateSpy).not.toHaveBeenCalled();
-            invalidateSpy.mockRestore();
-            dmWithInvalidate.queryNormalizer.unsubscribe();
-            dmWithInvalidate.queryClient.clear();
-          case 16:
-          case "end":
-            return _context36.stop();
-        }
-      }, _callee36);
-    })));
-  });
-});
-// #sourceMappingURL=subscriptions.test.js.map