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

-- | Native publication validates the archive and preserves its exact bytes.
module Ecluse.Core.Registry.RubyGems.Publish (
    rubyPublish,
    rubyPublishCodec,
    uploadClaims,
    classifyPublish,
) where

import Network.HTTP.Client (Request (method, requestBody, requestHeaders), RequestBody (RequestBodyBS))
import Network.HTTP.Types.Header (hContentType)
import UnliftIO.Exception (evaluate)

import Ecluse.Core.Credential (ClientCredential)
import Ecluse.Core.Deadline (inspectionDeadline)
import Ecluse.Core.Package (hashValue, renderPackageName)
import Ecluse.Core.Registry (FetchFault (FetchUrlUnformable), ParseError (..), PublishBodyFault (PublishMalformed), PublishError (PublishError), PublishFault (..), UrlFormationError (UnparseableUrl), isSuccessStatus)
import Ecluse.Core.Registry.Adapter.Capability
import Ecluse.Core.Registry.CachedDocument (rubyGemsCached)
import Ecluse.Core.Registry.Metadata (VersionDoc (vdRaw))
import Ecluse.Core.Registry.Metadata.Fetch.Preparation (presentedRead)
import Ecluse.Core.Registry.MirrorUpload
import Ecluse.Core.Registry.MirrorUpload.Internal (checkedMirrorUploadData)
import Ecluse.Core.Registry.Origin (OriginClient (ocToken), originBaseUrl)
import Ecluse.Core.Registry.Publish (PublishCodec (..), relayPublishRequest)
import Ecluse.Core.Registry.Request (CredentialMapping, ServicePresentation, StoreOperation (StoreRead, StoreWrite), apiEndpoint, attachCredential, metadataGet, parseRequestEither, presentedMapping)
import Ecluse.Core.Registry.RubyGems.Archive
import Ecluse.Core.Registry.RubyGems.CompactSpec (checkGemSpecification)
import Ecluse.Core.Registry.RubyGems.Credential
import Ecluse.Core.Registry.RubyGems.Document (GemRow (..))
import Ecluse.Core.Registry.RubyGems.Metadata (prepareGemRead)
import Ecluse.Core.Registry.RubyGems.Mirror (mirrorRow, rubyGemsMirrorDocuments, rubyGemsStateFormat, rubyMirrorCompanion)
import Ecluse.Core.Registry.RubyGems.Request (gemInfoUrl)
import Ecluse.Core.Security.Limits (Limits)
import Ecluse.Core.Server.Admission.Types (ChargeFactors (cfFullReadPermille))

