documents getLatestOf

Author: damian-molinski

catalyst_voices/packages/internal/catalyst_voices_repositories/lib/src/database/dao/documents_v2_dao.dart

@@ -35,6 +35,12 @@ abstract interface class DocumentsV2Dao {
   /// Returns null if no matching document is found.
   Future<DocumentEntityV2?> getDocument(DocumentRef ref);
 
+  /// Finds the latest version of a document.
+  ///
+  /// Takes a [ref] (which can be loose or exact) and returns a [DocumentRef]
+  /// pointing to the latest known version of that document.
+  Future<DocumentRef?> getLatestOf(DocumentRef ref);
+
   /// Saves a single document, ignoring if it conflicts on {id, ver}.
   ///
   /// Delegates to [saveAll] for consistent conflict handling and reuse.
@@ -146,6 +152,24 @@ class DriftDocumentsV2Dao extends DatabaseAccessor<DriftCatalystDatabase>
     return query.getSingleOrNull();
   }
 
+  @override
+  Future<DocumentRef?> getLatestOf(DocumentRef ref) {
+    final query = selectOnly(documentsV2)
+      ..addColumns([documentsV2.id, documentsV2.ver])
+      ..where(documentsV2.id.equals(ref.id))
+      ..orderBy([OrderingTerm.desc(documentsV2.createdAt)])
+      ..limit(1);
+
+    return query
+        .map(
+          (row) => SignedDocumentRef.exact(
+            id: row.read(documentsV2.id)!,
+            version: row.read(documentsV2.ver)!,
+          ),
+        )
+        .getSingleOrNull();
+  }
+
   @override
   Future<void> save(DocumentWithAuthorsEntity entity) => saveAll([entity]);
 

catalyst_voices/packages/internal/catalyst_voices_repositories/lib/src/document/document_repository.dart

@@ -85,6 +85,9 @@ abstract interface class DocumentRepository {
     CatalystId? authorId,
   });
 
