Classes

At its core, the Amplify class is simply a router that provides clients top-level access to categories and configuration methods. It provides convenient access to default plugins via the top-level category properties, but clients can access specific plugins by invoking getPlugin on a category and issuing methods directly to that plugin.

There are two exceptions to this. The Logging and Hub categories are configured with a default plugin that is available at initialization.

• Tag: Amplify

The API category provides a solution for making HTTP requests to REST and GraphQL endpoints.

Unchecked in the literal sense: plugins and isConfigured are plain mutable state with no lock, and isConfigured is public, so callers can flip it. add(plugin:) cannot race a configured category — it throws once isConfigured is set — but removePlugin(for:) has no such guard, so it can race a concurrent read. The exposure predates this annotation, which only stops the compiler from asking about it.

API Auth Provider Factory

GraphQL Subscription Operation

GraphQL Operation

REST Request

The Analytics category enables you to collect analytics data for your app.

Unchecked in the literal sense: plugins and isConfigured are plain mutable state with no lock. add(plugin:) cannot race a configured category — it throws once isConfigured is set — but removePlugin(for:) mutates plugins with no such guard and no lock, so it can race a concurrent read. That exposure predates this annotation; the annotation only stops the compiler from asking about it.

This class represents a lazy reference to a Model, meaning that the reference may or may not exist at instantiation time.

The default implementation DefaultModelProvider only handles in-memory data, therefore get() and require() will simply return the current reference.

List<ModelType> is a custom Collection that is capable of loading records from a data source. This is especially useful when dealing with Model associations that need to be lazy loaded. Lazy loading is performed when you access the Collection methods by retrieving the data from the underlying data source and then stored into this object, before returning the data to you. Consumers must be aware that multiple calls to the data source and then stored into this object will happen simultaneously if the object is used from different threads, thus not thread safe. Lazy loading is idempotent and will return the stored results on subsequent access.

Be aware this is an assertion, not a proof: loadedState is mutated on first load and is not synchronized, so two concurrent load() calls can both fetch. That race predates this migration; making it genuinely safe means putting the lazy-load transition behind a lock, which touches the Collection and Codable surface and is better done on its own.

Represents the Model structure itself, a container of property references.

• Example: “`swift class PostModelPath : ModelPath {}

extension ModelPath where ModelType == Post { var id: FieldPath { id() } var title: FieldPath { string("title”) } var blog: ModelPath { BlogModelPath(name: “blog”, parent: self) } }

The conformance is a genuine assertion, not a checked fact. and(_:) and or(_:) mutate predicates in place and return self when the group type already matches, so two tasks composing onto the same group race on an array — and predicates is public internal(set), so external code reads it directly and a lock here would not cover those reads without turning it into a computed property.

What makes this safe in practice is usage, not structure: a predicate is built up on one task and then handed to a query. Sharing a part-built group across tasks is unsupported, and nothing in the type enforces that. The exposure predates this annotation, which only stops the compiler asking.

The Geo category enables you to interact with geospacial services.

Amplify has a local eventing system called Hub. It is a lightweight implementation of Publisher-Subscriber pattern, and is used to share data between modules and components in your app. Hub enables different categories to communicate with one another when specific events occur, such as authentication events like a user sign-in or notification of a file download.

AWS Amplify writes console logs through Logger. You can use Logger in your apps for the same purpose.

In practice configuration happens once during start-up and the state is read-only afterwards, but nothing in this type enforces that. Bringing those two under the same lock would be the real fix and is worth doing separately — it needs care, because several accessors call each other and would deadlock on a non-recursive lock.

The Notifications parent category

The Push Notifications category allows you to receive and report push notifications.

AWS Amplify Storage module provides a simple mechanism for managing user content for your app in public, protected or private storage buckets.

• Tag: StorageCategory

An AmplifyOperation that emits InProcess values intermittently during the operation.

Unlike a regular AmplifyOperation, which emits a single Result at the completion of the operation’s work, an AmplifyInProcessReportingOperation may emit intermediate values while its work is ongoing. These values could be incidental to the operation (such as a Storage.downloadFile operation reporting Progress values periodically as the download proceeds), or they could be the primary delivery mechanism for an operation (such as a GraphQLSubscriptionOperation‘s emitting new subscription values).

An abstract representation of an Amplify unit of work. Subclasses may aggregate multiple work items to fulfull a single “AmplifyOperation”, such as an “extract text operation” which might include uploading an image to cloud storage, processing it via a Predictions engine, and translating the results.

AmplifyOperations are used by plugin developers to perform tasks on behalf of the calling app. They have a default implementation of a dispatch method that sends a contextualized payload to the Hub.

Pausable/resumable tasks that do not require Hub dispatching should use AsynchronousOperation instead.

This class is to facilitate executing asychronous requests. The caller can transition the operation to its finished state by calling finish() in the callback of an asychronous request to ensure that the operation is only removed from the OperationQueue after it has completed all its work. This class is not inherently thread safe. Although it is a subclass of Foundation’s Operation, it contains private state to support pausing, resuming, and finishing, that must be managed by callers.

A class that wraps access to its underlying value with an NSLocking instance.

A helper for executing asynchronous work serially.

A Tree data type with a value of some type E and children subtrees.

The default Hub plugin provided with the Amplify Framework

No guaranteed delivery order

AWSHubPlugin distributes messages in order to listeners, but makes no guarantees about the order in which a listener is called. This plugin does not guarantee synchronization between message delivery and listener management. In other words, the following sequence is not guaranteed to succeed:

plugin.listen(to: .custom("MyChannel") { event in print("event received: \(event)") }
plugin.dispatch(to: .custom("MyChannel"), payload: HubPayload("MY_EVENT"))

Instead, messages and listener states are guaranteed to be independently self-consistent. Callers can use hasListener(withToken:) to check that a listener has been registered.

A Logging category plugin that forwards calls to the OS’s Unified Logging system

Presents a developer menu using the provided DevMenuPresentationContextProvider upon notification from a TriggerRecognizer. Default recognizer is a LongPressGestureRecognizer

LoggingCategoryPlugin that wraps anotherLoggingCategoryPlugin and saves the logs in memory