apollographql/apollo-ios
Apollo Ios
apollo-ios is a GraphQL client library for iOS and Apple platforms that enables type-safe network communication. It transforms GraphQL operations into generated Swift models, ensuring that network responses are validated at compile time to eliminate manual mapping.
The library features a normalized cache manager that stores entities in a flat structure to maintain data consistency across different application views. It also optimizes network performance using hash-based persisted queries to reduce payload sizes and supports real-time data streaming via WebSockets or HTTP subscriptions.
The project covers comprehensive networking capabilities, including an interceptor-based request pipeline for authentication and logging, as well as operation-based data fetching and schema-driven model mapping.
Features
- GraphQL Model Generators - Automatically generates type-safe Swift models from GraphQL operations to eliminate manual network response mapping.
- GraphQL Normalized Caches - Implements a client-side cache that normalizes GraphQL results by unique identifiers to ensure data consistency.
- GraphQL iOS Clients - Provides a comprehensive GraphQL client library for executing queries and mutations in native iOS applications.
- GraphQL iOS Networking - Provides a comprehensive networking layer for fetching and managing GraphQL data within native Apple platform applications.
- GraphQL Clients - Ships a full-featured GraphQL client library for interacting with GraphQL APIs on iOS.
- Query Persistence Engines - Uploads persisted query manifests to a remote registry to reduce network payload size via query hashing.
- API Error Handling - Groups and filters errors by originating service, code, and path to accelerate debugging.
- Subgraph Health Evaluators - Evaluates how individual services contribute to performance by comparing request volumes and error rates.
- Real-Time Data Streams - Supports real-time data updates via GraphQL subscriptions over WebSockets or HTTP.
- Real-time Data Subscriptions - Implements a system for executing GraphQL subscriptions to stream live data updates via persistent connections.
- Compile-Time Code Generation - Generates Swift models from GraphQL operations during the build process to provide compile-time type safety.
- Alert Thresholds - Sets monitors and composite alerts based on metric thresholds to notify teams of traffic deviations.
- Field Usage Analytics - Tracks which clients and versions request particular schema fields to determine deprecation impact.
- Metric and Performance Monitors - Tracks request rates, response times, and error percentages to identify server overloads or latency.
- GraphQL Data Fetching - Executes named GraphQL operations and maps the resulting JSON to strongly typed Swift objects.
- Type-Safe Client Generators - Automatically transforms GraphQL operations into type-safe Swift models to eliminate manual response mapping.
- Type-Safe Model Mapping - Maps GraphQL query results to generated Swift types using a schema-aware transformation process.
- GraphQL Clients - Provides a networking layer that manages the execution of GraphQL operations and HTTP request handling.
- GraphQL Operation Validations - Verifies that GraphQL operations are valid against the latest schema within CI pipelines.
- Type-Safe API Integrations - Ensures compile-time validation of network responses by synchronizing GraphQL schemas with generated Swift models.
- API Response Caching - Implements caching mechanisms specifically for API endpoint responses to reduce network request volume.
- Schema Version Rollbacks - Restores a previous known-good state by updating the router configuration with a historical artifact URI.
- Entity Resolution - Resolves entity references by using foreign keys from one API to trigger data resolution in another.
- Stream Subscriptions - Streams real-time data updates to the client using GraphQL subscriptions over persistent connections.
- Schema State Diffing - Calculates changes between schema versions using a format-aware diffing engine.
- Schema Evolution Proposals - Manages schema updates through a review process with automated validation and impact analysis.
- Persisted Query Manifests - Generates manifests that map operations to persisted query hashes to reduce network payload size and enhance security.
- Automated Schema Synchronization - Integrates schema validation and publishing into CI/CD workflows to maintain synchronization with a central registry.
- Automated Deployment Pipelines - Automates the update of router configurations by fetching the latest graph artifact reference in a pipeline.
- Kubernetes Deployments - Uses Kubernetes custom resources and operators to orchestrate router deployments.
- Unified Data Models - Combines data from multiple REST and GraphQL APIs into a single unified schema by contributing fields.
- Graph Router Configurations - Provides utilities to fetch, validate, and update the cloud router configuration for specific graph references.
- Client Request Monitoring - Attaches a name and version to requests via headers to track which client version calls APIs.
- Payload Optimization - Implements hash-based persisted queries to reduce the size of network request payloads sent from the device.
- Schema Composition - Validates that changes to subgraph schemas do not break the overall composition of the supergraph during merge requests.
- Request Interceptors - Implements an interceptor pipeline for cross-cutting concerns like authentication and logging within network requests.
- Schema Registries - Publishes individual subgraph schemas to a centralized registry to update the global graph.
- GraphQL Linting - Analyzes GraphQL schema definitions against composition rules to prevent configuration errors.
- Cache Invalidation Strategies - Provides event-driven mechanisms for triggering the removal of specific cached entries using tags.
- Federation Engines - Supports the implementation of federated subgraphs by using standardized directives for entity resolution and field sharing.
- Supergraph Registry Syncing - Maintains supergraph configurations by uploading subgraph schemas and routing URLs to a remote registry.
- Subgraph Linting - Analyzes subgraph schemas to ensure they follow best practices and naming conventions before they are merged.
- Querying and Introspection - Provides capabilities to introspect the complete GraphQL schema of a running server.
- GraphQL Schema Management - Provides tools to upload local schemas or introspection results to a registry for graph variant management.
- Schema Validators - Verifies the structural correctness and consistency of GraphQL schema definitions to ensure API stability.
- GraphQL Subscriptions - Executes GraphQL subscription operations over WebSocket or HTTP protocols for real-time updates.
- Mobile Client Libraries - Strongly-typed GraphQL client for iOS applications.