-- | Caller publication uses the configured native key and checked OTP header.
rubyPublish :: ChargeFactors -> AdapterPublish
rubyPublish :: ChargeFactors -> AdapterPublish
rubyPublish ChargeFactors
factors =
    AdapterPublish
        { publishRelay :: ServicePresentation
-> OriginClient
-> PackageName
-> PublishRequestBody
-> IO (Either FetchFault PublishRelayResponse)
publishRelay = \ServicePresentation
presentation OriginClient
origin PackageName
_ PublishRequestBody
body -> OriginClient
-> Either UrlFormationError Request
-> IO (Either FetchFault PublishRelayResponse)
relayPublishRequest OriginClient
origin (CredentialMapping
-> Text
-> Maybe ClientCredential
-> PublishExtras
-> Method
-> Either UrlFormationError Request
bodyRequest (ServicePresentation
-> StoreOperation -> CredentialMapping -> CredentialMapping
presentedMapping ServicePresentation
presentation StoreOperation
StoreWrite CredentialMapping
rubyPublishCredential) (OriginClient -> Text
originBaseUrl OriginClient
origin) (OriginClient -> Maybe ClientCredential
ocToken OriginClient
origin) (PublishRequestBody -> PublishExtras
publishBodyExtras PublishRequestBody
body) (PublishRequestBody -> Method
publishBodyBytes PublishRequestBody
body))
        , publishCredential :: CredentialMapping
publishCredential = CredentialMapping
rubyPublishCredential
        , publishRequestExtras :: RequestHeaders -> Either PublishBodyFault PublishExtras
publishRequestExtras = RequestHeaders -> Either PublishBodyFault PublishExtras
rubyPublishExtras
        , publishUploadClaims :: Limits
-> (Int -> IO ())
-> Text
-> PublishRequestBody
-> IO (Either PublishBodyFault [Text])
publishUploadClaims = Limits
-> (Int -> IO ())
-> Text
-> PublishRequestBody
-> IO (Either PublishBodyFault [Text])
uploadClaims
        , publishCodec :: ServicePresentation -> PublishCodec
publishCodec = ChargeFactors -> ServicePresentation -> PublishCodec
rubyPublishCodec ChargeFactors
factors
        , publishMirrorRequirements :: MirrorRequirements
publishMirrorRequirements = WorkerMetadataRead
-> MirrorStateFormat
-> MirrorStateRequirement
-> MirrorRequirements
MirrorRequirements (PrepareRead -> WorkerMetadataRead
NativeChargedWorkerRead PrepareRead
prepareGemRead) MirrorStateFormat
rubyGemsStateFormat (MirrorDocuments -> MirrorStateRequirement
DurableVersionState MirrorDocuments
rubyGemsMirrorDocuments)
        , publishUploadEndpoint :: UploadEndpointRequirement
publishUploadEndpoint = UploadEndpointRequirement
ReadRootUpload
        , publishIdentity :: UploadIdentityRequirement
publishIdentity = UploadIdentityRequirement
TokenIdentity
        }

