-- SPDX-FileCopyrightText: 2026 Alexandra de Wit
--
-- SPDX-License-Identifier: MIT

{- | Shared outbound document assembly, paired with inbound "Ecluse.Core.Registry.WireSupport".
Ecosystem adapters own their wire shapes and reuse these name and location gates.
-}
module Ecluse.Core.Registry.ServedDocument (
    -- * The cached-document boundary
    assembleAcross,
    serialiseAcross,
    RenderRefused (..),

    -- * Replaying a merge plan
    overlaySurvivors,
    uniqueEntries,
    overlayObjectSurvivors,
    overlayObjectSources,

    -- * The interpolated-name gate
    safeDocumentName,

    -- * Rebasing an artifact location
    rebaseArtifactUrl,
    artifactUrlPacked,

    -- * Reading and editing a raw document
    documentObject,
    stringField,
    objectField,
    adjustField,
) where

import Data.Aeson (Encoding, Value (Object, String))
import Data.Aeson.Encoding (emptyObject_, encodingToLazyByteString)
import Data.Aeson.Key qualified as Key
import Data.Aeson.KeyMap (KeyMap)
import Data.Aeson.KeyMap qualified as KeyMap
import Data.Map.Strict qualified as Map
import Data.Text qualified as T
import Data.Vector (Vector)
import Data.Vector qualified as V
import Data.Vector.Mutable qualified as MV

import Ecluse.Core.Package.Entry (AdmittedEntry (..), EntryKey (..), validEntryKey)
import Ecluse.Core.Package.Merge (MergePlan (mpArtifacts, mpSurvivors), SourceId)
import Ecluse.Core.Registry.CachedDocument (CachedDoc)
import Ecluse.Core.Registry.Json.Packed (Packed, withoutHole)
import Ecluse.Core.Snapshot (ContentDigest, Snapshot (..))
import Ecluse.Core.Text (urlFilename)

{- | Run ecosystem assembly across its cached-document boundary.
A source or base that another ecosystem injected contributes nothing.
-}
assembleAcross ::
    (source -> CachedDoc, CachedDoc -> Maybe source) ->
    source ->
    (Text -> Map SourceId (Snapshot source) -> MergePlan -> source -> source) ->
    Text ->
    Map SourceId (Snapshot CachedDoc) ->
    MergePlan ->
    Maybe CachedDoc ->
    CachedDoc
assembleAcross :: forall source.
(source -> CachedDoc, CachedDoc -> Maybe source)
-> source
-> (Text
    -> Map SourceId (Snapshot source) -> MergePlan -> source -> source)
-> Text
-> Map SourceId (Snapshot CachedDoc)
-> MergePlan
-> Maybe CachedDoc
-> CachedDoc
assembleAcross (source -> CachedDoc
inject, CachedDoc -> Maybe source
project) source
emptySource Text
-> Map SourceId (Snapshot source) -> MergePlan -> source -> source
assemble Text
mountBase Map SourceId (Snapshot CachedDoc)
bySource MergePlan
plan Maybe CachedDoc
base =
    source -> CachedDoc
inject
        ( Text
-> Map SourceId (Snapshot source) -> MergePlan -> source -> source
assemble
            Text
mountBase
            ((Snapshot CachedDoc -> Maybe (Snapshot source))
-> Map SourceId (Snapshot CachedDoc)
-> Map SourceId (Snapshot source)
forall a b k. (a -> Maybe b) -> Map k a -> Map k b
Map.mapMaybe ((CachedDoc -> Maybe source)
-> Snapshot CachedDoc -> Maybe (Snapshot source)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Snapshot a -> f (Snapshot b)
traverse CachedDoc -> Maybe source
project) Map SourceId (Snapshot CachedDoc)
bySource)
            MergePlan
plan
            (source -> Maybe source -> source
forall a. a -> Maybe a -> a
fromMaybe source
emptySource (CachedDoc -> Maybe source
project (CachedDoc -> Maybe source) -> Maybe CachedDoc -> Maybe source
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Maybe CachedDoc
base))
        )

