add a “latest” flag to article vertices

Author: tayloraswift

Package.resolved

@@ -599,7 +599,8 @@ extension Unidoc.DB
         try await self.trees.insert(mesh.trees)
 
         try await self.redirects.insert(mesh.redirects)
-        try await self.vertices.insert(mesh.vertices)
+        try await self.vertices.insert(mesh.vertices,
+            latest: mesh.metadata.latest)
         try await self.groups.insert(mesh.groups,
             realm: mesh.metadata.latest ? mesh.metadata.realm : nil)
 
@@ -654,7 +655,8 @@ extension Unidoc.DB
         alignment:
         if  let latest:Unidoc.Edition = mesh.latestRelease
         {
-            try await self.update(with: Volumes.AlignLatest.init(to: latest))
+            try await self.update(with: Vertices.VacuumLatest.init(around: latest))
+            try await self.update(with: Volumes.VacuumLatest.init(around: latest))
 
             guard
             let realm:Unidoc.Realm = mesh.metadata.realm

Sources/UnidocDB/Unidoc.DB.swift

@@ -0,0 +1,57 @@
+import MongoDB
+import MongoQL
+import Unidoc
+import UnidocRecords
+
+extension Unidoc.DB.Vertices
+{
+    struct VacuumLatest
+    {
+        let latest:Unidoc.Edition
+
+        init(around latest:Unidoc.Edition)
+        {
+            self.latest = latest
+        }
+    }
+}
+extension Unidoc.DB.Vertices.VacuumLatest:Mongo.UpdateQuery
+{
+    typealias Target = Unidoc.DB.Vertices
+    typealias Effect = Mongo.Many
+
+    var ordered:Bool { true }
+
+    func build(updates:inout Mongo.UpdateListEncoder<Mongo.Many>)
+    {
+        let latest:ClosedRange<Unidoc.Scalar> = .edition(self.latest)
+        let all:ClosedRange<Unidoc.Scalar> = .package(self.latest.package)
+
+        updates
+        {
+            $0[.multi] = true
+            $0[.hint] = Unidoc.DB.Vertices.indexLinkableFlag.id
+            $0[.q]
+            {
+                $0[.and]
+                {
+                    $0 { $0[Unidoc.AnyVertex[.linkable]] = true }
+                    $0 { $0[Unidoc.AnyVertex[.id]] { $0[.gte] = all.lowerBound } }
+                    $0 { $0[Unidoc.AnyVertex[.id]] { $0[.lte] = all.upperBound } }
+                    $0
+                    {
+                        $0[.or]
+                        {
+                            $0 { $0[Unidoc.AnyVertex[.id]] { $0[.lt] = latest.lowerBound } }
+                            $0 { $0[Unidoc.AnyVertex[.id]] { $0[.gt] = latest.upperBound } }
+                        }
+                    }
+                }
+            }
+            $0[.u]
+            {
+                $0[.unset] { $0[Unidoc.AnyVertex[.linkable]] = true }
+            }
+        }
+    }
+}

Sources/UnidocDB/Vertices/Unidoc.DB.Vertices.VacuumLatest.swift

@@ -23,8 +23,8 @@ extension Unidoc.DB
 }
 extension Unidoc.DB.Vertices
 {
-    public static
-    let indexStem:Mongo.CollectionIndex = .init("Stem",
+    public
+    static let indexStem:Mongo.CollectionIndex = .init("Stem",
         collation: .casefolding,
         unique: true)
     {
@@ -44,14 +44,33 @@ extension Unidoc.DB.Vertices
         $0[Unidoc.AnyVertex[.stem]] { $0[.exists] = true }
     }
 
-    public static
-    let indexHash:Mongo.CollectionIndex = .init("Hash",
+    public
+    static let indexHash:Mongo.CollectionIndex = .init("Hash",
         collation: .casefolding,
         unique: true)
     {
         $0[Unidoc.AnyVertex[.hash]] = (+)
         $0[Unidoc.AnyVertex[.id]] = (+)
     }
+
+    public
+    static let indexLinkableFlag:Mongo.CollectionIndex = .init("LinkableFlag",
+        unique: true)
+    {
+        $0[Unidoc.AnyVertex[.linkable]] = (+)
+        $0[Unidoc.AnyVertex[.id]] = (+)
+    }
+
+    public
+    static let indexLinkableStem:Mongo.CollectionIndex = .init("LinkableStem",
+        collation: .casefolding)
+    {
+        $0[Unidoc.AnyVertex[.stem]] = (+)
+    }
+        where:
+    {
+        $0[Unidoc.AnyVertex[.linkable]] = true
+    }
 }
 extension Unidoc.DB.Vertices:Mongo.CollectionModel
 {
@@ -64,13 +83,17 @@ extension Unidoc.DB.Vertices:Mongo.CollectionModel
     @inlinable public static
     var indexes:[Mongo.CollectionIndex] { [ Self.indexStem, Self.indexHash ] }
 }
+@available(*, unavailable, message: """
+    Vertices contain flags set by the database, which would be lost if they were decoded and \
+    re-encoded.
+    """)
 extension Unidoc.DB.Vertices:Mongo.RecodableModel
 {
 }
 extension Unidoc.DB.Vertices
 {
     @discardableResult
-    func insert(_ vertices:Unidoc.Mesh.Vertices) async throws -> Mongo.Insertions
+    func insert(_ vertices:Unidoc.Mesh.Vertices, latest:Bool) async throws -> Mongo.Insertions
     {
         let response:Mongo.InsertResponse = try await session.run(
             command: Mongo.Insert.init(Self.name,
@@ -80,7 +103,16 @@ extension Unidoc.DB.Vertices
             }
                 documents:
             {
-                $0 += vertices.articles.lazy.map(Unidoc.AnyVertex.article(_:))
+                for article:Unidoc.ArticleVertex in vertices.articles
+                {
+                    $0[Unidoc.AnyVertex.CodingKey.self]
+                    {
+                        Unidoc.AnyVertex.article(article).encode(to: &$0)
+
+                        $0[.linkable] = latest ? latest : nil
+                    }
+                }
+
                 $0 += vertices.cultures.lazy.map(Unidoc.AnyVertex.culture(_:))
                 $0 += vertices.decls.lazy.map(Unidoc.AnyVertex.decl(_:))
                 $0 += vertices.files.lazy.map(Unidoc.AnyVertex.file(_:))

Sources/UnidocDB/Vertices/Unidoc.DB.Vertices.swift

@@ -0,0 +1,49 @@
+import MongoDB
+import MongoQL
+import Unidoc
+import UnidocRecords
+
+extension Unidoc.DB.Volumes
+{
+    struct VacuumLatest
+    {
+        let latest:Unidoc.Edition
+
+        init(around latest:Unidoc.Edition)
+        {
+            self.latest = latest
+        }
+    }
+}
+extension Unidoc.DB.Volumes.VacuumLatest:Mongo.UpdateQuery
+{
+    typealias Target = Unidoc.DB.Volumes
+    typealias Effect = Mongo.Many
+
+    var ordered:Bool { false }
+
+    func build(updates:inout Mongo.UpdateListEncoder<Mongo.Many>)
+    {
+        updates
+        {
+            $0[.multi] = true
+            $0[.hint] = Unidoc.DB.Volumes.indexLatestFlag.id
+            $0[.q]
+            {
+                $0[.and]
+                {
+                    let cell:ClosedRange<Unidoc.Edition> = .package(self.latest.package)
+
+                    $0 { $0[Unidoc.VolumeMetadata[.latest]] = true }
+                    $0 { $0[Unidoc.VolumeMetadata[.id]] { $0[.gte] = cell.lowerBound } }
+                    $0 { $0[Unidoc.VolumeMetadata[.id]] { $0[.lte] = cell.upperBound } }
+                    $0 { $0[Unidoc.VolumeMetadata[.id]] { $0[.ne] = self.latest } }
+                }
+            }
+            $0[.u]
+            {
+                $0[.unset] { $0[Unidoc.VolumeMetadata[.latest]] = true }
+            }
+        }
+    }
+}