📱  A strongly-typed, caching GraphQL client for iOS, written in Swift.

Fixed

• Fixed - Missing SPM plug-in: The missing Swift Package product has been added and the Install CLI plug-in is now available from the SPM command line and the Xcode project menu. #2683

Fixed

• Fixed - Convenience initializer for mock objects without fields: When mock objects did not have any fields a convenience initializer would still be generated causing infinite recursion during initialization. #2634 Thank you to @Gois for the contribution!
• Fixed - Ambiguous use of operator '??': When the nil coalescing operator was used on variables without a type the compiler could not determine which one to use. #2650. Thanks to @skreberem for raising the issue.
• Fixed - Generate library for test mock target: Previous versions would generate the SPM target for test mocks but not a library to properly import it into your unit tests. #2638 Thank you to @Gois for the contribution!
• Fixed - Podspec Swift version mismatched with SPM package version: The Swift version is now the same between the two dependency managers. #2657
• Fixed - Conflicting configuration values: There is now an error during code generation when the given configuration has conflicting values that cannot be fulfilled. #2677
• Fixed - DocumentType namespacing: The correct module namespacing is now used for DocumentType in generated operation code. #2679

New

• New - CLI version checker: This ensures that the version of the CLI being used to generate Swift code is the same as the version of the Apollo iOS dependency being used. #2659

Changed

• Changed - Removed SPM plug-ins: The SPM plug-ins for the CLI commands init, fetch-schema, and generate have been removed. There is a new plug-in to install the CLI and the CLI commands should be used from the command line instead. #2649
• Changed - CLI defaults: The updated default for the output of operation files is now .inSchemaModule, and the init command now requires a module type to be specified when creating a configuration file. #2673

• Fixed - Generated code produces compile error when accessing data dictionary in the InputDict struct if the name of the accessed property is hash: Dyanamic Member Lookup has been removed from InputDict to prevent potential name clashes. #2607
• Fixed - XCFramework archive builds: @inlinable has been removed from parts of ApolloAPI that were preventing xcframework builds with the BUILD_LIBRARY_FOR_DISTRIBUTION build setting. #2613
• Fixed - Variables type in local cache mutations is not properly namespaced: The Variables type in LocalCacheMutation now has the required prefix of GraphQLOperation to build successfully. #2615
• Fixed - Return error if no matches to schema or operation search paths: When a schema file could not be found errors were emitted but they were not indicative of the underlying problem. There is now validation to ensure that at least one match of the schema/operation search paths is found otherwise an error is thrown. #2618
• Fixed - File generation should ignore the .build/.swiftpm/.Pods folders: If code generation was executed from a path where subfolders contained the apollo-ios repo, it would find internal test schemas and fail. These special folders are now ignored. #2628
• Fixed - Download schema relative to root URL: Even though a root URL could be provided it was not being used in all schema download logic to output the downloaded schema file to the correct locaiton. This is now fixed. #2609 Thanks to @Anteo95 for the contribution.

• Fixed - Not generating code for subtypes only used as input to mutations: If you are using a JSON format schema that was fetched via GraphQL introspection code generation will now generate all referenced subtypes. #2583 Thank you to @vrutberg for reporting the issue.
• Fixed - When using the test mock, touching a GraphQLEnum property will cause a crash: JSON Encoding the mocks into the SelectionSet.DataDict was causing CustomScalar values to get encoded into their JSON values. The mock data is now converted into the correct format for the SelectionSet.DataDict. #2584 Thank you to @asapo for reporting the issue.
• Fixed - Add namespace for ApolloAPI types in generated code: The Apollo DocumentType enum is now correctly namespaced in generated code. #2585 Thank you to @matijakregarGH for reporting the issue.
• Fixed - Problems with schema name in generated code:
  • Schema name is now correctly cased for generated code namespacing. #2586 Thank you to @pchmelar for reporting the issue.
  • The schema name is now not allowed to match any referenced schema type, entity field, or entity list field names. #2589
• Fixed - Test mocks crash when touching array of objects: Test mock list of objects is now correctly converted into selection set data. #2591 Thank you to @konomae for reporting the issue.
• Fixed: GraphQLNullable nil coalescing: @exported import statements now ensure that the operator overload is imported when using the generated models. #2600 Thank you to bassrock for reporting the issue.

Fixes

• Fixed - apollo-ios-cli code generation on CocoaPods installation: All required resources for the CLI are now bundled correctly. This was an issue in CocoaPods installations where the generate command of apollo-ios-cli would result in a fatal error. #2548 Thank you to @ilockett for reporting the issue.
• Fixed - Xcode integration for Swift Package Plugins: The SwiftPM plugins now support XcodePluginContext from Xcode 14 and accepts the additional command line options that Xcode sends. #2554 Thank you to @SilverTab for reporting the issue.
• Fixed - Escaping input param names: Input parameter names recognized as reserved words are now escaped to prevent build errors. #2561 Thank you to @puls for the contribution.
• Fixed - Multiline deprecation messages: Deprecation messages that span multiple lines would previously result in build errors. #2579 Thank you to @TizianoCoroneo for the contribution.