-- | Encode a served document to its compact wire bytes, an empty object for a foreign one.
serialiseAcross :: (CachedDoc -> Maybe Encoding) -> CachedDoc -> LByteString
serialiseAcross :: (CachedDoc -> Maybe Encoding) -> CachedDoc -> LByteString
serialiseAcross CachedDoc -> Maybe Encoding
project = Encoding -> LByteString
forall a. Encoding' a -> LByteString
encodingToLazyByteString (Encoding -> LByteString)
-> (CachedDoc -> Encoding) -> CachedDoc -> LByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Encoding -> Maybe Encoding -> Encoding
forall a. a -> Maybe a -> a
fromMaybe Encoding
emptyObject_ (Maybe Encoding -> Encoding)
-> (CachedDoc -> Maybe Encoding) -> CachedDoc -> Encoding
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CachedDoc -> Maybe Encoding
project

{- | A served document whose render refused its plan, because the plan names a table or string it
lacks or the render does not fill its buffer exactly. The pipeline answers it as a render fault.
-}
data RenderRefused = RenderRefused
    deriving stock (RenderRefused -> RenderRefused -> Bool
(RenderRefused -> RenderRefused -> Bool)
-> (RenderRefused -> RenderRefused -> Bool) -> Eq RenderRefused
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RenderRefused -> RenderRefused -> Bool
== :: RenderRefused -> RenderRefused -> Bool
$c/= :: RenderRefused -> RenderRefused -> Bool
/= :: RenderRefused -> RenderRefused -> Bool
Eq, SourceId -> RenderRefused -> ShowS
[RenderRefused] -> ShowS
RenderRefused -> String
(SourceId -> RenderRefused -> ShowS)
-> (RenderRefused -> String)
-> ([RenderRefused] -> ShowS)
-> Show RenderRefused
forall a.
(SourceId -> a -> ShowS)
-> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: SourceId -> RenderRefused -> ShowS
showsPrec :: SourceId -> RenderRefused -> ShowS
$cshow :: RenderRefused -> String
show :: RenderRefused -> String
$cshowList :: [RenderRefused] -> ShowS
showList :: [RenderRefused] -> ShowS
Show)

instance Exception RenderRefused

{- | Select exact admitted entries from the winning source snapshot, preserving each source's order.
Missing keys, ambiguous keys, and mismatched snapshots contribute nothing.
-}
overlaySurvivors :: (src -> [(EntryKey, entry)]) -> Map SourceId (Snapshot src) -> MergePlan -> [(Text, entry)]
overlaySurvivors :: forall src entry.
(src -> [(EntryKey, entry)])
-> Map SourceId (Snapshot src) -> MergePlan -> [(Text, entry)]
overlaySurvivors src -> [(EntryKey, entry)]
entriesOf Map SourceId (Snapshot src)
bySource MergePlan
plan =
    [ (Text, entry)
selected
    | (SourceId
sid, Snapshot src
source) <- Map SourceId (Snapshot src) -> [(SourceId, Snapshot src)]
forall k a. Map k a -> [(k, a)]
Map.toAscList Map SourceId (Snapshot src)
bySource
    , (Text, entry)
selected <- [(EntryKey, (Text, AdmittedEntry))]
-> [(EntryKey, entry)] -> [(Text, entry)]
forall entry.
[(EntryKey, (Text, AdmittedEntry))]
-> [(EntryKey, entry)] -> [(Text, entry)]
selectEntries (MergePlan
-> SourceId -> Snapshot src -> [(EntryKey, (Text, AdmittedEntry))]
forall src.
MergePlan
-> SourceId -> Snapshot src -> [(EntryKey, (Text, AdmittedEntry))]
sourceAdmissions MergePlan
plan SourceId
sid Snapshot src
source) (src -> [(EntryKey, entry)]
entriesOf (Snapshot src -> src
forall a. Snapshot a -> a
snapshotValue Snapshot src
source))
    ]

