Align exceptions with Amplify v2 AmplifyException pattern\n\nSwitch AmplifyKinesisException to extend amplify_core's\nAmplifyException instead of amplify_foundation_dart's.\nAdopt positional message, optional recoverySuggestion,\nunderlyingException (was cause), const constructors,\nand runtimeTypeName overrides."

Author: ekjotmultani

packages/kinesis/aws_kinesis_datastreams_dart/lib/src/exception/amplify_kinesis_exception.dart

@@ -1,7 +1,7 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
-import 'package:amplify_foundation_dart/amplify_foundation_dart.dart';
+import 'package:amplify_core/amplify_core.dart';
 import 'package:aws_kinesis_datastreams_dart/src/exception/record_cache_exception.dart';
 
 /// Default recovery suggestion for errors.
@@ -13,10 +13,10 @@ const String defaultRecoverySuggestion =
 /// {@endtemplate}
 sealed class AmplifyKinesisException extends AmplifyException {
   /// {@macro aws_kinesis_datastreams.amplify_kinesis_exception}
-  AmplifyKinesisException({
-    required super.message,
-    required super.recoverySuggestion,
-    super.cause,
+  const AmplifyKinesisException(
+    super.message, {
+    super.recoverySuggestion,
+    super.underlyingException,
   });
 
   /// Maps an arbitrary error into the appropriate [AmplifyKinesisException]
@@ -36,49 +36,47 @@ sealed class AmplifyKinesisException extends AmplifyException {
     final RecordCacheDatabaseException e => KinesisStorageException(
       e.message,
       recoverySuggestion: e.recoverySuggestion,
-      cause: e.cause,
+      underlyingException: e.cause,
+    ),
+    final Exception e => KinesisUnknownException(
+      e.toString(),
+      underlyingException: e,
     ),
-    final Exception e => KinesisUnknownException(e.toString(), cause: e),
     _ => KinesisUnknownException(error.toString()),
   };
-
-  @override
-  String toString() {
-    final buf = StringBuffer('AmplifyKinesisException: $message');
-    if (recoverySuggestion.isNotEmpty) {
-      buf.write('\nRecovery suggestion: $recoverySuggestion');
-    }
-    if (cause != null) buf.write('\nCaused by: $cause');
-    return buf.toString();
-  }
 }
 
 /// {@template aws_kinesis_datastreams.kinesis_storage_exception}
 /// Thrown when a local cache/database error occurs.
 /// {@endtemplate}
 final class KinesisStorageException extends AmplifyKinesisException {
   /// {@macro aws_kinesis_datastreams.kinesis_storage_exception}
-  KinesisStorageException(
-    String message, {
-    String? recoverySuggestion,
-    super.cause,
-  }) : super(
-         message: message,
-         recoverySuggestion: recoverySuggestion ?? defaultRecoverySuggestion,
-       );
+  const KinesisStorageException(
+    super.message, {
+    super.recoverySuggestion,
+    super.underlyingException,
+  });
+
+  @override
+  String get runtimeTypeName => 'KinesisStorageException';
 }
 
 /// {@template aws_kinesis_datastreams.kinesis_limit_exceeded_exception}
 /// Thrown when the local cache is full.
 /// {@endtemplate}
 final class KinesisLimitExceededException extends AmplifyKinesisException {
   /// {@macro aws_kinesis_datastreams.kinesis_limit_exceeded_exception}
-  KinesisLimitExceededException({String? message, String? recoverySuggestion})
-    : super(
-        message: message ?? 'Cache is full',
-        recoverySuggestion:
-            recoverySuggestion ?? 'Call flush() or clearCache().',
-      );
+  const KinesisLimitExceededException({
+    String? message,
+    String? recoverySuggestion,
+  }) : super(
+         message ?? 'Cache is full',
+         recoverySuggestion:
+             recoverySuggestion ?? 'Call flush() or clearCache().',
+       );
+
+  @override
+  String get runtimeTypeName => 'KinesisLimitExceededException';
 }
 
 /// {@template aws_kinesis_datastreams.kinesis_validation_exception}
@@ -87,30 +85,34 @@ final class KinesisLimitExceededException extends AmplifyKinesisException {
 /// {@endtemplate}
 final class KinesisValidationException extends AmplifyKinesisException {
   /// {@macro aws_kinesis_datastreams.kinesis_validation_exception}
-  KinesisValidationException(String message, {String? recoverySuggestion})
-    : super(
-        message: message,
-        recoverySuggestion: recoverySuggestion ?? defaultRecoverySuggestion,
-      );
+  const KinesisValidationException(super.message, {super.recoverySuggestion});
+
+  @override
+  String get runtimeTypeName => 'KinesisValidationException';
 }
 
 /// {@template aws_kinesis_datastreams.kinesis_unknown_exception}
 /// Catch-all for unexpected errors.
 /// {@endtemplate}
 final class KinesisUnknownException extends AmplifyKinesisException {
   /// {@macro aws_kinesis_datastreams.kinesis_unknown_exception}
-  KinesisUnknownException(String message, {super.cause})
-    : super(message: message, recoverySuggestion: defaultRecoverySuggestion);
+  const KinesisUnknownException(super.message, {super.underlyingException});
+
+  @override
+  String get runtimeTypeName => 'KinesisUnknownException';
 }
 
 /// {@template aws_kinesis_datastreams.client_closed_exception}
 /// Thrown when an operation is attempted on a closed client.
 /// {@endtemplate}
 final class ClientClosedException extends AmplifyKinesisException {
   /// {@macro aws_kinesis_datastreams.client_closed_exception}
-  ClientClosedException()
+  const ClientClosedException()
     : super(
-        message: 'Client has been closed',
+        'Client has been closed',
         recoverySuggestion: 'Create a new AmplifyKinesisClient instance.',
       );
+
+  @override
+  String get runtimeTypeName => 'ClientClosedException';
 }

packages/kinesis/aws_kinesis_datastreams_dart/test/amplify_kinesis_exception_test.dart

@@ -8,7 +8,7 @@ import 'package:test/test.dart';
 void main() {
   group('AmplifyKinesisException.from', () {
     test('passes through AmplifyKinesisException unchanged', () {
-      final original = KinesisStorageException('msg');
+      const original = KinesisStorageException('msg');
       final result = AmplifyKinesisException.from(original);
       expect(identical(result, original), isTrue);
     });
@@ -37,7 +37,7 @@ void main() {
         expect(result, isA<KinesisStorageException>());
         expect(result.message, 'db error');
         expect(result.recoverySuggestion, 'retry');
-        expect(result.cause, underlying);
+        expect(result.underlyingException, underlying);
       },
     );
 
@@ -59,15 +59,15 @@ void main() {
       final cause = Exception('something unexpected');
       final result = AmplifyKinesisException.from(cause);
       expect(result, isA<KinesisUnknownException>());
-      expect(result.cause, cause);
+      expect(result.underlyingException, cause);
     });
 
     test('converts non-Exception error to KinesisUnknownException', () {
       const error = 'a string error';
       final result = AmplifyKinesisException.from(error);
       expect(result, isA<KinesisUnknownException>());
       expect(result.message, 'a string error');
-      expect(result.cause, isNull);
+      expect(result.underlyingException, isNull);
     });
   });
 }