Apply autoformat

jvh-aws · jvh-aws · commit fd1418b5d649 · 2026-03-12T18:54:41.000+01:00
diff --git a/packages/kinesis/aws_kinesis_datastreams_dart/lib/src/exception/amplify_kinesis_exception.dart b/packages/kinesis/aws_kinesis_datastreams_dart/lib/src/exception/amplify_kinesis_exception.dart
@@ -29,20 +29,16 @@ sealed class AmplifyKinesisException extends AmplifyException {
       e.message,
       recoverySuggestion: e.recoverySuggestion,
     ),
-    final RecordCacheLimitExceededException e =>
-      KinesisLimitExceededException(
-        message: e.message,
-        recoverySuggestion: e.recoverySuggestion,
-      ),
+    final RecordCacheLimitExceededException e => KinesisLimitExceededException(
+      message: e.message,
+      recoverySuggestion: e.recoverySuggestion,
+    ),
     final RecordCacheDatabaseException e => KinesisStorageException(
       e.message,
       recoverySuggestion: e.recoverySuggestion,
       cause: e.cause,
     ),
-    final Exception e => KinesisUnknownException(
-      e.toString(),
-      cause: e,
-    ),
+    final Exception e => KinesisUnknownException(e.toString(), cause: e),
     _ => KinesisUnknownException(error.toString()),
   };
 
