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

{- | The publication state as S3 user metadata, written in the same request as the artifact.

A metadata-only read returns it, so Pilot orders and sizes a publication without downloading the
stored database. Every value is printable ASCII, and the envelope stays under S3's user-metadata
limit. A missing key, an unknown version, and a bad value are distinct faults, so an object that
predates guarded publication never reads as an empty store.
-}
module Ecluse.Core.Osv.Publication.Envelope (
    envelopeVersion,
    maxEnvelopeBytes,
    encodeEnvelope,
    decodeEnvelope,
) where

import Data.ByteString qualified as BS
import Data.List (lookup)
import Data.Text qualified as T
import Data.Time (UTCTime)
import Data.Universe.Class (Universe (..))
import Data.Universe.Class qualified as Universe
import Data.Universe.Generic (universeGeneric)

import Ecluse.Core.Osv.Publication.Types (
    Adjustment,
    EnvelopeFault (..),
    PublishedState (..),
    SourceMarker (..),
    parsePublicationNonce,
    parseSourceDigestHex,
    parseSourceIdentityHex,
    renderAdjustment,
    renderPublicationNonce,
    sourceDigestHex,
    sourceIdentityHex,
 )
import Ecluse.Core.Osv.Schema (EpssStatus (EnrichmentAvailable, EnrichmentUnavailable), renderEpssStatus)
import Ecluse.Core.Text (readDecimalText)
import Ecluse.Core.Text.Iso8601 (readIso8601Utc, renderIso8601Utc)

-- | The envelope layout this build writes, and the only one it reads.
envelopeVersion :: Text
envelopeVersion :: Text
envelopeVersion = Text
"1"

-- | S3's user-metadata limit: the UTF-8 bytes of every key and value together.
maxEnvelopeBytes :: Int
maxEnvelopeBytes :: Int
maxEnvelopeBytes = Int
2048

data EnvelopeKey
    = KeyVersion
    | KeyEcosystem
    | KeySchemaEpoch
    | KeyOsvSource
    | KeyOsvLastModified
    | KeyOsvDigest
    | KeyEpssStatus
    | KeyEpssSource
    | KeyEpssLastModified
    | KeyEpssDigest
    | KeyRelevantRows
    | KeyScoredRows
    | KeyBaselineBytes
    | KeyEpssCreditBytes
    | KeyNonce
    | KeyAdjustment
    deriving stock (EnvelopeKey -> EnvelopeKey -> Bool
(EnvelopeKey -> EnvelopeKey -> Bool)
-> (EnvelopeKey -> EnvelopeKey -> Bool) -> Eq EnvelopeKey
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: EnvelopeKey -> EnvelopeKey -> Bool
== :: EnvelopeKey -> EnvelopeKey -> Bool
$c/= :: EnvelopeKey -> EnvelopeKey -> Bool
/= :: EnvelopeKey -> EnvelopeKey -> Bool
Eq, (forall x. EnvelopeKey -> Rep EnvelopeKey x)
-> (forall x. Rep EnvelopeKey x -> EnvelopeKey)
-> Generic EnvelopeKey
forall x. Rep EnvelopeKey x -> EnvelopeKey
forall x. EnvelopeKey -> Rep EnvelopeKey x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. EnvelopeKey -> Rep EnvelopeKey x
from :: forall x. EnvelopeKey -> Rep EnvelopeKey x
$cto :: forall x. Rep EnvelopeKey x -> EnvelopeKey
to :: forall x. Rep EnvelopeKey x -> EnvelopeKey
Generic)

instance Universe EnvelopeKey where universe :: [EnvelopeKey]
universe = [EnvelopeKey]
forall a. (Generic a, GUniverse (Rep a)) => [a]
universeGeneric

-- S3 stores metadata keys in lower case, so every key is written that way.
renderKey :: EnvelopeKey -> Text
renderKey :: EnvelopeKey -> Text
renderKey = \case
    EnvelopeKey
KeyVersion -> Text
"publication-version"
    EnvelopeKey
KeyEcosystem -> Text
"ecosystem"
    EnvelopeKey
KeySchemaEpoch -> Text
"schema-epoch"
    EnvelopeKey