-- The plan's admissions of this source's snapshot under versions the source won, in version order.
sourceAdmissions :: MergePlan -> SourceId -> Snapshot src -> [(EntryKey, (Text, AdmittedEntry))]
sourceAdmissions :: forall src.
MergePlan
-> SourceId -> Snapshot src -> [(EntryKey, (Text, AdmittedEntry))]
sourceAdmissions MergePlan
plan SourceId
sid Snapshot src
source =
    [ (AdmittedEntry -> EntryKey
admittedKey AdmittedEntry
entry, (Text
version, AdmittedEntry
entry))
    | (Text
version, NonEmpty AdmittedEntry
entries) <- Map Text (NonEmpty AdmittedEntry)
-> [(Text, NonEmpty AdmittedEntry)]
forall k a. Map k a -> [(k, a)]
Map.toList (MergePlan -> Map Text (NonEmpty AdmittedEntry)
mpArtifacts MergePlan
plan)
    , Text -> Map Text SourceId -> Maybe SourceId
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup Text
version (MergePlan -> Map Text SourceId
mpSurvivors MergePlan
plan) Maybe SourceId -> Maybe SourceId -> Bool
forall a. Eq a => a -> a -> Bool
== SourceId -> Maybe SourceId
forall a. a -> Maybe a
Just SourceId
sid
    , AdmittedEntry
entry <- NonEmpty AdmittedEntry -> [AdmittedEntry]
forall a. NonEmpty a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList NonEmpty AdmittedEntry
entries
    , AdmittedEntry -> ContentDigest
admittedSnapshot AdmittedEntry
entry ContentDigest -> ContentDigest -> Bool
forall a. Eq a => a -> a -> Bool
== Snapshot src -> ContentDigest
forall a. Snapshot a -> ContentDigest
snapshotDigest Snapshot src
source
    ]

-- A slot costs one word per position and a map node six per admission, so the table serves the denser case.
selectEntries :: [(EntryKey, (Text, AdmittedEntry))] -> [(EntryKey, entry)] -> [(Text, entry)]
selectEntries :: forall entry.
[(EntryKey, (Text, AdmittedEntry))]
-> [(EntryKey, entry)] -> [(Text, entry)]
selectEntries [(EntryKey, (Text, AdmittedEntry))]
admissions [(EntryKey, entry)]
entries = case [(EntryKey, entry)] -> Maybe SourceId
forall entry. [(EntryKey, entry)] -> Maybe SourceId
lastAscending [(EntryKey, entry)]
entries of
    Just SourceId
end | SourceId
end SourceId -> SourceId -> Bool
forall a. Ord a => a -> a -> Bool
< SourceId
6 SourceId -> SourceId -> SourceId
forall a. Num a => a -> a -> a
* [(EntryKey, (Text, AdmittedEntry))] -> SourceId
forall a. [a] -> SourceId
forall (t :: * -> *) a. Foldable t => t a -> SourceId
length [(EntryKey, (Text, AdmittedEntry))]
admissions -> Vector Slot -> [(EntryKey, entry)] -> [(Text, entry)]
forall entry. Vector Slot -> [(EntryKey, entry)] -> [(Text, entry)]
slotted (SourceId -> [(EntryKey, (Text, AdmittedEntry))] -> Vector Slot
admissionSlots SourceId
end [(EntryKey, (Text, AdmittedEntry))]
admissions) [(EntryKey, entry)]
entries
    Just SourceId
_ -> Map EntryKey (Text, AdmittedEntry)
-> [(EntryKey, entry)] -> [(Text, entry)]
forall entry.
Map EntryKey (Text, AdmittedEntry)
-> [(EntryKey, entry)] -> [(Text, entry)]
keyed ([(EntryKey, (Text, AdmittedEntry))]
-> Map EntryKey (Text, AdmittedEntry)
forall key value. Ord key => [(key, value)] -> Map key value
uniqueEntries [(EntryKey, (Text, AdmittedEntry))]
admissions) [(EntryKey, entry)]
entries
    Maybe SourceId
Nothing -> Map EntryKey (Text, AdmittedEntry)
-> [(EntryKey, entry)] -> [(Text, entry)]
forall entry.
Map EntryKey (Text, AdmittedEntry)
-> [(EntryKey, entry)] -> [(Text, entry)]
keyed ([(EntryKey, (Text, AdmittedEntry))]
-> Map EntryKey (Text, AdmittedEntry)
forall key value. Ord key => [(key, value)] -> Map key value
uniqueEntries [(EntryKey, (Text, AdmittedEntry))]
admissions) (((EntryKey, entry) -> Bool)
-> [(EntryKey, entry)] -> [(EntryKey, entry)]
forall a. (a -> Bool) -> [a] -> [a]
filter (\(EntryKey
key, entry
_) -> EntryKey -> Map EntryKey entry -> Bool
forall k a. Ord k => k -> Map k a -> Bool
Map.member EntryKey
key Map EntryKey entry
unrepeated) [(EntryKey, entry)]
entries)
  where
    unrepeated :: Map EntryKey entry
