dehydrate function

DehydratedState dehydrate(QueryClient client, { QuerySerializeData serializeData = _identity, bool shouldDehydrateQuery(Query query)?, bool shouldDehydrateMutation(Mutation mutation)?, bool includePending = false, bool redactErrors = true, })

Creates a snapshot suitable for server handoff or persistence.

Implementation

DehydratedState dehydrate(
  QueryClient client, {
  QuerySerializeData serializeData = _identity,
  bool Function(Query<dynamic> query)? shouldDehydrateQuery,
  bool Function(Mutation<dynamic, dynamic, dynamic> mutation)?
  shouldDehydrateMutation,
  bool includePending = false,
  bool redactErrors = true,
}) {
  final queryFilter =
      shouldDehydrateQuery ??
      (query) =>
          query.state.status == QueryStatus.success ||
          (includePending && query.state.status == QueryStatus.pending);
  final mutationFilter =
      shouldDehydrateMutation ?? (mutation) => mutation.state.isPaused;
  final now = client.scheduler.now();
  final queries = <DehydratedQuery>[];
  for (final query in client.queryCache.all.where(queryFilter)) {
    final state = query.state;
    queries.add(
      DehydratedQuery(
        key: query.key,
        dehydratedAt: now,
        meta: query.options.meta,
        pending: includePending
            ? query.promise?.then<Object?>((value) => serializeData(value))
            : null,
        state: <String, Object?>{
          'status': state.status.name,
          'hasData': state.hasData,
          if (state.hasData) 'data': serializeData(state.data),
          if (state.dataUpdatedAt != null)
            'dataUpdatedAt': state.dataUpdatedAt!.millisecondsSinceEpoch,
          if (!redactErrors && state.error != null)
            'error': serializeData(state.error),
          if (state.errorUpdatedAt != null)
            'errorUpdatedAt': state.errorUpdatedAt!.millisecondsSinceEpoch,
          'dataUpdateCount': state.dataUpdateCount,
          'errorUpdateCount': state.errorUpdateCount,
          'fetchFailureCount': state.fetchFailureCount,
          'isInvalidated': state.isInvalidated,
        },
      ),
    );
  }

  final mutations = <DehydratedMutation>[];
  for (final mutation in client.mutationCache.all.where(mutationFilter)) {
    final key = mutation.options.key;
    if (key == null) continue;
    mutations.add(
      DehydratedMutation(
        key: key,
        scope: mutation.options.scope,
        meta: mutation.options.meta,
        state: <String, Object?>{
          'status': mutation.state.status.name,
          'isPaused': mutation.state.isPaused,
          'variables': serializeData(mutation.state.variables),
          'optimistic': serializeData(mutation.state.optimistic),
          'failureCount': mutation.state.failureCount,
          if (mutation.state.submittedAt != null)
            'submittedAt': mutation.state.submittedAt!.millisecondsSinceEpoch,
        },
      ),
    );
  }
  return DehydratedState(
    queries: List<DehydratedQuery>.unmodifiable(queries),
    mutations: List<DehydratedMutation>.unmodifiable(mutations),
  );
}