aws-amplify/amplify-flutter

This system is the AWS Amplify Flutter SDK, a comprehensive framework for building cross-platform mobile and web applications with AWS backend services. It provides a unified interface for core categories including Authentication, DataStore, API, Storage, and Analytics, supporting both Gen 1 and Gen 2 configuration formats. The repository also includes the AFT CLI tool for monorepo management and extensive infrastructure-as-code templates for provisioning and testing these backend services.

135 changes.

This period focused on establishing the foundational architecture for Amplify Flutter Gen 2, introducing core packages like amplify\_core and aws\_common to support new configuration models and pluggable authentication. Significant effort was dedicated to scaffolding the new amplify\_datastore package, including its native bridges, model schemas, and comprehensive test suites. The work also expanded platform support to include Web, Windows, and Linux, while introducing the AFT CLI tool to streamline monorepo management.

51 changes.

This period focused on introducing support for Amplify Gen 2 configuration outputs and backend infrastructure, alongside a major architectural shift to migrate DataStore and authentication logic to native method channels. Significant effort was also dedicated to enhancing the Pinpoint analytics plugin with legacy data migration and web persistence, while expanding the AFT tooling with changelog parsing and version-bump automation.

9 changes.

This period focused on expanding the Amplify library ecosystem by introducing new packages for Kinesis, Firehose, and Amazon Connect, alongside a foundational foundation package for shared utilities. Significant effort was directed toward enabling WebAssembly compatibility across analytics and native wrappers, while also delivering a native Swift implementation for the DataStore plugin on Apple platforms.

The \packages/aft/lib\ package now provides a consolidated public API via \aft.dart\, exporting the core command implementations (such as \run\, \exec\, \create\, \constraints\, and \publish\) along with supporting models, utilities, and the \pub\_runner\. This change allows external consumers to programmatically access and utilize the AFT tool's functionality rather than relying solely on the CLI entry point.

packages/aft/lib · high confidence

The \aws\_signature\_v4\ package has been introduced to provide HTTP request signing for AWS Signature Version 4, enabling communication with AWS services across Web, VM, and Flutter environments. This release includes a new \AWSSigV4Signer\ class, configurable service settings (such as \S3ServiceConfiguration\ for chunked payloads), and support for WebAssembly (Wasm) compilation. The package also ships with a complete example application demonstrating S3 bucket creation and file uploads, along with updated Dart SDK constraints and dependency versions.

_packages/aws\_signature\v4 · high confidence

The \packages/aft/bin/aft.dart\ file introduces the main entry point for the AFT command-line interface. It initializes the application by invoking the internal command runner and handles standard error reporting for usage exceptions and general errors, ensuring proper exit codes are returned to the shell.

packages/aft/bin · high confidence

The \amplify\_core\ package now includes a comprehensive set of serializable configuration models for Amazon Cognito in the \config/auth/cognito\ directory. These new classes—such as \CognitoAuthConfig\, \CognitoUserPoolConfig\, \CognitoOAuthConfig\, \CognitoAppSyncConfig\, and \CognitoIdentityCredentialsProvider\—enable the SDK to parse and manage Gen 2-style JSON outputs. The update also introduces supporting enums for authentication flows (\AuthenticationFlowType\), MFA types (\MfaType\), and social providers, along with the necessary JSON serialization logic to map these configurations to the underlying AWS services.

_packages/amplify\_core/lib/src/config/auth/cognito, packages/amplify\core/lib/src/config/notifications · high confidence

The Analytics Pinpoint package now includes a Flutter implementation of the device context information provider. A new \FlutterDeviceContextInfoProvider\ collects platform-specific details such as locale, app name, package name, version, and device model/manufacturer, while a supporting \AppInfo\ class structures this data. This enables the Pinpoint endpoint demographic data to automatically include accurate Flutter app and device metadata.

_packages/analytics/amplify\_analytics\_pinpoint/lib/src/device\_context\_info\provider · high confidence

The storage configuration layer now includes new \S3PluginConfig\ and \StorageConfig\ classes to support Amplify Gen 2 outputs. These models parse and expose S3-specific settings (bucket and region) from the configuration JSON, providing a structured way to access storage plugin details rather than relying on raw map lookups.

_packages/amplify\core/lib/src/config/storage · high confidence

The \amplify\_core\ package now includes dedicated types for handling temporal data in compliance with AWS AppSync scalars. New classes \TemporalDate\, \TemporalDateTime\, \TemporalTime\, and \TemporalTimestamp\ provide strict parsing and formatting of ISO-8601 strings, including support for timezone offsets and nanosecond precision. These types ensure that date, time, and timestamp values are serialized and deserialized consistently with AppSync's expected formats.

_packages/amplify\core/lib/src/types/temporal · high confidence

The \amplify\_analytics\_pinpoint\_example\ app now includes native project scaffolding for Linux and Windows, allowing developers to build and run the example on these desktop platforms. The new Linux setup uses GTK and CMake, while the Windows setup uses CMake with Win32 window management, including support for high-DPI scaling and system theme integration. Both platforms are configured to register the \amplify\_db\_common\ and \connectivity\_plus\ plugins, ensuring the example app functions correctly on desktop environments.

_packages/analytics/amplify\_analytics\pinpoint/example/windows · high confidence

The Darwin (iOS/macOS) native legacy wrapper now includes Swift Package Manager support, introducing a new Swift source structure with \AmplifyNativeLegacyPlugin.swift\ (generated Pigeon bindings for Flutter message channels) and \AmplifyNativeLegacyWrapperPlugin.swift\ (the Flutter plugin implementation wrapping \AWSCognitoAuthPlugin\). This change also adds a \.gitignore\ file tailored for Swift/Flutter build artifacts and an \Assets/.gitkeep\ placeholder, enabling developers to integrate the wrapper via SPM in addition to existing methods.

_packages/amplify\_native\_legacy\wrapper/darwin · high confidence

The app info provider in the Analytics Pinpoint package now supports WebAssembly targets. This is achieved by splitting the implementation into platform-specific files: a web-specific provider using \package\_info\_plus\_platform\_interface\ to avoid \dart:io\, an IO-based provider for native platforms, and a stub for unsupported platforms. This change ensures that analytics data collection works correctly in WebAssembly environments by preventing incompatible native imports from being included in the web build.

_packages/analytics/amplify\_analytics\_pinpoint/lib/src/device\_context\_info\_provider/app\_info\provider · high confidence

The iOS example project for the Amplify DataStore package now includes the necessary configuration files to support building the Flutter framework and managing CocoaPods dependencies. Specifically, AppFrameworkInfo.plist defines the Flutter app framework metadata, while Debug.xcconfig and Release.xcconfig establish the build settings by including the generated configuration and the Pods support files, enabling the example app to compile and link correctly on iOS.

_packages/amplify\datastore/example/ios/Flutter · high confidence

Introduces the complete iOS project structure for the 'Amplified Todo' canary application, including the Xcode project, workspace, and Flutter runner configuration. This adds the necessary native iOS files (AppDelegate, Info.plist, storyboards, assets) and build configurations to enable running the Flutter canary on iOS devices and simulators.

canaries/ios · high confidence

The iOS example application for the Amplify Datastore package has been scaffolded, providing the necessary native iOS project files to run the example on iOS devices. This includes the AppDelegate implementing Flutter's implicit engine delegate, standard launch screens and app icons, and the Info.plist configured with modern iOS settings such as scene management and indirect input event support.

_packages/amplify\datastore/example/ios/Runner · high confidence

The Pinpoint analytics plugin now includes a new \DeviceInfo\ model and a platform-aware provider that collects device details (manufacturer, model, platform, and version) to populate Pinpoint Endpoint Demographics. The implementation uses conditional exports to supply native device info on Android, iOS, Linux, macOS, and Windows via \device\_info\_plus\, and web browser details on the web platform, ensuring analytics data is accurate across all supported environments.

_packages/analytics/amplify\_analytics\_pinpoint/lib/src/device\_context\_info\_provider/device\_info\provider · high confidence

The AFT CLI now includes a new \pub\ command that allows users to run Dart or Flutter pub commands (such as \pub get\ or \pub upgrade\) directly from the CLI. This feature is implemented in \packages/aft/lib/src/pub/pub\_runner.dart\, which provides a \pubAction\ extension on \AmplifyCommand\ to execute pub commands within a specified package directory. The implementation handles verbose logging and respects the \failFast\ option to control error handling behavior.

packages/aft/lib/src/pub · high confidence

The example application now includes a complete Android project structure, providing a standard Flutter V2 embedding setup with a Kotlin MainActivity, AndroidManifest files for debug, profile, and release builds, and resource definitions for light and dark mode launch themes. The build configuration has been updated to use Gradle 8.14, and ProGuard rules have been added to suppress warnings for AWS Amplify authentication components, ensuring the example app builds and runs correctly on Android devices.

_packages/amplify/amplify\_flutter/example/macos, packages/amplify\_native\_legacy\_wrapper/example/android, packages/analytics/amplify\_analytics\pinpoint/example/macos · high confidence

New backend configuration files have been added for the Kinesis and Firehose infrastructure areas, providing ready-to-use examples for AWS Kinesis Data Streams and Kinesis Data Firehose. These additions include Amplify backend definitions that configure authentication with email login and pre-sign-up triggers, alongside CDK resources for Kinesis streams and Firehose delivery streams writing to S3 buckets. The changes also set up the necessary IAM permissions for authenticated users to interact with these data services.

infra-gen2/backends/kinesis · high confidence

A new \PushNotificationException\ class has been introduced to serve as the base class for push notification errors. This allows users to catch and handle specific failures related to push notification services separately from other Amplify exceptions.

_packages/amplify\core/lib/src/types/exception/push · high confidence

The example application now includes the necessary build configuration and native runner code to run on Windows and Linux desktop platforms. This adds the CMake build files, native entry points, and window management logic required to host the Flutter view on these operating systems, enabling developers to test and run the Amplify Flutter example directly on desktop environments.

