Merge remote-tracking branch 'upstream/master' into pc_server

Author: pastordee

packages/dart/CHANGELOG.md

@@ -1,3 +1,24 @@
+# [dart-v9.4.4](https://github.com/parse-community/Parse-SDK-Flutter/compare/dart-9.4.3...dart-9.4.4) (2025-12-04)
+
+
+### Bug Fixes
+
+* `ParseBase.toJson()` failure when date fields are stored as Maps ([#1094](https://github.com/parse-community/Parse-SDK-Flutter/issues/1094)) ([04a8d5b](https://github.com/parse-community/Parse-SDK-Flutter/commit/04a8d5b6d3d811636ea1b54247e73871b25266d1))
+
+# [dart-v9.4.3](https://github.com/parse-community/Parse-SDK-Flutter/compare/dart-9.4.2...dart-9.4.3) (2025-12-04)
+
+
+### Bug Fixes
+
+* Flutter Web build failure with ambiguous import from `sembast` and `idb_shim` ([#1093](https://github.com/parse-community/Parse-SDK-Flutter/issues/1093)) ([71aa5f2](https://github.com/parse-community/Parse-SDK-Flutter/commit/71aa5f20ab160a6113ac8167d66c540de11ff88f))
+
+# [dart-v9.4.2](https://github.com/parse-community/Parse-SDK-Flutter/compare/dart-9.4.1...dart-9.4.2) (2025-12-02)
+
+
+### Bug Fixes
+
+* Ethernet not recognized as connectivity state ([#1090](https://github.com/parse-community/Parse-SDK-Flutter/issues/1090)) ([f76fde4](https://github.com/parse-community/Parse-SDK-Flutter/commit/f76fde4f348af5d3992663795d279d57658f4e87))
+
 # [dart-v9.4.1](https://github.com/parse-community/Parse-SDK-Flutter/compare/dart-9.4.0...dart-9.4.1) (2025-11-30)
 
 

packages/dart/lib/src/network/parse_connectivity.dart

@@ -5,6 +5,9 @@ enum ParseConnectivityResult {
   /// WiFi: Device connected via Wi-Fi
   wifi,
 
+  /// Ethernet: Device connected via Ethernet
+  ethernet,
+
   /// Mobile: Device connected to cellular network
   mobile,
 

packages/dart/lib/src/objects/parse_base.dart

@@ -52,22 +52,24 @@ abstract class ParseBase {
 
   /// Returns [DateTime] createdAt
   DateTime? get createdAt {
-    if (get<dynamic>(keyVarCreatedAt) is String) {
-      final String? dateAsString = get<String>(keyVarCreatedAt);
-      return dateAsString != null ? _parseDateFormat.parse(dateAsString) : null;
-    } else {
-      return get<DateTime>(keyVarCreatedAt);
+    final dynamic value = get<dynamic>(keyVarCreatedAt);
+    if (value is DateTime) return value;
+    if (value is String) return _parseDateFormat.parse(value);
+    if (value is Map<String, dynamic> && value['iso'] is String) {
+      return _parseDateFormat.parse(value['iso'] as String);
     }
+    return null;
   }
 
   /// Returns [DateTime] updatedAt
   DateTime? get updatedAt {
-    if (get<dynamic>(keyVarUpdatedAt) is String) {
-      final String? dateAsString = get<String>(keyVarUpdatedAt);
-      return dateAsString != null ? _parseDateFormat.parse(dateAsString) : null;
-    } else {
-      return get<DateTime>(keyVarUpdatedAt);
+    final dynamic value = get<dynamic>(keyVarUpdatedAt);
+    if (value is DateTime) return value;
+    if (value is String) return _parseDateFormat.parse(value);
+    if (value is Map<String, dynamic> && value['iso'] is String) {
+      return _parseDateFormat.parse(value['iso'] as String);
     }
+    return null;
   }
 
   /// Converts object to [String] in JSON format
@@ -140,12 +142,20 @@ abstract class ParseBase {
       } else if (key == keyVarCreatedAt) {
         if (value is String) {
           _getObjectData()[keyVarCreatedAt] = _parseDateFormat.parse(value);
+        } else if (value is Map<String, dynamic> && value['iso'] is String) {
+          _getObjectData()[keyVarCreatedAt] = _parseDateFormat.parse(
+            value['iso'] as String,
+          );
         } else {
           _getObjectData()[keyVarCreatedAt] = value;
         }
       } else if (key == keyVarUpdatedAt) {
         if (value is String) {
           _getObjectData()[keyVarUpdatedAt] = _parseDateFormat.parse(value);
+        } else if (value is Map<String, dynamic> && value['iso'] is String) {
+          _getObjectData()[keyVarUpdatedAt] = _parseDateFormat.parse(
+            value['iso'] as String,
+          );
         } else {
           _getObjectData()[keyVarUpdatedAt] = value;
         }

packages/dart/pubspec.yaml

@@ -1,6 +1,6 @@
 name: parse_server_sdk
 description: The Dart SDK to connect to Parse Server. Build your apps faster with Parse Platform, the complete application stack.
-version: 9.4.1
+version: 9.4.4
 homepage: https://parseplatform.org
 repository: https://github.com/parse-community/Parse-SDK-Flutter
 issue_tracker: https://github.com/parse-community/Parse-SDK-Flutter/issues
@@ -28,8 +28,8 @@ dependencies:
   web_socket_channel: ">=2.4.3 <4.0.0"
 
   #Database
-  sembast: ^3.6.0
-  sembast_web: ^2.4.2
+  sembast: ^3.7.4
+  sembast_web: ^2.4.0
 
   # Utils
   uuid: ^4.5.1

packages/dart/test/src/network/parse_live_query_test.dart

@@ -6,6 +6,30 @@ import 'package:test/test.dart';
 
 import '../../test_utils.dart';
 
+/// Mock connectivity provider for testing different connectivity states
+class MockConnectivityProvider implements ParseConnectivityProvider {
+  final StreamController<ParseConnectivityResult> _controller =
+      StreamController<ParseConnectivityResult>.broadcast();
+  ParseConnectivityResult _currentState = ParseConnectivityResult.wifi;
+
+  @override
+  Future<ParseConnectivityResult> checkConnectivity() async {
+    return _currentState;
+  }
+
+  @override
+  Stream<ParseConnectivityResult> get connectivityStream => _controller.stream;
+
+  void setConnectivity(ParseConnectivityResult state) {
+    _currentState = state;
+    _controller.add(state);
+  }
+
+  void dispose() {
+    _controller.close();
+  }
+}
+
 void main() {
   setUpAll(() async {
     // Create a fake server
@@ -62,4 +86,124 @@ void main() {
     // 10 millisecond hold for stream
     await Future.delayed(Duration(milliseconds: 10));
   });
+
+  group('Connectivity handling', () {
+    late MockConnectivityProvider mockConnectivity;
+
+    // Initialize once with mock provider, then test state changes
+    setUpAll(() async {
+      mockConnectivity = MockConnectivityProvider();
+      // Initialize Parse once with the mock provider
+      await Parse().initialize(
+        'appId',
+        serverUrl,
+        debug: false,
+        fileDirectory: 'someDirectory',
+        appName: 'appName',
+        appPackageName: 'somePackageName',
+        appVersion: 'someAppVersion',
+        connectivityProvider: mockConnectivity,
+      );
+    });
+
+    tearDownAll(() {
+      mockConnectivity.dispose();
+    });
+
+    // Test data for parameterized connectivity state tests
+    final connectivityTestCases = <Map<String, dynamic>>[
+      {
+        'state': ParseConnectivityResult.wifi,
+        'isOnline': true,
+        'description': 'wifi should be treated as online',
+      },
+      {
+        'state': ParseConnectivityResult.ethernet,
+        'isOnline': true,
+        'description': 'ethernet should be treated as online',
+      },
+      {
+        'state': ParseConnectivityResult.mobile,
+        'isOnline': true,
+        'description': 'mobile should be treated as online',
+      },
+      {
+        'state': ParseConnectivityResult.none,
+        'isOnline': false,
+        'description': 'none should be treated as offline',
+      },
+    ];
+
+    for (final testCase in connectivityTestCases) {
+      test(testCase['description'], () async {
+        // arrange
+        final state = testCase['state'] as ParseConnectivityResult;
+        final isOnline = testCase['isOnline'] as bool;
+
+        // act
+        mockConnectivity.setConnectivity(state);
+        final result = await mockConnectivity.checkConnectivity();
+
+        // assert - verify the state is correctly identified
+        expect(result, state);
+        expect(result != ParseConnectivityResult.none, isOnline);
+      });
+    }
+
+    test('should emit connectivity state transitions through stream', () async {
+      // arrange
+      final emittedStates = <ParseConnectivityResult>[];
+      final subscription = mockConnectivity.connectivityStream.listen((state) {
+        emittedStates.add(state);
+      });
+
+      // act - transition through different connectivity states
+      mockConnectivity.setConnectivity(ParseConnectivityResult.wifi);
+      await Future.delayed(Duration(milliseconds: 10));
+      mockConnectivity.setConnectivity(ParseConnectivityResult.ethernet);
+      await Future.delayed(Duration(milliseconds: 10));
+      mockConnectivity.setConnectivity(ParseConnectivityResult.mobile);
+      await Future.delayed(Duration(milliseconds: 10));
+      mockConnectivity.setConnectivity(ParseConnectivityResult.none);
+      await Future.delayed(Duration(milliseconds: 10));
+
+      // assert - all state changes should be emitted
+      expect(emittedStates.length, 4);
+      expect(emittedStates[0], ParseConnectivityResult.wifi);
+      expect(emittedStates[1], ParseConnectivityResult.ethernet);
+      expect(emittedStates[2], ParseConnectivityResult.mobile);
+      expect(emittedStates[3], ParseConnectivityResult.none);
+
+      // verify online states (wifi, ethernet, mobile) are not "none"
+      expect(emittedStates[0], isNot(ParseConnectivityResult.none));
+      expect(emittedStates[1], isNot(ParseConnectivityResult.none));
+      expect(emittedStates[2], isNot(ParseConnectivityResult.none));
+
+      await subscription.cancel();
+    });
+
+    test('should transition from offline to online correctly', () async {
+      // arrange
+      final stateChanges = <ParseConnectivityResult>[];
+      final subscription = mockConnectivity.connectivityStream.listen((state) {
+        stateChanges.add(state);
+      });
+
+      // act - start offline, then go online via ethernet
+      mockConnectivity.setConnectivity(ParseConnectivityResult.none);
+      await Future.delayed(Duration(milliseconds: 10));
+      mockConnectivity.setConnectivity(ParseConnectivityResult.ethernet);
+      await Future.delayed(Duration(milliseconds: 10));
+
+      // assert
+      expect(stateChanges.length, 2);
+      expect(stateChanges[0], ParseConnectivityResult.none);
+      expect(stateChanges[1], ParseConnectivityResult.ethernet);
+      // Verify the transition is from offline to online
+      expect(stateChanges[0] == ParseConnectivityResult.none, true);
+      expect(stateChanges[1] != ParseConnectivityResult.none, true);
+
+      await subscription.cancel();
+    });
+  });
 }

packages/dart/test/src/objects/parse_base_test.dart

@@ -170,5 +170,86 @@ void main() {
         );
       },
     );
+
+    group('date parsing', () {
+      test('createdAt and updatedAt should handle Map date format', () {
+        // Create a parse object and simulate server response with date as Map
+        final parseObject = ParseObject('TestClass');
+
+        // This is what the server sometimes returns - date as Map
+        parseObject.fromJson({
+          'objectId': 'testObjectId',
+          'createdAt': {'__type': 'Date', 'iso': '2023-01-01T00:00:00.000Z'},
+          'updatedAt': {'__type': 'Date', 'iso': '2023-01-02T00:00:00.000Z'},
+        });
+
+        // These should not throw and return DateTime objects
+        expect(parseObject.createdAt, isA<DateTime>());
+        expect(parseObject.updatedAt, isA<DateTime>());
+
+        expect(parseObject.createdAt?.year, equals(2023));
+        expect(parseObject.createdAt?.month, equals(1));
+        expect(parseObject.createdAt?.day, equals(1));
+
+        expect(parseObject.updatedAt?.year, equals(2023));
+        expect(parseObject.updatedAt?.month, equals(1));
+        expect(parseObject.updatedAt?.day, equals(2));
+      });
+
+      test('createdAt and updatedAt should handle String date format', () {
+        final parseObject = ParseObject('TestClass');
+
+        parseObject.fromJson({
+          'objectId': 'testObjectId',
+          'createdAt': '2023-01-01T00:00:00.000Z',
+          'updatedAt': '2023-01-02T00:00:00.000Z',
+        });
+
+        expect(parseObject.createdAt, isA<DateTime>());
+        expect(parseObject.updatedAt, isA<DateTime>());
+
+        expect(parseObject.createdAt?.year, equals(2023));
+        expect(parseObject.updatedAt?.year, equals(2023));
+      });
+
+      test('createdAt and updatedAt should handle DateTime objects', () {
+        final createdAt = DateTime(2023, 1, 1);
+        final updatedAt = DateTime(2023, 1, 2);
+
+        final parseObject = ParseObject('TestClass');
+        parseObject.fromJson({
+          'objectId': 'testObjectId',
+          'createdAt': createdAt,
+          'updatedAt': updatedAt,
+        });
+
+        expect(parseObject.createdAt, equals(createdAt));
+        expect(parseObject.updatedAt, equals(updatedAt));
+      });
+
+      test('toJson should work when date fields are stored as Maps', () {
+        final parseObject = ParseObject('TestClass');
+
+        // Simulate server response with date as Map
+        parseObject.fromJson({
+          'objectId': 'testObjectId',
+          'createdAt': {'__type': 'Date', 'iso': '2023-01-01T00:00:00.000Z'},
+          'updatedAt': {'__type': 'Date', 'iso': '2023-01-02T00:00:00.000Z'},
+        });
+
+        // toJson should work without throwing
+        expect(() => parseObject.toJson(full: true), returnsNormally);
+        expect(() => parseObject.toString(), returnsNormally);
+      });
+
+      test('createdAt and updatedAt should return null for null values', () {
+        final parseObject = ParseObject('TestClass');
+
+        parseObject.fromJson({'objectId': 'testObjectId'});
+
+        expect(parseObject.createdAt, isNull);
+        expect(parseObject.updatedAt, isNull);
+      });
+    });
   });
 }

packages/flutter/CHANGELOG.md

@@ -1,3 +1,17 @@
+# [flutter-v10.6.2](https://github.com/parse-community/Parse-SDK-Flutter/compare/flutter-10.6.1...flutter-10.6.2) (2025-12-04)
+
+
+### Bug Fixes
+
+* Flutter Web build failure with ambiguous import from `sembast` and `idb_shim` ([#1093](https://github.com/parse-community/Parse-SDK-Flutter/issues/1093)) ([71aa5f2](https://github.com/parse-community/Parse-SDK-Flutter/commit/71aa5f20ab160a6113ac8167d66c540de11ff88f))
+
+# [flutter-v10.6.1](https://github.com/parse-community/Parse-SDK-Flutter/compare/flutter-10.6.0...flutter-10.6.1) (2025-12-03)
+
+
+### Bug Fixes
+
+* LiveQuery not working due to ethernet not recognized as connectivity state ([#1091](https://github.com/parse-community/Parse-SDK-Flutter/issues/1091)) ([60520d6](https://github.com/parse-community/Parse-SDK-Flutter/commit/60520d678b470dd04f125e1d207e1558b339acf7))
+
 # [flutter-v10.6.0](https://github.com/parse-community/Parse-SDK-Flutter/compare/flutter-10.5.0...flutter-10.6.0) (2025-11-30)