KeyOsvSource -> Text
"osv-source"
    EnvelopeKey
KeyOsvLastModified -> Text
"osv-last-modified"
    EnvelopeKey
KeyOsvDigest -> Text
"osv-digest"
    EnvelopeKey
KeyEpssStatus -> Text
"epss-status"
    EnvelopeKey
KeyEpssSource -> Text
"epss-source"
    EnvelopeKey
KeyEpssLastModified -> Text
"epss-last-modified"
    EnvelopeKey
KeyEpssDigest -> Text
"epss-digest"
    EnvelopeKey
KeyRelevantRows -> Text
"relevant-rows"
    EnvelopeKey
KeyScoredRows -> Text
"scored-rows"
    EnvelopeKey
KeyBaselineBytes -> Text
"baseline-bytes"
    EnvelopeKey
KeyEpssCreditBytes -> Text
"epss-credit-bytes"
    EnvelopeKey
KeyNonce -> Text
"publication-nonce"
    EnvelopeKey
KeyAdjustment -> Text
"baseline-adjustment"

-- | Render the state for a write. A value outside printable ASCII, or a state past the limit, is refused.
encodeEnvelope :: PublishedState -> Either EnvelopeFault [(Text, Text)]
encodeEnvelope :: PublishedState -> Either EnvelopeFault [(Text, Text)]
encodeEnvelope PublishedState
published = do
    [(Text, Text)]
-> ((Text, Text) -> Either EnvelopeFault ())
-> Either EnvelopeFault ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ [(Text, Text)]
pairs (((Text, Text) -> Either EnvelopeFault ())
 -> Either EnvelopeFault ())
-> ((Text, Text) -> Either EnvelopeFault ())
-> Either EnvelopeFault ()
forall a b. (a -> b) -> a -> b
$ \(Text
key, Text
value) -> Bool -> Either EnvelopeFault () -> Either EnvelopeFault ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless ((Char -> Bool) -> Text -> Bool
T.all Char -> Bool
printableAscii Text
value) (EnvelopeFault -> Either EnvelopeFault ()
forall a b. a -> Either a b
Left (Text -> EnvelopeFault
EnvelopeMalformed Text
key))
    [(Text, Text)] -> Either EnvelopeFault [(Text, Text)]
within [(Text, Text)]
pairs
  where
    pairs :: [(Text, Text)]
pairs = [(EnvelopeKey -> Text
renderKey EnvelopeKey
key, PublishedState -> EnvelopeKey -> Text
renderValue PublishedState
published EnvelopeKey
key) | EnvelopeKey
key <- [EnvelopeKey]
forall a. Universe a => [a]
Universe.universe]

renderValue :: PublishedState -> EnvelopeKey -> Text
renderValue :: PublishedState -> EnvelopeKey -> Text
renderValue PublishedState
published = \case
    EnvelopeKey
KeyVersion -> Text
envelopeVersion
    EnvelopeKey
KeyEcosystem -> PublishedState -> Text
psEcosystem PublishedState
published
    EnvelopeKey
KeySchemaEpoch -> Int -> Text
forall b a. (Show a, IsString b) => a -> b
show (PublishedState -> Int
psSchemaEpoch PublishedState
published)
    EnvelopeKey
KeyOsvSource -> SourceMarker -> Text
identityText (PublishedState -> SourceMarker
psOsv PublishedState
published)
    EnvelopeKey
KeyOsvLastModified -> SourceMarker -> Text
stampText (PublishedState -> SourceMarker
psOsv PublishedState
published)
    EnvelopeKey
KeyOsvDigest -> SourceMarker -> Text
digestText (PublishedState -> SourceMarker
psOsv PublishedState
published)
    EnvelopeKey
KeyEpssStatus -> EpssStatus -> Text
renderEpssStatus (PublishedState -> EpssStatus
psEpssStatus PublishedState
published)
    EnvelopeKey
KeyEpssSource -> Text -> (SourceMarker -> Text) -> Maybe SourceMarker -> Text
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Text
noMarker SourceMarker -> Text
identityText (PublishedState -> Maybe SourceMarker
psLastEpss PublishedState
published)
    EnvelopeKey