unrepeated = [(EntryKey, entry)] -> Map EntryKey entry
forall key value. Ord key => [(key, value)] -> Map key value
uniqueEntries [(EntryKey, entry)]
entries

-- The last of strictly ascending non-negative array positions, which are already unique.
lastAscending :: [(EntryKey, entry)] -> Maybe Int
lastAscending :: forall entry. [(EntryKey, entry)] -> Maybe SourceId
lastAscending = SourceId -> [(EntryKey, entry)] -> Maybe SourceId
forall {b}. SourceId -> [(EntryKey, b)] -> Maybe SourceId
go (-SourceId
1)
  where
    go :: SourceId -> [(EntryKey, b)] -> Maybe SourceId
go !SourceId
previous = \case
        (ArrayEntry SourceId
position, b
_) : [(EntryKey, b)]
rest | SourceId
position SourceId -> SourceId -> Bool
forall a. Ord a => a -> a -> Bool
> SourceId
previous -> SourceId -> [(EntryKey, b)] -> Maybe SourceId
go SourceId
position [(EntryKey, b)]
rest
        [] -> SourceId -> Maybe SourceId
forall a. a -> Maybe a
Just SourceId
previous
        [(EntryKey, b)]
_ -> Maybe SourceId
forall a. Maybe a
Nothing

data Slot = Vacant | Admitted Text AdmittedEntry | Ambiguous

-- One slot per position up to @end@. A position admitted twice selects nothing.
admissionSlots :: Int -> [(EntryKey, (Text, AdmittedEntry))] -> Vector Slot
admissionSlots :: SourceId -> [(EntryKey, (Text, AdmittedEntry))] -> Vector Slot
admissionSlots SourceId
end [(EntryKey, (Text, AdmittedEntry))]
admissions = (forall s. ST s (MVector s Slot)) -> Vector Slot
forall a. (forall s. ST s (MVector s a)) -> Vector a
V.create ((forall s. ST s (MVector s Slot)) -> Vector Slot)
-> (forall s. ST s (MVector s Slot)) -> Vector Slot
forall a b. (a -> b) -> a -> b
$ do
    slots <- SourceId -> Slot -> ST s (MVector (PrimState (ST s)) Slot)
forall (m :: * -> *) a.
PrimMonad m =>
SourceId -> a -> m (MVector (PrimState m) a)
MV.replicate (SourceId
end SourceId -> SourceId -> SourceId
forall a. Num a => a -> a -> a
+ SourceId
1) Slot
Vacant
    for_ admissions $ \case
        (ArrayEntry SourceId
position, (Text
version, AdmittedEntry
kept)) ->
            MVector (PrimState (ST s)) Slot -> SourceId -> ST s (Maybe Slot)
forall (m :: * -> *) a.
PrimMonad m =>
MVector (PrimState m) a -> SourceId -> m (Maybe a)
MV.readMaybe MVector s Slot
MVector (PrimState (ST s)) Slot
slots SourceId
position ST s (Maybe Slot) -> (Maybe Slot -> ST s ()) -> ST s ()
forall a b. ST s a -> (a -> ST s b) -> ST s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Slot -> ST s ()) -> Maybe Slot -> ST s ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
(a -> f b) -> t a -> f ()
traverse_ (\Slot
slot -> MVector (PrimState (ST s)) Slot -> SourceId -> Slot -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
MVector (PrimState m) a -> SourceId -> a -> m ()
MV.write MVector s Slot
MVector (PrimState (ST s)) Slot
slots SourceId
position (Slot -> ST s ()) -> Slot -> ST s ()
forall a b. (a -> b) -> a -> b
$! Text -> AdmittedEntry -> Slot -> Slot
occupy Text
version AdmittedEntry
kept Slot
slot)
        (EntryKey, (Text, AdmittedEntry))
_ -> ST s ()
forall (f :: * -> *). Applicative f => f ()
pass
    pure slots

occupy :: Text -> AdmittedEntry -> Slot -> Slot
occupy :: Text -> AdmittedEntry -> Slot -> Slot
occupy Text
version AdmittedEntry
kept = \case
    Slot
Vacant -> Text -> AdmittedEntry -> Slot
Admitted Text
version AdmittedEntry
kept
    Slot
_ -> Slot
Ambiguous