_packages/amplify/amplify\flutter/example/windows · high confidence

The iOS example application for Amplify DataStore now includes a defined Xcode scheme (Runner.xcscheme). This configuration enables the build, run, test, profile, and archive actions for the Runner app and its associated unit tests, providing the necessary project-level setup for developers to build and test the iOS implementation locally.

_packages/amplify\datastore/example/ios/Runner.xcodeproj/xcshareddata · high confidence

The \aft create\ command now generates the initial file structure for new packages. For Dart packages, this includes the main library file and an example configuration file. For Flutter packages, it generates the complete Android application scaffold, including the main activity, Android manifests with necessary permissions, and launch theme resources, alongside the main library file.

(repo-wide) · high confidence

The \amplify\_storage\_s3\ package has been updated to version 2.15.0, which adds support for iOS 27. This release also includes minor bug fixes and improvements as part of the ongoing maintenance of the storage category plugin.

packages/storage · high confidence

The \amplify\_flutter\ package has been restructured to support running on web platforms alongside mobile. A new \AmplifyClassImpl\ factory now detects the target platform and, for non-mobile environments (such as web), returns a pure Dart implementation instead of the previous hybrid native/Dart bridge. This change enables the library to function in web browsers without requiring native iOS/Android plugins, while still routing mobile platforms through the existing \AmplifyHybridImpl\ that uses method channels.

_packages/amplify/amplify\flutter/lib/src · high confidence

The Android side of the Amplify DataStore package now includes the full native Kotlin implementation, including the \AmplifyDataStorePlugin\ entry point, \AndroidManifest.xml\, and the Pigeon-generated \NativePluginBindings\. This adds the native bridge layer that connects Flutter calls to the Amplify Android SDK, handling method channels for DataStore operations and event streams for hub events (such as sync status and network changes).

_packages/amplify\datastore/android/src/main · high confidence

The Android side of the \amplify\_native\_legacy\_wrapper\ package now includes the Kotlin implementation and Pigeon-generated bindings for the \LegacyNativePlugin\. This adds native support for configuring the Amplify SDK, signing in with username and password, signing out, and remembering the device, bridging these specific authentication actions from Flutter to the underlying Android Amplify libraries.

_packages/amplify\_native\_legacy\wrapper/android · high confidence

The canaries directory now contains a new Flutter project scaffold (\amplified\_todo\) including standard configuration files like \.gitignore\, \.metadata\, and \analysis\_options.yaml\. The setup explicitly supports Amplify Gen 2 by ignoring generated output files such as \amplify\_outputs.dart\ and \amplifyconfiguration.dart\, and by excluding generated models from linting, indicating the canary is prepared to test the integration of Flutter with the newer Amplify output format.

canaries · high confidence

This change introduces the Gen 2 infrastructure components for analytics and user management in the \infra-gen2/infra-common\ module. For analytics, it provisions an Amazon Pinpoint app, a Kinesis Data Stream, and an AppSync GraphQL API to capture and store events. For user management, it provides a GraphQL API backed by Lambda functions to create, delete, and manage users in a Cognito User Pool, including custom email/SMS senders for MFA codes and SMS-only MFA support.

infra-gen2/infra-common · high confidence

The Android portion of the Amplify DataStore example application has been scaffolded, providing the necessary structure to run the Flutter app on Android devices. This includes the main AndroidManifest.xml with Flutter embedding configuration, a Kotlin MainActivity extending FlutterActivity, standard launch splash screen drawables and themes (supporting both light and dark modes), and debug/profile manifests with internet permissions. Additionally, a basic Android instrumented test (MainActivityTest) is included to verify the activity launches correctly using the FlutterTestRunner.

_packages/amplify\datastore/example/android/app · high confidence

The Dart implementation for the Amplify Analytics Pinpoint plugin is introduced, providing the core library entry point. This change exports the analytics plugin implementation, its configuration options, and the AWS Pinpoint user profile endpoint client, establishing the foundational structure for analytics functionality in Dart applications.

_packages/analytics/amplify\_analytics\_pinpoint\dart/lib · high confidence

The amplify\_flutter package is introduced with its foundational structure, including a CHANGELOG.md documenting support for iOS 27, WebAssembly (Wasm) across multiple categories (analytics, authenticator, db\_common, firehose, kinesis, sigv4, smithy, storage), and Swift Package Manager integration for iOS. The package also includes standard Flutter plugin configuration files such as .gitignore, .metadata, analysis\_options.yaml, and build.yaml to ensure proper build isolation and linting.

_packages/amplify/amplify\flutter · high confidence

The \packages/analytics/amplify\_analytics\_pinpoint\ directory has been initialized with the standard structure for a Flutter plugin. This includes the Apache 2.0 license, a README detailing platform support (Android, iOS, Web, Windows, macOS, Linux), and a changelog documenting the history from version 0.4.2 through 2.15.0, which highlights features like iOS 27 and WebAssembly (Wasm) support. The package also includes build configuration files such as \.gitignore\, \.metadata\ for Flutter tooling, \analysis\_options.yaml\ for linting, and a \Makefile\ to manage code generation via Pigeon.

_packages/analytics/amplify\_analytics\pinpoint · high confidence

The \amplify\_core\ package is introduced as a new foundational component of the Amplify Flutter library, providing base types and utilities shared across the ecosystem. This release establishes the package structure with essential configuration files, including a \.pubignore\ to exclude generated documentation from published artifacts, \analysis\_options.yaml\ for linting, and \build.yaml\ for code generation. It also includes a comprehensive changelog documenting the history from version 0.0.2-dev.1 through 2.15.0, covering features like WebAssembly support, Gen 2 compatibility, and various bug fixes, alongside a README detailing platform support for categories such as Analytics, API, Authentication, and Storage.

_packages/amplify\_core, packages/amplify\_datastore\_plugin\_interface, packages/amplify\_native\_legacy\wrapper · high confidence

This change introduces the new \amplify\_analytics\_pinpoint\_dart\ package (version 0.4.21), providing a Dart implementation for AWS Pinpoint analytics. The plugin allows developers to configure analytics via \AmplifyOutputs\, automatically manages user sessions (recording start/stop events), and handles event persistence with a configurable auto-flush interval (defaulting to 30 seconds). It also includes a deprecation warning in the configuration step, advising users that Amazon Pinpoint support will end on October 30, 2026, and recommending migration to AWS End User Messaging or other AWS services.

_packages/analytics/amplify\_analytics\_pinpoint\dart/lib/src · high confidence

The \amplify\_authenticator\ package is now available, providing a fully customizable authentication flow for Flutter applications. This release includes the core Authenticator widget, prebuilt UI components (such as sign-in and sign-up forms), and comprehensive integration tests within the example app to validate various authentication scenarios like email/phone sign-up and MFA flows.

packages/authenticator · high confidence

This change establishes the foundational structure of the repository by adding essential configuration and documentation files. It introduces \.codecov.yml\ to configure code coverage reporting thresholds and comment behavior, \.gitattributes\ to define text/binary handling and mark generated files (such as Pigeon, Drift, and Smithy outputs) for GitHub Linguist, and \.gitignore\ to exclude build artifacts, IDE settings, and generated Amplify configuration files. Additionally, it adds \.gitmodules\ to manage external dependencies like \aws-c-auth\ and \libsecret\, \.pubignore\ to exclude templates from published packages, \.spr.yml\ for pull request merge settings, and \AGENTS.md\ to document the monorepo's architecture, coding conventions, and development workflow. The \README.md\ is also updated with comprehensive project information, supported platforms, and deprecation notices for v1.

(repo-wide) · high confidence

The example application for the amplify\_datastore package has been initialized, providing a starting point for users to explore local and cloud-synced data capabilities. The project includes a README detailing how to run the app in local mode with pre-defined models (Blog, Post, Comment) and instructions for setting up cloud sync with AppSync. Essential Flutter and Amplify configuration files, such as .gitignore and .metadata, have been added to support the development environment.

_packages/amplify\datastore/example · high confidence

This change introduces the foundational structure for the new \amplify\_datastore\ package. It includes the Apache 2.0 license, a \.gitignore\ for Flutter artifacts, and a \.metadata\ file tracking the Flutter tool revision. A \CHANGELOG.md\ is added, documenting the package's history from version 0.0.2-dev.1 through 2.15.1, highlighting features like Swift Package Manager support, iOS 27 support, and various bug fixes. The package also provides a \Makefile\ for generating native plugin bindings via Pigeon, a \README.md\ detailing platform support (noting DataStore is currently supported on Android and iOS only), and the necessary iOS workspace configuration files for the example application.

_packages/amplify\datastore · high confidence

Adds the \amplify\_connect\_client\ Flutter package, enabling apps to identify users and manage device push tokens against the Amazon Connect Customer Profiles endpoint. The client exposes \identifyUser\, \registerDevice\, and \removeDevice\ methods, reading the service endpoint and region from the \notifications.amazon\_connect\ section of \amplify\_outputs.json\. This location also includes a macOS example app for manual testing and integration tests that verify the client's behavior with both authenticated and guest AWS credentials.

_packages/amplify\_connect\client · high confidence

The Pinpoint analytics plugin for Dart now includes the core implementation files for the \AnalyticsClient\ and \SessionManager\. The \AnalyticsClient\ acts as a builder that initializes and exposes the \EventClient\ (for sending events) and \EndpointClient\ (for interacting with Pinpoint endpoints), handling device context and secure storage. The \SessionManager\ automatically tracks app lifecycle events (foreground/background) to create, start, and stop sessions, attaching session metadata to analytics events sent to AWS Pinpoint.

_packages/analytics/amplify\_analytics\_pinpoint\_dart/lib/src/impl/analytics\client · high confidence

The Pinpoint analytics plugin for Flutter/Dart now includes a new internal event client implementation that manages the lifecycle of analytics events. This change introduces the \EventClient\ to handle recording, caching, and flushing events to AWS Pinpoint, utilizing an \EventStorageAdapter\ for local persistence and an \EventCreator\ to construct events according to the Pinpoint specification. The implementation adds support for global custom properties (attributes and metrics) that are automatically attached to all new events, enforces event size and type length limits, and implements retry logic for recoverable network failures during batch flushes.

