Safe Haskell	None
Language	GHC2021

Ecluse.Core.Registry.Publish

Contents

The adapter's protocol codec
The shared transport
The married capability

Description

The mirror-write capability: a shared publish transport, an adapter-provided protocol codec, and the married MirrorPublish handle the worker's per-ecosystem bundle carries.

The mirror write splits along what genuinely varies per ecosystem. The PublishCodec is protocol: how a publish document is assembled and shaped into a request, how a mirror listing is read for the presence probe, and what the registry's status answer means. The MirrorTransport is everything else: the trusted-path connection manager, the credential-minting action (with whatever refresh and breaker apparatus sits behind it), the response bound, and the fault classification into the typed channels. newMirrorPublish marries the two against one mirror-target endpoint; the composition root performs that marriage once per mounted ecosystem, so a new ecosystem contributes a codec and never a transport.

Both effectful operations report failure as a value (FetchFault on the probe, PublishFault on the write), never a throw, so the worker's fall-through and retry-vs-drop decisions stay total at the call site. The codec carries no authentication: the bearer is minted by the transport per call and handed to the codec's request formers, which attach it at the shared single attach point (withToken for npm), preserving the credential-redirect invariant per married client.

Synopsis

data PublishCodec = PublishCodec {
- pcProbeRequest :: Text -> Maybe Secret -> PackageName -> Either UrlFormationError Request
- pcParseVersionList :: RegistryResponse -> Either ParseError [Version]
- pcPublishRequest :: Text -> Maybe Secret -> PackageName -> Version -> MirrorArtifact -> ByteString -> Either UrlFormationError Request
- pcPublishOutcome :: Int -> Either PublishFault ()
}
data MirrorTransport = MirrorTransport {
- ptManager :: Manager
- ptMintToken :: IO (Maybe Secret)
- ptLimits :: Limits
}
data MirrorPublish = MirrorPublish {
- mpProbeMetadata :: PackageName -> IO (Either FetchFault RegistryResponse)
- mpParseVersionList :: RegistryResponse -> Either ParseError [Version]
- mpPublishArtifact :: PackageName -> Version -> MirrorArtifact -> ByteString -> IO (Either PublishFault ())
}
newMirrorPublish :: MirrorTransport -> Text -> PublishCodec -> MirrorPublish

The adapter's protocol codec

data PublishCodec Source #

One ecosystem's mirror-write protocol: the pure request formations and projections that differ per registry protocol, and nothing effectful. An adapter registers exactly one of these (AdapterPublish); the target endpoint and bearer arrive as arguments from the transport, so the codec holds no URL, no credential, and no connection state, and the mirror target's protocol (a packument-fragment PUT, a multipart upload, a binary push) is entirely the codec's to shape through the Request it forms.

Constructors

PublishCodec

Fields

pcProbeRequest :: Text -> Maybe Secret -> PackageName -> Either UrlFormationError Request
Form the mirror-listing read for the presence probe: the package's metadata at the given target endpoint, under the given bearer.
pcParseVersionList :: RegistryResponse -> Either ParseError [Version]
Project a probed metadata response onto the versions the mirror holds.
pcPublishRequest :: Text -> Maybe Secret -> PackageName -> Version -> MirrorArtifact -> ByteString -> Either UrlFormationError Request
Form the complete publish request for one verified artifact: document assembly and request shaping in one step, from the re-admitted artifact's descriptor and the verified bytes.
pcPublishOutcome :: Int -> Either PublishFault ()
What the registry's status answer means for the write: which statuses are success (idempotent already-present answers included, where the protocol has them) and which are the retryable PublishRejected. Protocol semantics, so it lives with the codec: registries disagree on how an immutable re-publish answers.

The shared transport

data MirrorTransport Source #

The shared half of the mirror write: the trusted-path connection manager, the credential mint, and the response bound the probe reads under. Supplied by the environment at construction (the composition root builds one per marriage from process-wide parts), exactly like the queue handle: nothing here is ecosystem-shaped.

Constructors

MirrorTransport

Fields

ptManager :: Manager
The trusted-path connection manager the mirror target is dialled through.
ptMintToken :: IO (Maybe Secret)
Mint the bearer for one request. Minted per call, never cached here: the refresh, expiry, and breaker policy live behind the action (Ecluse.Core.Credential.Refresh), so the marriage always writes under a current token.
ptLimits :: Limits
The response bound the probe's metadata read is held to (fail-closed).

The married capability

data MirrorPublish Source #

The married mirror-write capability one worker bundle carries: the presence probe's read pair and the verified-bytes publish, all bound to one mirror-target endpoint under one credential mint. A record of functions (the Handle pattern), so the worker consumes a plain handle and never sees the codec, the transport, or the adapter that contributed them.

Constructors

MirrorPublish

Fields

mpProbeMetadata :: PackageName -> IO (Either FetchFault RegistryResponse)
Read the package's metadata from the mirror target. Every failure is a FetchFault value (an unformable URL, a bound breach, a transport fault), so the probe's positive-confirmation fall-through is a total match.
mpParseVersionList :: RegistryResponse -> Either ParseError [Version]
Project a probed response onto the versions the mirror holds.
mpPublishArtifact :: PackageName -> Version -> MirrorArtifact -> ByteString -> IO (Either PublishFault ())
Publish one verified artifact to the mirror target. Every failure is a PublishFault value, so the worker's retry-vs-drop decision is total at the call site.

newMirrorPublish :: MirrorTransport -> Text -> PublishCodec -> MirrorPublish Source #

Marry a protocol codec to the shared transport against one mirror-target endpoint. The transport executes what the codec forms: it mints the bearer per call, runs the request over the trusted manager, folds a thrown transport failure into the typed channel (classifyTransport on both the probe's read and the write), reads the probe's body bounded, and hands the write's status answer to the codec's own outcome classification.