KeyEpssLastModified -> Text -> (SourceMarker -> Text) -> Maybe SourceMarker -> Text
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Text
noMarker SourceMarker -> Text
stampText (PublishedState -> Maybe SourceMarker
psLastEpss PublishedState
published)
    EnvelopeKey
KeyEpssDigest -> Text -> (SourceMarker -> Text) -> Maybe SourceMarker -> Text
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Text
noMarker SourceMarker -> Text
digestText (PublishedState -> Maybe SourceMarker
psLastEpss PublishedState
published)
    EnvelopeKey
KeyRelevantRows -> Integer -> Text
forall b a. (Show a, IsString b) => a -> b
show (PublishedState -> Integer
psRelevantRows PublishedState
published)
    EnvelopeKey
KeyScoredRows -> Integer -> Text
forall b a. (Show a, IsString b) => a -> b
show (PublishedState -> Integer
psScoredRows PublishedState
published)
    EnvelopeKey
KeyBaselineBytes -> Integer -> Text
forall b a. (Show a, IsString b) => a -> b
show (PublishedState -> Integer
psBaselineBytes PublishedState
published)
    EnvelopeKey
KeyEpssCreditBytes -> Integer -> Text
forall b a. (Show a, IsString b) => a -> b
show (PublishedState -> Integer
psEpssCreditBytes PublishedState
published)
    EnvelopeKey
KeyNonce -> PublicationNonce -> Text
renderPublicationNonce (PublishedState -> PublicationNonce
psNonce PublishedState
published)
    EnvelopeKey
KeyAdjustment -> Adjustment -> Text
renderAdjustment (PublishedState -> Adjustment
psAdjustment PublishedState
published)
  where
    identityText :: SourceMarker -> Text
identityText = (Text
identityLabel Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>) (Text -> Text) -> (SourceMarker -> Text) -> SourceMarker -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SourceIdentity -> Text
sourceIdentityHex (SourceIdentity -> Text)
-> (SourceMarker -> SourceIdentity) -> SourceMarker -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SourceMarker -> SourceIdentity
smIdentity
    digestText :: SourceMarker -> Text
digestText = (Text
digestLabel Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>) (Text -> Text) -> (SourceMarker -> Text) -> SourceMarker -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SourceDigest -> Text
sourceDigestHex (SourceDigest -> Text)
-> (SourceMarker -> SourceDigest) -> SourceMarker -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SourceMarker -> SourceDigest
smDigest
    stampText :: SourceMarker -> Text
stampText = Text -> (UTCTime -> Text) -> Maybe UTCTime -> Text
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Text
unknownStamp UTCTime -> Text
renderIso8601Utc (Maybe UTCTime -> Text)
-> (SourceMarker -> Maybe UTCTime) -> SourceMarker -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SourceMarker -> Maybe UTCTime
smLastModified

-- | Read the state a stored object carries. Keys compare without case, as S3 may return them in any.
decodeEnvelope :: [(Text, Text)] -> Either EnvelopeFault PublishedState
decodeEnvelope :: [(Text, Text)] -> Either EnvelopeFault PublishedState
decodeEnvelope [(Text, Text)]
raw = do
    Either EnvelopeFault [(Text, Text)] -> Either EnvelopeFault ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void ([(Text, Text)] -> Either EnvelopeFault [(Text, Text)]
within [(Text, Text)]
raw)
    Maybe Text
-> (Text -> Either EnvelopeFault ()) -> Either EnvelopeFault ()
forall (f :: * -> *) a.
Applicative f =>
Maybe a -> (a -> f ()) -> f ()
whenJust (EnvelopeKey -> Maybe Text
lookupKey EnvelopeKey
KeyVersion) ((Text -> Either EnvelopeFault ()) -> Either EnvelopeFault ())
-> (Text -> Either EnvelopeFault ()) -> Either EnvelopeFault ()
forall a b. (a -> b) -> a -> b
$ \Text
version ->
        Bool -> Either EnvelopeFault () -> Either EnvelopeFault ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (Text
version Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
envelopeVersion) (EnvelopeFault -> Either EnvelopeFault ()
forall a b. a -> Either a b
Left (Text -> EnvelopeFault
EnvelopeUnsupported (Int -> Text -> Text
T.take Int
32 Text
version)))
    Maybe (NonEmpty Text)