_packages/analytics/amplify\_analytics\_pinpoint\_dart/lib/src/impl/analytics\_client/event\client · high confidence

The \example\_common\ package now provides a lightweight, Dart-native web UI component system for use in example applications. It includes a base \Component\ class with lifecycle hooks (\componentDidMount\, \setState\), layout primitives (\FlexComponent\, \ColumnComponent\, \RowComponent\, \CenterComponent\, \ContainerComponent\), and interactive elements (\ButtonComponent\, \TextFormFieldComponent\, \TableComponent\, \TextComponent\). The package also exports utility classes like \ComponentEdgeInsets\ and a \renderApp\ helper to mount components into the DOM, enabling consistent, framework-agnostic UI examples across the repository.

_packages/example\common · high confidence

This change introduces a new Dart-based GitHub Action package located in \actions/bin\, providing custom tooling for CI workflows. It adds \launch\_android\_emulator\ and \launch\_ios\_simulator\ actions that support configurable API levels, targets, and ABIs, along with built-in retry logic and timeout handling for emulator launch and test script execution. Additionally, it includes a \log\_cw\_metric\ action to report test results to CloudWatch with detailed dimensions (test type, framework, platform), and a \setup\_chromedriver\ action to automatically detect the local Chrome version and install the matching ChromeDriver. A new \actions/tool/build.dart\ script is also added to compile these Dart entrypoints into distributable GitHub Actions bundles.

actions/bin · high confidence

This change adds a new Dart library in \actions/lib\ that provides a JavaScript interop layer for GitHub Actions Node.js modules. It exposes Dart wrappers for core functionality such as input/output handling, logging, environment variables, and state management via \@actions/core\, along with bindings for \@actions/exec\, \@actions/http-client\, \@actions/tool-cache\, and the \github\ context. The library also includes utilities for Android emulator management (AVD creation, SDK installation, and boot waiting) and ChromeDriver download resolution, enabling CI workflows to leverage these tools directly from Dart scripts.

actions/lib · high confidence

The DataStore API now exposes explicit types for handling sync conflicts and configuring data filtering. Users can define custom conflict handlers using the new \DataStoreConflictHandler\ typedef, which receives \ConflictData\ containing local and remote model instances and returns a \ConflictResolutionDecision\ to apply remote changes, retry with local data, or retry with a custom model. Additionally, the \DataStoreSyncExpression\ class allows users to specify query predicates for selectively persisting subsets of data to the local device, with built-in support for serializing these expressions for native platform integration.

_packages/amplify\_core/lib/src/types/datastore/conflict\handler · high confidence

The Amplify Core package now includes a Hub mechanism that allows applications to subscribe to real-time events from various categories. Users can listen to events on specific channels (such as Auth, DataStore, and API) using the new \AmplifyHub\ interface, which manages stream subscriptions and provides a way to register custom channels. This enables reactive updates and better state synchronization across different parts of the application by decoupling event producers from listeners.

_packages/amplify\core/lib/src/hub · high confidence

Adds the \amplify\_db\_common\ package, providing common utilities for working with SQLite databases via the Drift library. This includes a \connect()\ function that creates a \QueryExecutor\ for both VM and Web platforms, with specific guidance for including \sqlite3.wasm\ in web apps. The release also includes a full example application demonstrating usage, integration tests for database operations, and native platform plugins for Android (Kotlin) and iOS (Swift) to support Flutter embedding.

packages/common · high confidence

The new \amplify\_foundation\_dart\ package provides common types and utilities for Amplify packages, including a centralized logging system (\AmplifyLogging\) with configurable sinks and log levels, AWS credential models (\StaticCredentials\, \TemporaryCredentials\) with JSON serialization, and a \Result\<T\>\ type for handling success/failure states. It also includes platform detection constants (\zIsWeb\, \zIsWasm\, etc.) for compile-time tree-shaking and an example demonstrating both minimal and maximal customization of logging and credentials.

_packages/amplify\foundation · high confidence

This change adds the \amplify\_secure\_storage\ Flutter plugin package, providing a new entry point for secure storage functionality. The diff introduces the full Android native implementation, including the \AmplifySecureStoragePlugin\ and \EncryptedKeyValueRepository\ classes that utilize Android's \EncryptedSharedPreferences\ for secure key-value storage. It also includes the necessary Pigeon-generated code for platform channel communication, unit tests for the repository logic, and supporting project files such as the \Makefile\ for code generation, \analysis\_options.yaml\, and an example application to demonstrate usage.

_packages/secure\storage · high confidence

The new \aws\_common\ package provides the shared types and utilities used across AWS and Amplify packages. It introduces an \AWSConfigValue\ system that resolves configuration (such as region, max attempts, and file paths) from zone overrides, Dart environment variables, and platform environment variables. It also includes an \AWSPathProvider\ for resolving local file paths (like \\~/.aws/config\) and an \AWSProfileFile\ loader/parser to read and merge AWS configuration and credentials files. Additionally, the package exposes core HTTP abstractions (\AWSHttpRequest\, \AWSHttpResponse\, \AWSHttpClient\) and a logging infrastructure (\AWSLogger\) to support network operations and debugging.

_packages/aws\common · high confidence

A new internal interface package, \amplify\_datastore\_plugin\_interface\, has been added to define the platform interface for the Amplify Flutter DataStore plugin. This package exposes core DataStore types—including model definitions, temporal types, sync expressions, subscription events, and conflict-handling primitives—by re-exporting specific types from \amplify\_core\. It is intended for internal plugin use only; application code should depend on the main \amplify\_datastore\ package instead.

_packages/amplify\_datastore\_plugin\interface/lib · high confidence

Added a new \amplify\_native\_legacy\_wrapper\ package that provides a unified Dart interface for legacy native authentication capabilities. This wrapper exposes methods to configure the SDK, sign in with username and password, sign out, and remember the current device, routing these calls through platform-specific channels generated by Pigeon to handle Android and iOS native implementations.

_packages/amplify\_native\_legacy\wrapper/lib · high confidence

The \packages/notifications/push/amplify\_push\_notifications\ directory now contains a new, service-agnostic push notification plugin implementation. This adds native Android support (Kotlin) that handles token management, foreground/background message routing, and background execution via WorkManager, alongside the necessary Flutter plugin infrastructure (Pigeon bindings, event channels, and lifecycle observers). This new package serves as the underlying engine for push notifications, decoupled from specific AWS services like Pinpoint.

packages/notifications · high confidence

This change adds a set of new core types in the \amplify\_core\ auth module to support user attribute management. It introduces \AuthUserAttributeKey\ and \CognitoUserAttributeKey\ to represent attribute identifiers (including standard claims like email and phone number, plus custom attributes), \AuthUserAttribute\ to hold key-value pairs, and \AuthUpdateAttributeStep\ to define the state of an update flow (confirming with a code or done). Additionally, it adds result and options classes such as \UpdateUserAttributeResult\, \SendUserAttributeVerificationCodeResult\, \ConfirmUserAttributeResult\, and corresponding options for \fetchUserAttributes\, \updateUserAttribute\, \updateUserAttributes\, \confirmUserAttribute\, and \sendUserAttributeVerificationCode\, enabling structured handling of attribute updates and verifications.

_packages/amplify\core/lib/src/types/auth/attribute · high confidence

This change introduces the \aft\ command-line tool, a new suite of repository management utilities for the Amplify Flutter project. The tool provides a comprehensive set of commands including \aft run\, \aft constraints\ (renamed from \deps\), \aft version-bump\, \aft publish\, \aft exec\, \aft create\, and \aft clean\. It handles complex repository operations such as validating dependency constraints against global configurations, managing version bumps with specific rules for breaking and non-breaking changes, and orchestrating the publishing of multiple packages in the correct dependency order with automatic analysis waiting. The implementation includes a new command runner, constraint checking logic, Git integration for tracking changes and version history, and a publish scheduler that respects package dependencies.

packages/aft/lib/src · high confidence

This change adds the foundational components for the new state machine architecture within the core package. It introduces a \DependencyManager\ service locator to handle plugin dependencies (such as HTTP clients and user agents) with scoped support and proper lifecycle management. Additionally, it defines the core state machine primitives: \StateMachineEvent\ and \StateMachineState\ base classes, a \Transition\ model to track state changes, and an \EventCompleter\ to manage asynchronous event processing and zone-aware completion. The \StateMachineManager\ acts as the central dispatcher, allowing plugins to register state machines and exposing streams for observing state transitions and events.

_packages/amplify\_core/lib/src/state\machine · high confidence

The Pinpoint analytics package now includes a new \legacy\_native\_data\_provider\ module to support migrating legacy endpoint IDs. This change adds platform-specific implementations for Android (using Pigeon-generated native code) and iOS (reading from secure storage), along with a factory class that selects the correct provider based on the target platform. This enables the analytics system to access and migrate endpoint identifiers stored by older versions of the Amplify SDK.

_packages/analytics/amplify\_analytics\_pinpoint/lib/src/legacy\_native\_data\provider · high confidence

This change adds the core Swift implementation for the Amplify DataStore plugin on Apple platforms (iOS, macOS, watchOS, tvOS), replacing or supplementing previous platform-specific code. It provides the \AWSDataStorePlugin\ class and its behaviors for saving, querying, and subscribing to model data, including support for lazy-loading of model associations via \DataStoreListProvider\ and \DataStoreModelProvider\. The update also introduces a migration system (\ModelMigrations\, \ModelSyncMetadataMigration\) to handle database schema upgrades, such as adding the \syncPredicate\ column to \ModelSyncMetadata\, and configures platform-specific defaults, notably disabling subscriptions on watchOS due to WebSocket limitations.

_packages/amplify\datastore/darwin · high confidence