Changes

• Changed - Warnings for deprecated enums: Deprecated enum cases are no longer annotated with the Swift @available attribute. They will now have comments indicating their deprecated status. #2579

This is the first major version release of Apollo iOS! The primary goal of Apollo iOS 1.0 is to stabilize the API of the model layer and provide a foundation for future feature additions and evolution of the library.

In a nutshell, v1.0.0 brings:

• A new code generation engine built entirely in Swift
• Improvements to the generated models
• Syntax and performance improvements across the entire library

There is documentation and a blog post coming soon. Feel free to ask questions by either opening an issue on our GitHub repo, or joining the community.

Thank you to all contributors who have helped us get to this first major release! ❤️

This is the first Release Candidate for Apollo iOS 1.0. The Release Candidate is a fully featured and code-complete representation of the final 1.0 version. This includes full feature parity with the 0.x.x releases.

API breaking changes are not expected between the Release Candidate and the General Availability (GA) release. The only code changes will be non-breaking bug fixes due to user feedback. The Release Candidate does not have complete documentation or usage guides, which will be completed prior to GA.

This first major version will include a new code generation engine, better generated models, and many syntax and performance improvements across the entire library. The primary goal of Apollo iOS 1.0 is to stabilize the API of the model layer and provide a foundation for future feature additions and evolution of the library.

• New: Option to Include Deprecated Input Arguments on Fields During Schema Download Thanks to @dave-perry for this addition!
• Fixed: Code Generation Config JSON File Compatibility
  • Previously, the apollo-codegen-config.json file used by the Apollo CLI needed to contain values for all optional fields. When new codegen options were added, this would cause errors until all newly added options has values provided.
  • The Codable implementation for the ApolloCodgenConfiguration has been implemented manually to prevent this. Now, only required fields must be provided, all optional fields can be omitted from the config file safely.
  • The CLI's init command also now generates a template config file with only the required fields.
• Fixed: Swift Keywords are escaped when used as names of Input Parameters
• Fixed: Compilation Error when using @skip and @include conditions on the same field
• Fixed: Added permissions request to SPM Code Generation Plugin
  • When running the code generation plugin, you will be prompted to give permission for the plugin to write to the package directory.
  • This permission check can be avoided by passing the --allow-writing-to-package-directory flag when executing the plugin command.
• Fixed: APQ Operations Will no Longer be Retried when Unrecognized if using .persistedOperationsOnly
  • .persistedOperationsOnly is for use with allow-listed operations only. If an operation identifier is not recognized by the server, there is no way to register the operation in this configuration.
• Breaking: Updated ApolloAPI internal metadata properties to be __ prefixed.
  • Generated GraphQL files expose certain properties/functions that are consumed by the Apollo library during GraphQL Execution. These members must be public in order to be exposed to Apollo, but are not intended for external consumption. We have added underscore prefixes to each of these members to signify that intention, using __ for GraphQL Metadata (in alignment with the GraphQL Specification) and _ for Apollo's utility and helper functions.
  • The affected signatures are:
    • SelectionSet.schema -> SelectionSet.__schema
    • SelectionSet.selection -> SelectionSet.__selection
    • JSONEncodable.jsonValue -> JSONEncodable._jsonValue
    • JSONDecodable.init(jsonValue:) -> JSONDecodable.init(_jsonValue:)
    • AnyHashableConvertible.asAnyHashable -> AnyHashableConvertible._asAnyHashable
    • OutputTypeConvertible.asOutputType -> OutputTypeConvertible._asOutputType
    • GraphQLOperation.variables -> GraphQLOperation._variables
    • LocalCacheMutation.variables -> LocalCacheMutation._variables

This is the fourth Beta Release of Apollo iOS 1.0. The Beta version has full feature parity with the 0.x.x releases. The API is expected to be mostly stable. Some breaking changes may occur due to user feedback prior to General Availability (GA) Release. The Beta does not have complete documentation or usage guides, which will be completed prior to GA.

This first major version will include a new code generation engine, better generated models, and many syntax and performance improvements across the entire library. The primary goal of Apollo iOS 1.0 is to stabilize the API of the model layer and provide a foundation for future feature additions and evolution of the library.

• Breaking: Generated Files now have the file extension .graphql.swift.
  • This allows you to clearly distinguish which files in your project are Apollo generated files.
  • Generated template files that are user-editable will still have the .swift file extension.
    • CustomScalar templates as well as the SchemaConfiguration file are user-editable. Once these are generated, they are never overwritten by future code generation execution.
  • This change is also necessary for the identification of generated files for the pruning functionality.