-> (NonEmpty Text -> Either EnvelopeFault ())
-> Either EnvelopeFault ()
forall (f :: * -> *) a.
Applicative f =>
Maybe a -> (a -> f ()) -> f ()
whenJust ([Text] -> Maybe (NonEmpty Text)
forall a. [a] -> Maybe (NonEmpty a)
nonEmpty [EnvelopeKey -> Text
renderKey EnvelopeKey
key | EnvelopeKey
key <- [EnvelopeKey]
forall a. Universe a => [a]
Universe.universe, Maybe Text -> Bool
forall a. Maybe a -> Bool
isNothing (EnvelopeKey -> Maybe Text
lookupKey EnvelopeKey
key)]) (EnvelopeFault -> Either EnvelopeFault ()
forall a b. a -> Either a b
Left (EnvelopeFault -> Either EnvelopeFault ())
-> (NonEmpty Text -> EnvelopeFault)
-> NonEmpty Text
-> Either EnvelopeFault ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty Text -> EnvelopeFault
EnvelopeMissing)
    osv <- EnvelopeKey
-> EnvelopeKey -> EnvelopeKey -> Either EnvelopeFault SourceMarker
marker EnvelopeKey
KeyOsvSource EnvelopeKey
KeyOsvLastModified EnvelopeKey
KeyOsvDigest
    status <- field KeyEpssStatus epssStatusOf
    lastEpss <- epssMarker
    when (status == EnrichmentAvailable && isNothing lastEpss) (Left (EnvelopeMalformed (renderKey KeyEpssStatus)))
    PublishedState
        <$> field KeyEcosystem ecosystemOf
        <*> field KeySchemaEpoch (fmap fromInteger . boundedCount)
        <*> pure osv
        <*> pure status
        <*> pure lastEpss
        <*> field KeyRelevantRows boundedCount
        <*> field KeyScoredRows boundedCount
        <*> field KeyBaselineBytes boundedCount
        <*> field KeyEpssCreditBytes boundedCount
        <*> field KeyNonce parsePublicationNonce
        <*> field KeyAdjustment adjustmentOf
  where
    lowered :: [(Text, Text)]
lowered = [(Text -> Text
T.toLower Text
key, Text
value) | (Text
key, Text
value) <- [(Text, Text)]
raw]
    lookupKey :: EnvelopeKey -> Maybe Text
lookupKey EnvelopeKey
key = Text -> Text
T.strip (Text -> Text) -> Maybe Text -> Maybe Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Text -> [(Text, Text)] -> Maybe Text
forall a b. Eq a => a -> [(a, b)] -> Maybe b
lookup (EnvelopeKey -> Text
renderKey EnvelopeKey
key) [(Text, Text)]
lowered
    field :: EnvelopeKey -> (Text -> Maybe b) -> Either EnvelopeFault b
field EnvelopeKey
key Text -> Maybe b
parse = Either EnvelopeFault b
-> (b -> Either EnvelopeFault b)
-> Maybe b
-> Either EnvelopeFault b
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (EnvelopeFault -> Either EnvelopeFault b
forall a b. a -> Either a b
Left (Text -> EnvelopeFault
EnvelopeMalformed (EnvelopeKey -> Text
renderKey EnvelopeKey
key))) b -> Either EnvelopeFault b
forall a b. b -> Either a b
Right (Text -> Maybe b
parse (Text -> Maybe b) -> Maybe Text -> Maybe b
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< EnvelopeKey -> Maybe Text
lookupKey EnvelopeKey
key)
    marker :: EnvelopeKey
-> EnvelopeKey -> EnvelopeKey -> Either EnvelopeFault SourceMarker
marker EnvelopeKey
identityKey EnvelopeKey
stamp EnvelopeKey
digest =
        SourceIdentity -> Maybe UTCTime -> SourceDigest -> SourceMarker
SourceMarker
            (SourceIdentity -> Maybe UTCTime -> SourceDigest -> SourceMarker)