The \packages/amplify\_core/lib/src/plugin\ directory now contains new abstract plugin interfaces for each Amplify category (Auth, API, Storage, DataStore, Analytics, and Push Notifications). These interfaces define the contract for category-specific operations—such as \signIn\ for Auth, \query\/\mutate\ for API, and \uploadData\/\downloadFile\ for Storage—allowing the core library to manage multiple plugin registrations and standardize how category implementations interact with the Amplify framework.

_packages/amplify\core/lib/src/plugin · high confidence

This change establishes the foundational type system for the Amplify Storage category within \amplify\_core\. It defines the abstract interfaces for storage operations, including base classes for resumable and cancelable actions, and specific operation types for downloading, uploading, copying, moving, listing, and removing files. The update also introduces the data models required for these operations, such as \StoragePath\ for handling static and dynamic (identity-based) paths, \StorageBucket\ for multi-bucket support, \StorageItem\ for object metadata, and \StorageDataPayload\ for managing upload content. Additionally, it exposes the \StorageTransferState\ and \StorageTransferProgress\ enums and classes to allow users to monitor the status and progress of storage transfers.

_packages/amplify\core/lib/src/types/storage · high confidence

This change adds the \aft\ command-line interface to the repository, providing a suite of commands to streamline local development and release workflows. The new tool includes \bootstrap\ to link packages and run dependency resolution, \link\ to manage local package overrides, \constraints\ to check and update dependency versions across the repo, \create\ to scaffold new packages using standard templates, \docs\ to build and serve API documentation, \exec\ to run shell commands across all packages, and \clean\ to remove build artifacts. It also features \locate-package\ to find packages by name or tag, \list\ to enumerate packages, and \get-release-notes\ to extract changelog entries for specific versions.

packages/aft/lib/src/commands · high confidence

The \amplify\_core\ package now exposes an \AppPathProvider\ interface that abstracts access to application-specific directories, specifically providing methods to retrieve the application support path and the temporary path. This interface is exported via the main \amplify\_core.dart\ barrel file, allowing consumers to resolve platform-specific file locations in a unified manner without relying on platform-specific implementations directly.

_packages/amplify\core/lib · high confidence

The core library now exposes a generic \AmplifyAuthProvider\ interface and a repository for managing auth providers, replacing the previous hardcoded authentication logic. This change introduces specific provider types including \AWSIamAmplifyAuthProvider\ for signing requests with IAM credentials, \ApiKeyAmplifyAuthProvider\ for API key authentication, and \TokenAmplifyAuthProvider\ (including \TokenIdentityAmplifyAuthProvider\) for token-based authentication. Users can now register and retrieve these providers via the \AmplifyAuthProviderRepository\, enabling more flexible and extensible authentication strategies for API requests.

_packages/amplify\core/lib/src/types/common · high confidence

A new \RestOperation\ class has been added to the core API types to handle REST-specific HTTP operations. This class wraps the underlying \AWSHttpOperation\ and ensures that responses are not streamed by default; if a streamed response is detected, it automatically reads the full content into memory before returning a standard \AWSHttpResponse\. This provides a consistent, non-streaming interface for REST API consumers within the Amplify Flutter core.

_packages/amplify\core/lib/src/types/api/types/rest · high confidence

The \aft\ CLI now includes a \generate\ command with four new subcommands: \sdk\ generates AWS SDK code from Smithy models, \workflows\ generates GitHub Actions and Dependabot configurations for repository packages, \goldens\ generates Smithy test models, and \amplify-swift\ generates Swift DataStore plugin code. These commands automate the creation and maintenance of generated code and CI/CD configurations across the repository.

packages/aft/lib/src/commands/generate · high confidence

The \amplify\_firehose\ package is introduced, providing a Flutter implementation for streaming data to Amazon Data Firehose with offline support. The library includes an \AmplifyFirehoseClient\ that manages record buffering and flushing, supporting configuration for cache limits and retry strategies. This release adds support for WebAssembly (Wasm) and iOS 27, and includes a comprehensive example app with integration tests to demonstrate usage and validate behavior.

packages/kinesis · high confidence

The example application in the amplify\_flutter package has been updated to include a new main.dart entry point. This example demonstrates how to initialize and configure the Amplify library within a Flutter app, displaying a simple status indicator to confirm whether the configuration was successful.

_packages/amplify/amplify\flutter/example/lib · high confidence

The Auth category now exposes structured hub events to notify applications about key authentication lifecycle changes. Developers can listen for \signedIn\ (emitted on successful login or app start if a user is already logged in), \signedOut\ (triggered by explicit sign-out or user deletion), \sessionExpired\ (when Cognito tokens or AWS credentials expire and cannot be refreshed), and \userDeleted\ (when a user is removed via the API). These events provide a standardized way to react to authentication state changes within the Amplify hub system.

_packages/amplify\core/lib/src/types/auth/hub · high confidence

The auth configuration layer now includes new \AuthConfig\ and \CognitoPluginConfig\ classes (with generated serialization code) that support the Amplify Gen 2 outputs format. \AuthConfig\ provides a \cognito\ factory helper to construct configuration from standard Cognito parameters (user pool, identity pool, OAuth, social providers, MFA, etc.) and exposes a \toAuthOutputs\ method to map this configuration into the new \AuthOutputs\ structure. \CognitoPluginConfig\ serves as the underlying plugin configuration container, managing sub-configurations for identity management, credentials, user pools, auth, AppSync, Pinpoint, and S3, enabling the core library to properly parse and serialize Gen 2-style auth settings.

_packages/amplify\core/lib/src/config/auth · high confidence

The DataStore Hub now exposes a richer set of event types and associated payload classes, allowing you to subscribe to more granular state changes. The new \DataStoreHubEventType\ enum includes events for network status changes, subscription establishment, sync query progress (started, ready, model-synced), and detailed outbox mutation lifecycle events (enqueued, processed, failed, status). Corresponding payload classes such as \NetworkStatusEvent\, \ModelSyncedEvent\, \OutboxMutationEvent\, and \SubscriptionDataProcessedEvent\ provide structured data like model names, sync counts, version metadata, and mutation status, enabling more precise monitoring of DataStore synchronization and local mutation processing.

_packages/amplify\core/lib/src/types/datastore/hub · high confidence

The \amplify\_core\ package introduces several new types in the \datastore/models\ directory to support the \observeQuery\ functionality. This includes \QuerySnapshot\<T\>\, which holds a sorted list of local store items and tracks sync status, along with \SortedList\<E\>\ to efficiently maintain item order. It also adds \ObserveQueryThrottleOptions\ to control how frequently snapshots are emitted during sync, \SubscriptionEvent\<T\>\ to represent backend mutations (create, update, delete), and \AuthModeStrategy\ to define authorization strategies for API interactions.

_packages/amplify\core/lib/src/types/datastore/models · high confidence

The \infra-gen2/backends/api\ location now includes a new \api-multi-auth\ backend implementation for the Gen 2 infrastructure. This adds a complete backend stack featuring an Amplify Data API with a schema supporting multiple models (such as Blog, Post, and Comment) and granular authorization rules for public API keys, guests, and authenticated users. It also provisions a custom REST API backed by a Lambda function, configured with IAM authorization for authenticated users and a separate policy allowing unauthenticated (guest) access to specific GET endpoints.

infra-gen2/backends/api · high confidence

Added new Mason brick templates (\dart-package\ and \flutter-package\) that provide a standardized starting point for creating Amplify Dart and Flutter packages. These templates include pre-configured project structures with Apache 2.0 licenses, analysis options using \amplify\_lints\, example applications for both CLI and web targets, and a post-generation hook that automatically links the package and installs dependencies via \aft link\ and \dart pub upgrade\.

templates · high confidence

Added a suite of shell and PowerShell scripts in the build-support directory to standardize and automate the build, testing, and CI workflows. The build\_canary.sh script now generates a fresh Flutter project with specific Amplify plugin versions and configures the Android toolchain (Gradle 8.14, Kotlin 2.2.20, AGP 8.11.1) and iOS platform (13.0) for canary builds. New integration test runners (integ\_test.sh, integ\_test\_ios.sh) support retry logic, cloud sync toggles, and WebAssembly compilation for web-server tests. Platform-specific timeout and retry mechanisms (linux\_timeout\_attempts.sh, windows\_timeout\_attempts.ps1, linux\_like\_timeout.ps1) ensure robust CI execution with configurable attempts and timeouts. Additional utilities include a Codecov uploader wrapper, an Android lint script, and a backend pull script for automated environment setup.

build-support · high confidence

The AFT tool now includes a new internal library for parsing and generating CHANGELOG.md files. This change introduces a \Changelog\ class that parses markdown into a structured representation of versions and commits, and provides methods to update changelog entries with new commit messages. It supports semantic versioning, including a 'NEXT' tag for unreleased changes, and groups commits by type (features, fixes, breaking changes, etc.) for structured output.

packages/aft/lib/src/changelog · high confidence

The \amplify\_core\ package introduces a new set of configuration classes in \packages/amplify\_core/lib/src/config\ to support Amplify Gen 2 outputs. This includes \AmplifyConfig\ as the root configuration holder, \AmplifyPluginRegistry\ for managing plugin configuration factories, and category-specific configs like \ApiConfig\ and \AWSApiPluginConfig\. These classes provide a structured way to parse, store, and serialize Amplify configuration data, including support for unknown plugins via \UnknownPluginConfig\ and JSON serialization via \json\_annotation\.

_packages/amplify\core/lib/src/config · high confidence

The \infra\ directory now contains a complete AWS CDK project to provision backend environments for testing the Amplify Flutter Auth category. This infrastructure supports multiple configuration types, including a full Cognito setup with User and Identity Pools, and custom authorizer scenarios using both IAM and User Pools. It introduces support for custom authentication flows (with and without SRP), MFA capabilities, device tracking, and Hosted UI. The setup includes AppSync resolvers for administrative operations like user creation and deletion, and Lambda triggers to intercept and broadcast SMS/Email verification codes for testing purposes.

infra · high confidence