• New: Pruning of Unused Generated Files
  • Generated files that no longer should exist are automatically deleted now. This occurs when a .graphql file is removed from your project. The generated file will also be deleted the next time code generation is run.
  • This can be disabled with the new pruneGeneratedFiles codegen option.
  • Breaking: Automatic Deletion will not delete files generated in previous Alpha/Beta versions.
    • Only files with the .graphql.swift file extension will be deleted.
    • If you have used previous Alpha/Beta versions, you will need to delete your generated files manually one last time before running code generation with this version.
• New: Enum Case Names are Converted to Camel Case in Generated Enums.
  • Breaking: This is enabled by default, your call sites will need to be updated.
  • Camel case conversion for enum cases can be disabled with the new conversionStrategies.enumCases codegen option.
  • Thanks @bannzai for this one!
• Fixed: Swift Keywords are escaped when used as names of Enum Values Thanks @bannzai for the fix!
• Fixed: Compilation Error when Using Fragment with Lowercased Name This was an edge case that only occured when referencing a nested, merged selection set from the lowercase named fragment.
• Fixed: Retain Cycle in ReadTransaction Thanks @lorraine-hatch for the fix!
• Fixed: String jsonValue Initializer for Large Numbers Thanks @Almaz5200 for the fix!

This is the third Beta Release of Apollo iOS 1.0. The Beta version has full feature parity with the 0.x.x releases. The API is expected to be mostly stable. Some breaking changes may occur due to user feedback prior to General Availability (GA) Release. The Beta does not have complete documentation or usage guides, which will be completed prior to GA.

This first major version will include a new code generation engine, better generated models, and many syntax and performance improvements across the entire library. The primary goal of Apollo iOS 1.0 is to stabilize the API of the model layer and provide a foundation for future feature additions and evolution of the library.

• Breaking: Changed the generated Schema files
  • The schema will now have two generated files, SchemaMetadata.swift and SchemaConfiguration.swift.
  • We wanted to more clearly separate the parts of the schema that are generated for you (metadata) from the parts that you can configure yourself (configuration).
  • *If you were using the last beta, you’ll need to move your cache key resolution logic into SchemaConfiguration.swift. You should also delete the old generated files.
  • We will be implementing automatic deletion of generated files that should no longer be part of your project in a future beta, so you won't need to delete those files manually anymore.
• New: Added SPM Plugin for Code Generation CLI
  • When including Apollo iOS via Swift Package Manager, the Code Generation CLI is now accessible as an SPM Plugin.
  • After installing the apollo-ios package, run swift package --disable-sandbox apollo-initialize-codegen-config to create the codegen configuration file.
  • Then you can run swift package --disable-sandbox apollo-generate to run code generation.
  • The --disable-sandbox or --allow-writing-to-directory . arguments must be used when running the Code Generation CLI via the SPM plugin to give the plugin permission to write the generated files to the output directory configured in your codegen configuration file.
• Fixed: Compilation errors when schema types had lowercase names
• Fixed: Codegen engine crashing in specific situations
  • There were some bugs in the codegen compiler when merging nested fragments with non-matching parent types and using default values for input object list fields.
• Fixed: Issues with websocket reconnections Thanks @STomperi for the fix!

This is the second Beta Release of Apollo iOS 1.0. The Beta version has full feature parity with the 0.x.x releases. The API is expected to be mostly stable. Some breaking changes may occur due to user feedback prior to General Availability (GA) Release. The Beta does not have complete documentation or usage guides, which will be completed prior to GA.

This first major version will include a new code generation engine, better generated models, and many syntax and performance improvements across the entire library. The primary goal of Apollo iOS 1.0 is to stabilize the API of the model layer and provide a foundation for future feature additions and evolution of the library.