-> Either EnvelopeFault SourceIdentity
-> Either
     EnvelopeFault (Maybe UTCTime -> SourceDigest -> SourceMarker)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> EnvelopeKey
-> (Text -> Maybe SourceIdentity)
-> Either EnvelopeFault SourceIdentity
forall {b}.
EnvelopeKey -> (Text -> Maybe b) -> Either EnvelopeFault b
field EnvelopeKey
identityKey (Text -> Maybe SourceIdentity
parseSourceIdentityHex (Text -> Maybe SourceIdentity)
-> (Text -> Maybe Text) -> Text -> Maybe SourceIdentity
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< Text -> Text -> Maybe Text
T.stripPrefix Text
identityLabel)
            Either
  EnvelopeFault (Maybe UTCTime -> SourceDigest -> SourceMarker)
-> Either EnvelopeFault (Maybe UTCTime)
-> Either EnvelopeFault (SourceDigest -> SourceMarker)
forall a b.
Either EnvelopeFault (a -> b)
-> Either EnvelopeFault a -> Either EnvelopeFault b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> EnvelopeKey
-> (Text -> Maybe (Maybe UTCTime))
-> Either EnvelopeFault (Maybe UTCTime)
forall {b}.
EnvelopeKey -> (Text -> Maybe b) -> Either EnvelopeFault b
field EnvelopeKey
stamp Text -> Maybe (Maybe UTCTime)
stampOf
            Either EnvelopeFault (SourceDigest -> SourceMarker)
-> Either EnvelopeFault SourceDigest
-> Either EnvelopeFault SourceMarker
forall a b.
Either EnvelopeFault (a -> b)
-> Either EnvelopeFault a -> Either EnvelopeFault b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> EnvelopeKey
-> (Text -> Maybe SourceDigest)
-> Either EnvelopeFault SourceDigest
forall {b}.
EnvelopeKey -> (Text -> Maybe b) -> Either EnvelopeFault b
field EnvelopeKey
digest (Text -> Maybe SourceDigest
parseSourceDigestHex (Text -> Maybe SourceDigest)
-> (Text -> Maybe Text) -> Text -> Maybe SourceDigest
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< Text -> Text -> Maybe Text
T.stripPrefix Text
digestLabel)
    epssKeys :: [EnvelopeKey]
epssKeys = [EnvelopeKey
KeyEpssSource, EnvelopeKey
KeyEpssLastModified, EnvelopeKey
KeyEpssDigest]
    epssMarker :: Either EnvelopeFault (Maybe SourceMarker)
epssMarker
        | (EnvelopeKey -> Bool) -> [EnvelopeKey] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all ((Maybe Text -> Maybe Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text -> Maybe Text
forall a. a -> Maybe a
Just Text
noMarker) (Maybe Text -> Bool)
-> (EnvelopeKey -> Maybe Text) -> EnvelopeKey -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. EnvelopeKey -> Maybe Text
lookupKey) [EnvelopeKey]
epssKeys = Maybe SourceMarker -> Either EnvelopeFault (Maybe SourceMarker)
forall a b. b -> Either a b
Right Maybe SourceMarker
forall a. Maybe a
Nothing
        | Bool
otherwise = SourceMarker -> Maybe SourceMarker
forall a. a -> Maybe a
Just (SourceMarker -> Maybe SourceMarker)
-> Either EnvelopeFault SourceMarker
-> Either EnvelopeFault (Maybe SourceMarker)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> EnvelopeKey
-> EnvelopeKey -> EnvelopeKey -> Either EnvelopeFault SourceMarker
marker EnvelopeKey
KeyEpssSource EnvelopeKey
KeyEpssLastModified EnvelopeKey
KeyEpssDigest

within :: [(Text, Text)] -> Either EnvelopeFault [(Text, Text)]
within :: [(Text, Text)] -> Either EnvelopeFault [(Text, Text)]
within [(Text, Text)]
pairs
    | Int
size Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
maxEnvelopeBytes = EnvelopeFault -> Either EnvelopeFault [(Text, Text)]
forall a b. a -> Either a b
Left (Int -> EnvelopeFault
EnvelopeTooLarge Int
size)
    | Bool