slotted :: Vector Slot -> [(EntryKey, entry)] -> [(Text, entry)]
slotted :: forall entry. Vector Slot -> [(EntryKey, entry)] -> [(Text, entry)]
slotted Vector Slot
slots [(EntryKey, entry)]
entries =
    [ (Text
version, entry
entry)
    | (ArrayEntry SourceId
position, entry
entry) <- [(EntryKey, entry)]
entries
    , Just (Admitted Text
version AdmittedEntry
kept) <- [Vector Slot
slots Vector Slot -> SourceId -> Maybe Slot
forall a. Vector a -> SourceId -> Maybe a
V.!? SourceId
position]
    , AdmittedEntry -> Bool
usableEntry AdmittedEntry
kept
    ]

keyed :: Map EntryKey (Text, AdmittedEntry) -> [(EntryKey, entry)] -> [(Text, entry)]
keyed :: forall entry.
Map EntryKey (Text, AdmittedEntry)
-> [(EntryKey, entry)] -> [(Text, entry)]
keyed Map EntryKey (Text, AdmittedEntry)
admitted [(EntryKey, entry)]
entries =
    [ (Text
version, entry
entry)
    | (EntryKey
key, entry
entry) <- [(EntryKey, entry)]
entries
    , Just (Text
version, AdmittedEntry
kept) <- [EntryKey
-> Map EntryKey (Text, AdmittedEntry)
-> Maybe (Text, AdmittedEntry)
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup EntryKey
key Map EntryKey (Text, AdmittedEntry)
admitted]
    , AdmittedEntry -> Bool
usableEntry AdmittedEntry
kept
    ]

{- | Select exact admitted entries by lookup in each winning source's key map, in source and key order.
Only object coordinates are served. Missing keys, ambiguous keys, and mismatched snapshots contribute nothing.
-}
overlayObjectSurvivors :: (src -> KeyMap entry) -> Map SourceId (Snapshot src) -> MergePlan -> [(Text, entry)]
overlayObjectSurvivors :: forall src entry.
(src -> KeyMap entry)
-> Map SourceId (Snapshot src) -> MergePlan -> [(Text, entry)]
overlayObjectSurvivors src -> KeyMap entry
entriesOf Map SourceId (Snapshot src)
bySource MergePlan
plan = [(Text
version, entry
entry) | (Text
version, SourceId
_, entry
entry) <- (src -> KeyMap entry)
-> Map SourceId (Snapshot src)
-> MergePlan
-> [(Text, SourceId, entry)]
forall src entry.
(src -> KeyMap entry)
-> Map SourceId (Snapshot src)
-> MergePlan
-> [(Text, SourceId, entry)]
overlayObjectSources src -> KeyMap entry
entriesOf Map SourceId (Snapshot src)
bySource MergePlan
plan]

-- | 'overlayObjectSurvivors' with the source each entry came from.
overlayObjectSources :: (src -> KeyMap entry) -> Map SourceId (Snapshot src) -> MergePlan -> [(Text, SourceId, entry)]
overlayObjectSources :: forall src entry.
(src -> KeyMap entry)
-> Map SourceId (Snapshot src)
-> MergePlan
-> [(Text, SourceId, entry)]
overlayObjectSources src -> KeyMap entry
entriesOf Map SourceId (Snapshot src)
bySource MergePlan
plan =
    [ (Text
version, SourceId
sid, entry
entry)
    | ((SourceId
sid, ContentDigest
digest, ObjectEntry Text
key), (Text
version, AdmittedEntry
kept)) <- Map (SourceId, ContentDigest, EntryKey) (Text, AdmittedEntry)
-> [((SourceId, ContentDigest, EntryKey), (Text, AdmittedEntry))]
forall k a. Map k a -> [(k, a)]
Map.toAscList (MergePlan
-> Map (SourceId, ContentDigest, EntryKey) (Text, AdmittedEntry)
admittedIndex MergePlan
plan)
    , AdmittedEntry -> Bool
usableEntry AdmittedEntry
kept
    , Just Snapshot src
source <- [SourceId -> Map SourceId (Snapshot src) -> Maybe (Snapshot src)
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup SourceId
sid Map SourceId (Snapshot src)
bySource]
    , Snapshot src -> ContentDigest
forall a. Snapshot a -> ContentDigest
snapshotDigest Snapshot src
source ContentDigest -> ContentDigest -> Bool
forall a. Eq a => a -> a -> Bool
== ContentDigest
digest
    , Just entry
entry <- [Key -> KeyMap entry -> Maybe entry
forall v. Key -> KeyMap v -> Maybe v
KeyMap.lookup (Text -> Key
Key.fromText Text
key) (src -> KeyMap entry
entriesOf (Snapshot src -> src
forall a. Snapshot a -> a
snapshotValue Snapshot src
source))]
    ]

