feat(import): persist MacDive dive/site metadata to DB

ericgriffin · ericgriffin · commit 1cc0b6247e20 · 2026-04-22T22:14:27.000-04:00
Adds 7 new columns on dives and dive_sites for previously
extract-but-discard fields:
- dives: dive_number_of_day, boat_name, boat_captain, dive_operator,
  surface_conditions
- dive_sites: water_type, body_of_water

Also wires the existing weather_description column for UDDF imports
(populated from MacDive &lt;weather&gt;). The importer calls narrow new
applyImportedMetadata helpers on DiveRepository and SiteRepository so
the new columns ride along with the existing repository-created rows
without needing entity field churn (copyWith, equatable, sync serialiser).

Schema v70 -&gt; v71 with an idempotent migration guarded by PRAGMA
introspection, matching the v69/v70 house style. Closes the parser-to-DB
gap for the MacDive extended fields extracted in Milestone 1 Tasks 5-6.
diff --git a/lib/core/database/database.dart b/lib/core/database/database.dart
@@ -126,6 +126,12 @@ class Dives extends Table {
       text().withDefault(const Constant('recreational'))();
   TextColumn get buddy => text().nullable()();
   TextColumn get diveMaster => text().nullable()();
+  // MacDive import fields — common dive metadata
+  IntColumn get diveNumberOfDay => integer().nullable()();
+  TextColumn get boatName => text().nullable()();
+  TextColumn get boatCaptain => text().nullable()();
+  TextColumn get diveOperator => text().nullable()();
+  TextColumn get surfaceConditions => text().nullable()();
   TextColumn get notes => text().withDefault(const Constant(''))();
   TextColumn get siteId => text().nullable().references(DiveSites, #id)();
   IntColumn get rating => integer().nullable()();
@@ -300,6 +306,9 @@ class DiveSites extends Table {
   RealColumn get maxDepth => real().nullable()(); // Deepest point
   TextColumn get difficulty =>
       text().nullable()(); // Beginner, Intermediate, Advanced, Technical
+  // MacDive site metadata
+  TextColumn get waterType => text().nullable()();
+  TextColumn get bodyOfWater => text().nullable()();
   TextColumn get country => text().nullable()();
   TextColumn get region => text().nullable()();
   RealColumn get rating => real().nullable()();
@@ -1327,7 +1336,7 @@ class AppDatabase extends _$AppDatabase {
 
   /// The current schema version as a static constant so that pre-open checks
   /// (e.g. version-mismatch guard) can reference it without an instance.
-  static const int currentSchemaVersion = 70;
+  static const int currentSchemaVersion = 71;
 
   /// Every schema version that has a migration block in onUpgrade.
   /// Used to calculate progress step counts. When adding a new migration,
@@ -1401,6 +1410,7 @@ class AppDatabase extends _$AppDatabase {
     68,
     69,
     70,
+    71,
   ];
 
   /// Returns the number of migration steps that will execute when upgrading
@@ -3265,6 +3275,61 @@ class AppDatabase extends _$AppDatabase {
           }
         }
         if (from < 70) await reportProgress();
+        if (from < 71) {
+          // Migration 71: add MacDive dive + site metadata fields.
+          final divesCols = await customSelect(
+            "PRAGMA table_info('dives')",
+          ).get();
+          final divesExisting = divesCols
+              .map((r) => r.data['name'] as String)
+              .toSet();
+          if (divesCols.isNotEmpty) {
+            if (!divesExisting.contains('dive_number_of_day')) {
+              await customStatement(
+                'ALTER TABLE dives ADD COLUMN dive_number_of_day INTEGER',
+              );
+            }
+            if (!divesExisting.contains('boat_name')) {
+              await customStatement(
+                'ALTER TABLE dives ADD COLUMN boat_name TEXT',
+              );
+            }
+            if (!divesExisting.contains('boat_captain')) {
+              await customStatement(
+                'ALTER TABLE dives ADD COLUMN boat_captain TEXT',
+              );
+            }
+            if (!divesExisting.contains('dive_operator')) {
+              await customStatement(
+                'ALTER TABLE dives ADD COLUMN dive_operator TEXT',
+              );
+            }
+            if (!divesExisting.contains('surface_conditions')) {
+              await customStatement(
+                'ALTER TABLE dives ADD COLUMN surface_conditions TEXT',
+              );
+            }
+          }
+          final sitesCols = await customSelect(
+            "PRAGMA table_info('dive_sites')",
+          ).get();
+          final sitesExisting = sitesCols
+              .map((r) => r.data['name'] as String)
+              .toSet();
+          if (sitesCols.isNotEmpty) {
+            if (!sitesExisting.contains('water_type')) {
+              await customStatement(
+                'ALTER TABLE dive_sites ADD COLUMN water_type TEXT',
+              );
+            }
+            if (!sitesExisting.contains('body_of_water')) {
+              await customStatement(
+                'ALTER TABLE dive_sites ADD COLUMN body_of_water TEXT',
+              );
+            }
+          }
+        }
+        if (from < 71) await reportProgress();
       },
       beforeOpen: (details) async {
         // Enable foreign keys
diff --git a/lib/features/dive_import/data/services/uddf_entity_importer.dart b/lib/features/dive_import/data/services/uddf_entity_importer.dart
@@ -1,7 +1,7 @@
 import 'package:drift/drift.dart' show Value;
 import 'package:submersion/core/constants/enums.dart';
 import 'package:submersion/core/database/database.dart'
-    show DiveDataSourcesCompanion;
+    show DiveDataSourcesCompanion, DiveSitesCompanion, DivesCompanion;
 import 'package:submersion/core/services/export/export_service.dart';
 import 'package:submersion/core/services/location_service.dart';
 import 'package:submersion/core/services/logger_service.dart';
@@ -813,6 +813,21 @@ class UddfEntityImporter {
       );
 
       final createdSite = await repository.createSite(newSite);
+
+      // Write MacDive site metadata columns that don't flow through the
+      // DiveSite domain entity. Only set columns when source provides a value.
+      final waterType = siteData['waterType'] as String?;
+      final bodyOfWater = siteData['bodyOfWater'] as String?;
+      if (waterType != null || bodyOfWater != null) {
+        await repository.applyImportedMetadata(
+          createdSite.id,
+          DiveSitesCompanion(
+            waterType: Value(waterType),
+            bodyOfWater: Value(bodyOfWater),
+          ),
+        );
+      }
+
       if (uddfId != null) idMapping[uddfId] = createdSite;
       count++;
       onProgress?.call(ImportPhase.sites, count, selected.length);
@@ -1188,6 +1203,35 @@ class UddfEntityImporter {
       await repos.diveRepository.createDive(dive);
       importedDiveIds.add(diveId);
 
+      // Write MacDive dive metadata columns that don't flow through the Dive
+      // domain entity. Also plug `weather` into the existing weatherDescription
+      // column (it wasn't being populated for UDDF imports). Only issue the
+      // UPDATE when at least one value is present to avoid a no-op write.
+      final diveNumberOfDay = diveData['diveNumberOfDay'] as int?;
+      final boatName = diveData['boatName'] as String?;
+      final boatCaptain = diveData['boatCaptain'] as String?;
+      final diveOperator = diveData['diveOperator'] as String?;
+      final surfaceConditions = diveData['surfaceConditions'] as String?;
+      final weather = diveData['weather'] as String?;
+      if (diveNumberOfDay != null ||
+          boatName != null ||
+          boatCaptain != null ||
+          diveOperator != null ||
+          surfaceConditions != null ||
+          weather != null) {
+        await repos.diveRepository.applyImportedMetadata(
+          diveId,
+          DivesCompanion(
+            diveNumberOfDay: Value(diveNumberOfDay),
+            boatName: Value(boatName),
+            boatCaptain: Value(boatCaptain),
+            diveOperator: Value(diveOperator),
+            surfaceConditions: Value(surfaceConditions),
+            weatherDescription: Value(weather),
+          ),
+        );
+      }
+
       // Store per-tank pressure data
       if (profileData != null && tanks.isNotEmpty) {
         await _storeTankPressures(
diff --git a/lib/features/dive_log/data/repositories/dive_repository_impl.dart b/lib/features/dive_log/data/repositories/dive_repository_impl.dart
@@ -3573,6 +3573,37 @@ class DiveRepository {
     }
   }
 
+  /// Apply a partial [DivesCompanion] update to a dive row.
+  ///
+  /// Used by the UDDF importer to persist fields that do not flow through
+  /// the [domain.Dive] entity (e.g. MacDive boat/operator/weather metadata).
+  /// Only columns set on [patch] are written; others are left untouched.
+  /// Marks the row pending for sync.
+  Future<void> applyImportedMetadata(
+    String diveId,
+    DivesCompanion patch,
+  ) async {
+    try {
+      final now = DateTime.now().millisecondsSinceEpoch;
+      await (_db.update(_db.dives)..where((t) => t.id.equals(diveId))).write(
+        patch.copyWith(updatedAt: Value(now)),
+      );
+      await _syncRepository.markRecordPending(
+        entityType: 'dives',
+        recordId: diveId,
+        localUpdatedAt: now,
+      );
+      SyncEventBus.notifyLocalChange();
+    } catch (e, stackTrace) {
+      _log.error(
+        'Failed to apply imported metadata to dive: $diveId',
+        error: e,
+        stackTrace: stackTrace,
+      );
+      rethrow;
+    }
+  }
+
   /// Insert a new computer reading snapshot.
   Future<void> saveComputerReading(DiveDataSourcesCompanion reading) async {
     try {
diff --git a/lib/features/dive_sites/data/repositories/site_repository_impl.dart b/lib/features/dive_sites/data/repositories/site_repository_impl.dart
@@ -153,6 +153,36 @@ class SiteRepository {
     }
   }
 
+  /// Apply a partial [DiveSitesCompanion] update to a site row.
+  ///
+  /// Used by the UDDF importer to persist columns that do not flow through
+  /// the [domain.DiveSite] entity (e.g. MacDive waterType / bodyOfWater).
+  /// Only columns set on [patch] are written; others are left untouched.
+  /// Marks the row pending for sync.
+  Future<void> applyImportedMetadata(
+    String siteId,
+    DiveSitesCompanion patch,
+  ) async {
+    try {
+      final now = DateTime.now().millisecondsSinceEpoch;
+      await (_db.update(_db.diveSites)..where((t) => t.id.equals(siteId)))
+          .write(patch.copyWith(updatedAt: Value(now)));
+      await _syncRepository.markRecordPending(
+        entityType: 'diveSites',
+        recordId: siteId,
+        localUpdatedAt: now,
+      );
+      SyncEventBus.notifyLocalChange();
+    } catch (e, stackTrace) {
+      _log.error(
+        'Failed to apply imported metadata to site: $siteId',
+        error: e,
+        stackTrace: stackTrace,
+      );
+      rethrow;
+    }
+  }
+
   /// Flip the shared state of a single site. Marks it pending for sync.
   Future<void> setShared(String id, bool isShared) async {
     try {
diff --git a/test/core/database/migration_v71_test.dart b/test/core/database/migration_v71_test.dart
@@ -0,0 +1,117 @@
+import 'package:drift/native.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:submersion/core/database/database.dart';
+
+void main() {
+  group('Migration v71 - MacDive dive + site metadata columns', () {
+    /// Creates an in-memory database at v70 (pre-migration) with the dives
+    /// and dive_sites tables the v71 migration touches.
+    ///
+    /// Only the parent tables and the two columns-of-interest tables are
+    /// created; the migration must cope with missing ancillary tables as it
+    /// runs in older migration contexts.
+    NativeDatabase setupDb() {
+      return NativeDatabase.memory(
+        setup: (rawDb) {
+          rawDb.execute('PRAGMA foreign_keys = ON');
+          rawDb.execute('PRAGMA user_version = 70');
+
+          // v70 schema: minimal columns present before v71 -- no MacDive
+          // metadata. Only what's needed for the PRAGMA introspection to
+          // find the tables and the ALTER TABLE statements to succeed.
+          rawDb.execute('''
+            CREATE TABLE dives (
+              id TEXT NOT NULL PRIMARY KEY,
+              dive_date_time INTEGER NOT NULL DEFAULT 0,
+              dive_type TEXT NOT NULL DEFAULT 'recreational',
+              notes TEXT NOT NULL DEFAULT '',
+              is_favorite INTEGER NOT NULL DEFAULT 0,
+              dive_mode TEXT NOT NULL DEFAULT 'oc',
+              cns_start REAL NOT NULL DEFAULT 0,
+              is_planned INTEGER NOT NULL DEFAULT 0,
+              created_at INTEGER NOT NULL,
+              updated_at INTEGER NOT NULL
+            )
+          ''');
+          rawDb.execute('''
+            CREATE TABLE dive_sites (
+              id TEXT NOT NULL PRIMARY KEY,
+              name TEXT NOT NULL,
+              description TEXT NOT NULL DEFAULT '',
+              notes TEXT NOT NULL DEFAULT '',
+              is_shared INTEGER NOT NULL DEFAULT 0,
+              created_at INTEGER NOT NULL,
+              updated_at INTEGER NOT NULL
+            )
+          ''');
+        },
+      );
+    }
+
+    test('fresh database has MacDive dive columns on dives table', () async {
+      final db = AppDatabase(NativeDatabase.memory());
+      addTearDown(db.close);
+
+      final cols = await db.customSelect("PRAGMA table_info('dives')").get();
+      final names = cols.map((c) => c.read<String>('name')).toSet();
+
+      expect(names, contains('dive_number_of_day'));
+      expect(names, contains('boat_name'));
+      expect(names, contains('boat_captain'));
+      expect(names, contains('dive_operator'));
+      expect(names, contains('surface_conditions'));
+    });
+
+    test(
+      'fresh database has MacDive site columns on dive_sites table',
+      () async {
+        final db = AppDatabase(NativeDatabase.memory());
+        addTearDown(db.close);
+
+        final cols = await db
+            .customSelect("PRAGMA table_info('dive_sites')")
+            .get();
+        final names = cols.map((c) => c.read<String>('name')).toSet();
+
+        expect(names, contains('water_type'));
+        expect(names, contains('body_of_water'));
+      },
+    );
+
+    test(
+      'v70 -> v71 migration adds MacDive dive columns idempotently',
+      () async {
+        final nativeDb = setupDb();
+        final db = AppDatabase(nativeDb);
+        addTearDown(db.close);
+
+        // Opening the database triggers migration from v70 to v71.
+        final cols = await db.customSelect("PRAGMA table_info('dives')").get();
+        final names = cols.map((c) => c.read<String>('name')).toSet();
+
+        expect(names, contains('dive_number_of_day'));
+        expect(names, contains('boat_name'));
+        expect(names, contains('boat_captain'));
+        expect(names, contains('dive_operator'));
+        expect(names, contains('surface_conditions'));
+      },
+    );
+
+    test(
+      'v70 -> v71 migration adds MacDive site columns idempotently',
+      () async {
+        final nativeDb = setupDb();
+        final db = AppDatabase(nativeDb);
+        addTearDown(db.close);
+
+        final cols = await db
+            .customSelect("PRAGMA table_info('dive_sites')")
+            .get();
+        final names = cols.map((c) => c.read<String>('name')).toSet();
+
+        expect(names, contains('water_type'));
+        expect(names, contains('body_of_water'));
+      },
+    );
+  });
+}
diff --git a/test/features/dive_import/uddf_import_macdive_fields_test.dart b/test/features/dive_import/uddf_import_macdive_fields_test.dart