otherwise = [(Text, Text)] -> Either EnvelopeFault [(Text, Text)]
forall a b. b -> Either a b
Right [(Text, Text)]
pairs
  where
    size :: Int
size = [Int] -> Int
forall a (f :: * -> *). (Foldable f, Num a) => f a -> a
sum [Text -> Int
forall {a}. ConvertUtf8 a ByteString => a -> Int
utf8Length Text
key Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Text -> Int
forall {a}. ConvertUtf8 a ByteString => a -> Int
utf8Length Text
value | (Text
key, Text
value) <- [(Text, Text)]
pairs]
    utf8Length :: a -> Int
utf8Length a
text = ByteString -> Int
BS.length (a -> ByteString
forall a b. ConvertUtf8 a b => a -> b
encodeUtf8 a
text :: ByteString)

-- An absent timestamp is written as a word, so it never reads as a missing key.
stampOf :: Text -> Maybe (Maybe UTCTime)
stampOf :: Text -> Maybe (Maybe UTCTime)
stampOf Text
value
    | Text
value Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
unknownStamp = Maybe UTCTime -> Maybe (Maybe UTCTime)
forall a. a -> Maybe a
Just Maybe UTCTime
forall a. Maybe a
Nothing
    | Bool
otherwise = UTCTime -> Maybe UTCTime
forall a. a -> Maybe a
Just (UTCTime -> Maybe UTCTime)
-> Maybe UTCTime -> Maybe (Maybe UTCTime)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Text -> Maybe UTCTime
readIso8601Utc Text
value

epssStatusOf :: Text -> Maybe EpssStatus
epssStatusOf :: Text -> Maybe EpssStatus
epssStatusOf Text
value = (EpssStatus -> Bool) -> [EpssStatus] -> Maybe EpssStatus
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Maybe a
find ((Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
value) (Text -> Bool) -> (EpssStatus -> Text) -> EpssStatus -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. EpssStatus -> Text
renderEpssStatus) [EpssStatus
EnrichmentAvailable, EpssStatus
EnrichmentUnavailable]

ecosystemOf :: Text -> Maybe Text
ecosystemOf :: Text -> Maybe Text
ecosystemOf Text
value = Text
value Text -> Maybe () -> Maybe Text
forall a b. a -> Maybe b -> Maybe a
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Bool -> Maybe ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (Bool -> Bool
not (Text -> Bool
T.null Text
value) Bool -> Bool -> Bool
&& Text -> Int -> Ordering
T.compareLength Text
value Int
64 Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
/= Ordering
GT Bool -> Bool -> Bool
&& (Char -> Bool) -> Text -> Bool
T.all Char -> Bool
printableAscii Text
value)

-- Counts fit 'Int64', which also bounds what a hostile value can make the comparison hold.
boundedCount :: Text -> Maybe Integer
boundedCount :: Text -> Maybe Integer
boundedCount Text
value = do
    count <- Text -> Maybe Integer
forall a. Integral a => Text -> Maybe a
readDecimalText Text
value
    count <$ guard (count <= toInteger (maxBound :: Int64))

adjustmentOf :: Text -> Maybe Adjustment
adjustmentOf :: Text -> Maybe Adjustment
adjustmentOf Text
value = (Adjustment -> Bool) -> [Adjustment] -> Maybe Adjustment
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Maybe a
find ((Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
value) (Text -> Bool) -> (Adjustment -> Text) -> Adjustment -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Adjustment -> Text
renderAdjustment) [Adjustment]
forall a. Universe a => [a]
Universe.universe

printableAscii :: Char -> Bool
printableAscii :: Char -> Bool
printableAscii Char
c = Char
c Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
>= Char
' ' Bool -> Bool -> Bool
&& Char
c Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
<= Char
'~'

-- The labels name each hash's input, so a reader never compares a URL hash with a body hash.
identityLabel, digestLabel, unknownStamp, noMarker :: Text
identityLabel :: Text
identityLabel = Text
"sha256-url:"
digestLabel :: Text
digestLabel = Text
"sha256-wire:"
unknownStamp :: Text
unknownStamp = Text
"unknown"
noMarker :: Text
noMarker = Text
"none"