admittedIndex :: MergePlan -> Map (SourceId, ContentDigest, EntryKey) (Text, AdmittedEntry)
admittedIndex :: MergePlan
-> Map (SourceId, ContentDigest, EntryKey) (Text, AdmittedEntry)
admittedIndex MergePlan
plan =
    [((SourceId, ContentDigest, EntryKey), (Text, AdmittedEntry))]
-> Map (SourceId, ContentDigest, EntryKey) (Text, AdmittedEntry)
forall key value. Ord key => [(key, value)] -> Map key value
uniqueEntries
        [ ((SourceId
sid, AdmittedEntry -> ContentDigest
admittedSnapshot AdmittedEntry
entry, AdmittedEntry -> EntryKey
admittedKey AdmittedEntry
entry), (Text
version, AdmittedEntry
entry))
        | (Text
version, NonEmpty AdmittedEntry
entries) <- Map Text (NonEmpty AdmittedEntry)
-> [(Text, NonEmpty AdmittedEntry)]
forall k a. Map k a -> [(k, a)]
Map.toList (MergePlan -> Map Text (NonEmpty AdmittedEntry)
mpArtifacts MergePlan
plan)
        , Just SourceId
sid <- [Text -> Map Text SourceId -> Maybe SourceId
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup Text
version (MergePlan -> Map Text SourceId
mpSurvivors MergePlan
plan)]
        , AdmittedEntry
entry <- NonEmpty AdmittedEntry -> [AdmittedEntry]
forall a. NonEmpty a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList NonEmpty AdmittedEntry
entries
        ]

usableEntry :: AdmittedEntry -> Bool
usableEntry :: AdmittedEntry -> Bool
usableEntry AdmittedEntry
entry = EntryKey -> Bool
validEntryKey (AdmittedEntry -> EntryKey
admittedKey AdmittedEntry
entry) Bool -> Bool -> Bool
&& Bool -> Bool
not (Text -> Bool
T.null (AdmittedEntry -> Text
admittedFilename AdmittedEntry
entry))

-- | Keep only keys that occur exactly once, so ambiguous source coordinates cannot select an entry.
uniqueEntries :: (Ord key) => [(key, value)] -> Map key value
uniqueEntries :: forall key value. Ord key => [(key, value)] -> Map key value
uniqueEntries = (Maybe value -> Maybe value)
-> Map key (Maybe value) -> Map key value
forall a b k. (a -> Maybe b) -> Map k a -> Map k b
Map.mapMaybe Maybe value -> Maybe value
forall a. a -> a
id (Map key (Maybe value) -> Map key value)
-> ([(key, value)] -> Map key (Maybe value))
-> [(key, value)]
-> Map key value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe value -> Maybe value -> Maybe value)
-> [(key, Maybe value)] -> Map key (Maybe value)
forall k a. Ord k => (a -> a -> a) -> [(k, a)] -> Map k a
Map.fromListWith (\Maybe value
_ Maybe value
_ -> Maybe value
forall a. Maybe a
Nothing) ([(key, Maybe value)] -> Map key (Maybe value))
-> ([(key, value)] -> [(key, Maybe value)])
-> [(key, value)]
-> Map key (Maybe value)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((key, value) -> (key, Maybe value))
-> [(key, value)] -> [(key, Maybe value)]
forall a b. (a -> b) -> [a] -> [b]
map ((value -> Maybe value) -> (key, value) -> (key, Maybe value)
forall b c a. (b -> c) -> (a, b) -> (a, c)
forall (p :: * -> * -> *) b c a.
Bifunctor p =>
(b -> c) -> p a b -> p a c
second value -> Maybe value
forall a. a -> Maybe a
Just)