The \amplify\_core\ package now includes a comprehensive set of new types for defining and representing data models, including \Model\, \ModelSchema\, \ModelField\, \ModelFieldType\, \AuthRule\, \ModelAssociation\, and \ModelIndex\. These classes provide the foundational structures for model schemas, field definitions, and authorization rules, enabling the core library to support model-based operations and schema definitions previously handled by other packages.

_packages/amplify\core/lib/src/types/models · high confidence

The core library now includes \PaginatedResult\ and \PaginatedModelType\ classes to handle paginated list query responses. \PaginatedResult\ wraps the returned items, limit, next token, and filter, and provides a \hasNextResult\ getter and a \requestForNextResult\ object to easily fetch subsequent pages. \PaginatedModelType\ implements the decoding logic for these results, mapping JSON items to model instances using the provided model type, enabling more robust handling of paginated GraphQL list requests.

_packages/amplify\core/lib/src/types/api/types/pagination · high confidence

The \amplify\_core\ package now includes a new set of data models and interfaces to support push notifications. This adds \PushNotificationMessage\ for handling notification payloads (including specific options for APNS and FCM), \ApnsPlatformOptions\ and \FcmPlatformOptions\ for platform-specific configuration, and \PushNotificationPermissionStatus\ to manage permission states. Additionally, a \ServiceProviderClient\ abstract class is introduced to define the contract for push notification service providers (such as Pinpoint), enabling device registration, user identification, and event recording.

_packages/amplify\core/lib/src/types/notifications/push · high confidence

The \notification\_types.dart\ file has been introduced to centralize and export core types for push notifications. This includes platform-specific options for APNS and FCM, callback definitions, Pinpoint event sources and types, the push notification message model, permission status, and the service provider client interface. Users relying on these types will now import them from this consolidated location.

_packages/amplify\core/lib/src/types/notifications · high confidence

The \amplify\_core\ package now exposes a new set of types for constructing queries, including \QueryField\, \QueryPredicate\, \QueryPredicateGroup\, \QuerySortBy\, and \QueryPagination\. These classes provide a structured API for filtering (e.g., \eq\, \ne\, \le\, \lt\, \ge\, \gt\, \contains\), combining conditions with logical operators (\and\, \or\, \not\), sorting results by field and order, and paginating query results. A new \ModelQueryException\ is also introduced to handle errors specific to model query operations.

_packages/amplify\core/lib/src/types/query · high confidence

The repository now includes a suite of new tooling scripts to streamline development workflows. A new Dart script automates the version bumping process across pubspec files, the main amplify library, and changelogs. License management is standardized with a script that adds Apache 2.0 headers to source files. CI/CD support is enhanced with scripts to provision integration test resources, send CloudWatch metrics for canary failures, and run unit tests for Flutter, Android, and iOS plugins. Additionally, a helper script simplifies AWS credential configuration for testing.

tool · high confidence

The \amplify\_core\ package introduces a new set of types in the \auth/sign\_in\ directory to support advanced authentication flows. \AuthSignInStep\ and \AuthNextSignInStep\ define the specific stages of the sign-in process, including MFA selection, TOTP setup, and first-factor selection, while \AuthFactorType\ enumerates the available authentication mechanisms (password, SRP, email OTP, SMS OTP). \AuthProvider\ provides a structured way to handle federated identity providers like Google, Facebook, and SAML, and dedicated options classes (\SignInOptions\, \ConfirmSignInOptions\, \SignInWithWebUIOptions\) allow plugin-specific configuration for these flows.

_packages/amplify\_core/lib/src/types/auth/sign\in · high confidence

A new Dart-based deployment tool (\deploy\_gen2.dart\) has been added to the \infra-gen2/tool\ directory. This script serves as the central configuration and execution point for deploying Amplify Gen 2 backends across categories including API, Auth, Storage, Analytics, Kinesis, and Firehose. It reads a defined configuration of backend groups and their source paths, builds the projects, and generates the corresponding \amplify\_outputs.dart\ and \amplifyconfiguration.dart\ files into the respective package example directories, enabling automated infrastructure provisioning for these services.

infra-gen2/tool · high confidence

The \amplify\_core\ package now includes new internal utility files in the \lib/src/util\ directory to support core functionality. \serializable.dart\ defines global JSON serialization options (using \json\_annotation\) for Amplify and AWS types, including specific converters for Cognito user attributes, and introduces a \SerializableMap\ class. \uuid.dart\ provides a static \getUUID()\ method wrapping the \uuid\ package to generate version 4 UUIDs. \parsers.dart\ adds internal helper functions for converting enums to and from strings and checking if a dynamic value is an enum.

_packages/amplify\core/lib/src/util · high confidence

The core library now introduces a new configuration model to parse and represent the JSON outputs generated by Amplify Gen 2. This change adds a comprehensive set of serializable data classes for all backend categories—including Auth (with MFA, OAuth, and password policy details), Data (GraphQL), API (REST), Storage (including multi-bucket support), Analytics (Amazon Pinpoint), and Notifications. These classes enable the SDK to natively consume the new Gen 2 configuration format while maintaining backward compatibility with Gen 1 settings through internal mapping logic.

_packages/amplify\_core/lib/src/config/amplify\outputs · high confidence

The API layer now supports OpenID Connect (OIDC) and AWS Lambda authorization modes for GraphQL and REST API calls. This change introduces new abstract provider classes (OIDCAuthProvider and FunctionAuthProvider) to handle token retrieval for these modes, and extends the APIAuthorizationType enum to include 'OPENID\_CONNECT' and 'AWS\_LAMBDA' options, enabling developers to configure these specific authentication strategies for their AppSync or API Gateway endpoints.

_packages/amplify\core/lib/src/types/api/auth · high confidence

The storage backend infrastructure now supports defining multiple S3 buckets within a single Amplify Gen 2 application. The \main\ configuration demonstrates this by defining two distinct storage resources (\firstBucket\ and \secondBucket\), each with its own access rules and enabled S3 acceleration. Additionally, a new \dots-in-name\ configuration validates that storage buckets can be successfully provisioned with names containing dots, ensuring compatibility with non-standard naming conventions.

infra-gen2/backends/storage · high confidence

The Pinpoint analytics plugin now includes a set of abstract provider interfaces in the \flutter\_provider\_interfaces\ directory to decouple platform-specific data collection from the core logic. These new files define contracts for \AppLifecycleProvider\ (handling foreground/background state), \CachedEventsPathProvider\ (locating the Drift database for event caching), \DeviceContextInfoProvider\ (gathering device demographic data like OS, model, and app version for Pinpoint endpoints), and \LegacyNativeDataProvider\ (retrieving stored Pinpoint Endpoint IDs). This structural change enables better testability and platform abstraction for analytics data collection.

_packages/analytics/amplify\_analytics\_pinpoint\_dart/lib/src/impl/flutter\_provider\interfaces · high confidence

The AFT tool now reads its configuration from the \aft\ section within \pubspec.yaml\ files instead of a separate \aft.yaml\. This change introduces a new config model (\AftConfig\) and loader that parse global dependency constraints, environment settings, component definitions, and package selectors directly from the project's pubspec hierarchy, merging configurations from child directories into the root.

packages/aft/lib/src/config · high confidence

The API category's exception types have been refactored to use Dart's sealed classes, introducing a strict hierarchy where \ApiException\ is the sealed base class. Two specific subclasses have been added: \HttpStatusException\ for REST API calls returning non-2xx status codes (which now exposes the raw HTTP response), and \ApiOperationException\ for in-process processing errors. This change aligns exception handling across the API category and may require updates to existing error-catch logic that relied on the previous, less structured exception types.

_packages/amplify\core/lib/src/types/exception/api · high confidence

A new \native\_api\_helpers.dart\ utility file has been added to the DataStore package to facilitate communication with the native Amplify Swift layer. This file introduces functions for converting between native and Dart GraphQL request/response types, mapping authorization modes (such as API Key, IAM, OIDC, and User Pools) to their corresponding API types, and handling subscription lifecycle events (connecting, start\_ack, data, error, complete). It also includes logic to transform exceptions into error payloads, specifically tagging unauthorized errors to allow DataStore sync to continue silently.

_packages/amplify\datastore/lib/src/utils · high confidence

The \amplify\_core\ package has been refactored to introduce a new \AmplifyClass\ singleton and its \AmplifyClassImpl\ implementation, which centralizes plugin management and configuration. Users can now add multiple plugins simultaneously via the new \addPlugins\ method, and the core configuration process (\configure\) has been updated to support both Gen 1 (\AmplifyConfig\) and Gen 2 (\AmplifyOutputs\) configuration formats, providing clearer error messages if the JSON cannot be decoded. The implementation also ensures that all added plugins are processed before configuration completes and registers auth providers through the core dependency manager.

_packages/amplify\core/lib/src · high confidence

The analytics infrastructure backend has been updated to provide three distinct deployment configurations for handling unauthenticated users: a default setup that includes both authenticated and unauthenticated roles, a restricted setup that excludes unauthenticated roles entirely, and a secure setup that explicitly disables unauthenticated identities in the Cognito Identity Pool. These changes allow users to tailor the analytics backend's security posture regarding anonymous access without modifying the core Amplify Gen2 auth resource definitions.

infra-gen2/backends/analytics · high confidence

The Pinpoint analytics plugin now stores queued analytics events locally on web platforms using IndexedDB, ensuring that events are preserved across page reloads and browser restarts. On non-web platforms (VM), the implementation continues to use the Drift SQL database for persistence. If IndexedDB is unavailable on the web, the system automatically falls back to an in-memory store, which means queued events will be lost when the page is closed.

_packages/analytics/amplify\_analytics\_pinpoint\_dart/lib/src/impl/analytics\_client/event\_client/queued\_item\store · high confidence

The analytics module now uses a sealed \AnalyticsException\ base class, replacing the previous abstract implementation. This change introduces a specific \InvalidEventException\ for cases where event data is invalid, and provides a \fromException\ factory method to automatically map generic exceptions (including \AWSHttpException\ and existing \AmplifyException\ instances) to appropriate analytics error types, ensuring more precise error handling for analytics operations.