• Breaking: Changed API for Cache Key Configuration: Cache Key Resolution is now easier to configure. See CacheKeyInfo for examples and documentation.
• Breaking: Changed API for generated Schema Types to support dynamic types The API for generated schema types now initializes instances of Object, Interface, and Union for each corresponding type in your schema. These are still generated by the code generation engine. This differs from the previous API which generated static types that were subclasses of Object, Interface, and Union. The change provides the API to support the future addition of dynamic types added to your schema at runtime.
• New: Codegen CLI will now automatically create output directories: You no longer are required to have already created all intermediary directories for your codegen output paths prior to running code generation.
• New: CodegenCLI is built locally with CocoaPods installations: This is to ensure that the version of the Codegen CLI is the same as ApolloCodegenLib. This behavior will be extended to Swift Package Manager installations too.
• New: Swift Keywords are escaped when used as names of fields or types in generated objects: Previously, using Swift keywords (eg. self, protocol, Type) as the names of fields in your operations or types in your schema would cause compilation errors in your generated code. Now, these names will be escaped with backticks to prevent compiler errors. The names __data and fragments cannot be used as field names as they conflict with Apollo's generated object APIs Using these names will result in a validation error being thrown when attempting to run the code generation engine.
• Fixed: Fragments with lowercase names caused compilation errors: This bug is fixed. Fragments with lowercase names will be correctly uppercased when referencing the generated Fragment objects.
• Fixed: Build errors in Xcode 14/Swift 5.7: The library was updated to support the Swift 5.7 language version. Swift 5.6 is still supported.
• Fixed: Xcode 14 does not support Bitcode: Starting with Xcode 14, bitcode is no longer required for watchOS and tvOS applications, and the App Store no longer accepts bitcode submissions from Xcode 14.
• Fixed: "No such module ApolloAPI" error when using CocoaPods: The podspec was not configured to import all required source files and some import statements were unnecessary in a CocoaPods environment. A code generation configuration option was added to order to ensure generated files are generated with the correct import statements in a CocoaPods environment. When generating code for a project that includes Apollo via Cocoapods, you must set the cocoapodsCompatibleImportStatements option to true in your ApolloCodegenConfiguration. When using the Codegen CLI that is built for you during pod install the apollo-ios-cli init command will default this option to true. When building the Codegen CLI in by other method, this option will default to false.
• Removed: ApolloUtils target no longer necessary: The things that used to be shared here are actually no longer shared. There is no code shared between the Apollo and ApolloCodegenLib targets.
• Removed: ApolloCodegenConfiguration.validation: This method was incorrectly requiring destination paths to exist before code generation. Once that was removed it was no longer necessary. Any errors that are encountered with destination output paths will be raised during code generation.

• Remove all instances of bitcode as not supported in Xcode 14: Starting with Xcode 14, bitcode is no longer required for watchOS and tvOS applications, and the App Store no longer accepts bitcode submissions from Xcode 14. #2398 - Thanks to @stareque-atlassian for the contribution!

• Add codegen option for excludes: There is a new property on the codegen configuration options to allow files matching the pattern to be excluded, in the case they are found in the includes path. #2205 - Thanks to @bannzai for the contribution!
• Fixed - Using the graphql_transport_ws protocol could result in 4400 errors from the server: The correct protocol message is now being sent to the server to end communication. #2320
• Replace print statement with CodegenLogger.log: All codegen output is logged with CodegenLogger which can be disabled if needed. #2348 - Thanks to @hiltonc for the contribution!
• Expose GraphQLResultError path string: Adds a new publicly available computed property to GraphQLResultError which just exposes the path description. #2361 - Thanks to @joshuashroyer-toast for the contribution!

This is the first Beta Release of Apollo iOS 1.0. The Beta version has full feature parity with the 0.x.x releases. The API is expected to be mostly stable. Some breaking changes may occur due to user feedback prior to General Availability (GA) Release. The Beta does not have complete documentation or usage guides, which will be completed prior to GA.

This first major version will include a new code generation engine, better generated models, and many syntax and performance improvements across the entire library. The primary goal of Apollo iOS 1.0 is to stabilize the API of the model layer and provide a foundation for future feature additions and evolution of the library.

• New: Additional Generated Code Output Configuration Options.
  • queryStringLiteralFormat: Configures how the generated operations render the operation document source. Either multi-line (as defined in operation definition) or minified to a single line.
  • schemaDocumentation: Documentation of fields and objects from your schema will now be included as in-line documentation on generated objects. This can be disabled by setting schemaDocumentation to .excluded in your codegen configuration.
  • warningsOnDeprecatedUsage: Adds warning annotation when using fields and arguments in generated operations that are deprecated by the schema.
  • additionalInflectionRules: Allows you to configure custom singularization rules for generated fields names.
• New: Support Automatic Persisted Queries: APQs are now fully functional. Note: Legacy operation safelisting support may experience issues in some cases. If you have problems using operation safelisting, please create an issue so that we may understand and resolve the edge cases in the safelisting process.
• Fixed: Singularization of plural names for non-list fields.
• Fixed: Runtime failure on execution of operations with InputObjects.
• Fixed: __typename field no longer generated when manually included: __typename is automatically included in all operations and fragments and has a default property on all Selection Sets. Generating the field was redundant and caused compilation errors.

This is the eighth Alpha Release of Apollo iOS 1.0. This first major version will include a new code generation engine, better generated models, and many syntax and performance improvements across the entire library. The primary goal of Apollo iOS 1.0 is to stabilize the API of the model layer and provide a foundation for future feature additions and evolution of the library.