diff --git a/packages/kinesis/aws_kinesis_datastreams_dart/lib/src/impl/auto_flush_scheduler.dart b/packages/kinesis/aws_kinesis_datastreams_dart/lib/src/impl/auto_flush_scheduler.dart
@@ -18,11 +18,9 @@ import 'package:aws_kinesis_datastreams_dart/src/impl/record_client.dart';
 /// {@endtemplate}
 final class AutoFlushScheduler {
   /// {@macro aws_kinesis_datastreams.auto_flush_scheduler}
-  AutoFlushScheduler({
-    required Duration interval,
-    required RecordClient client,
-  }) : _interval = interval,
-       _client = client;
+  AutoFlushScheduler({required Duration interval, required RecordClient client})
+    : _interval = interval,
+      _client = client;
 
   final Duration _interval;
   final RecordClient _client;
diff --git a/packages/kinesis/aws_kinesis_datastreams_dart/lib/src/impl/kinesis_sender.dart b/packages/kinesis/aws_kinesis_datastreams_dart/lib/src/impl/kinesis_sender.dart
@@ -39,11 +39,9 @@ final class PutRecordsResult {
 /// {@endtemplate}
 class KinesisSender {
   /// {@macro aws_kinesis_datastreams.kinesis_sender}
-  KinesisSender({
-    required KinesisClient kinesisClient,
-    required int maxRetries,
-  }) : _kinesisClient = kinesisClient,
-       _maxRetries = maxRetries;
+  KinesisSender({required KinesisClient kinesisClient, required int maxRetries})
+    : _kinesisClient = kinesisClient,
+      _maxRetries = maxRetries;
 
   final KinesisClient _kinesisClient;
   final int _maxRetries;
diff --git a/packages/kinesis/aws_kinesis_datastreams_dart/lib/src/impl/record_client.dart b/packages/kinesis/aws_kinesis_datastreams_dart/lib/src/impl/record_client.dart
@@ -73,9 +73,7 @@ class RecordClient {
           );
           await _handleFailedRequest(records);
         } catch (e) {
-          _logger.warn(
-            'Error flushing stream $streamName: $e. Aborting flush',
-          );
+          _logger.warn('Error flushing stream $streamName: $e. Aborting flush');
           await _handleFailedRequest(records);
           rethrow;
         }
diff --git a/packages/kinesis/aws_kinesis_datastreams_dart/lib/src/impl/storage/record_storage.dart b/packages/kinesis/aws_kinesis_datastreams_dart/lib/src/impl/storage/record_storage.dart
@@ -5,8 +5,7 @@ import 'package:aws_kinesis_datastreams_dart/src/exception/amplify_kinesis_excep
     show defaultRecoverySuggestion;
 import 'package:aws_kinesis_datastreams_dart/src/exception/record_cache_exception.dart';
 import 'package:aws_kinesis_datastreams_dart/src/impl/kinesis_record.dart';
-import 'package:aws_kinesis_datastreams_dart/src/kinesis_limits.dart'
-    as limits;
+import 'package:aws_kinesis_datastreams_dart/src/kinesis_limits.dart' as limits;
 import 'package:aws_kinesis_datastreams_dart/src/model/record.dart';
 import 'package:meta/meta.dart';
 
@@ -105,22 +104,20 @@ abstract class RecordStorage {
       });
 
   /// Increments the retry count for the specified records.
-  Future<void> incrementRetryCount(Iterable<int> ids) =>
-      _wrap(
-        'Failed to increment retry count',
-        () => doIncrementRetryCount(ids),
-      );
+  Future<void> incrementRetryCount(Iterable<int> ids) => _wrap(
+    'Failed to increment retry count',
+    () => doIncrementRetryCount(ids),
+  );
 
   /// Returns the total number of cached records.
   Future<int> getRecordCount() =>
       _wrap('Failed to get record count', doGetRecordCount);
 
   /// Deletes all records and resets [cachedSize] to 0.
-  Future<void> clearRecords() =>
-      _wrap('Failed to clear cache', () async {
-        await doClearRecords();
-        cachedSize = 0;
-      });
+  Future<void> clearRecords() => _wrap('Failed to clear cache', () async {
+    await doClearRecords();
+    cachedSize = 0;
+  });
 
   /// Closes the storage and releases resources.
   Future<void> close() => _wrap('Failed to close storage', doClose);
@@ -159,10 +156,7 @@ abstract class RecordStorage {
   @protected
   Future<void> doClose();
 
-  Future<T> _wrap<T>(
-    String message,
-    Future<T> Function() operation,
-  ) async {
+  Future<T> _wrap<T>(String message, Future<T> Function() operation) async {
     try {
       return await operation();
     } on RecordCacheException {
diff --git a/packages/kinesis/aws_kinesis_datastreams_dart/lib/src/impl/storage/record_storage_indexeddb.dart b/packages/kinesis/aws_kinesis_datastreams_dart/lib/src/impl/storage/record_storage_indexeddb.dart
@@ -196,8 +196,7 @@ final class IndexedDbRecordStorage extends RecordStorage {
       }
     }
 
-    final request = db.open(dbName, 1)
-      ..onupgradeneeded = onUpgradeNeeded.toJS;
+    final request = db.open(dbName, 1)..onupgradeneeded = onUpgradeNeeded.toJS;
     final result = await request.future;
     if (result.isA<IDBDatabase>()) {
       return result as IDBDatabase;
@@ -223,10 +222,9 @@ final class IndexedDbRecordStorage extends RecordStorage {
         final idbCursor = cursor as IDBCursorWithValue;
         final value = idbCursor.value;
         if (!value.isUndefinedOrNull) {
-          total +=
-              (value as JSObject)
-                  .getProperty<JSNumber>('data_size'.toJS)
-                  .toDartInt;
+          total += (value as JSObject)
+              .getProperty<JSNumber>('data_size'.toJS)
+              .toDartInt;
         }
         idbCursor.continue_();
       }).toJS
diff --git a/packages/kinesis/aws_kinesis_datastreams_dart/lib/src/impl/storage/record_storage_memory.dart b/packages/kinesis/aws_kinesis_datastreams_dart/lib/src/impl/storage/record_storage_memory.dart
@@ -8,7 +8,7 @@ import 'package:aws_kinesis_datastreams_dart/src/impl/storage/record_storage.dar
 
 /// {@template aws_kinesis_datastreams.in_memory_record_storage}
 /// In-memory [RecordStorage] fallback for web when IndexedDB is unavailable.
-/// Records are not persisted. 
+/// Records are not persisted.
 /// {@endtemplate}
 final class InMemoryRecordStorage extends RecordStorage {
   /// {@macro aws_kinesis_datastreams.in_memory_record_storage}
diff --git a/packages/kinesis/aws_kinesis_datastreams_dart/lib/src/impl/storage/record_storage_sqlite.dart b/packages/kinesis/aws_kinesis_datastreams_dart/lib/src/impl/storage/record_storage_sqlite.dart
@@ -121,9 +121,7 @@ final class SqliteRecordStorage extends RecordStorage {
   @override
   Future<void> doIncrementRetryCount(Iterable<int> ids) async {
     if (ids.isEmpty) return;
-    await (_db.update(
-      _db.kinesisRecords,
-    )..where((t) => t.id.isIn(ids))).write(
+    await (_db.update(_db.kinesisRecords)..where((t) => t.id.isIn(ids))).write(
       KinesisRecordsCompanion.custom(
         retryCount: _db.kinesisRecords.retryCount + const Constant(1),
       ),
diff --git a/packages/kinesis/aws_kinesis_datastreams_dart/test/auto_flush_scheduler_test.dart b/packages/kinesis/aws_kinesis_datastreams_dart/test/auto_flush_scheduler_test.dart
@@ -16,8 +16,7 @@ void main() {
 
     setUp(() {
       mockClient = _MockRecordClient();
-      when(() => mockClient.flush())
-          .thenAnswer((_) async => const FlushData());
+      when(() => mockClient.flush()).thenAnswer((_) async => const FlushData());
     });
 
     tearDown(() {
@@ -72,15 +71,16 @@ void main() {
 
     test('rapid start/stop/start does not leak loops', () {
       fakeAsync((async) {
-        final scheduler = AutoFlushScheduler(
-          interval: const Duration(seconds: 1),
-          client: mockClient,
-        )
-          ..start()
-          ..stop()
-          ..start()
-          ..stop()
-          ..start();
+        final scheduler =
+            AutoFlushScheduler(
+                interval: const Duration(seconds: 1),
+                client: mockClient,
+              )
+              ..start()
+              ..stop()
+              ..start()
+              ..stop()
+              ..start();
 
         // Only one loop should be active.
         async.elapse(const Duration(milliseconds: 2500));
diff --git a/packages/kinesis/aws_kinesis_datastreams_dart/test/in_memory_record_storage_test.dart b/packages/kinesis/aws_kinesis_datastreams_dart/test/in_memory_record_storage_test.dart
@@ -111,9 +111,27 @@ void main() {
 
     group('getRecordsByStream', () {
       test('returns records grouped by stream name', () async {
-        await storage.addRecord(RecordInput.now(data: Uint8List.fromList([1]), partitionKey: 'pk', streamName: 'stream-a'));
-        await storage.addRecord(RecordInput.now(data: Uint8List.fromList([2]), partitionKey: 'pk', streamName: 'stream-b'));
-        await storage.addRecord(RecordInput.now(data: Uint8List.fromList([3]), partitionKey: 'pk', streamName: 'stream-a'));
+        await storage.addRecord(
+          RecordInput.now(
+            data: Uint8List.fromList([1]),
+            partitionKey: 'pk',
+            streamName: 'stream-a',
+          ),
+        );
+        await storage.addRecord(
+          RecordInput.now(
+            data: Uint8List.fromList([2]),
+            partitionKey: 'pk',
+            streamName: 'stream-b',
+          ),
+        );
+        await storage.addRecord(
+          RecordInput.now(
+            data: Uint8List.fromList([3]),
+            partitionKey: 'pk',
+            streamName: 'stream-a',
+          ),
+        );
 
         final result = await storage.getRecordsByStream();
         expect(result.keys, containsAll(['stream-a', 'stream-b']));
@@ -125,13 +143,18 @@ void main() {
         final result = await storage.getRecordsByStream();
         expect(result, isEmpty);
       });
-
     });
 
     group('clearRecords', () {
       test('removes all records', () async {
         for (var i = 0; i < 5; i++) {
-          await storage.addRecord(RecordInput.now(data: Uint8List.fromList([i]), partitionKey: 'pk-$i', streamName: 'stream'));
+          await storage.addRecord(
+            RecordInput.now(
+              data: Uint8List.fromList([i]),
+              partitionKey: 'pk-$i',
+              streamName: 'stream',
+            ),
+          );
         }
         expect(await getAllRecords(), hasLength(5));
 
@@ -145,7 +168,13 @@ void main() {
       test('returns correct count', () async {
         expect(await storage.getRecordCount(), equals(0));
         for (var i = 0; i < 3; i++) {
-          await storage.addRecord(RecordInput.now(data: Uint8List.fromList([i]), partitionKey: 'pk-$i', streamName: 'stream'));
+          await storage.addRecord(
+            RecordInput.now(
+              data: Uint8List.fromList([i]),
+              partitionKey: 'pk-$i',
+              streamName: 'stream',
+            ),
+          );
         }
         expect(await storage.getRecordCount(), equals(3));
       });
diff --git a/packages/kinesis/aws_kinesis_datastreams_dart/test/kinesis_data_streams_test.dart b/packages/kinesis/aws_kinesis_datastreams_dart/test/kinesis_data_streams_test.dart
@@ -187,8 +187,7 @@ void main() {
       test('enable sets isEnabled to true', () {
         final client = AmplifyKinesisClient.withRecordClient(
           recordClient: mockRecordClient,
-        )
-          ..disable();
+        )..disable();
         expect(client.isEnabled, isFalse);
 
         client.enable();
diff --git a/packages/kinesis/aws_kinesis_datastreams_dart/test/kinesis_sender_test.dart b/packages/kinesis/aws_kinesis_datastreams_dart/test/kinesis_sender_test.dart
@@ -107,60 +107,60 @@ void main() {
       expect(captured.records[1].data, equals(Uint8List.fromList([4, 5, 6])));
     });
 
-    test('correctly categorizes response into success, retryable, failed',
-        () async {
-      // - Record 1 (retryCount=0): success (no error code)
-      // - Record 2 (retryCount=1): retryable (error code + under retry limit)
-      // - Record 3 (retryCount=maxRetries): failed (error code + at retry limit)
-      when(() => mockClient.putRecords(any())).thenReturn(
-        mockSmithyOperation(
-          () => PutRecordsResponse(
-            records: [
-              PutRecordsResultEntry(
-                sequenceNumber: 'seq1',
-                shardId: 'shard1',
-              ),
-              PutRecordsResultEntry(
-                errorCode: 'ProvisionedThroughputExceededException',
-              ),
-              PutRecordsResultEntry(
-                errorCode: 'InternalFailure',
-              ),
-            ],
-          ),
-        ),
-      );
-
-      final sender = _DirectMockSender(mockClient, maxRetries: maxRetries);
-
-      final result = await sender.putRecords(
-        streamName: 'test-stream',
-        records: [
-          _testRecord(
-            id: 1,
-            partitionKey: 'key1',
-            data: Uint8List.fromList([1]),
-            retryCount: 0,
-          ),
-          _testRecord(
-            id: 2,
-            partitionKey: 'key2',
-            data: Uint8List.fromList([2]),
-            retryCount: 1,
-          ),
-          _testRecord(
-            id: 3,
-            partitionKey: 'key3',
-            data: Uint8List.fromList([3]),
-            retryCount: maxRetries,
+    test(
+      'correctly categorizes response into success, retryable, failed',
+      () async {
+        // - Record 1 (retryCount=0): success (no error code)
+        // - Record 2 (retryCount=1): retryable (error code + under retry limit)
+        // - Record 3 (retryCount=maxRetries): failed (error code + at retry limit)
+        when(() => mockClient.putRecords(any())).thenReturn(
+          mockSmithyOperation(
+            () => PutRecordsResponse(
+              records: [
+                PutRecordsResultEntry(
+                  sequenceNumber: 'seq1',
+                  shardId: 'shard1',
+                ),
+                PutRecordsResultEntry(
+                  errorCode: 'ProvisionedThroughputExceededException',
+                ),
+                PutRecordsResultEntry(errorCode: 'InternalFailure'),
+              ],
+            ),
           ),
-        ],
-      );
-
-      expect(result.successfulIds, equals([1]));
-      expect(result.retryableIds, equals([2]));
-      expect(result.failedIds, equals([3]));
-    });
+        );
+
+        final sender = _DirectMockSender(mockClient, maxRetries: maxRetries);
+
+        final result = await sender.putRecords(
+          streamName: 'test-stream',
+          records: [
+            _testRecord(
+              id: 1,
+              partitionKey: 'key1',
+              data: Uint8List.fromList([1]),
+              retryCount: 0,
+            ),
+            _testRecord(
+              id: 2,
+              partitionKey: 'key2',
+              data: Uint8List.fromList([2]),
+              retryCount: 1,
+            ),
+            _testRecord(
+              id: 3,
+              partitionKey: 'key3',
+              data: Uint8List.fromList([3]),
+              retryCount: maxRetries,
+            ),
+          ],
+        );
+
+        expect(result.successfulIds, equals([1]));
+        expect(result.retryableIds, equals([2]));
+        expect(result.failedIds, equals([3]));
+      },
+    );
   });
 }
 
diff --git a/packages/kinesis/aws_kinesis_datastreams_dart/test/record_client_concurrent_flush_test.dart b/packages/kinesis/aws_kinesis_datastreams_dart/test/record_client_concurrent_flush_test.dart
diff --git a/packages/kinesis/aws_kinesis_datastreams_dart/test/record_client_test.dart b/packages/kinesis/aws_kinesis_datastreams_dart/test/record_client_test.dart
diff --git a/packages/kinesis/aws_kinesis_datastreams_dart/test/record_validation_test.dart b/packages/kinesis/aws_kinesis_datastreams_dart/test/record_validation_test.dart
diff --git a/packages/kinesis/aws_kinesis_datastreams_dart/test/sqlite_record_storage_cache_accuracy_test.dart b/packages/kinesis/aws_kinesis_datastreams_dart/test/sqlite_record_storage_cache_accuracy_test.dart