-- | Gate the document's claimed name before it enters a rewritten artifact URL.
safeDocumentName :: (Text -> Maybe a) -> KeyMap Value -> Maybe a
safeDocumentName :: forall a. (Text -> Maybe a) -> KeyMap Value -> Maybe a
safeDocumentName Text -> Maybe a
parse KeyMap Value
document = case Key -> KeyMap Value -> Maybe Value
forall v. Key -> KeyMap v -> Maybe v
KeyMap.lookup Key
"name" KeyMap Value
document of
    Just (String Text
name) -> Text -> Maybe a
parse Text
name
    Maybe Value
_ -> Maybe a
forall a. Maybe a
Nothing

{- | Rebase an artifact under this mount, checking filenames before and after URL whitespace trimming.
Idempotent while the renderer keeps the filename in the terminal path segment.
-}
rebaseArtifactUrl :: (Text -> Maybe Text) -> Text -> Maybe Text
rebaseArtifactUrl :: (Text -> Maybe Text) -> Text -> Maybe Text
rebaseArtifactUrl Text -> Maybe Text
renderMountUrl Text
url = do
    filename <- Text -> Maybe Text
urlFilename Text
url
    guard (trimmed == url || isJust (urlFilename trimmed))
    renderMountUrl filename
  where
    trimmed :: Text
trimmed = Text -> Text
T.strip Text
url

-- | Remove an unusable URL hole without changing the source payload or encoded length.
artifactUrlPacked :: Maybe Text -> Packed -> Packed
artifactUrlPacked :: Maybe Text -> Packed -> Packed
artifactUrlPacked Maybe Text
url Packed
packed
    | Maybe Text -> Bool
forall a. Maybe a -> Bool
isJust (Maybe Text
url Maybe Text -> (Text -> Maybe Text) -> Maybe Text
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Text -> Maybe Text) -> Text -> Maybe Text
rebaseArtifactUrl Text -> Maybe Text
forall a. a -> Maybe a
Just) = Packed
packed
    | Bool
otherwise = Packed -> Packed
withoutHole Packed
packed

-- | A raw document's own object, empty for a document that is not one.
documentObject :: Value -> KeyMap Value
documentObject :: Value -> KeyMap Value
documentObject = \case
    Object KeyMap Value
o -> KeyMap Value
o
    Value
_ -> KeyMap Value
forall a. Monoid a => a
mempty

-- | The 'Text' at @key@ in a raw document object, if present and a JSON string.
stringField :: Key.Key -> KeyMap Value -> Maybe Text
stringField :: Key -> KeyMap Value -> Maybe Text
stringField Key
key KeyMap Value
o = case Key -> KeyMap Value -> Maybe Value
forall v. Key -> KeyMap v -> Maybe v
KeyMap.lookup Key
key KeyMap Value
o of
    Just (String Text
s) -> Text -> Maybe Text
forall a. a -> Maybe a
Just Text
s
    Maybe Value
_ -> Maybe Text
forall a. Maybe a
Nothing

-- | The object at @key@ in a raw document object, if present and a JSON object.
objectField :: Key.Key -> KeyMap Value -> Maybe (KeyMap Value)
objectField :: Key -> KeyMap Value -> Maybe (KeyMap Value)
objectField Key
key KeyMap Value
o = case Key -> KeyMap Value -> Maybe Value
forall v. Key -> KeyMap v -> Maybe v
KeyMap.lookup Key
key KeyMap Value
o of
    Just (Object KeyMap Value
inner) -> KeyMap Value -> Maybe (KeyMap Value)
forall a. a -> Maybe a
Just KeyMap Value
inner
    Maybe Value
_ -> Maybe (KeyMap Value)
forall a. Maybe a
Nothing

-- | Edit the value an object carries at @key@. A missing field stays absent.
adjustField :: Key.Key -> (Value -> Value) -> KeyMap Value -> KeyMap Value
adjustField :: Key -> (Value -> Value) -> KeyMap Value -> KeyMap Value
adjustField Key
key Value -> Value
edit KeyMap Value
o = case Key -> KeyMap Value -> Maybe Value
forall v. Key -> KeyMap v -> Maybe v
KeyMap.lookup Key
key KeyMap Value
o of
    Just Value
v -> Key -> Value -> KeyMap Value -> KeyMap Value
forall v. Key -> v -> KeyMap v -> KeyMap v
KeyMap.insert Key
key (Value -> Value
edit Value
v) KeyMap Value
o
    Maybe Value
Nothing -> KeyMap Value
o