Cache Fetch Fails with GraphQLExecutionError for 2D Array Data Structure

[gurusekhar-dev]

Summary

Description:
When querying data containing a two-dimensional array from the cache, Apollo iOS SDK throws a GraphQLExecutionError with underlying ApolloAPI.JSONDecodingError.wrongType. The data successfully parses and normalizes into the cache during network response, but fails when reading from the cache.

Expected Behavior:

Data should be successfully retrieved from cache with the same structure that was originally parsed from network response

Two-dimensional arrays should maintain their nested structure when reading from cache

Actual Behavior:

Cache read fails with GraphQLExecutionError pointing to specific nested array indices

Error shows ApolloAPI.JSONDecodingError.wrongType suggesting incorrect type conversion

The cache appears to store nested array elements as individual keys (e.g., scores.sets.0.0, scores.sets.0.1) rather than preserving the array structure

Version

Apollo iOS SDK Version: 1.25.3

Xcode Version: V26.1

iOS Version: iOS 26.1

Steps to reproduce the behavior

Execute a GraphQL query that returns data containing a two-dimensional array structure

Data successfully loads from network and normalizes into cache

Subsequent queries for the same data (reading from cache) fail with decoding error

Error occurs at specific path indicating nested array indices (e.g., liveScores.matches.0.scores.sets.0.0)

Logs

Anything else?

No response

[BobaFetters]

Thanks for the report, we will take a look into this, if possible if you can provide a small sample project that illustrates the issue it would help us with investigating.

[AnthonyMDev]

It's likely there is a very specific edge case here that you're hitting. 2D arrays should work just fine. Lost of people have been using them for a long time and we have unit tests around their usage.

In order to dig deeper into this one, we're going to need a reproduction case, since I'm fairly certain it's not just failing with any 2D array.

Did this issue start to appear for you when you upgraded from an older version, maybe it's an uncaught regression?

[gurusekhar-dev]

Reproducible Steps:

Initial Setup: Execute a GraphQL query that fetches an array of match objects, each containing a two-dimensional array of score objects in the structure: [[Score, Score], [Score, Score], [Score, Score]]

Cache Normalization:

Each match object is properly normalized in SQLite using its unique match ID

The scores two-dimensional array is automatically normalized by Apollo's default mechanism

Score objects are stored as individual cache references with flattened keys:

match:id1.scores.0.0

match:id1.scores.0.1

match:id1.scores.1.0

match:id1.scores.1.1

etc.

Error Trigger:

After successful network fetch and cache normalization

Execute the same query with cache-only fetch policy

Apollo attempts to decode the normalized cache data back into Match objects

Failure occurs during the decoding process at path match.0.scores.0.0

Root Cause:

The decoder encounters a cache reference key at match.0.scores.0.0

However, it expects to find the actual Score JSON object at this position

This type mismatch causes the decoding failure while reconstructing the two-dimensional scores array from normalized cache

The core issue is that Apollo's cache normalization creates flattened references for nested array elements, but the decoding process fails to properly resolve these references back to the original object structure during cache reads.

Source Code Location:

The error occurs in GraphQLExecutor.swift during cache resolution:

public final class GraphQLExecutor<Source: GraphQLExecutionSource> {
  private func complete<Accumulator: GraphQLResultAccumulator>(
    fields fieldInfo: FieldExecutionInfo,
    withValue value: JSONValue?,
    asType returnType: Selection.Field.OutputType,
    accumulator: Accumulator
  ) -> PossiblyDeferred<Accumulator.PartialResult> {
    
    switch returnType {
    // ... other cases ...
    
    case let .object(rootSelectionSetType):
      // ❌ FAILS HERE - Expected RawObjectData but found cache reference string
      guard let object = value as? Source.RawObjectData else {
        return PossiblyDeferred { throw JSONDecodingError.wrongType }
      }
      
      return execute(selectionSet: fieldInfo.field.selectionSet!,
                     on: object,
                     withRootType: rootSelectionSetType,
                     accumulator: accumulator)
    }
  }
}

[calvincestari]

@gurusekhar-dev, if you could please put that into a standalone project that reproduces the problem it will be far more helpful to debug - thank you.

[AnthonyMDev]

We're still waiting on a reproduction case for this one, but while looking into this we should look at #3380. They may be related.