-- | Reads present the Basic pair and writes the raw API key, unless the target store declares otherwise.
rubyPublishCodec :: ChargeFactors -> ServicePresentation -> PublishCodec
rubyPublishCodec :: ChargeFactors -> ServicePresentation -> PublishCodec
rubyPublishCodec ChargeFactors
factors ServicePresentation
presentation =
    PublishCodec
        { pcPrepareSource :: PackageName
-> Version
-> VersionDoc
-> Either PublishFault (MirrorInventory, ())
pcPrepareSource = \PackageName
name Version
version VersionDoc
doc -> do
            source <- PublishFault
-> Maybe GemDocument -> Either PublishFault GemDocument
forall l r. l -> Maybe r -> Either l r
maybeToRight (Text -> PublishFault
PublishSourceUnavailable Text
"RubyGems snapshot has no paired native source") (VersionDoc -> Maybe CachedDoc
vdRaw VersionDoc
doc Maybe CachedDoc
-> (CachedDoc -> Maybe GemDocument) -> Maybe GemDocument
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (GemDocument -> CachedDoc, CachedDoc -> Maybe GemDocument)
-> CachedDoc -> Maybe GemDocument
forall a b. (a, b) -> b
snd (GemDocument -> CachedDoc, CachedDoc -> Maybe GemDocument)
rubyGemsCached)
            inventory <- checkedMirrorInventory name version doc (RubyGemsMirrorRead source)
            pure (inventory, ())
        , pcPrepareUpload :: Deadlines
-> Limits
-> (Int -> IO ())
-> MirrorInventory
-> ()
-> ExpectedMirrorFile
-> VerifiedArtifactBytes
-> IO (Either PublishFault (MirrorUploadData GemArchive))
pcPrepareUpload = \Deadlines
deadlines Limits
limits Int -> IO ()
charge MirrorInventory
inventory () ExpectedMirrorFile
file VerifiedArtifactBytes
verified -> Deadlines
-> PublishFault
-> IO (Either PublishFault (MirrorUploadData GemArchive))
-> IO (Either PublishFault (MirrorUploadData GemArchive))
forall e a. Deadlines -> e -> IO (Either e a) -> IO (Either e a)
inspectionDeadline Deadlines
deadlines (Text -> PublishFault
PublishSourceUnavailable Text
"gem archive validation timed out") (IO (Either PublishFault (MirrorUploadData GemArchive))
 -> IO (Either PublishFault (MirrorUploadData GemArchive)))
-> IO (Either PublishFault (MirrorUploadData GemArchive))
-> IO (Either PublishFault (MirrorUploadData GemArchive))
forall a b. (a -> b) -> a -> b
$ do
            inspected <- Limits
-> (Int -> IO ()) -> Method -> IO (Either ParseError GemArchive)
inspectGemArchive Limits
limits Int -> IO ()
charge (VerifiedArtifactBytes -> Method
verifiedBytes VerifiedArtifactBytes
verified)
            evaluate $ do
                archive <- first (PublishSourceUnavailable . parseErrorMessage) (inspected >>= checkRawEnvelope)
                row <- mirrorRow inventory file
                checked <- first (PublishSourceUnavailable . parseErrorMessage) (checkGemArchive (grCoordinate row) (hashValue (grChecksum row)) archive)
                _ <- first (PublishSourceUnavailable . parseErrorMessage) (checkGemSpecification (grCoordinate row) row (gemArchiveSpecification checked))
                checkedMirrorUploadData inventory file verified checked
        , pcMirrorCompanion :: Maybe MirrorCompanion
pcMirrorCompanion = MirrorCompanion -> Maybe MirrorCompanion
forall a. a -> Maybe a
Just MirrorCompanion
rubyMirrorCompanion
        , pcNativeComplete :: PackageName -> Version -> PackageInfo -> Bool
pcNativeComplete = \PackageName
_ Version
_ PackageInfo
_ -> Bool
False
        , pcTargetRead :: PrepareRead
pcTargetRead = CredentialMapping -> PrepareRead -> PrepareRead
presentedRead CredentialMapping
readAs PrepareRead
prepareGemRead
        , pcTargetReadPermille :: Int
pcTargetReadPermille = ChargeFactors -> Int
cfFullReadPermille ChargeFactors
factors
        , pcProbeRequest :: Text
-> Maybe ClientCredential
-> PackageName
-> Either UrlFormationError Request
pcProbeRequest = \Text
target Maybe ClientCredential
credential PackageName
name -> CredentialMapping
-> Maybe ClientCredential -> Method -> Request -> Request
metadataGet CredentialMapping
readAs Maybe ClientCredential
credential Method
"text/plain" (Request -> Request)
-> Either UrlFormationError Request
-> Either UrlFormationError Request
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Text -> PackageName -> Either UrlFormationError Text
gemInfoUrl Text
target PackageName
name Either UrlFormationError Text
-> (Text -> Either UrlFormationError Request)
-> Either UrlFormationError Request
forall a b.
Either UrlFormationError a
-> (a -> Either UrlFormationError b) -> Either UrlFormationError b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Text -> Either UrlFormationError Request
parseRequestEither)
        , pcVersionListWalk :: Maybe (Limits -> Cursor -> Step VersionListState)
pcVersionListWalk = Maybe (Limits -> Cursor -> Step VersionListState)
forall a. Maybe a
Nothing
        , pcPrepareTarget :: OriginClient
-> RegistryUrl -> IO (Either MetadataError RegistryUrl)
pcPrepareTarget = \OriginClient
_ RegistryUrl
target -> Either MetadataError RegistryUrl
-> IO (Either MetadataError RegistryUrl)
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (RegistryUrl -> Either MetadataError RegistryUrl
forall a b. b -> Either a b
Right RegistryUrl
target)
        , pcPublishRequest :: Text
