elm-pages 3.0.0-beta.15 → 3.0.0-beta.17

package/src/ApiRoute.elm

@@ -173,7 +173,7 @@ You define your ApiRoute's in `app/Api.elm`. Here's a simple example:
 -}
 
 import BackendTask exposing (BackendTask)
-import Exception exposing (Throwable)
+import FatalError exposing (FatalError)
 import Head
 import Internal.ApiRoute exposing (ApiRoute(..), ApiRouteBuilder(..))
 import Json.Decode as Decode
@@ -192,14 +192,14 @@ type alias ApiRoute response =
 {-| Same as [`preRender`](#preRender), but for an ApiRoute that has no dynamic segments. This is just a bit simpler because
 since there are no dynamic segments, you don't need to provide a BackendTask with the list of dynamic segments to pre-render because there is only a single possible route.
 -}
-single : ApiRouteBuilder (BackendTask Throwable String) (List String) -> ApiRoute Response
+single : ApiRouteBuilder (BackendTask FatalError String) (List String) -> ApiRoute Response
 single handler =
     handler
         |> preRender (\constructor -> BackendTask.succeed [ constructor ])
 
 
 {-| -}
-serverRender : ApiRouteBuilder (Server.Request.Parser (BackendTask Throwable (Server.Response.Response Never Never))) constructor -> ApiRoute Response
+serverRender : ApiRouteBuilder (Server.Request.Parser (BackendTask FatalError (Server.Response.Response Never Never))) constructor -> ApiRoute Response
 serverRender ((ApiRouteBuilder patterns pattern _ _ _) as fullHandler) =
     ApiRoute
         { regex = Regex.fromString ("^" ++ pattern ++ "$") |> Maybe.withDefault Regex.never
@@ -218,7 +218,7 @@ serverRender ((ApiRouteBuilder patterns pattern _ _ _) as fullHandler) =
                                 |> BackendTask.onError
                                     (\stringError ->
                                         -- TODO make error with title and better context/formatting
-                                        Exception.fromString stringError |> BackendTask.fail
+                                        FatalError.fromString stringError |> BackendTask.fail
                                     )
                                 |> BackendTask.andThen
                                     (\rendered ->
@@ -260,10 +260,10 @@ serverRender ((ApiRouteBuilder patterns pattern _ _ _) as fullHandler) =
 
 
 {-| -}
-preRenderWithFallback : (constructor -> BackendTask Throwable (List (List String))) -> ApiRouteBuilder (BackendTask Throwable (Server.Response.Response Never Never)) constructor -> ApiRoute Response
+preRenderWithFallback : (constructor -> BackendTask FatalError (List (List String))) -> ApiRouteBuilder (BackendTask FatalError (Server.Response.Response Never Never)) constructor -> ApiRoute Response
 preRenderWithFallback buildUrls ((ApiRouteBuilder patterns pattern _ toString constructor) as fullHandler) =
     let
-        buildTimeRoutes__ : BackendTask Throwable (List String)
+        buildTimeRoutes__ : BackendTask FatalError (List String)
         buildTimeRoutes__ =
             buildUrls (constructor [])
                 |> BackendTask.map (List.map toString)
@@ -302,15 +302,15 @@ encodeStaticFileBody fileBody =
 
 
 {-| -}
-preRender : (constructor -> BackendTask Throwable (List (List String))) -> ApiRouteBuilder (BackendTask Throwable String) constructor -> ApiRoute Response
+preRender : (constructor -> BackendTask FatalError (List (List String))) -> ApiRouteBuilder (BackendTask FatalError String) constructor -> ApiRoute Response
 preRender buildUrls ((ApiRouteBuilder patterns pattern _ toString constructor) as fullHandler) =
     let
-        buildTimeRoutes__ : BackendTask Throwable (List String)
+        buildTimeRoutes__ : BackendTask FatalError (List String)
         buildTimeRoutes__ =
             buildUrls (constructor [])
                 |> BackendTask.map (List.map toString)
 
-        preBuiltMatches : BackendTask Throwable (List (List String))
+        preBuiltMatches : BackendTask FatalError (List (List String))
         preBuiltMatches =
             buildUrls (constructor [])
     in
@@ -323,7 +323,7 @@ preRender buildUrls ((ApiRouteBuilder patterns pattern _ toString constructor) a
                     matches =
                         Internal.ApiRoute.pathToMatches path fullHandler
 
-                    routeFound : BackendTask Throwable Bool
+                    routeFound : BackendTask FatalError Bool
                     routeFound =
                         preBuiltMatches
                             |> BackendTask.map (List.member matches)
@@ -431,19 +431,19 @@ capture (ApiRouteBuilder patterns pattern previousHandler toString constructor)
 
 {-| For internal use by generated code. Not so useful in user-land.
 -}
-getBuildTimeRoutes : ApiRoute response -> BackendTask Throwable (List String)
+getBuildTimeRoutes : ApiRoute response -> BackendTask FatalError (List String)
 getBuildTimeRoutes (ApiRoute handler) =
     handler.buildTimeRoutes
 
 
 {-| Include head tags on every page's HTML.
 -}
-withGlobalHeadTags : BackendTask Throwable (List Head.Tag) -> ApiRoute response -> ApiRoute response
+withGlobalHeadTags : BackendTask FatalError (List Head.Tag) -> ApiRoute response -> ApiRoute response
 withGlobalHeadTags globalHeadTags (ApiRoute handler) =
     ApiRoute { handler | globalHeadTags = Just globalHeadTags }
 
 
 {-| -}
-getGlobalHeadTagsBackendTask : ApiRoute response -> Maybe (BackendTask Throwable (List Head.Tag))
+getGlobalHeadTagsBackendTask : ApiRoute response -> Maybe (BackendTask FatalError (List Head.Tag))
 getGlobalHeadTagsBackendTask (ApiRoute handler) =
     handler.globalHeadTags

package/src/BackendTask/{Port.elm → Custom.elm}

@@ -1,38 +1,38 @@
-module BackendTask.Port exposing
-    ( get
+module BackendTask.Custom exposing
+    ( run
     , Error(..)
     )
 
 {-| In a vanilla Elm application, ports let you either send or receive JSON data between your Elm application and the JavaScript context in the user's browser at runtime.
 
-With `BackendTask.Port`, you send and receive JSON to JavaScript running in NodeJS. As with any `BackendTask`, Port BackendTask's are either run at build-time (for pre-rendered routes) or at request-time (for server-rendered routes). See [`BackendTask`](BackendTask) for more about the
+With `BackendTask.Custom`, you send and receive JSON to JavaScript running in NodeJS. As with any `BackendTask`, Custom BackendTask's are either run at build-time (for pre-rendered routes) or at request-time (for server-rendered routes). See [`BackendTask`](BackendTask) for more about the
 lifecycle of `BackendTask`'s.
 
 This means that you can call shell scripts, run NPM packages that are installed, or anything else you could do with NodeJS to perform custom side-effects, get some data, or both.
 
-A `BackendTask.Port` will call an async JavaScript function with the given name from the definition in a file called `port-data-source.js` in your project's root directory. The function receives the input JSON value, and the Decoder is used to decode the return value of the async function.
+A `BackendTask.Custom` will call an async JavaScript function with the given name from the definition in a file called `custom-backend-task.js` in your project's root directory. The function receives the input JSON value, and the Decoder is used to decode the return value of the async function.
 
-@docs get
+@docs run
 
-Here is the Elm code and corresponding JavaScript definition for getting an environment variable (or an `Exception BackendTask.Port.Error` if it isn't found). In this example,
-we're using `BackendTask.throw` to let the framework treat that as an unexpected exception, but we could also handle the possible failures of the `Exception` (see [`Exception`](Exception)).
+Here is the Elm code and corresponding JavaScript definition for getting an environment variable (or an `FatalError BackendTask.Custom.Error` if it isn't found). In this example,
+we're using `BackendTask.allowFatal` to let the framework treat that as an unexpected exception, but we could also handle the possible failures of the `FatalError` (see [`FatalError`](FatalError)).
 
     import BackendTask exposing (BackendTask)
-    import BackendTask.Port
+    import BackendTask.Custom
     import Json.Encode
     import OptimizedDecoder as Decode
 
-    data : BackendTask Throwable String
+    data : BackendTask FatalError String
     data =
-        BackendTask.Port.get "environmentVariable"
+        BackendTask.Custom.run "environmentVariable"
             (Json.Encode.string "EDITOR")
             Decode.string
-            |> BackendTask.throw
+            |> BackendTask.allowFatal
 
     -- will resolve to "VIM" if you run `EDITOR=vim elm-pages dev`
 
 ```javascript
-// port-data-source.js
+// custom-backend-task.js
 
 module.exports =
   /**
@@ -60,33 +60,37 @@ ${Object.keys(process.env).join("\n")}
 ## Performance
 
 As with any JavaScript or NodeJS code, avoid doing blocking IO operations. For example, avoid using `fs.readFileSync`, because blocking IO can slow down your elm-pages builds and dev server. `elm-pages` performances all `BackendTask`'s in parallel whenever possible.
-So if you do `BackendTask.map2 Tuple.pair myHttpBackendTask myPortBackendTask`, it will resolve those two in parallel. NodeJS performs best when you take advantage of its ability to do non-blocking I/O (file reads, HTTP requests, etc.). If you use `BackendTask.andThen`,
-it will need to resolve them in sequence rather than in parallel, but it's still best to avoid blocking IO operations in your BackendTask Port definitions.
+So if you do `BackendTask.map2 Tuple.pair myHttpBackendTask myCustomBackendTask`, it will resolve those two in parallel. NodeJS performs best when you take advantage of its ability to do non-blocking I/O (file reads, HTTP requests, etc.). If you use `BackendTask.andThen`,
+it will need to resolve them in sequence rather than in parallel, but it's still best to avoid blocking IO operations in your Custom BackendTask definitions.
 
 
 ## Error Handling
 
-There are a few different things that can go wrong when running a port-data-source. These possible errors are captured in the `BackendTask.Port.Error` type.
+There are a few different things that can go wrong when running a custom-backend-task. These possible errors are captured in the `BackendTask.Custom.Error` type.
 
 @docs Error
 
-Any time you throw a JavaScript exception from a BackendTask.Port definition, it will give you a `PortCallException`. It's usually easier to add a `try`/`catch` in your JavaScript code in `port-data-source.js`
-to handle possible errors, but you can throw a JSON value and handle it in Elm in the `PortCallException` call error.
+Any time you throw a JavaScript exception from a BackendTask.Custom definition, it will give you a `CustomBackendTaskException`. It's usually easier to add a `try`/`catch` in your JavaScript code in `custom-backend-task.js`
+to handle possible errors, but you can throw a JSON value and handle it in Elm in the `CustomBackendTaskException` call error.
 
 -}
 
 import BackendTask
 import BackendTask.Http
 import BackendTask.Internal.Request
-import Exception exposing (Exception)
+import FatalError exposing (FatalError)
 import Json.Decode as Decode exposing (Decoder)
 import Json.Encode as Encode
 import TerminalText
 
 
 {-| -}
-get : String -> Encode.Value -> Decoder b -> BackendTask.BackendTask (Exception Error) b
-get portName input decoder =
+run :
+    String
+    -> Encode.Value
+    -> Decoder b
+    -> BackendTask.BackendTask { fatal : FatalError, recoverable : Error } b
+run portName input decoder =
     BackendTask.Internal.Request.request
         { name = "port"
         , body =
@@ -100,16 +104,17 @@ get portName input decoder =
                 [ Decode.field "elm-pages-internal-error" Decode.string
                     |> Decode.andThen
                         (\errorKind ->
-                            if errorKind == "PortNotDefined" then
-                                Exception.Exception (PortNotDefined { name = portName })
-                                    { title = "Port Error"
+                            if errorKind == "CustomBackendTaskNotDefined" then
+                                FatalError.recoverable
+                                    { title = "Custom BackendTask Error"
                                     , body =
-                                        [ TerminalText.text "Something went wrong in a call to BackendTask.Port.get. I expected to find a port named `"
+                                        [ TerminalText.text "Something went wrong in a call to BackendTask.Custom.run. I expected to find a port named `"
                                         , TerminalText.yellow portName
-                                        , TerminalText.text "` but I couldn't find it. Is the function exported in your port-data-source file?"
+                                        , TerminalText.text "` but I couldn't find it. Is the function exported in your custom-backend-task file?"
                                         ]
                                             |> TerminalText.toString
                                     }
+                                    (CustomBackendTaskNotDefined { name = portName })
                                     |> Decode.succeed
 
                             else if errorKind == "ExportIsNotFunction" then
@@ -117,75 +122,78 @@ get portName input decoder =
                                     |> Decode.maybe
                                     |> Decode.map (Maybe.withDefault "")
                                     |> Decode.map
-                                        (\incorrectPortType ->
-                                            Exception.Exception ExportIsNotFunction
-                                                { title = "Port Error"
+                                        (\incorrectType ->
+                                            FatalError.recoverable
+                                                { title = "Custom BackendTask Error"
                                                 , body =
-                                                    [ TerminalText.text "Something went wrong in a call to BackendTask.Port.get. I found an export called `"
+                                                    [ TerminalText.text "Something went wrong in a call to BackendTask.Custom.run. I found an export called `"
                                                     , TerminalText.yellow portName
                                                     , TerminalText.text "` but I expected its type to be function, but instead its type was: "
-                                                    , TerminalText.red incorrectPortType
+                                                    , TerminalText.red incorrectType
                                                     ]
                                                         |> TerminalText.toString
                                                 }
+                                                ExportIsNotFunction
                                         )
 
-                            else if errorKind == "MissingPortsFile" then
-                                Exception.Exception MissingPortsFile
-                                    { title = "Port Error"
+                            else if errorKind == "MissingCustomBackendTaskFile" then
+                                FatalError.recoverable
+                                    { title = "Custom BackendTask Error"
                                     , body =
-                                        [ TerminalText.text "Something went wrong in a call to BackendTask.Port.get. I couldn't find your port-data-source file. Be sure to create a 'port-data-source.ts' or 'port-data-source.js' file."
+                                        [ TerminalText.text "Something went wrong in a call to BackendTask.Custom.run. I couldn't find your custom-backend-task file. Be sure to create a 'custom-backend-task.ts' or 'custom-backend-task.js' file."
                                         ]
                                             |> TerminalText.toString
                                     }
+                                    MissingCustomBackendTaskFile
                                     |> Decode.succeed
 
-                            else if errorKind == "ErrorInPortsFile" then
+                            else if errorKind == "ErrorInCustomBackendTaskFile" then
                                 Decode.field "error" Decode.string
                                     |> Decode.maybe
                                     |> Decode.map (Maybe.withDefault "")
                                     |> Decode.map
                                         (\errorMessage ->
-                                            Exception.Exception
-                                                ErrorInPortsFile
-                                                { title = "Port Error"
+                                            FatalError.recoverable
+                                                { title = "Custom BackendTask Error"
                                                 , body =
-                                                    [ TerminalText.text "Something went wrong in a call to BackendTask.Port.get. I couldn't import the port definitions file, because of this exception:\n\n"
+                                                    [ TerminalText.text "Something went wrong in a call to BackendTask.Custom.run. I couldn't import the port definitions file, because of this exception:\n\n"
                                                     , TerminalText.red errorMessage
                                                     , TerminalText.text "\n\nAre there syntax errors or exceptions thrown during import?"
                                                     ]
                                                         |> TerminalText.toString
                                                 }
+                                                ErrorInCustomBackendTaskFile
                                         )
 
-                            else if errorKind == "PortCallException" then
+                            else if errorKind == "CustomBackendTaskException" then
                                 Decode.field "error" Decode.value
                                     |> Decode.maybe
                                     |> Decode.map (Maybe.withDefault Encode.null)
                                     |> Decode.map
                                         (\portCallError ->
-                                            Exception.Exception
-                                                (PortCallException portCallError)
-                                                { title = "Port Error"
+                                            FatalError.recoverable
+                                                { title = "Custom BackendTask Error"
                                                 , body =
-                                                    [ TerminalText.text "Something went wrong in a call to BackendTask.Port.get. I was able to import the port definitions file, but when running it I encountered this exception:\n\n"
+                                                    [ TerminalText.text "Something went wrong in a call to BackendTask.Custom.run. I was able to import the port definitions file, but when running it I encountered this exception:\n\n"
                                                     , TerminalText.red (Encode.encode 2 portCallError)
-                                                    , TerminalText.text "\n\nYou could add a `try`/`catch` in your `port-data-source` JavaScript code to handle that error."
+                                                    , TerminalText.text "\n\nYou could add a `try`/`catch` in your `custom-backend-task` JavaScript code to handle that error."
                                                     ]
                                                         |> TerminalText.toString
                                                 }
+                                                (CustomBackendTaskException portCallError)
                                         )
 
                             else
-                                Exception.Exception ErrorInPortsFile
-                                    { title = "Port Error"
+                                FatalError.recoverable
+                                    { title = "Custom BackendTask Error"
                                     , body =
-                                        [ TerminalText.text "Something went wrong in a call to BackendTask.Port.get. I expected to find a port named `"
+                                        [ TerminalText.text "Something went wrong in a call to BackendTask.Custom.run. I expected to find a port named `"
                                         , TerminalText.yellow portName
                                         , TerminalText.text "`."
                                         ]
                                             |> TerminalText.toString
                                     }
+                                    ErrorInCustomBackendTaskFile
                                     |> Decode.succeed
                         )
                     |> Decode.map Err
@@ -199,8 +207,8 @@ get portName input decoder =
 {-| -}
 type Error
     = Error
-    | ErrorInPortsFile
-    | MissingPortsFile
-    | PortNotDefined { name : String }
-    | PortCallException Decode.Value
+    | ErrorInCustomBackendTaskFile
+    | MissingCustomBackendTaskFile
+    | CustomBackendTaskNotDefined { name : String }
+    | CustomBackendTaskException Decode.Value
     | ExportIsNotFunction

package/src/BackendTask/Env.elm

@@ -8,23 +8,23 @@ down into the final `Data` value, it won't end up in the client!
 
     import BackendTask exposing (BackendTask)
     import BackendTask.Env
-    import Exception exposing (Throwable)
+    import FatalError exposing (FatalError)
 
     type alias EnvVariables =
         { sendGridKey : String
         , siteUrl : String
         }
 
-    sendEmail : Email -> BackendTask Throwable ()
+    sendEmail : Email -> BackendTask FatalError ()
     sendEmail email =
         BackendTask.map2 EnvVariables
-            (BackendTask.Env.expect "SEND_GRID_KEY" |> BackendTask.throw)
+            (BackendTask.Env.expect "SEND_GRID_KEY" |> BackendTask.allowFatal)
             (BackendTask.Env.get "BASE_URL"
                 |> BackendTask.map (Maybe.withDefault "http://localhost:1234")
             )
             |> BackendTask.andThen (sendEmailBackendTask email)
 
-    sendEmailBackendTask : Email -> EnvVariables -> BackendTask Throwable ()
+    sendEmailBackendTask : Email -> EnvVariables -> BackendTask FatalError ()
     sendEmailBackendTask email envVariables =
         Debug.todo "Not defined here"
 
@@ -40,7 +40,7 @@ down into the final `Data` value, it won't end up in the client!
 import BackendTask exposing (BackendTask)
 import BackendTask.Http
 import BackendTask.Internal.Request
-import Exception exposing (Exception)
+import FatalError exposing (FatalError)
 import Json.Decode as Decode
 import Json.Encode as Encode
 import TerminalText
@@ -65,9 +65,9 @@ get envVariableName =
         }
 
 
-{-| Get an environment variable, or a BackendTask Exception if there is no environment variable matching that name.
+{-| Get an environment variable, or a BackendTask FatalError if there is no environment variable matching that name.
 -}
-expect : String -> BackendTask (Exception Error) String
+expect : String -> BackendTask { fatal : FatalError, recoverable : Error } String
 expect envVariableName =
     envVariableName
         |> get
@@ -75,7 +75,7 @@ expect envVariableName =
             (\maybeValue ->
                 maybeValue
                     |> Result.fromMaybe
-                        (Exception.Exception (MissingEnvVariable envVariableName)
+                        (FatalError.recoverable
                             { title = "Missing Env Variable"
                             , body =
                                 [ TerminalText.text "BackendTask.Env.expect was expecting a variable `"
@@ -84,6 +84,7 @@ expect envVariableName =
                                 ]
                                     |> TerminalText.toString
                             }
+                            (MissingEnvVariable envVariableName)
                         )
                     |> BackendTask.fromResult
             )

package/src/BackendTask/File.elm

@@ -51,7 +51,7 @@ plain old JSON in Elm.
 import BackendTask exposing (BackendTask)
 import BackendTask.Http
 import BackendTask.Internal.Request
-import Exception exposing (Exception)
+import FatalError exposing (FatalError)
 import Json.Decode as Decode exposing (Decoder)
 import TerminalText
 
@@ -141,7 +141,15 @@ It's common to parse the body with a markdown parser or other format.
                 )
 
 -}
-bodyWithFrontmatter : (String -> Decoder frontmatter) -> String -> BackendTask (Exception (FileReadError Decode.Error)) frontmatter
+bodyWithFrontmatter :
+    (String -> Decoder frontmatter)
+    -> String
+    ->
+        BackendTask
+            { fatal : FatalError
+            , recoverable : FileReadError Decode.Error
+            }
+            frontmatter
 bodyWithFrontmatter frontmatterDecoder filePath =
     read filePath
         (body
@@ -213,7 +221,15 @@ the [`BackendTask`](BackendTask) API along with [`BackendTask.Glob`](BackendTask
             |> BackendTask.resolve
 
 -}
-onlyFrontmatter : Decoder frontmatter -> String -> BackendTask (Exception (FileReadError Decode.Error)) frontmatter
+onlyFrontmatter :
+    Decoder frontmatter
+    -> String
+    ->
+        BackendTask
+            { fatal : FatalError
+            , recoverable : FileReadError Decode.Error
+            }
+            frontmatter
 onlyFrontmatter frontmatterDecoder filePath =
     read filePath
         (frontmatter frontmatterDecoder)
@@ -240,7 +256,14 @@ Hey there! This is my first post :)
 Then data will yield the value `"Hey there! This is my first post :)"`.
 
 -}
-bodyWithoutFrontmatter : String -> BackendTask (Exception (FileReadError decoderError)) String
+bodyWithoutFrontmatter :
+    String
+    ->
+        BackendTask
+            { fatal : FatalError
+            , recoverable : FileReadError decoderError
+            }
+            String
 bodyWithoutFrontmatter filePath =
     read filePath
         body
@@ -264,7 +287,7 @@ You could read a file called `hello.txt` in your root project directory like thi
         File.rawFile "hello.txt"
 
 -}
-rawFile : String -> BackendTask (Exception (FileReadError decoderError)) String
+rawFile : String -> BackendTask { fatal : FatalError, recoverable : FileReadError decoderError } String
 rawFile filePath =
     read filePath (Decode.field "rawFile" Decode.string)
 
@@ -286,7 +309,15 @@ The Decode will strip off any unused JSON data.
             "elm.json"
 
 -}
-jsonFile : Decoder a -> String -> BackendTask (Exception (FileReadError Decode.Error)) a
+jsonFile :
+    Decoder a
+    -> String
+    ->
+        BackendTask
+            { fatal : FatalError
+            , recoverable : FileReadError Decode.Error
+            }
+            a
 jsonFile jsonFileDecoder filePath =
     rawFile filePath
         |> BackendTask.andThen
@@ -295,13 +326,14 @@ jsonFile jsonFileDecoder filePath =
                     |> Decode.decodeString jsonFileDecoder
                     |> Result.mapError
                         (\jsonDecodeError ->
-                            Exception.Exception (DecodingError jsonDecodeError)
+                            FatalError.recoverable
                                 { title = "JSON Decoding Error"
                                 , body =
                                     [ TerminalText.text (Decode.errorToString jsonDecodeError)
                                     ]
                                         |> TerminalText.toString
                                 }
+                                (DecodingError jsonDecodeError)
                         )
                     |> BackendTask.fromResult
             )
@@ -314,7 +346,7 @@ body =
     Decode.field "withoutFrontmatter" Decode.string
 
 
-read : String -> Decoder a -> BackendTask (Exception (FileReadError error)) a
+read : String -> Decoder a -> BackendTask { fatal : FatalError, recoverable : FileReadError error } a
 read filePath decoder =
     BackendTask.Internal.Request.request
         { name = "read-file"
@@ -330,10 +362,16 @@ read filePath decoder =
         |> BackendTask.andThen BackendTask.fromResult
 
 
-errorDecoder : String -> Decoder (Exception (FileReadError decoding))
+errorDecoder :
+    String
+    ->
+        Decoder
+            { fatal : FatalError
+            , recoverable : FileReadError decoding
+            }
 errorDecoder filePath =
     Decode.succeed
-        (Exception.Exception FileDoesntExist
+        (FatalError.recoverable
             { title = "File Doesn't Exist"
             , body =
                 [ TerminalText.text "Couldn't find file at path `"
@@ -342,4 +380,5 @@ errorDecoder filePath =
                 ]
                     |> TerminalText.toString
             }
+            FileDoesntExist
         )

package/src/BackendTask/Glob.elm

@@ -229,7 +229,7 @@ import BackendTask exposing (BackendTask)
 import BackendTask.Http
 import BackendTask.Internal.Glob exposing (Glob(..))
 import BackendTask.Internal.Request
-import Exception exposing (Exception, Throwable)
+import FatalError exposing (FatalError, Recoverable)
 import Json.Decode as Decode
 import Json.Encode as Encode
 import List.Extra
@@ -1054,7 +1054,7 @@ so it's ideal to make this kind of assertion rather than having fallback behavio
 issues (like if we had instead ignored the case where there are two or more matching blog post files).
 
 -}
-expectUniqueMatch : Glob a -> BackendTask (Exception String) a
+expectUniqueMatch : Glob a -> BackendTask (Recoverable String) a
 expectUniqueMatch glob =
     glob
         |> toBackendTask
@@ -1066,14 +1066,14 @@ expectUniqueMatch glob =
 
                     [] ->
                         BackendTask.fail <|
-                            Exception.fromStringWithValue
-                                ("No files matched the pattern: " ++ toPatternString glob)
+                            FatalError.recoverable
+                                { title = "Non-Unique Glob", body = "No files matched the pattern: " ++ toPatternString glob }
                                 ("No files matched the pattern: " ++ toPatternString glob)
 
                     _ ->
                         BackendTask.fail <|
-                            Exception.fromStringWithValue
-                                "More than one file matched."
+                            FatalError.recoverable
+                                { title = "Non-Unique Glob", body = "Expected a unique match, but more than one file matched." }
                                 "More than one file matched."
             )