3-way diff

package.yaml

@@ -115,6 +115,7 @@ dependencies:
 - share-auth
 - unison-hashing-v2
 - unison-codebase-sqlite-hashing-v2
+- unison-merge
 - unison-parser-typechecker
 - unison-prelude
 - unison-pretty-printer

share-api.cabal

@@ -46,6 +46,7 @@ library
       Share.IDs
       Share.Metrics
       Share.Monitoring
+      Share.Names.Postgres
       Share.NamespaceDiffs
       Share.Postgres
       Share.Postgres.Admin
@@ -85,6 +86,7 @@ library
       Share.Postgres.Users.Queries
       Share.Prelude
       Share.Prelude.Orphans
+      Share.PrettyPrintEnvDecl.Postgres
       Share.Project
       Share.Redis
       Share.Release
@@ -170,7 +172,6 @@ library
       Share.Web.UCM.SyncV2.Impl
       Share.Web.UCM.SyncV2.Queries
       Share.Web.UCM.SyncV2.Types
-      Unison.PrettyPrintEnvDecl.Postgres
       Unison.Server.NameSearch.Postgres
       Unison.Server.Share.Definitions
       Unison.Server.Share.DefinitionSummary
@@ -295,6 +296,7 @@ library
     , unison-core1
     , unison-hash
     , unison-hashing-v2
+    , unison-merge
     , unison-parser-typechecker
     , unison-prelude
     , unison-pretty-printer
@@ -445,6 +447,7 @@ executable share-api
     , unison-core1
     , unison-hash
     , unison-hashing-v2
+    , unison-merge
     , unison-parser-typechecker
     , unison-prelude
     , unison-pretty-printer

sql/2025-02-12_namespace_diff_key.sql

@@ -0,0 +1,17 @@
+-- Recreate namespace diffs table, since we're changing a foreign key reference
+-- Could truncate and alter columns instead, but it's more work
+
+DROP TABLE namespace_diffs;
+
+CREATE TABLE namespace_diffs (
+    left_causal_id INTEGER NOT NULL REFERENCES causals(id) ON DELETE CASCADE,
+    right_causal_id INTEGER NOT NULL REFERENCES causals(id) ON DELETE CASCADE,
+
+    -- Since different codebases can have different variable names and such we also need to sandbox diffs by codebase owner
+    left_codebase_owner_user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+    right_codebase_owner_user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+
+    diff JSONB NOT NULL,
+
+    PRIMARY KEY (left_causal_id, right_causal_id, left_codebase_owner_user_id, right_codebase_owner_user_id)
+);

src/Share/BackgroundJobs.hs

@@ -1,14 +1,15 @@
 module Share.BackgroundJobs (startWorkers) where
 
 import Ki.Unlifted qualified as Ki
+import Share.BackgroundJobs.Diffs.ContributionDiffs qualified as ContributionDiffs
 import Share.BackgroundJobs.Monad (Background)
 import Share.BackgroundJobs.Search.DefinitionSync qualified as DefnSearch
 
 -- | Kicks off all background workers.
 startWorkers :: Ki.Scope -> Background ()
 startWorkers scope = do
   DefnSearch.worker scope
+  ContributionDiffs.worker scope
 
 -- Temporary disable background diff jobs until the new diffing logic is done.
--- ContributionDiffs.worker scope
 -- SerializedEntitiesMigration.worker scope

src/Share/BackgroundJobs/Diffs/ContributionDiffs.hs

@@ -53,17 +53,18 @@ processDiffs authZReceipt = Metrics.recordContributionDiffDuration . runExceptT
 
 diffContribution :: AuthZ.AuthZReceipt -> ContributionId -> ExceptT NamespaceDiffError Background ()
 diffContribution authZReceipt contributionId = do