_packages/amplify\core/lib/src/types/exception/analytics · high confidence

The analytics module now exposes its core types through a unified \analytics\_types.dart\ file. This change consolidates the public API by exporting the analytics-specific exception classes (such as \AnalyticsException\, \InvalidEventException\, \NetworkException\, and \UnknownException\) alongside the primary API types (\AnalyticsEvent\, \CustomProperties\, \UserProfile\, and \UserProfileLocation\). Users importing this module will now access these components from a single location rather than scattered paths.

_packages/amplify\core/lib/src/types/analytics · high confidence

The Android implementation for the Pinpoint analytics plugin now includes support for migrating legacy endpoint data. A new Pigeon-generated interface and Kotlin plugin implementation allow the Flutter side to retrieve the legacy Pinpoint Endpoint ID from Android shared preferences, ensuring continuity for existing users during the transition to new data structures.

_packages/analytics/amplify\_analytics\pinpoint/android · high confidence

The Auth category's exception hierarchy has been restructured: the base \AuthException\ is now a sealed class, and specific error conditions (such as \InvalidStateException\, \AuthNotAuthorizedException\, \AuthServiceException\, \SessionExpiredException\, \SignedOutException\, \UserCancelledException\, and \AuthValidationException\) are now distinct, concrete types. This change improves type safety and allows developers to handle specific authentication errors more precisely rather than relying on generic exception handling.

_packages/amplify\core/lib/src/types/exception/auth · high confidence

The integration test tooling now includes a script to automatically download the Amplify configuration file from the designated S3 bucket, ensuring that the example app uses the correct backend settings for analytics integration tests.

_packages/analytics/amplify\_analytics\pinpoint/example/tool · high confidence

The canaries project's Amplify backend configuration has been updated to version 3.1, introducing a new project structure that includes an AppSync API with automatic merge conflict resolution, a Cognito authentication setup with a PreSignup Lambda trigger, and Pinpoint analytics. This change adds the necessary CloudFormation templates and configuration files to define these resources, ensuring the canaries environment is provisioned with the correct infrastructure dependencies.

canaries/amplify, canaries/amplify/backend/function/canaries741cf74ePreSignup, canaries/tool · high confidence

The canary application in canaries/lib has been updated to integrate the Amplify Authenticator UI component, wrapping the main application to provide built-in sign-in and sign-out flows. Additionally, the Amplify configuration now passes the model provider via the APIPluginOptions constructor, aligning with the new plugin options pattern for optional parameters.

canaries/lib · high confidence

The \api\_types.dart\ file has been introduced to serve as a central export hub for API-related types within the \amplify\_core\ package. This change consolidates and exposes key components for users, including retry options, various exception types (such as \ApiException\ and \NetworkException\), authorization providers and types, GraphQL operation and response models, WebSocket options, Hub event structures, and REST/Pagination utilities. This simplifies imports for consumers needing access to these foundational API definitions.

_packages/amplify\core/lib/src/types/api · high confidence

The DataStore example application has been updated to integrate the Amplify Authenticator for user sign-in flows and implements a custom error handler within the DataStore plugin options. This change ensures that the example app properly manages authentication state and provides feedback when DataStore operations encounter errors, reflecting current best practices for integrating DataStore with other Amplify plugins.

_packages/amplify\datastore/example/lib · high confidence

The generated model classes in the DataStore example app have been regenerated to support custom primary keys (CPK). This change introduces a \modelIdentifier\ getter on all models, deprecating the legacy \getId()\ method. Models with composite keys (such as \CpkHasManyChildBidirectionalExplicit\) now require multiple fields for their identifier. Additionally, the JSON serialization logic has been updated to handle nested model relationships via a \serializedData\ field, and required fields are now enforced with explicit runtime checks during deserialization.

_packages/amplify\datastore/example/lib/models · high confidence

The DataStore category's error handling has been restructured to improve clarity and serialization support. A new \DataStoreException\ class now extends \AmplifyException\ and includes a \fromMap\ factory method, allowing exceptions to be instantiated from serialized data maps. Additionally, a dedicated \DataStoreExceptionMessages\ class has been introduced to centralize common error messages, specifically providing detailed guidance for scenarios where a required, non-nullable field is accessed but was not initialized.

_packages/amplify\core/lib/src/types/datastore/exception · high confidence

The DataStore observeQuery API now includes built-in throttling to prevent excessive event emissions during rapid sync changes. This change introduces a new ObserveQueryThrottleOptions configuration (allowing limits on count and duration) and implements the underlying stream transformation logic in the Dart package. Users will see smoother, rate-limited updates from observeQuery streams, reducing unnecessary processing when the local database is syncing heavily.

_packages/amplify\datastore/lib · high confidence

The DataStore plugin implementation has been restructured to communicate with native iOS and Android backends via Flutter method channels. This change introduces a new \DataStoreStreamController\ to handle hub events (such as sync status and mutations) and a \DataStorePluginOptions\ class to centralize configuration like sync expressions, conflict handlers, and error handling. The core logic now resides in \method\_channel\_datastore.dart\, which serializes model data and delegates operations to the native layer, replacing the previous direct integration approach.

_packages/amplify\datastore/lib/src · high confidence

The datastore type exports have been consolidated into a single \datastore\_types.dart\ file. This change reorganizes how users import core Datastore components—such as models, query fields, temporal types, conflict handlers, exceptions, hub events, and sync expressions—by providing a unified entry point instead of scattered individual paths.

_packages/amplify\core/lib/src/types/datastore · high confidence

The DataStore example application has been refactored to demonstrate multi-auth capabilities. A new \AuthView\ widget allows users to create and manage \MultiAuthTodo\ items alongside standard \PrivateTodo\ items, with real-time event streaming for both types. The app's navigation has been updated to include a tabbed interface (\NavigatorScaffold\) separating public data views from protected, authenticated views, enabling users to test DataStore operations under different authorization contexts.

_packages/amplify\datastore/example/lib/widgets · high confidence

The amplify\_flutter example application has been regenerated to align with Flutter 3.47, introducing a new .metadata file to track project migration state and a .gitignore file that excludes generated artifacts like amplify\_outputs.dart. Additionally, the project now includes a README and an analysis\_options.yaml configuration that enforces the amplify\_lints package, ensuring consistent code quality checks for the example app.

_packages/amplify/amplify\flutter/example · high confidence

The analytics example application has been regenerated to support Flutter 3.47 and the new Amplify Gen 2 outputs. This update introduces a new \.gitignore\ that excludes generated configuration files (such as \amplify\_outputs.dart\ and \aws-exports.js\) and sets up standard project metadata, linting via \amplify\_lints\, and build configurations required for the modernized example setup.

_packages/analytics/amplify\_analytics\pinpoint/example · medium confidence

The Android example application has been migrated to the Flutter V2 embedding model, which is required for modern Flutter versions and ensures compatibility with Android API 32 and above. This update includes new AndroidManifest files for debug and profile builds to grant internet permissions, a MainActivity implementation extending FlutterActivity, and updated theme resources to support the V2 embedding and dark mode.

_packages/amplify/amplify\flutter/example/android/app · high confidence

The Pinpoint analytics plugin now includes a dedicated Flutter implementation layer that wires platform-specific providers into the core analytics logic. This introduces a Flutter app lifecycle observer to accurately track foreground and background state changes for session handling, and utilizes Flutter's secure storage and path providers to manage endpoint information and legacy data. These changes ensure the analytics service correctly integrates with Flutter's native environment for data persistence and lifecycle awareness.

_packages/analytics/amplify\_analytics\pinpoint/lib/src · high confidence

The GraphQL API type definitions have been restructured to support advanced request handling and subscription management. GraphQLRequest now includes support for custom headers, explicit authorization modes, and a copyWith method for request modification. Subscription connectivity is now observable via Hub events that expose detailed network and intended states, allowing applications to track connection status (connected, connecting, disconnected, failed) and implement custom reconnection or error-handling logic.

_packages/amplify\core/lib/src/types/api/graphql · high confidence

The auth core types have been restructured with new classes to model authentication state and user information. AuthSession now provides a simple isSignedIn flag, while AuthUser exposes userId, username, and SignInDetails. New option classes (FetchAuthSessionOptions, GetCurrentUserOptions) and their plugin-specific counterparts allow for configurable behavior in fetchAuthSession and getCurrentUser operations, including a forceRefresh option for credentials.

_packages/amplify\core/lib/src/types/auth/session · high confidence

The analytics core types have been restructured with the introduction of new model classes: \AnalyticsEvent\ now encapsulates event names and associated \CustomProperties\, while \CustomProperties\ provides a typed API for storing and retrieving string, double, boolean, and integer attributes. Additionally, \UserProfile\ and \UserProfileLocation\ classes have been added to support user-specific data, including location details like latitude, longitude, and city, enabling more granular user tracking and attribute management within the analytics system.

_packages/amplify\core/lib/src/types/analytics/analytics · high confidence

The Auth category now exposes explicit \SignOutOptions\ and \SignOutResult\ types to manage sign-out behavior. Users can configure sign-out via a \globalSignOut\ flag to sign out the user from all devices, and pass plugin-specific options through \SignOutPluginOptions\. The sign-out operation now returns a dedicated \SignOutResult\ object, providing a structured response instead of an implicit or void return.

_packages/amplify\_core/lib/src/types/auth/sign\out · high confidence

The sign-up API now uses dedicated, serializable types to provide clearer structure and better type safety. \SignUpResult\ now exposes a \nextStep\ field of type \AuthNextSignUpStep\ (which contains an \AuthSignUpStep\ enum with \confirmSignUp\ and \done\ states) instead of a generic step description, and includes an optional \userId\. New options classes (\SignUpOptions\, \ConfirmSignUpOptions\, \ResendSignUpCodeOptions\) and result types (\ResendSignUpCodeResult\) are introduced to handle plugin-specific options and API responses consistently across the Auth category.

_packages/amplify\_core/lib/src/types/auth/sign\up · high confidence

