Standalone.hs

module Kiroku.Cli.Standalone (
    StandaloneOptions (..),
    StandaloneRuntime (..),
    standaloneOptionsParser,
    standaloneParserInfo,
    resolveStandaloneOptions,
    runStandaloneCommand,
) where

import Control.Applicative ((<|>))
import Data.Generics.Labels ()
import Data.Text (Text)
import Data.Text qualified as T
import GHC.Generics (Generic)
import Kiroku.Cli.Command (
    KirokuCommand (..),
    RemoteEndpoint (..),
    StatusOptions (..),
    SubscriptionCommand (..),
 )
import Kiroku.Cli.Parser (kirokuCommandParser)
import Kiroku.Cli.Subscription.Status (renderRemoteSubscriptionStatus)
import Options.Applicative (
    Parser,
    ParserInfo,
    fullDesc,
    header,
    helper,
    info,
    progDesc,
    (<**>),
 )

{- | Options for the standalone @kiroku@ binary. The binary is a pure remote
client: it carries only the parsed command (whose @--remote-url@ lives inside
'StatusOptions'); it never opens a store.
-}
newtype StandaloneOptions = StandaloneOptions
    { command :: KirokuCommand
    }
    deriving stock (Generic, Eq, Show)

{- | The resolved command, with any subscription-status endpoint filled in from
@--remote-url@ or @KIROKU_REMOTE_URL@.
-}
newtype StandaloneRuntime = StandaloneRuntime
    { command :: KirokuCommand
    }
    deriving stock (Generic)

standaloneParserInfo :: ParserInfo StandaloneOptions
standaloneParserInfo =
    info
        (standaloneOptionsParser <**> helper)
        ( fullDesc
            <> progDesc
                "Inspect a running Kiroku worker over HTTP. Subscription status queries the worker's \
                \kiroku-metrics /subscriptions endpoint (--remote-url or KIROKU_REMOTE_URL); the binary \
                \opens no store of its own."
            <> header "kiroku - remote operator client for Kiroku event stores"
        )

standaloneOptionsParser :: Parser StandaloneOptions
standaloneOptionsParser =
    StandaloneOptions <$> kirokuCommandParser

{- | Resolve the parsed options into a runnable command. For a subscription-status
command, the endpoint is taken from @--remote-url@ or, failing that, the
@KIROKU_REMOTE_URL@ environment variable; if neither is present, fail with
guidance. Commands that need no endpoint pass through unchanged.
-}
resolveStandaloneOptions :: [(String, String)] -> StandaloneOptions -> Either Text StandaloneRuntime
resolveStandaloneOptions env (StandaloneOptions cmd) =
    case cmd of
        KirokuNoCommand -> Right (StandaloneRuntime KirokuNoCommand)
        KirokuSubscriptions (SubscriptionStatus (StatusOptions format mEndpoint)) ->
            case mEndpoint <|> envEndpoint of
                Just ep ->
                    Right
                        ( StandaloneRuntime
                            (KirokuSubscriptions (SubscriptionStatus (StatusOptions format (Just ep))))
                        )
                Nothing -> Left noEndpointMessage
  where
    envEndpoint =
        case T.pack <$> lookup "KIROKU_REMOTE_URL" env of
            Just url | not (T.null url) -> Just (RemoteEndpoint url)
            _ -> Nothing
    noEndpointMessage =
        "kiroku: no worker endpoint; pass --remote-url or set KIROKU_REMOTE_URL. \
        \The standalone binary inspects a running worker over HTTP; it cannot see \
        \in-process subscriptions because it runs none."

runStandaloneCommand :: StandaloneRuntime -> IO Text
runStandaloneCommand (StandaloneRuntime cmd) =
    case cmd of
        KirokuNoCommand -> pure "No Kiroku operator command was selected."
        KirokuSubscriptions (SubscriptionStatus (StatusOptions format (Just ep))) ->
            renderRemoteSubscriptionStatus ep format
        KirokuSubscriptions (SubscriptionStatus (StatusOptions _ Nothing)) ->
            -- Unreachable: resolveStandaloneOptions fills the endpoint or fails.
            pure
                "kiroku: no worker endpoint; pass --remote-url or set KIROKU_REMOTE_URL."