-  ( project,
+  ( bestCommonAncestorCausalId,
+    project,
     newBranch@Branch {causal = newBranchCausalId},
     oldBranch@Branch {causal = oldBranchCausalId}
     ) <- ExceptT $ PG.tryRunTransaction $ do
-    Contribution {sourceBranchId = newBranchId, targetBranchId = oldBranchId, projectId} <- ContributionsQ.contributionById contributionId `whenNothingM` throwError (MissingEntityError $ EntityMissing (ErrorID "contribution:missing") "Contribution not found")
+    Contribution {bestCommonAncestorCausalId, sourceBranchId = newBranchId, targetBranchId = oldBranchId, projectId} <- ContributionsQ.contributionById contributionId `whenNothingM` throwError (MissingEntityError $ EntityMissing (ErrorID "contribution:missing") "Contribution not found")
     project <- Q.projectById projectId `whenNothingM` throwError (MissingEntityError $ EntityMissing (ErrorID "project:missing") "Project not found")
     newBranch <- Q.branchById newBranchId `whenNothingM` throwError (MissingEntityError $ EntityMissing (ErrorID "branch:missing") "Source branch not found")
     oldBranch <- Q.branchById oldBranchId `whenNothingM` throwError (MissingEntityError $ EntityMissing (ErrorID "branch:missing") "Target branch not found")
-    pure (project, newBranch, oldBranch)
+    pure (bestCommonAncestorCausalId, project, newBranch, oldBranch)
   let oldCodebase = Codebase.codebaseForProjectBranch authZReceipt project oldBranch
   let newCodebase = Codebase.codebaseForProjectBranch authZReceipt project newBranch
   -- This method saves the diff so it'll be there when we need it, so we don't need to do anything with it.
-  _ <- Diffs.diffCausals authZReceipt (oldCodebase, oldBranchCausalId) (newCodebase, newBranchCausalId)
+  _ <- Diffs.diffCausals authZReceipt (oldCodebase, oldBranchCausalId) (newCodebase, newBranchCausalId) bestCommonAncestorCausalId
   pure ()

src/Share/BackgroundJobs/Search/DefinitionSync.hs

@@ -36,6 +36,7 @@ import Share.Postgres.Queries qualified as PG
 import Share.Postgres.Releases.Queries qualified as RQ
 import Share.Postgres.Search.DefinitionSearch.Queries qualified as DDQ
 import Share.Prelude
+import Share.PrettyPrintEnvDecl.Postgres qualified as PPEPostgres
 import Share.Project (Project (..))
 import Share.Release (Release (..))
 import Share.Utils.Logging qualified as Logging
@@ -52,7 +53,6 @@ import Unison.Name qualified as Name
 import Unison.NameSegment (libSegment)
 import Unison.PrettyPrintEnv qualified as PPE
 import Unison.PrettyPrintEnvDecl qualified as PPED
-import Unison.PrettyPrintEnvDecl.Postgres qualified as PPEPostgres
 import Unison.Reference (TypeReference)
 import Unison.Reference qualified as Reference
 import Unison.Server.Share.DefinitionSummary qualified as Summary
@@ -124,10 +124,10 @@ syncRelease authZReceipt releaseId = fmap (fromMaybe []) . runMaybeT $ do
     let codebaseLoc = Codebase.codebaseLocationForProjectRelease ownerUserId
     let codebase = Codebase.codebaseEnv authZReceipt codebaseLoc
     Codebase.codebaseMToTransaction codebase $ do
-      termsCursor <- lift $ NLOps.termsWithinNamespace nlReceipt bhId
+      termsCursor <- lift $ NLOps.projectTermsWithinRoot nlReceipt bhId
 
       termErrs <- syncTerms namesPerspective bhId projectId releaseId termsCursor
-      typesCursor <- lift $ NLOps.typesWithinNamespace nlReceipt bhId
+      typesCursor <- lift $ NLOps.projectTypesWithinRoot nlReceipt bhId
       typeErrs <- syncTypes namesPerspective projectId releaseId typesCursor
       pure (termErrs <> typeErrs)
 

src/Share/Codebase.hs

@@ -31,6 +31,7 @@ module Share.Codebase
     expectTypeOfTerms,
     expectTypeOfReferent,
     expectTypeOfReferents,
+    expectTypeOfConstructor,
     loadTypeOfConstructor,
     loadTypeOfReferent,
     loadTypeDeclaration,

src/Share/Names/Postgres.hs

@@ -0,0 +1,38 @@
+-- | Efficiently fetch a Names object for a given set of labeled dependencies.
+module Share.Names.Postgres (namesForReferences) where
+
+import Control.Lens
+import Data.Set qualified as Set
+import Share.Postgres qualified as PG
+import Share.Postgres.NameLookups.Conversions qualified as CV
+import Share.Postgres.NameLookups.Ops qualified as NameLookupOps
+import Share.Postgres.NameLookups.Types (NamesPerspective)
+import Share.Postgres.NameLookups.Types qualified as NameLookups
+import Share.Postgres.Refs.Types
+import Share.Prelude
+import Unison.LabeledDependency (LabeledDependency)
+import Unison.Name (Name)
+import Unison.Names (Names)
+import Unison.Names qualified as Names
+import Unison.Reference qualified as V1
+import Unison.Referent qualified as V1
+
+namesForReferences :: forall m. (PG.QueryM m) => NamesPerspective -> Set LabeledDependency -> m Names
+namesForReferences namesPerspective refs = do
+  withPGRefs <-
+    Set.toList refs
+      & CV.labeledDependencies1ToPG
+  (termNames, typeNames) <- foldMapM namesForReference withPGRefs
+  pure $ Names.fromTermsAndTypes termNames typeNames
+  where
+    -- TODO: Can probably speed this up by skipping suffixification.
+    namesForReference :: Either (V1.Referent, PGReferent) (V1.Reference, PGReference) -> m ([(Name, V1.Referent)], [(Name, V1.Reference)])
+    namesForReference = \case
+      Left (ref, pgref) -> do
+        termNames <- fmap (bothMap NameLookups.reversedNameToName) <$> NameLookupOps.termNamesForRefWithinNamespace namesPerspective pgref Nothing
+        let termNames' = termNames <&> \(fqn, _suffixed) -> (fqn, ref)
+        pure $ (termNames', [])
+      Right (ref, pgref) -> do
+        typeNames <- fmap (bothMap NameLookups.reversedNameToName) <$> NameLookupOps.typeNamesForRefWithinNamespace namesPerspective pgref Nothing
+        let typeNames' = typeNames <&> \(fqn, _suffixed) -> (fqn, ref)
+        pure $ ([], typeNames')