The core logging system now uses a dedicated AmplifyLogger class that extends AWSLogger, establishing a strict namespace hierarchy rooted at 'aws\_common.Amplify'. This change ensures that all loggers created via the public API or internal mixins are automatically prefixed with the correct root namespace, preventing namespace collisions and providing consistent log level behavior across the Amplify framework. Additionally, a new AmplifyLoggerPlugin abstract class and AmplifyLoggerMixin are introduced to allow plugins to handle log entries and provide easy logger access to Amplify classes respectively.

_packages/amplify\core/lib/src/logger · high confidence

The Gen 2 authentication infrastructure backends have been updated to support Email OTP multi-factor authentication (MFA). This change introduces new backend configurations for various MFA scenarios, including optional and required modes for email, SMS, and TOTP factors. Specifically, it adds support for Email OTP MFA alongside existing SMS and TOTP options, allowing for more flexible authentication flows. The migration also includes adjustments to account recovery settings to comply with MFA requirements, such as disabling self-service recovery when email is used for MFA.

infra-gen2/backends/auth · high confidence

The Android canary project has been updated to use Gradle 8.14, Kotlin Gradle Plugin 2.2.20, and Android Gradle Plugin 8.11.1. This includes adding a \.gitignore\ to exclude build artifacts and keystore files, creating standard Android manifest files for debug, profile, and main builds (including the required INTERNET permission for development), and setting up the necessary resource files for launch themes and splash screens. The main activity is now implemented in Kotlin as a standard FlutterActivity.

canaries/android · high confidence

The analytics configuration layer now includes dedicated data models for AWS Pinpoint, specifically \AnalyticsConfig\, \PinpointPluginConfig\, \PinpointAnalytics\, and \PinpointTargeting\. These classes, generated with JSON serialization support, allow the SDK to parse and manage Pinpoint-specific settings such as the application ID and AWS region from configuration outputs, enabling more granular control over analytics plugin parameters.

_packages/amplify\core/lib/src/config/analytics · high confidence

The DataStore package now includes a new Pigeon-based native bridge definition (native\_plugin.dart) that establishes the interface for communication between the Flutter DataStore plugin and native iOS/Android code. This file defines the specific API contracts for Auth (fetching sessions, updating current user), API (mutating, querying, subscribing, unsubscribing, handling offline states), and general Amplify configuration, along with the necessary data classes for GraphQL requests/responses and authentication credentials. This change introduces the structural bindings required for the native implementation, effectively moving the native bridge implementation details into the DataStore package.

_packages/amplify\datastore/pigeons · high confidence

The Amazon Pinpoint Dart SDK has been regenerated using smithy-dart 0.3.2, introducing a new \WrappedPinpointClient\ that delegates to the standard \PinpointClient\ while allowing the underlying HTTP client to be injected via the dependency manager. This change enables the analytics plugin to use a mockable HTTP client, which improves testability and allows for better control over network interactions during unit testing.

_packages/analytics/amplify\_analytics\_pinpoint\dart/lib/src/sdk · high confidence

The Pinpoint analytics plugin now converts AWS SDK errors (such as BadRequestException and ForbiddenException) into the unified Amplify AnalyticsException type. This ensures that errors from Pinpoint are handled consistently with other analytics operations, providing users with standardized recovery suggestions and underlying exception details.

_packages/analytics/amplify\_analytics\_pinpoint\dart/lib/src/exception · high confidence

The core platform abstraction has been updated to include a web-specific implementation that identifies the operating system and version by parsing the browser's user-agent string. This change allows the SDK to correctly report platform details (such as identifying Edge, Opera, Chrome, Firefox, or Safari) when running in a browser environment, complementing the existing native OS detection for IO-based platforms.

_packages/amplify\core/lib/src/platform · high confidence

The Pinpoint analytics plugin now uses a platform-aware path provider to locate the application support directory for storing cached events. On native platforms (iOS/Android/Desktop), it leverages the \path\_provider\ package to return the actual support directory path, while on Web it returns an empty string, effectively disabling local caching in the browser environment. This change ensures that event caching behaves correctly across all supported Flutter targets without throwing errors on unsupported platforms.

_packages/analytics/amplify\_analytics\_pinpoint/lib/src/flutter\_path\provider · high confidence

The main entry point for the \amplify\_analytics\_pinpoint\ package has been restructured to explicitly control which symbols are exposed to consumers. The library now re-exports the core implementation from the \amplify\_analytics\_pinpoint\_dart\ package while explicitly hiding the internal \AmplifyAnalyticsPinpointDart\ class, ensuring that only the intended public interface is available to users. Additionally, the \src/analytics\_plugin\_impl.dart\ file is now part of the public export list, making the plugin implementation details accessible to external code that depends on this specific package.

_packages/analytics/amplify\_analytics\pinpoint/lib · high confidence

The password reset workflow in the core Auth types has been restructured to use a dedicated \AuthResetPasswordStep\ enum (\confirmResetPasswordWithCode\, \done\) instead of previous generic or string-based step indicators. This change introduces new, clearly defined types for the reset and confirm-reset operations (\ResetPasswordOptions\, \ConfirmResetPasswordOptions\, \ResetPasswordResult\, \UpdatePasswordOptions\, \UpdatePasswordResult\) and their corresponding plugin-specific option abstractions, providing a more structured and type-safe API for handling password reset states and configurations.

_packages/amplify\core/lib/src/types/auth/password · high confidence

The storage exception types in the core package have been restructured into a sealed class hierarchy. A new base \StorageException\ class now serves as the parent for specific error types, including \StorageAccessDeniedException\, \StorageHttpStatusException\, \InvalidStorageBucketException\, \StorageLocalFileNotFoundException\, \StorageNotFoundException\, \StorageOperationCanceledException\, and \StoragePathValidationException\. This change standardizes how storage-related errors are handled and reported within the application.

_packages/amplify\core/lib/src/types/exception/storage · high confidence

The Pinpoint analytics implementation now manages endpoint data (ID, global attributes, and metrics) locally using secure storage, replacing the previous approach. This change introduces a migration path that automatically transfers the existing Endpoint ID from the legacy native data provider to the new store, ensuring continuity for existing users. The new architecture includes an \EndpointClient\ that handles user profile updates and attribute management, an \EndpointGlobalFieldsManager\ for persisting attributes and metrics with enforced length limits, and an \EndpointInfoStoreManager\ to coordinate initialization and storage access.

_packages/analytics/amplify\_analytics\_pinpoint\_dart/lib/src/impl/analytics\_client/endpoint\client · high confidence

The internal Pinpoint SDK implementation in the Amplify Analytics package has been regenerated using smithy-dart 0.3.2. This update refreshes the generated endpoint resolution logic to include FIPS-compliant endpoints for supported AWS regions and partitions, and rebuilds the data model classes (such as AttributeDimension and BadRequestException) with updated serialization and builder patterns to align with the latest AWS API specifications.

_packages/analytics/amplify\_analytics\_pinpoint\dart/lib/src/sdk/src · high confidence

The main library entry point has been reorganized to explicitly re-export the core Amplify singleton and specific serializers from amplify\_core and amplify\_secure\_storage. This change ensures that internal serialization types remain accessible to preserve backward compatibility while hiding implementation-specific classes like Amplify and WebSocketOptions from the public barrel, effectively tightening the public surface area of the package.

_packages/amplify/amplify\flutter/lib · high confidence

The \amplify\_core\ package has been refactored to provide a more structured and type-safe authentication API. This change introduces a new \AuthCodeDeliveryDetails\ class to explicitly track where confirmation codes are sent (email, SMS, TOTP, etc.) and replaces the previous \UserAttributeKey\ with \AuthUserAttributeKey\ for attribute updates. It also adds comprehensive support for TOTP Multi-Factor Authentication (MFA), including new types for setup (\TotpSetupDetails\, \TotpSetupOptions\), verification (\VerifyTotpSetupOptions\), and user preference management (\UserMfaPreference\, \MfaPreference\). Additionally, the \AuthNextStep\ hierarchy has been simplified to use specific enum-based step types for sign-in, sign-up, and password reset flows, improving clarity for developers handling multi-step authentication flows.

_packages/amplify\core/lib/src/types/auth · high confidence

The exception handling in amplify\_core has been restructured to provide a clearer separation between recoverable exceptions and non-recoverable errors. A new \AmplifyError\ base class (with \ConfigurationError\ and \PluginError\ subclasses) now handles non-recoverable issues, while \AmplifyException\ serves as the base for recoverable errors across categories like API, Auth, Storage, and Analytics. Specific exception types such as \AmplifyAlreadyConfiguredException\, \NetworkException\, \UnknownException\, and \UrlLauncherException\ have been introduced or reorganized to improve type safety and debugging.

_packages/amplify\core/lib/src/types/exception · high confidence

The HTTP layer now automatically enriches outgoing request headers with detailed user-agent information. A new \AmplifyHttpClient\ intercepts requests to append a scoped user-agent string that includes the base platform identifier (e.g., \amplify-flutter\ or \amplify-dart\), the OS, and the specific originating category and method (e.g., \auth/fetchCurrentDevice\). This is achieved via a new \AmplifyCategoryMethod\ enum system and zone-based context propagation, allowing backend services to distinguish traffic by the specific Amplify API being invoked.

_packages/amplify\core/lib/src/http · high confidence

The \amplify\_core\ library now exposes a consolidated category interface (\amplify\_categories.dart\) that manages plugin registration and dispatch for Analytics, API, Auth, DataStore, Notifications, Push Notifications, and Storage. This change introduces support for multiple plugins per category (e.g., \Auth\ and \Storage\ now allow \getPlugin\ to select specific providers), while maintaining backward compatibility by routing default calls to the first registered plugin. DataStore remains single-plugin with explicit configuration steps, and the Notifications category now delegates to a dedicated Push Notifications interface.

_packages/amplify\core/lib/src/category · high confidence

