@gravity-ui/data-source/build/esm/react-query/utils/normalize.js

A wrapper around data fetching

import _typeof from "@babel/runtime/helpers/typeof";
var shouldInvalidateData = function shouldInvalidateData(globalConfig, mutationConfig) {
  if (mutationConfig === false) {
    return false;
  }
  if (!globalConfig) {
    return false;
  }
  return true;
};
var shouldUpdateOptimistically = function shouldUpdateOptimistically(globalConfig, mutationConfig) {
  if (mutationConfig === false) {
    return false;
  }
  if (typeof mutationConfig === 'boolean' && mutationConfig || _typeof(mutationConfig) === 'object' && mutationConfig) {
    return true;
  }
  if (!globalConfig) {
    return false;
  }
  return true;
};
var getOptimisticProps = function getOptimisticProps(globalConfig, mutationConfig) {
  var globalAutoRollback = _typeof(globalConfig) === 'object' ? globalConfig.autoCalculateRollback : undefined;
  var mutationAutoRollback = _typeof(mutationConfig) === 'object' ? mutationConfig.autoCalculateRollback : undefined;
  var globalDevLogging = _typeof(globalConfig) === 'object' ? globalConfig.devLogging : undefined;
  var mutationDevLogging = _typeof(mutationConfig) === 'object' ? mutationConfig.devLogging : undefined;
  return {
    autoRollback: mutationAutoRollback !== null && mutationAutoRollback !== void 0 ? mutationAutoRollback : globalAutoRollback,
    devLogging: mutationDevLogging !== null && mutationDevLogging !== void 0 ? mutationDevLogging : globalDevLogging
  };
};
export var createQueryNormalizer = function createQueryNormalizer(normalizer, queryClient, config, optimisticUpdate, invalidateData) {
  if (!normalizer || !config) {
    return undefined;
  }
  var globalOptimistic = _typeof(config) === 'object' && 'optimistic' in config ? config.optimistic : false;
  var globalInvalidateData = _typeof(config) === 'object' && 'invalidate' in config ? config.invalidate : false;
  var unsubscribeQueryCache = null;
  var unsubscribeMutationCache = null;
  return {
    /** Get normalized data */
    getNormalizedData: normalizer.getNormalizedData,
    /** Set normalized data (for manual updates, WebSocket, etc.) */
    setNormalizedData: function setNormalizedData(data) {
      return optimisticUpdate(data);
    },
    /** Clear all normalized data */
    clear: normalizer.clearNormalizedData,
    /** Get object by ID */
    getObjectById: normalizer.getObjectById,
    /** Get query fragment */
    getQueryFragment: normalizer.getQueryFragment,
    /** Get dependent queries by data */
    getDependentQueries: function getDependentQueries(mutationData) {
      return normalizer.getDependentQueries(mutationData).map(function (key) {
        return JSON.parse(key);
      });
    },
    /** Get dependent queries by IDs */
    getDependentQueriesByIds: function getDependentQueriesByIds(ids) {
      return normalizer.getDependentQueriesByIds(ids).map(function (key) {
        return JSON.parse(key);
      });
    },
    /** Subscribe to QueryCache changes */
    subscribe: function subscribe() {
      // Subscribe to QueryCache (query additions/updates/removals)
      unsubscribeQueryCache = queryClient.getQueryCache().subscribe(function (event) {
        var _queryOptions$normali;
        var queryKeyStr = JSON.stringify(event.query.queryKey);
        if (event.type === 'removed') {
          normalizer.removeQuery(queryKeyStr);
          return;
        }

        // Check if the query should be normalized
        // At this point options are already merged (DataSource + Hook)
        var queryOptions = event.query.options;
        var queryNormalize = (_queryOptions$normali = queryOptions === null || queryOptions === void 0 ? void 0 : queryOptions.normalize) !== null && _queryOptions$normali !== void 0 ? _queryOptions$normali : true;
        if (!queryNormalize) {
          return;
        }
        if (event.type === 'added' && event.query.state.data !== undefined) {
          normalizer.setQuery(queryKeyStr, event.query.state.data);
        } else if (event.type === 'updated' && event.action.type === 'success' && event.action.data !== undefined) {
          normalizer.setQuery(queryKeyStr, event.action.data);
        }
      });

      // Subscribe to MutationCache for normalization + optimistic updates
      unsubscribeMutationCache = queryClient.getMutationCache().subscribe(function (event) {
        var _event$mutation;
        // Cast to extended type with additional configs, if available
        var mutationOptions = (_event$mutation = event.mutation) === null || _event$mutation === void 0 ? void 0 : _event$mutation.options;
        var mutationQueryNormalize = mutationOptions === null || mutationOptions === void 0 ? void 0 : mutationOptions.normalize;
        var mutationQueryOptimistic = mutationOptions === null || mutationOptions === void 0 ? void 0 : mutationOptions.optimistic;
        var mutationQueryInvalidateData = mutationOptions === null || mutationOptions === void 0 ? void 0 : mutationOptions.invalidate;
        if (shouldInvalidateData(globalInvalidateData, mutationQueryInvalidateData)) {
          if (event.type === 'updated' && event.action.type === 'success' && event.action.data) {
            invalidateData(event.action.data);
          }
        }
        if (!mutationQueryNormalize || !shouldUpdateOptimistically(globalOptimistic, mutationQueryOptimistic)) {
          return;
        }
        var _getOptimisticProps = getOptimisticProps(globalOptimistic, mutationQueryOptimistic),
          autoRollback = _getOptimisticProps.autoRollback,
          devLogging = _getOptimisticProps.devLogging;
        if (event.type === 'updated' && event.action.type === 'success' && event.action.data) {
          optimisticUpdate(event.action.data);
        } else if (event.type === 'updated' && event.action.type === 'pending') {
          var context = event.mutation.state.context;
          if (context !== null && context !== void 0 && context.optimisticData) {
            if (!context.rollbackData && mutationQueryOptimistic && autoRollback !== false) {
              context.rollbackData = normalizer.getCurrentData(context.optimisticData);
              if (devLogging) {
                console.log('[OptimisticUpdate] Auto-calculated rollbackData:', context.rollbackData);
              }
            }
            optimisticUpdate(context.optimisticData);
          }
        } else if (event.type === 'updated' && event.action.type === 'error') {
          var _context = event.mutation.state.context;
          if (_context !== null && _context !== void 0 && _context.rollbackData) {
            if (devLogging) {
              console.log('[OptimisticUpdate] Rolling back changes');
            }
            optimisticUpdate(_context.rollbackData);
          }
        }
      });
    },
    unsubscribe: function unsubscribe() {
      var _unsubscribeQueryCach, _unsubscribeMutationC;
      (_unsubscribeQueryCach = unsubscribeQueryCache) === null || _unsubscribeQueryCach === void 0 || _unsubscribeQueryCach();
      (_unsubscribeMutationC = unsubscribeMutationCache) === null || _unsubscribeMutationC === void 0 || _unsubscribeMutationC();
      unsubscribeQueryCache = null;
      unsubscribeMutationCache = null;
    }
  };
};
// #sourceMappingURL=normalize.js.map