@gravity-ui/data-source/build/cjs/react-query/__tests__/updateQueriesFromMutationData.test.js

A wrapper around data fetching

"use strict";

var _ClientDataManager = require("../ClientDataManager");
describe('updateQueriesFromMutationData', function () {
  var dataManager;
  beforeEach(function () {
    dataManager = new _ClientDataManager.ClientDataManager({
      defaultOptions: {
        queries: {
          retry: false
        },
        mutations: {
          retry: false
        }
      },
      normalizerConfig: {
        devLogging: false
      }
    });
  });
  afterEach(function () {
    dataManager.queryClient.clear();
  });
  it('should update query data based on normalized data', function () {
    expect(dataManager.normalizer).toBeDefined();

    // Set initial data in query
    var queryKey = ['users'];
    dataManager.queryClient.setQueryData(queryKey, [{
      id: '1',
      name: 'Old Name'
    }]);

    // Add query to normalizer
    dataManager.normalizer.setQuery(JSON.stringify(queryKey), [{
      id: '1',
      name: 'Old Name'
    }]);

    // Update data via mutation
    var mutationData = {
      id: '1',
      name: 'New Name'
    };
    dataManager.optimisticUpdate(mutationData);

    // Verify that data was updated
    var updatedData = dataManager.queryClient.getQueryData(queryKey);
    expect(updatedData).toBeDefined();
    expect(updatedData[0].name).toBe('New Name');
  });
  it('should update multiple queries with the same object', function () {
    expect(dataManager.normalizer).toBeDefined();
    var queryKey1 = ['users'];
    var queryKey2 = ['user', '1'];

    // Set data in both queries
    dataManager.queryClient.setQueryData(queryKey1, [{
      id: '1',
      name: 'User 1'
    }]);
    dataManager.queryClient.setQueryData(queryKey2, {
      id: '1',
      name: 'User 1'
    });

    // Add to normalizer
    dataManager.normalizer.setQuery(JSON.stringify(queryKey1), [{
      id: '1',
      name: 'User 1'
    }]);
    dataManager.normalizer.setQuery(JSON.stringify(queryKey2), {
      id: '1',
      name: 'User 1'
    });

    // Update via mutation
    var mutationData = {
      id: '1',
      name: 'Updated User'
    };
    dataManager.optimisticUpdate(mutationData);

    // Check both queries
    var data1 = dataManager.queryClient.getQueryData(queryKey1);
    var data2 = dataManager.queryClient.getQueryData(queryKey2);
    expect(data1[0].name).toBe('Updated User');
    expect(data2.name).toBe('Updated User');
  });
  it('should preserve dataUpdatedAt on update', function () {
    expect(dataManager.normalizer).toBeDefined();
    var queryKey = ['users'];
    var originalUpdatedAt = Date.now();

    // Set initial data
    dataManager.queryClient.setQueryData(queryKey, [{
      id: '1',
      name: 'Old'
    }], {
      updatedAt: originalUpdatedAt
    });
    dataManager.normalizer.setQuery(JSON.stringify(queryKey), [{
      id: '1',
      name: 'Old'
    }]);

    // Update data
    var mutationData = {
      id: '1',
      name: 'New'
    };
    dataManager.optimisticUpdate(mutationData);

    // Verify that dataUpdatedAt was preserved
    var cachedQuery = dataManager.queryClient.getQueryCache().find({
      queryKey: queryKey
    });
    expect(cachedQuery === null || cachedQuery === void 0 ? void 0 : cachedQuery.state.dataUpdatedAt).toBe(originalUpdatedAt);
  });
  it('should preserve error state on update', function () {
    expect(dataManager.normalizer).toBeDefined();
    var queryKey = ['users'];
    var error = new Error('Test error');

    // Set initial data with error
    dataManager.queryClient.setQueryData(queryKey, [{
      id: '1',
      name: 'Old'
    }]);
    var cachedQuery = dataManager.queryClient.getQueryCache().find({
      queryKey: queryKey
    });
    cachedQuery === null || cachedQuery === void 0 || cachedQuery.setState({
      error: error,
      status: 'error'
    });
    dataManager.normalizer.setQuery(JSON.stringify(queryKey), [{
      id: '1',
      name: 'Old'
    }]);

    // Update data
    var mutationData = {
      id: '1',
      name: 'New'
    };
    dataManager.optimisticUpdate(mutationData);

    // Verify that error and status were preserved
    var updatedQuery = dataManager.queryClient.getQueryCache().find({
      queryKey: queryKey
    });
    expect(updatedQuery === null || updatedQuery === void 0 ? void 0 : updatedQuery.state.error).toBe(error);
    expect(updatedQuery === null || updatedQuery === void 0 ? void 0 : updatedQuery.state.status).toBe('error');
  });
  it('should preserve isInvalidated flag on update', function () {
    expect(dataManager.normalizer).toBeDefined();
    var queryKey = ['users'];

    // Set initial data and invalidate
    dataManager.queryClient.setQueryData(queryKey, [{
      id: '1',
      name: 'Old'
    }]);
    dataManager.queryClient.invalidateQueries({
      queryKey: queryKey
    });
    dataManager.normalizer.setQuery(JSON.stringify(queryKey), [{
      id: '1',
      name: 'Old'
    }]);
    var cachedQueryBefore = dataManager.queryClient.getQueryCache().find({
      queryKey: queryKey
    });
    var isInvalidatedBefore = cachedQueryBefore === null || cachedQueryBefore === void 0 ? void 0 : cachedQueryBefore.state.isInvalidated;

    // Update data
    var mutationData = {
      id: '1',
      name: 'New'
    };
    dataManager.optimisticUpdate(mutationData);

    // Verify that isInvalidated was preserved
    var cachedQueryAfter = dataManager.queryClient.getQueryCache().find({
      queryKey: queryKey
    });
    expect(cachedQueryAfter === null || cachedQueryAfter === void 0 ? void 0 : cachedQueryAfter.state.isInvalidated).toBe(isInvalidatedBefore);
  });
  it('should work correctly with nested objects', function () {
    expect(dataManager.normalizer).toBeDefined();
    var queryKey = ['posts'];
    var initialData = [{
      id: '1',
      title: 'Post 1',
      author: {
        id: '10',
        name: 'Author 1'
      }
    }];
    dataManager.queryClient.setQueryData(queryKey, initialData);
    dataManager.normalizer.setQuery(JSON.stringify(queryKey), initialData);

    // Update author
    var mutationData = {
      id: '10',
      name: 'Updated Author'
    };
    dataManager.optimisticUpdate(mutationData);

    // Verify that author was updated
    var data = dataManager.queryClient.getQueryData(queryKey);
    expect(data[0].author.name).toBe('Updated Author');
  });
  it('should not throw if query is not in cache', function () {
    expect(dataManager.normalizer).toBeDefined();
    var mutationData = {
      id: '1',
      name: 'New'
    };

    // Don't add query to cache, only to normalizer
    // This should not throw an error
    expect(function () {
      dataManager.optimisticUpdate(mutationData);
    }).not.toThrow();
  });
});
// #sourceMappingURL=updateQueriesFromMutationData.test.js.map