+  /// Returns latest matching [DocumentRef] version with same id as [ref].
+  Future<DocumentRef?> getLatestOf({required DocumentRef ref});
+
   /// Returns count of documents matching [ref] id and [type].
   Future<int> getRefCount({
     required DocumentRef ref,
@@ -320,6 +323,17 @@ final class DocumentRepositoryImpl implements DocumentRepository {
     return [latestDocument, latestDraft].nonNulls.sorted((a, b) => a.compareTo(b)).firstOrNull;
   }
 
+  // TODO(damian-molinski): consider also checking with remote source.
+  @override
+  Future<DocumentRef?> getLatestOf({required DocumentRef ref}) async {
+    final draft = await _drafts.getLatestOf(ref: ref);
+    if (draft != null) {
+      return draft;
+    }
+
+    return _localDocuments.getLatestOf(ref: ref);
+  }
+
   @override
   Future<int> getRefCount({
     required DocumentRef ref,

catalyst_voices/packages/internal/catalyst_voices_repositories/lib/src/document/source/database_documents_data_source.dart

@@ -69,6 +69,11 @@ final class DatabaseDocumentsDataSource
         .then((value) => value?.toModel());
   }
 
+  @override
+  Future<DocumentRef?> getLatestOf({required DocumentRef ref}) {
+    return _database.documentsV2Dao.getLatestOf(ref);
+  }
+
   @override
   Future<List<ProposalDocumentData>> getProposals({
     SignedDocumentRef? categoryRef,

catalyst_voices/packages/internal/catalyst_voices_repositories/lib/src/document/source/database_drafts_data_source.dart

@@ -50,6 +50,12 @@ final class DatabaseDraftsDataSource implements DraftDataSource {
     return _database.draftsDao.queryLatest(authorId: authorId).then((value) => value?.toModel());
   }
 
+  @override
+  Future<DocumentRef?> getLatestOf({required DocumentRef ref}) async {
+    // TODO(damian-molinski): not implemented
+    return null;
+  }
+
   @override
   Future<List<DocumentData>> queryVersionsOfId({required String id}) async {
     final documentEntities = await _database.draftsDao.queryVersionsOfId(id: id);

catalyst_voices/packages/internal/catalyst_voices_repositories/lib/src/document/source/document_data_remote_source.dart

@@ -30,6 +30,16 @@ final class CatGatewayDocumentDataSource implements DocumentDataRemoteSource {
     return DocumentDataFactory.create(signedDocument);
   }
 
+  @override
+  Future<DocumentRef?> getLatestOf({required DocumentRef ref}) async {
+    final ver = await getLatestVersion(ref.id);
+    if (ver == null) {
+      return null;
+    }
+
+    return SignedDocumentRef(id: ref.id, version: ver);
+  }
+
   @override
   Future<String?> getLatestVersion(String id) {
     final ver = allConstantDocumentRefs

catalyst_voices/packages/internal/catalyst_voices_repositories/lib/src/document/source/document_data_source.dart

@@ -3,4 +3,6 @@ import 'package:catalyst_voices_models/catalyst_voices_models.dart';
 //ignore: one_member_abstracts
 abstract interface class DocumentDataSource {
   Future<DocumentData> get({required DocumentRef ref});
+
+  Future<DocumentRef?> getLatestOf({required DocumentRef ref});
 }

catalyst_voices/packages/internal/catalyst_voices_repositories/test/src/database/dao/documents_v2_dao_test.dart

@@ -892,6 +892,124 @@ void main() {
         await expectation;
       });
     });
+
+    group('getLatestOf', () {
+      test('returns null for non-existing id in empty database', () async {
+        // Given
+        const ref = SignedDocumentRef.exact(id: 'non-existent-id', version: 'non-existent-ver');
+
+        // When
+        final result = await dao.getLatestOf(ref);
+
+        // Then
+        expect(result, isNull);
+      });
+
+      test('returns the document ref when only one version exists', () async {
+        // Given
+        final entity = _createTestDocumentEntity(id: 'test-id', ver: 'test-ver');
+        await dao.save(entity);
+
+        // And
+        const ref = SignedDocumentRef.loose(id: 'test-id');
+
+        // When
+        final result = await dao.getLatestOf(ref);
+
+        // Then
+        expect(result, isNotNull);
+        expect(result!.id, 'test-id');
+        expect(result.version, 'test-ver');
+        expect(result.isExact, isTrue);
+      });
+
+      test('returns latest version when multiple versions exist (loose ref input)', () async {
+        // Given
+        final oldCreatedAt = DateTime.utc(2023, 1, 1);
+        final newerCreatedAt = DateTime.utc(2024, 6, 15);
+
+        final oldVer = _buildUuidV7At(oldCreatedAt);
+        final newerVer = _buildUuidV7At(newerCreatedAt);
+        final entityOld = _createTestDocumentEntity(id: 'test-id', ver: oldVer);
+        final entityNew = _createTestDocumentEntity(id: 'test-id', ver: newerVer);
+        await dao.saveAll([entityOld, entityNew]);
+
+        // And
+        const ref = SignedDocumentRef.loose(id: 'test-id');
+
+        // When
+        final result = await dao.getLatestOf(ref);
+
+        // Then
+        expect(result, isNotNull);
+        expect(result!.id, 'test-id');
+        expect(result.version, newerVer);
+      });
+
+      test('returns latest version even when exact ref points to older version', () async {
+        // Given
+        final oldCreatedAt = DateTime.utc(2023, 1, 1);
+        final newerCreatedAt = DateTime.utc(2024, 6, 15);
+
+        final oldVer = _buildUuidV7At(oldCreatedAt);
+        final newerVer = _buildUuidV7At(newerCreatedAt);
+        final entityOld = _createTestDocumentEntity(id: 'test-id', ver: oldVer);
+        final entityNew = _createTestDocumentEntity(id: 'test-id', ver: newerVer);
+        await dao.saveAll([entityOld, entityNew]);
+
+        // And: exact ref pointing to older version
+        final ref = SignedDocumentRef.exact(id: 'test-id', version: oldVer);
+
+        // When
+        final result = await dao.getLatestOf(ref);
+
+        // Then: still returns the latest version
+        expect(result, isNotNull);
+        expect(result!.id, 'test-id');
+        expect(result.version, newerVer);
+      });
+
+      test('returns null for non-existing id when other documents exist', () async {
+        // Given
+        final entity = _createTestDocumentEntity(id: 'other-id', ver: 'other-ver');
+        await dao.save(entity);
+
+        // And
+        const ref = SignedDocumentRef.loose(id: 'non-existent-id');
+
+        // When
+        final result = await dao.getLatestOf(ref);
+
+        // Then
+        expect(result, isNull);
+      });
+
+      test('returns latest among many versions', () async {
+        // Given
+        final dates = [
+          DateTime.utc(2023, 1, 1),
+          DateTime.utc(2023, 6, 15),
+          DateTime.utc(2024, 3, 10),
+          DateTime.utc(2024, 12, 25),
+          DateTime.utc(2024, 8, 1),
+        ];
+        final versions = dates.map(_buildUuidV7At).toList();
+        final entities = versions
+            .map((ver) => _createTestDocumentEntity(id: 'multi-ver-id', ver: ver))
+            .toList();
+        await dao.saveAll(entities);
+
+        // And
+        const ref = SignedDocumentRef.loose(id: 'multi-ver-id');
+
+        // When
+        final result = await dao.getLatestOf(ref);
+
+        // Then: returns the version with latest createdAt (2024-12-25)
+        expect(result, isNotNull);
+        expect(result!.version, versions[3]);
+      });
+    });
   });
 }
 

catalyst_voices/packages/internal/catalyst_voices_services/lib/src/proposal/proposal_service.dart

@@ -250,17 +250,13 @@ final class ProposalServiceImpl implements ProposalService {
   }
 
   @override
-  Future<DocumentRef> getLatestProposalVersion({
-    required DocumentRef ref,
-  }) async {
-    final proposalVersions = await _documentRepository.getAllVersionsOfId(
-      id: ref.id,
-    );
-    final refList = List<DocumentRef>.from(
-      proposalVersions.map((e) => e.metadata.selfRef).toList(),
-    )..sort();
+  Future<DocumentRef> getLatestProposalVersion({required DocumentRef ref}) async {
+    final latest = await _documentRepository.getLatestOf(ref: ref);
+    if (latest == null) {
+      throw DocumentNotFoundException(ref: ref);
+    }
 
-    return refList.last;
+    return latest;
   }
 
   @override