Use purescript-github-actions-toolkit library (#8)

Author: Colin Wahl

packages.dhall

@@ -1,5 +1,5 @@
 let upstream =
-      https://github.com/purescript/package-sets/releases/download/psc-0.13.8-20200724/packages.dhall sha256:bb941d30820a49345a0e88937094d2b9983d939c9fd3a46969b85ce44953d7d9
+      https://github.com/purescript/package-sets/releases/download/psc-0.13.8-20200909/packages.dhall sha256:b899488adf6f02a92bbaae88039935bbc61bcba4cf4462f6d915fc3d0e094604
 
 in  upstream
   with versions =

spago.dhall

@@ -8,6 +8,7 @@
   , "argonaut-core"
   , "console"
   , "effect"
+  , "github-actions-toolkit"
   , "node-fs"
   , "node-path"
   , "node-process"

src/Actions/Core.js

@@ -2,18 +2,27 @@ module Main where
 
 import Prelude
 
+import Control.Monad.Except.Trans (mapExceptT, runExceptT)
 import Data.Argonaut.Core (Json)
+import Data.Either (Either(..))
 import Data.Foldable (traverse_)
 import Effect (Effect)
-import Effect.Aff (launchAff_)
+import Effect.Aff (launchAff_, runAff_)
+import Effect.Class (liftEffect)
+import Effect.Exception (message)
+import GitHub.Actions.Core as Core
 import Setup.BuildPlan (constructBuildPlan)
 import Setup.GetTool (getTool)
 import Setup.UpdateVersions (updateVersions)
 
 main :: Json -> Effect Unit
-main json = do
-  tools <- constructBuildPlan json
-  launchAff_ $ traverse_ getTool tools
+main json = runAff_ go $ runExceptT do
+  tools <- mapExceptT liftEffect $ constructBuildPlan json
+  traverse_ getTool tools
+  where
+  go res = case join res of
+    Left err -> Core.setFailed (message err)
+    Right a -> pure unit
 
 update :: Effect Unit
 update = launchAff_ updateVersions

src/Actions/Core.purs

@@ -2,22 +2,24 @@ module Setup.BuildPlan (constructBuildPlan, BuildPlan) where
 
 import Prelude
 
-import Actions.Core as Core
+import Control.Monad.Except.Trans (ExceptT)
 import Data.Argonaut.Core (Json)
 import Data.Argonaut.Decode (decodeJson, printJsonDecodeError, (.:))
-import Data.Array as Array
-import Data.Bifunctor (bimap, lmap)
+import Data.Bifunctor (lmap)
 import Data.Either (Either(..))
 import Data.Foldable (fold)
-import Data.Maybe (Maybe(..))
+import Data.Newtype (unwrap)
 import Data.Traversable (traverse)
 import Data.Version (Version)
 import Data.Version as Version
 import Effect (Effect)
 import Effect.Aff (error, throwError)
+import Effect.Class (liftEffect)
+import Effect.Exception (Error)
+import GitHub.Actions.Core as Core
 import Setup.Data.Key (Key)
 import Setup.Data.Key as Key
-import Setup.Data.Tool (Tool, required)
+import Setup.Data.Tool (Tool)
 import Setup.Data.Tool as Tool
 import Text.Parsing.Parser (parseErrorMessage)
 import Text.Parsing.Parser as ParseError
@@ -26,42 +28,34 @@ import Text.Parsing.Parser as ParseError
 type BuildPlan = Array { tool :: Tool, version :: Version }
 
 -- | Construct the list of tools that sholud be downloaded and cached by the action
-constructBuildPlan :: Json -> Effect BuildPlan
-constructBuildPlan json = map Array.catMaybes $ traverse (resolve json) Tool.allTools
+constructBuildPlan :: Json -> ExceptT Error Effect BuildPlan
+constructBuildPlan json = traverse (resolve json) Tool.allTools
 
 -- | The parsed value of an input field that specifies a version
 data VersionField = Latest | Exact Version
 
 -- | Attempt to read the value of an input specifying a tool version
-getVersionField :: Key -> Effect (Maybe (Either String VersionField))
-getVersionField = map (map parse) <<< Core.getInput
-  where
-  parse = case _ of
+getVersionField :: Key -> ExceptT Error Effect VersionField
+getVersionField key = do
+  value <- Core.getInput' (unwrap key)
+  case value of
     "latest" -> pure Latest
-    value -> bimap ParseError.parseErrorMessage Exact (Version.parseVersion value)
+    val -> case Version.parseVersion val of
+      Left msg -> throwError (error (ParseError.parseErrorMessage msg))
+      Right version -> pure (Exact version)
 
 -- | Resolve the exact version to provide for a tool in the environment, based
 -- | on the action.yml file.
-resolve :: Json -> Tool -> Effect (Maybe { tool :: Tool, version :: Version })
+resolve :: Json -> Tool -> ExceptT Error Effect { tool :: Tool, version :: Version }
 resolve versionsContents tool = do
   let key = Key.fromTool tool
-  getVersionField key >>= case _ of
-    Nothing | required tool -> throwError $ error "No input received for required key."
-    Nothing -> pure Nothing
-    Just field -> map Just $ getVersion field
-
-  where
-  getVersion :: Either String VersionField -> Effect { tool :: Tool, version :: Version }
-  getVersion = case _ of
-    Left err -> do
-      Core.setFailed $ fold [ "Unable to parse version: ", err ]
-      throwError $ error "Unable to complete fetching version."
-
-    Right (Exact v) -> do
+  field <- getVersionField key
+  case field of
+    Exact v -> liftEffect do
       Core.info "Found exact version"
       pure { tool, version: v }
 
-    Right Latest -> do
+    Latest -> liftEffect do
       Core.info $ fold [ "Fetching latest tag for ", Tool.name tool ]
 
       let