Skip to content

Latest commit

 

History

History
115 lines (69 loc) · 7.42 KB

ROADMAP.md

File metadata and controls

115 lines (69 loc) · 7.42 KB
Raw

🔮 Apollo iOS Roadmap

Last updated: 2024-04-16

For up to date release notes, refer to the project's Changelog.

Please note: This is an approximation of larger effort work planned for the next 6 - 12 months. It does not cover all new functionality that will be added, and nothing here is set in stone. Also note that each of these releases, and several patch releases in-between, will include bug fixes (based on issue triaging) and community submitted PR's.

✋ Community feedback & prioritization

  • Please report feature requests or bugs as a new issue.
  • If you already see an issue that interests you please add a 👍 or a comment so we can measure community interest.

1.x.x patch releases

Please see our patch releases milestone for more information about the fixes and enhancements we plan to ship in the near future. Anything labeled planned-next is slated for the next patch release.

Upcoming 1.x features

As we identify feature sets that we intend to ship, we'll add to and update the subheadings in this section. We intend to keep this section in chronological order. In order to enable rapid and continuous feature delivery, we'll avoid assigning minor version numbers to these feature groups in the roadmap.

@defer support

The @defer directive enables your queries to receive data for specific fields asynchronously. This is helpful whenever some fields in a query take much longer to resolve than others. Apollo Kotlin and Apollo Client (web) currently support this syntax, so if you're interested in learning more check out their documentation. Apollo iOS has released a preview version of this feature in the preview-defer.1 branch. This will be released as an experimental feature in an upcoming 1.x minor version.

The feature is being rolled out on the preview-defer.n tags (currently preview-defer.2:

  • ✅ Code generation
  • ✅ Partial incremental execution
  • 🔨 Partial and incremental caching (approx. 2024-04-29)
  • 🔲 Selection Set Initializers (next)

Improvements to code generation configuration and performance

Approximate Date: to be released incrementally

  • This effort encompasses several smaller features:
    • ✅ Make codegen support Swift concurrency (async/await): available in v1.7.0
    • (in progress) Add configuration for disabling merging of fragment fields
    • (in progress) Fix retain cycles and memory issues causing code generation to take very long on certain large, complex schemas with deeply nested fragment composition

Swift 6 compatibility

Approximate Date: 2024-05-17

Configuration to rename generated models for schema types

Approximate Date: 2024-05-29

  • Allow client-side users to override the names of schema types in the generated models.
  • This will allow user's to improve the quality and expressiveness of client side APIs when schema type names are not appropriate for client usage.
  • This also allows workarounds for issues when names of schema types conflict with Swift types.

Reduce generated schema types

Approximate Date: 2024-05-31

  • Right now we are naively generating schema types that we don't always need. A smarter algorithm can reduce generated code for certain large schemas that are currently having every type in their schema generated
  • Create configuration for manually indicating schema types you would like to have schema types and TestMocks generated for

Mutable generated reponse models

Approximate Date: TBD

  • Provide a mechanism for making generated reponse models mutable.
  • This will allow mutability on an opt-in basis per selection set or definition.

Support codegen of operations without response models

Approximate Date: TBD

  • Support generating models that expose only the minimal necessary data for operation execution (networking and caching).
    • This would remove the generated response models, exposing response data as a simple JSONObject (ie. [String: AnyHashable]).
  • This feature is useful for projects that want to use their own custom data models or have binary size constraints.

Declarative caching

Approximate Date: TBD

  • Similar to Apollo Kotlin declarative caching via the @typePolicy directive
  • Provide ability to configure cache keys using directives on schema types as an alternative to programmatic cache key configuration

Apollo iOS Pagination

Version 0.1 of this module was released in March 2024. We are iterating quickly based on user feedback - please see the project's Issues and PRs for up-to-date information. We expect the API to become more stable over time and will consider a v1 release when appropriate.

2.0

Approximate Date: TBD

These are the major initiatives planned for 2.0/2.x:

  • Networking Stack Improvements: The goal is to simplify and stabilise the networking stack.
    • The updated network stack solved a number of long standing issues with the old barebones NetworkTransport but still has limitations and is complicated to use. Adopting patterns that have proven useful for the web client, such as Apollo Link, will provide more flexibility and give developers full control over the steps that are invoked to satisfy requests.
    • We will support some of the new Swift concurrency features, such as async/await, in Apollo iOS. It may involve Apollo iOS dropping support for macOS 10.14 and iOS 12.

3.0

Approximate Date: TBD

These are the major initiatives planned for 3.0/3.x:

  • Cache Improvements: Here we are looking at bringing across some features inspired by Apollo Client 3 and Apollo Kotlin
    • Better pagination support. Better support for caching and updating paginated lists of objects.
    • Result model improvements
    • Reducing over-normalization. Only separating out results into individual records when something that can identify them is present
    • Real cache eviction & dangling reference collection. There's presently a way to manually remove objects for a given key or pattern, but Apollo Client 3 has given us a roadmap for how to handle some of this stuff much more thoroughly and safely.
    • Cache metadata. Ability to add per-field metadata if needed, to allow for TTL and time-based invalidation, etc.

This major release is still in pre-planning, more details will come in the future.