• New: Added Equatable and Hashable Conformance to public API Models: Object's like GraphQLRequest and GraphQLError now can be compared!
• New: Code Generation now supports Schema Extensions.
• Fixed: Namespacing and Access Control on Generated Models: Generated models were failing to compile due to namespacing and access control issues in certain code generation configurations. This is fixed now!
• Improved: Custom Scalar Default Float Behavior: If the response for a custom scalar is provided as a Float, it will automatically be converetd to a String (just like it's always done for Int).
• Improved: GraphQL Float now treated as Swift Double: The Float defined in the GraphQL spec is actually compliant with a Swift Double. Generated code will now generate Swift code with fields of type Double for GraphQL Float.
• Improved: Rename SelectionSet.data to SelectionSet.__data: This is to prevent naming conflicts with GraphQL fields named data.
• Fixed: graphql_transport_ws protocol now sends 'complete' to end subscription: The protocol implementation was previously sending the wrong message to close the connection.
• Improved: Generated Operations Folder Structure: The generated output folder structure for fragments and operations are now organized into sub-folders.
• New: Introspection Schema Download can output JSON: Schema downloads via Introspection now support output as JSON instead of only SDL. Note that Apollo Registry schema downloads still only support SDL as the output.

This is the seventh Alpha Release of Apollo iOS 1.0. This first major version will include a new code generation engine, better generated models, and many syntax and performance improvements across the entire library. The primary goal of Apollo iOS 1.0 is to stabilize the API of the model layer and provide a foundation for future feature additions and evolution of the library.

• New: Local Cache Mutations are now supported: In order to perform a local cache mutation, define a .graphql file with an operation or a fragment and mark it with the directive @apollo_client_ios_localCacheMutation. This will ensure the code generator generates a mutable cache mutation operation.
  • Note: Local Cache Mutation operations cannot be used for fetching from the network! You should define separate GraphQL operations for network operations and local cache mutations.
  • Example Usage:

/// SampleLocalCacheMutation.graphql
query SampleLocalCacheMutation @apollo_client_ios_localCacheMutation {
  allAnimals {
    species
    skinCovering
    ... on Bird {
      wingspan
    }
  }
}

/// SampleLocalCacheMutationFragment.graphql
fragment SampleLocalCacheMutationFragment on Pet @apollo_client_ios_localCacheMutation {
  owner {
    firstName
  }
}

• New: Support Code Generation Configuration Option: deprecatedEnumCases: If deprecatedEnumCases is set to exclude, deprecated cases in graphql enums from your schema will not be generated and will be treated as unknown enum values.
• Fixed - Compilation Errors in Generated Code When Schema was Embedded In Target: When embedding the generated schema in your own target, rather than generating a separate module for it, there were compilation errors due to access control and namespacing issues. These are resolved. This fixes #2301 & #2302. Thanks @kimdv for calling attention to these bugs!
  • Note: Compilation Errors for Test Mocks are still present. We are aware of ongoing issues with generated test mocks. We are actively working on fixing these issues and they will be resolved in a future alpha release soon.
• Fixed: Crash When Accessing a Conditionally Included Fragment That is Nil. This is fixed now and will return nil as it should. This fixes #2310.

This is the sixth Alpha Release of Apollo iOS 1.0. This first major version will include a new code generation engine, better generated models, and many syntax and performance improvements across the entire library. The primary goal of Apollo iOS 1.0 is to stabilize the API of the model layer and provide a foundation for future feature additions and evolution of the library.

• New - Objects and InputObjects are now equatable: Many objects now conform to AnyHashable bringing with them the ability to conform to Equatable, this should make tests easier to write.
• Change - GraphQLOperation fields are now static: Previously an instance of a GraphQLOperation was required to query any of it's properties, you can do that on the type now.
• Fixed - Nested fragment type cases: Nested fragment type cases were not being generated causing a crash in selection set generation.
• New - Code generation now has a CLI: A new command line executable has been built and will be available on Homebrew very soon! Check it out here.
• Fixed - SelectionSet and InlineFragment protocol definitions: These were incorrectly being generated within the namespace when a module of type .embeddedInTarget was being used.
• Fixed - Test mock convenience initializers: These were incorrectly defining parameter types for Interface and Union fields and the generated package could not successfully build.

This is the fifth Alpha Release of Apollo iOS 1.0. This first major version will include a new code generation engine, better generated models, and many syntax and performance improvements across the entire library. The primary goal of Apollo iOS 1.0 is to stabilize the API of the model layer and provide a foundation for future feature additions and evolution of the library.

• Test Mocks are now supported!
  • Test mocks can be generated to make it much easier to create mocks of your generated selection sets for unit testing.
  • This long requested feature can be enabled in your code generation config with the option config.output.testMocks.
  • Once you've generated test mocks, import the new ApolloTestSupport target (as well as your generated mocks) in your unit tests to start.
  • More documentation for test mocks will be coming soon. In the mean time, here is some example usage:

let mockDog = Mock<Dog>()
mock.species = "Canine"
mock.height = Mock<Height>(feet: 3, inches: 6)

// To mock an object in a generated operation:
let generatedDogMock: AnimalQuery.Data.Animal = AnimalQuery.Data.Animal.mock(from: mockDog)

// To mock an entire query:
let queryMock = Mock<Query>()
queryMock.animals = [mockDog]
let generatedSelectionSetMock: AnimalQuery.Data = AnimalQuery.Data.mock(from: queryMock)

• GraphQLNullable and GraphQLEnum from the ApolloAPI target are now exported by your generated operations. This prevents you from having to import ApolloAPI everywhere that you are consuming your generated models.
• CacheKeyProvider now supports grouping multiple types that share key uniqueness.
• Lots of performance improvements
  • Using StaticString instead of String in generated files.
  • Added @inlinable to many ApolloAPI functions consumed by generated code.
  • And more!

This is the fourth Alpha Release of Apollo iOS 1.0. This first major version will include a new code generation engine, better generated models, and many syntax and performance improvements across the entire library. The primary goal of Apollo iOS 1.0 is to stabilize the API of the model layer and provide a foundation for future feature additions and evolution of the library.

• Client Controlled Nullability (CCN) is now supported!
  • CCN is an experimental new feature addition to GraphQL. This feature allows you to override the optionality of fields from a schema in your client operations. CCN can help you create cleaner generated models that require less optional unwrapping.
  • You can read more about CCN here.
  • Because CCN is an experimental feature, the API is subject to change before its final release.
  • Apollo iOS 1.0.0 is the first client to provide support for this new functionality! Huge thanks to @twof!
• Fixed - Names of generated objects are now correctly uppercased.
• Fixed - Names of inline fragments with inclusion conditions were sometimes generated incorrectly.
• Fixed - __typename field is now selected by executor on all entities automatically.

This is the third Alpha Release of Apollo iOS 1.0. This first major version will include a new code generation engine, better generated models, and many syntax and performance improvements across the entire library. The primary goal of Apollo iOS 1.0 is to stabilize the API of the model layer and provide a foundation for future feature additions and evolution of the library.

• Include/Skip Directives are now supported!
  • Adding @include/@skip directives to fields, inline fragments, or fragment spreads will now generate code that respects the optionality of these conditionally included selections.
• Changed - Generated TypeCase renamed to InlineFragment These are now used for both type cases and inline fragments that are conditionally included using @include/@skip directives.
• Custom Scalars are now supported!
  • Template Files will be generated for custom scalars. The template files typealias each custom scalar to a String by default. These generated files can be edited to provide custom functionality for advanced custom scalars. Custom scalar template files that have been edited will not be overwritten on later code generation executions.
• Improved multi-module support
  • Including your generated code using package managers other than SPM can be done using the .other option for moduleType in your code generation configuration.
• Nil Coalescing Operator added to GraphQLNullable
  • This allows for optional variables to easily be used with GraphQLNullable parameters and a default value

var myVar: GraphQLNullable<String>
let optionalString: String?

// Before
myVar = optionalString.map { .some($0) } ?? .none

// After
myVar = optionalString ?? .none

• Fixed - fragments not accessible on generated SelectionSets.
• Fixed - __typename is now added to all operation and fragment definitions.
• Fixed - Missing Generated Interface Types
  • Interface types that were only referenced as an implemented interface of a referenced concrete type were not being generated previously.

• Fixed - APQ Retrying Failing in 0.51.1: Fixes a bug introduced in the last version that broke APQs. #2206 - Thanks to Kyle Browning for bringing this to our attention.

• Expose request body creation to better support custom interceptors: Enable lazy access to the request body creation for leverage in custom built interceptors, since JSONRequest.toURLRequest() encapsulates the creation. This enables the GraphQLMap to be accessed without re-creating the body. #2184 - Thanks to Rick Fast for the contribution.

• Allow periods in arguments to be ignored when parsing cacheKeys: If your query arguments include periods they will no longer cause broken cache keys. This means the cached data for those queries can be correctly found and returned. The caveat with this change though is that if you use a persisted cache, after the upgrade you could see cache misses and the data would be refetched. #2057 - Thanks to Hesham Salman for the contribution.
• Fixed - Sendable class JavaScriptError cannot inherit from another class other than NSObject: Xcode 13.3 introduced some additional requirements for Error types and JavaScriptError did not conform causing compile errors in ApolloCodegenLib. This change disables Sendable type checking for JavaScriptError while maintaining type-safety across concurrency boundaries. #2147 - Thank you to Tiziano Coroneo for the contribution.
• Fixed - Watcher using a policy that shouldn't hit the network, can still hit the network: If the cache policy given to the watch(query:cachePolicy:) method of ApolloClient was .returnCacheDataDontFetch it could still trigger a remote fetch of the query. - Thank you to Peter Potrebic for raising the issue.
• BREAKING CHANGE - graphql-ws Protocol Support: We've added official support for the graphql-ws library and its graphql-transport-ws protocol. This is a breaking change because the WebSocket initializers now require you to specify which protocol to use.

This is the second Alpha Release of Apollo iOS 1.0. This first major version will include a new code generation engine, better generated models, and many syntax and performance improvements across the entire library. The primary goal of Apollo iOS 1.0 is to stabilize the API of the model layer and provide a foundation for future feature additions and evolution of the library.

• Operation Variables and Field Arguments are now supported!
• Fixed - Capitalized field names generate code that doesn't compile #2167

This is the first Alpha Release of Apollo iOS 1.0. This first major version will include a new code generation engine, better generated models, and many syntax and performance improvements across the entire library. The primary goal of Apollo iOS 1.0 is to stabilize the API of the model layer and provide a foundation for future feature additions and evolution of the library.

What’s New

• The size of generated code has been reduced dramatically. In the most complex operations, the generated code can be up to 90% smaller than in the previous version.
• Generated response objects are more powerful and easier to consume.
  • The response objects now intelligently merge fields from not only their parents, but also other matching sibling fragments.

query AnimalQuery {
  allAnimals {
    species
    ... on Pet {
      name
    }
    ... on Cat {
      furColor
    }
}

In the past, the AsCat model would have fields for species, and furColor, but to access the name field, you would need to keep a reference to the AllAnimal object and call AsPet.name. This means that you couldn’t just pass the AsCat object to a UI component.

In 1.0, because we know that Cat implements the Pet interface, the name field is merged into the Cat object.

Any property that should exist based on the type of the object will be accessible. This makes consuming our generated response objects in your applications much easier. This should greatly reduce the need for view models to wrap our generated response objects.

• The code generation engine is now written in native Swift! This makes it easier for Swift developers to contribute to the project or alter the generated code for their specific needs! In future iterations, we hope to open up the code generation templating API to allow for even easier customization of your generated code!
• Computation of Cache Keys is protocol oriented now. Instead of a single cacheKeyForObject closure on your ApolloClient, you can implement cache key computation on individual object types with the CacheKeyProvider protocol. See Cache Key Resolution in the RFC for more information.

What’s Next - (Things Not Supported in Alpha 1)

• Operation Variables and Field Arguments
• @include/@skip Directives
• Cocoapods and Carthage Support for Generated Objects
  • Currently, the generated code supports creating an SPM package you can include as a target in your Package.swift file. Cocoapods and Carthage support will be coming soon.
  • In the mean time, you can still generate your operations and manually include the generated code in your project.
• Automatically Persisted Queries
• Cache Mutations
  • We are re-writing the entire cache mutation system to be easier to work with. Instead of exposing the cache via the operations you have defined, you’ll be able to access the cache through custom generated types that have a view of the entire cache at once. *This means no more writing query operations that are only used for local cache mutations.

Feedback we are looking for

While any and all feedback about the API design, structure, and usability of the library is appreciated, this Alpha version version focuses on the new generated operation models. We would love to hear about your experiences with:

• Generating your models using the SwiftScripts method
• Consuming the new generated models in your application code
  • Are there any use cases that were supported in the previous versions that are not supported or regress in the Alpha? (Other than the known cases listed above that will be supported soon.)
  • Do the new generated models make working with your data easier or more difficult?
  • Do you have specific suggestions for things that can be added or altered in the generated objects to make them more useful?

Expected Alpha Roadmap

• Operation Variables and Field Arguments
  • ASAP - Planned for next Alpha release within a week or two.
• @include/@skip Directives
  • Next priority after variables and arguments. Maybe the same release, maybe the next release after that
• Cocoapods and Carthage Support for Generated Objects
  • Probably a little while out, but shouldn’t be too hard. So maybe after the two above this.
• Automatically Persisted Queries
  • This is mostly done, just need to actually figure out how to compute the operation identifier hash and generate the operationIds.json file. This is lower priority though, since not a ton of people use it.
• Cache Mutations
  • This is going to take a long time still. We won’t move into Beta until we have the solution for this ready to test, but it’s only about 70% solved so far, and the implementation is not written yet.
  • I’m considering exposing an API to mutate the cache just using the stringly-typed dictionary of data in the mean time, to unblock people from trying out the Alpha in their applications while we solve this. This would be unsafe and not great for production, but should work just fine and be quick and easy to implement as a stop-gap.

Installation

Currently, only SPM is fully supported. Because the generated models can’t easily be consumed by a Cocoapods project yet, we have not included support for installation of the client with Cocoapods. This will be included in an upcoming release shortly.

SPM

.package(name: "Apollo",
         url: "https://github.com/apollographql/apollo-ios.git", 
         from: "1.0.0-alpha.1")

Run codegen using the instructions from the Swift scripting documentation.

• Dropped SPM support for Swift 5.2: The minimum version of the Swift tools and language compatibilty required to process the SPM manifest is Swift 5.3. This means a minimum of Xcode version 12 is required for Swift Package Manager support. #1992
• Removed unnecessary assertion failure: The completion handler on returnResultAsyncIfNeeded is defined as optional but if not included would cause debug builds to crash with an assertionFailure in the case of a failure of the Result. #2005 - Thank you to Richard Topchii for raising this issue!
• CachePolicy.default is now a stored property: It is now easier to configure a different default value for the CachePolicy property on any ApolloClient instance instead of having to override it in a subclass. #1998 - Thank you to Tiziano Coroneo for the contribution!
• Exposed cacheKey function as public: The access modifier of this function on GraphQLField has changed from internal to public. It is not recommended to rely on internal behaviour of the cache, and this is subject to change in future major versions. #2014 - Thank you to Peter Potrebic for the discussion!
• GET method support for ApolloSchemaDownloader: Introspection-based schema downloads can now be queried using a GET request. #2010 - Thank you to Mike Pitre for the contribution!
• Updated to version 2.33.9 of the Apollo CLI: This update will add __typename fields to inline fragments in operations to match the output from the client:push CLI command which used for operation safelisting. This should not affect the behaviour of your operations. #2028.
• Updated to version 0.13.1 of SQLite.swift: This update brings in some iOS 14 fixes and new table functionality such as upsert and insertMany. #2015 - Thank you to Hesham Salman for the contribution.

• ApolloSchemaDownloadConfiguration.HTTPHeader initializer was not public: The struct initializer that Swift automatically generates is marked with the internal access level, which meant that custom HTTP headers could not be added to an instance of ApolloSchemaDownloadConfiguration. #1962 - Thank you to Nikolai Sivertsen for the contribution!
• Documentation update: Fixed an inline code block that had specified language where such specification is not supported. #1954 - Thank you to Kim Røen for the contribution!
• Fix - ApolloCodegenOptions could not find schema input file: - If you created ApolloSchemaDownloadConfiguration and ApolloCodegenOptions objects using only output folders the default output filename for the schema download was different from the default schema input filename for codegen. #1968 - Thank you to Arnaud Coomans for finding this issue!

• Breaking - Schema download is now Swift-based: The dependency on the Apollo CLI (Typescript-based) for schema downloading has been removed. Schema downloading is now Swift-based, outputs GraphQL SDL (Schema Definition Language) by default, and is maintainable/extensible within apollo-ios with full API documentation. This is a breaking change because some of the API signatures have changed. Swift scripting offers a convenient way to perform certain operations that would otherwise require the command line - it's worth a look if you haven't tried it yet. #1935

• Customizable subscription message identifiers: The WebSocketTransport initializer can be configured with a subclass of OperationMessageIdCreator to provide a unique identifier per request. The default implementation is ApolloSequencedOperationMessageIdCreator and retains the current behavior of sequential message numbering. #1919 - Thank you to Clark McNally for the contribution!
• AWS AppSync Compatibility: Apollo-ios will now correctly handle the start_ack message that AWS AppSync servers respond with when a subscription is requested. #1919 - Thank you to Clark McNally for the contribution!
• Updated to version 2.33.6 of the Apollo CLI: Applies some new vulnerability patches to the CLI, but should not change any output. #1929
• Improved documentation: Clarification of cache normalization concepts. #1710 - Thank you to Daniel Morgan for the contribution!

• Fixed - Websocket default implementation not included in ApolloWebSocket via Cocoapods: Thank you to ketenshi for the contribution!

• Breaking - Removed Starscream dependency: Due to dependency management conflicts it has become easier for us to maintain our WebSockets as part of the ApolloWebSockets target instead of an external dependency on a forked version of Starscream. #1906
  • Removed Starscream as an external dependency in Cocoapods and Swift Package Manager.
  • The DefaultWebSocket implementation has been replaced with WebSocket.
• Fixed - clearCache not using the provided callback queue: ApolloClient was not passing the provided callback queue to ApolloStore and therefore the completion block for clearCache was being called on the main queue. #1904, #1901 - Thank you to Isaac Ressler for the contribution!
• Removed - Swift playground: The playground has been moved to a separate repository. #1905