The example application in the analytics Pinpoint package has been updated to demonstrate the new plugin options pattern and secure storage integration. The app now configures the \AmplifyAnalyticsPinpoint\ plugin using \AnalyticsPinpointPluginOptions\ to set the \autoFlushEventsInterval\, and passes a custom \secureStorageFactory\ to both the Auth Cognito and Analytics Pinpoint plugins to handle platform-specific secure storage requirements.

_packages/analytics/amplify\_analytics\pinpoint/example/lib · high confidence

The Android example app for the Pinpoint analytics plugin has been updated to use the Flutter v2 embedding. This includes migrating the MainActivity to extend FlutterActivity, adding the required flutterEmbedding meta-data to the AndroidManifest.xml, and introducing standard launch themes and splash screen resources to support modern Android development practices and API 32+ compatibility.

_packages/analytics/amplify\_analytics\pinpoint/example/android/app · high confidence

The \packages/amplify\_core/doc/lib/auth.dart\ file has been updated to provide detailed code excerpts for the Auth category. This includes new and expanded examples for handling various sign-in steps, such as MFA selection, TOTP setup and verification, email OTP, and passwordless flows, ensuring the documentation reflects the current API capabilities for user authentication.

_packages/amplify\core/doc/lib · high confidence

The iOS configuration for the Amplify Flutter example app has been updated to align with modern Flutter standards. The \AppDelegate\ now implements \FlutterImplicitEngineDelegate\ to support implicit engine initialization, and the \Info.plist\ has been configured with \UIApplicationSceneManifest\ and \CADisableMinimumFrameDurationOnPhone\ to support iOS 13+ scene lifecycle and modern display behavior. Additionally, the Xcode project structure has been refreshed to include standard Flutter build configurations and workspace settings.

_packages/amplify/amplify\flutter/example/ios · high confidence

The iOS example app for the Pinpoint analytics plugin has been regenerated to support the implicit Flutter engine. This update introduces a new \AppDelegate.swift\ that implements \FlutterImplicitEngineDelegate\ to handle plugin registration, and updates the \Info.plist\ to configure the \FlutterSceneDelegate\ for modern iOS scene management. These changes ensure the example app remains compatible with current Flutter iOS standards.

_packages/analytics/amplify\_analytics\pinpoint/example/ios · high confidence

The web entry point for the amplify\_flutter example has been updated to align with modern Flutter standards. The index.html file now includes a dynamic base href placeholder ($FLUTTER\_BASE\_HREF) to support non-root deployment paths, and the manifest.json has been refreshed to define the app as a standalone PWA with updated icon assets and theme colors.

_packages/amplify/amplify\flutter/example/web · high confidence

The web entry point for the amplify\_analytics\_pinpoint example app has been updated to align with modern Flutter web standards. The index.html file now uses the $FLUTTER\_BASE\_HREF placeholder for the base path, ensuring correct asset resolution when the app is served from non-root paths. Additionally, a new manifest.json file has been added to define the app as a standalone PWA, specifying the app name, theme colors, and icon assets for mobile and desktop browsers.

_packages/analytics/amplify\_analytics\pinpoint/example/web · high confidence

The iOS example project for the Amplify Native Legacy Wrapper has been initialized with a standard Flutter 3 template. This adds full support for the iOS 13+ multi-scene lifecycle (via UISceneConfiguration in Info.plist) and updates the AppDelegate to implement FlutterImplicitEngineDelegate, ensuring plugins are correctly registered when the implicit Flutter engine starts. The change also includes the necessary Xcode project structure, CocoaPods workspace configuration, and asset catalogs to allow the example app to build and run on modern iOS versions.

_packages/amplify\_native\_legacy\wrapper/example/ios · high confidence

The iOS example app for the Amplify DataStore package now includes the necessary Xcode workspace configuration files. This adds the workspace definition, enables the 32-bit warning check, and disables SwiftUI Previews by default, ensuring the example project builds correctly in Xcode without unnecessary preview compilation overhead.

_packages/amplify\datastore/example/ios/Runner.xcodeproj/project.xcworkspace · high confidence

The Android release build configuration now includes R8 rules to prevent the obfuscation of \HostedUiException\ class names. This ensures that error codes (such as "CANCELLED") sent from the native layer to Dart remain readable and correctly mapped during Hosted UI sign-in and sign-out flows in production builds.

packages/auth · high confidence

Add Smithy Dart golden testbed and generated protocol fixtures; Add Worker Bee end-to-end test suite for Web and Flutter Web; Add iOS unit test resources for Datastore model serialization and schema definitions; Added Android unit tests for DataStore plugin and hub events; Added WASM smoke test for Analytics Pinpoint example; Added common test mocks for Pinpoint analytics; Added iOS unit tests for DataStore plugin; Added integration test driver entry point for Flutter example app; Added integration test for Amplify Flutter canary app; Added integration test utilities for Pinpoint analytics; Added integration tests for DataStore query operations; Added integration tests for DataStore query predicates; Added placeholder test for AmplifyAnalyticsPinpoint; Added snapshot generation script for version-bump tests; Added snapshot tests for the \aft version-bump\ command; Added test coverage for AFT changelog, constraints, and repository logic; Added test data for Amplify CLI configuration compatibility; Added test fixtures for Gen 2 outputs mapping; Added test resource for fake stream controller; Added test snapshots for \aft version-bump\ validation; Added tests for AFT command version resolution and release note extraction; Added tests for AWSEquatable equality logic; Added tests for Amplify Gen 2 outputs configuration parsing; Added tests for Amplify config to outputs mapping; Added tests for Amplify configuration parsing; Added tests for Auth, DataStore, Storage, and TOTP types; Added tests for Hub channel listening and stream availability; Added tests for User-Agent header construction and propagation; Added tests for config loading and package selection logic; Added tests for plugin registration and auth provider interdependencies; Added tests for state machine dependency management and event handling; Added unit tests for Amplify Core configuration, auth providers, and temporal types; Added unit tests for Android DataStore query builders; Added unit tests for DataStore operations and configuration; Added unit tests for Datastore plugin interface models and queries; Added unit tests for Pinpoint Analytics plugin internals; Added widget smoke test for the canary application; Amplify API example app restructured for Gen 1 and Gen 2 testing; Expanded DataStore integration tests for custom primary keys and relationship types; New DataStore integration test infrastructure and schema; New DataStore integration test utilities for the Flutter example app; New integration test packages for Auth and general Amplify testing; Updated Chrome for Testing download manifest; iOS example app now includes unit test infrastructure.

Introduces a new internal Dart package (\actions\) that provides a Dart wrapper for the GitHub Actions Node.js modules, alongside a companion CI helper (\dart\_format\_check\) for running \dart format\ while respecting \analysis\_options.yaml\ exclusions. The \actions\ package depends on \@actions/core\, \@actions/exec\, \@actions/github\, \@actions/http-client\, and \@actions/tool-cache\, with \@vercel/ncc\ used for bundling, enabling Dart-based GitHub Actions workflows.

(dependencies) · high confidence

The example app's Android build configuration now uses Gradle 8.14 via the wrapper, ensuring consistent builds with the latest Gradle release.

_packages/amplify\datastore/example/android/gradle · high confidence

The Android build configuration for the Amplify DataStore plugin now uses Gradle 8.14 as the distribution version. This update ensures the project uses a consistent, modern Gradle wrapper, which may affect build performance and compatibility with the Android Gradle Plugin.

_packages/amplify/amplify\_flutter/example/android/gradle, packages/amplify\_datastore/android/gradle, packages/analytics/amplify\_analytics\pinpoint/example/android/gradle · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• First survey — no prior run to compare against. CAI 52.

• Code Health 49
• Architecture 65
• Maturity 65
• Readiness 51
• Security 61
• Domain Modelling 100
• Event-Driven 80
• Event Sourcing 49

• 300 commits — 233 feature/other, 67 fixes

• .github/workflows — 38 commits
• infra-gen2/package-lock.json — 33 commits
• packages/notifications — 26 commits
• packages/aft — 22 commits
• infra/package.json — 20 commits
• packages/amplify_datastore — 20 commits
• packages/authenticator — 16 commits
• packages/kinesis — 16 commits
• packages/auth — 14 commits
• packages/amplify_core — 10 commits
• packages/api — 10 commits
• packages/worker_bee — 10 commits
• (root) — 9 commits
• .github/composite_actions — 9 commits
• packages/smithy — 8 commits
• packages/secure_storage — 7 commits
• packages/storage — 7 commits
• packages/amplify_foundation — 4 commits
• packages/analytics — 4 commits
• packages/amplify_connect_client — 3 commits

• fix: Merge pull request #6559 from aws-amplify/jv/fix-linter-form-field
• fix: chore(version): Revert Version bump (#7377)
• fix: chore(version): Revert version bump (#7371)
• fix: chore: Apply format fixes (#6570)
• fix: chore: Apply lint fixes
• fix: chore: fix null-aware-elements warning in form field
• fix: ci: Fix release workflow (#7381)
• fix: fix(aft): Cascade constraints for foundation_dart +foundation_dart_bridge minor bumps (#7125)
• fix: fix(aft): Create CHANGELOG.md if missing during version-bump (#6938)
• fix: fix(aft): Fix aft publish command (awaiting new versions) (#7141)
• fix: fix(aft): Fix tests (#6939)
• fix: fix(aft): Pending analysis detection (#6810)
• fix: fix(aft): Print repo slug in bootstrap publisher instructions (#7262)
• fix: fix(aft): Stop propagating 2.x versions into 0.x Dart packages (#7284)
• fix: fix(aft): Sync package_selector_test with repo (#7261)
• fix: fix(analyzer): Resolve invalid_export_of_internal_element (#7033)
• fix: fix(api): Don't block subscription events during WebSocket reconnect (#7282)
• fix: fix(auth): Await Future returns in try blocks (Dart 3.13 beta lint) (#7042)
• fix: fix(auth): Don't generate unused JsonWebKeySet.fromJson (#7194)
• fix: fix(auth): Fix flaky web tests (#6652)
• …and 280 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

aws-amplify/amplify-flutter was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.