.

Author: JhonaCodes

lib/src/database/database_web_import.dart

@@ -0,0 +1,5 @@
+// Conditional import for web database
+// This ensures web code only compiles on web platform
+
+export 'database_web_stub.dart' // Default stub for non-web platforms
+    if (dart.library.html) 'database_web.dart'; // Real implementation for web

lib/src/database/database_web_stub.dart

@@ -0,0 +1,59 @@
+import '../model/local_db_error_model.dart';
+import '../model/local_db_request_model.dart';
+import '../service/local_db_result.dart';
+import 'database_interface.dart';
+
+/// Stub implementation for non-web platforms
+/// This prevents web code from being compiled on mobile/desktop
+class DatabaseWeb implements DatabaseInterface {
+  DatabaseWeb._();
+  
+  static final DatabaseWeb instance = DatabaseWeb._();
+
+  @override
+  bool get isSupported => false;
+
+  @override
+  String get platformName => 'web-stub';
+
+  @override
+  Future<void> initialize(String databaseName) async {
+    throw UnsupportedError('Web database is not supported on this platform');
+  }
+
+  @override
+  Future<bool> ensureConnectionValid() async => false;
+
+  @override
+  Future<void> closeDatabase() async {}
+
+  @override
+  Future<LocalDbResult<LocalDbModel, ErrorLocalDb>> post(LocalDbModel model) async {
+    return Err(ErrorLocalDb.databaseError('Web database not supported on this platform'));
+  }
+
+  @override
+  Future<LocalDbResult<LocalDbModel?, ErrorLocalDb>> getById(String id) async {
+    return Err(ErrorLocalDb.databaseError('Web database not supported on this platform'));
+  }
+
+  @override
+  Future<LocalDbResult<List<LocalDbModel>, ErrorLocalDb>> getAll() async {
+    return Err(ErrorLocalDb.databaseError('Web database not supported on this platform'));
+  }
+
+  @override
+  Future<LocalDbResult<LocalDbModel, ErrorLocalDb>> put(LocalDbModel model) async {
+    return Err(ErrorLocalDb.databaseError('Web database not supported on this platform'));
+  }
+
+  @override
+  Future<LocalDbResult<bool, ErrorLocalDb>> delete(String id) async {
+    return Err(ErrorLocalDb.databaseError('Web database not supported on this platform'));
+  }
+
+  @override
+  Future<LocalDbResult<bool, ErrorLocalDb>> cleanDatabase() async {
+    return Err(ErrorLocalDb.databaseError('Web database not supported on this platform'));
+  }
+}

test/platform_detection_test.dart

@@ -0,0 +1,114 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:flutter/foundation.dart' show kIsWeb;
+import 'package:flutter_local_db/flutter_local_db.dart';
+
+void main() {
+  group('Platform Detection Tests', () {
+    test('Should detect correct platform without compilation errors', () {
+      // This test verifies that the platform detection works
+      // and there are no compilation errors with conditional imports
+      
+      if (kIsWeb) {
+        // Running on web - should use IndexedDB implementation
+        expect(kIsWeb, true);
+        print('Test running on Web platform - IndexedDB should be used');
+      } else {
+        // Running on mobile/desktop - should use native implementation
+        expect(kIsWeb, false);
+        print('Test running on Native platform - Rust+RedB should be used');
+      }
+    });
+
+    test('Should initialize LocalDB without platform errors', () async {
+      // Test that initialization doesn't throw platform-specific errors
+      try {
+        if (kIsWeb) {
+          await LocalDB.init(localDbName: 'test_web_db');
+          print('Web initialization successful');
+        } else {
+          // For native platforms, we use initForTesting
+          await LocalDB.initForTesting(
+            localDbName: 'test_native.db',
+            binaryPath: '../flutter_local_db/macos/Frameworks/liboffline_first_core_arm64.dylib'
+          );
+          print('Native initialization successful');
+        }
+        
+        // If we reach here, initialization worked
+        expect(true, true);
+        
+      } catch (e) {
+        // Print detailed error for debugging
+        print('Platform detection or initialization error: $e');
+        // Only fail if it's an unexpected platform-related error
+        if (e.toString().contains('Web database not supported') && !kIsWeb) {
+          // This is expected behavior - web code on native platform
+          expect(true, true);
+        } else if (e.toString().contains('FFI is not supported') && kIsWeb) {
+          // This is expected behavior - native code on web platform
+          expect(true, true);
+        } else {
+          // Unexpected error - test should fail
+          fail('Unexpected platform error: $e');
+        }
+      }
+    });
+
+    test('Should handle cross-platform API calls gracefully', () async {
+      // Test that basic operations don't crash due to platform issues
+      try {
+        final testData = {'test': 'data', 'platform': kIsWeb ? 'web' : 'native'};
+        
+        // Try a basic operation - this should either work or fail gracefully
+        final result = await LocalDB.Post('platform-test', testData);
+        
+        if (result.isOk) {
+          print('Platform operation successful: ${result.data}');
+          expect(result.data.data['platform'], kIsWeb ? 'web' : 'native');
+          
+          // Clean up
+          await LocalDB.Delete('platform-test');
+        } else {
+          print('Platform operation failed as expected: ${result.errorOrNull}');
+          // This is acceptable - not all platforms may be fully set up in tests
+          expect(result.isErr, true);
+        }
+        
+      } catch (e) {
+        print('Platform API call error (may be expected): $e');
+        // Don't fail the test for platform-specific limitations
+        expect(e.toString(), isA<String>());
+      }
+    });
+
+    test('Should not import web code on native platforms', () {
+      // This test verifies that conditional imports work correctly
+      if (!kIsWeb) {
+        // On native platforms, web-specific code should not be compiled
+        print('Running on native platform - web code should be stubbed');
+        expect(kIsWeb, false);
+        
+        // Try to trigger any potential web import issues
+        expect(() {
+          // This should work without throwing web-related compilation errors
+          final platformName = kIsWeb ? 'web' : 'native';
+          return platformName;
+        }, returnsNormally);
+      }
+    });
+
+    test('Should not import native code on web platforms', () {
+      // This test verifies that native code doesn't cause issues on web
+      if (kIsWeb) {
+        print('Running on web platform - native FFI code should be avoided');
+        expect(kIsWeb, true);
+        
+        // Verify that web-specific behavior works
+        expect(() {
+          final platformName = kIsWeb ? 'web' : 'native';
+          return platformName;
+        }, returnsNormally);
+      }
+    });
+  });
+}