-> Maybe ClientCredential
-> PublishPlan
-> MirrorUploadData GemArchive
-> Either PublishFault Request
pcPublishRequest = \Text
target Maybe ClientCredential
credential PublishPlan
_ MirrorUploadData GemArchive
upload -> (UrlFormationError -> PublishFault)
-> Either UrlFormationError Request -> Either PublishFault Request
forall a b c. (a -> b) -> Either a c -> Either b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first (FetchFault -> PublishFault
PublishFetch (FetchFault -> PublishFault)
-> (UrlFormationError -> FetchFault)
-> UrlFormationError
-> PublishFault
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UrlFormationError -> FetchFault
FetchUrlUnformable) (CredentialMapping
-> Text
-> Maybe ClientCredential
-> PublishExtras
-> Method
-> Either UrlFormationError Request
bodyRequest (ServicePresentation
-> StoreOperation -> CredentialMapping -> CredentialMapping
presentedMapping ServicePresentation
presentation StoreOperation
StoreWrite CredentialMapping
rubyPublishCredential) Text
target Maybe ClientCredential
credential PublishExtras
NoPublishExtras (MirrorUploadData GemArchive -> Method
forall metadata. MirrorUploadData metadata -> Method
uploadBytes MirrorUploadData GemArchive
upload))
        , pcPublishOutcome :: Int -> Method -> Either PublishFault ()
pcPublishOutcome = Int -> Method -> Either PublishFault ()
classifyPublish
        }
  where
    readAs :: CredentialMapping
readAs = ServicePresentation
-> StoreOperation -> CredentialMapping -> CredentialMapping
presentedMapping ServicePresentation
presentation StoreOperation
StoreRead CredentialMapping
rubyReadCredential

-- | Archive identity controls first-party ownership before the server forwards any bytes.
uploadClaims :: Limits -> (Int -> IO ()) -> Text -> PublishRequestBody -> IO (Either PublishBodyFault [Text])
uploadClaims :: Limits
-> (Int -> IO ())
-> Text
-> PublishRequestBody
-> IO (Either PublishBodyFault [Text])
uploadClaims Limits
limits Int -> IO ()
charge Text
_ PublishRequestBody
body = do
    inspected <- Limits
-> (Int -> IO ()) -> Method -> IO (Either ParseError GemArchive)
inspectGemArchive Limits
limits Int -> IO ()
charge (PublishRequestBody -> Method
publishBodyBytes PublishRequestBody
body)
    case inspected >>= checkRawEnvelope of
        Left ParseError
fault -> Either PublishBodyFault [Text]
-> IO (Either PublishBodyFault [Text])
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (PublishBodyFault -> Either PublishBodyFault [Text]
forall a b. a -> Either a b
Left (ParseError -> PublishBodyFault
PublishMalformed ParseError
fault))
        Right GemArchive
archive -> do
            name <- PackageName -> IO PackageName
forall (m :: * -> *) a. MonadIO m => a -> m a
evaluate (GemArchive -> PackageName
gemArchiveName GemArchive
archive)
            pure (Right [renderPackageName name])

bodyRequest :: CredentialMapping -> Text -> Maybe ClientCredential -> PublishExtras -> ByteString -> Either UrlFormationError Request
bodyRequest :: CredentialMapping
-> Text
-> Maybe ClientCredential
-> PublishExtras
-> Method
-> Either UrlFormationError Request
bodyRequest CredentialMapping
credentialMapping Text
target Maybe ClientCredential
credential PublishExtras
extras Method
bytes = do
    base <- UrlFormationError
-> Text -> Text -> Either UrlFormationError Request
apiEndpoint (Text -> UrlFormationError
UnparseableUrl Text
"RubyGems publication root contains a query or fragment") Text
target Text
"api/v1/gems"
    pure . attachCredential credentialMapping credential $
        base
            { method = "POST"
            , requestHeaders = (hContentType, "application/octet-stream") : rubyOtpHeaders extras
            , requestBody = RequestBodyBS bytes
            }

-- | A successful write still needs an independent whole-version inventory proof.
classifyPublish :: Int -> ByteString -> Either PublishFault ()
classifyPublish :: Int -> Method -> Either PublishFault ()
classifyPublish Int
status Method
_
    | Int -> Bool
isSuccessStatus Int
status = () -> Either PublishFault ()
forall a b. b -> Either a b
Right ()
    | Bool
otherwise = PublishFault -> Either PublishFault ()
forall a b. a -> Either a b
Left (PublishError -> PublishFault
PublishRejected (Text -> PublishError
PublishError (Text
"RubyGems publication failed with HTTP status " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Int -> Text
forall b a. (Show a, IsString b) => a -> b
show Int
status)))