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

package/src/ApiRoute.elm

@@ -5,12 +5,12 @@ module ApiRoute exposing
     , ApiRoute, ApiRouteBuilder, Response
     , capture, literal, slash, succeed
     , withGlobalHeadTags
-    , toJson, getBuildTimeRoutes, getGlobalHeadTagsDataSource
+    , toJson, getBuildTimeRoutes, getGlobalHeadTagsBackendTask
     )
 
 {-| ApiRoute's are defined in `src/Api.elm` and are a way to generate files, like RSS feeds, sitemaps, or any text-based file that you output with an Elm function! You get access
-to a DataSource so you can pull in HTTP data, etc. Because ApiRoutes don't hydrate into Elm apps (like pages in elm-pages do), you can pull in as much data as you want in
-the DataSource for your ApiRoutes, and it won't effect the payload size. Instead, the size of an ApiRoute is just the content you output for that route.
+to a BackendTask so you can pull in HTTP data, etc. Because ApiRoutes don't hydrate into Elm apps (like pages in elm-pages do), you can pull in as much data as you want in
+the BackendTask for your ApiRoutes, and it won't effect the payload size. Instead, the size of an ApiRoute is just the content you output for that route.
 
 Similar to your elm-pages Route Modules, ApiRoute's can be either server-rendered or pre-rendered. Let's compare the differences between pre-rendered and server-rendered ApiRoutes, and the different
 use cases they support.
@@ -25,7 +25,7 @@ A pre-rendered ApiRoute is just a generated file. For example:
   - A redirect file for a hosting provider like Netlify
 
 You could even generate a JavaScript file, an Elm file, or any file with a String body! It's really just a way to generate files, which are typically used to serve files to a user or Browser, but you execute them, copy them, etc. The only limit is your imagination!
-The beauty is that you have a way to 1) pull in type-safe data using DataSource's, and 2) write those files, and all in pure Elm!
+The beauty is that you have a way to 1) pull in type-safe data using BackendTask's, and 2) write those files, and all in pure Elm!
 
 @docs single, preRender
 
@@ -62,11 +62,11 @@ You define your ApiRoute's in `app/Api.elm`. Here's a simple example:
     module Api exposing (routes)
 
     import ApiRoute
-    import DataSource exposing (DataSource)
+    import BackendTask exposing (BackendTask)
     import Server.Request
 
     routes :
-        DataSource (List Route)
+        BackendTask (List Route)
         -> (Maybe { indent : Int, newLines : Bool } -> Html Never -> String)
         -> List (ApiRoute.ApiRoute ApiRoute.Response)
     routes getStaticRoutes htmlToString =
@@ -89,7 +89,7 @@ You define your ApiRoute's in `app/Api.elm`. Here's a simple example:
     preRenderedExample =
         ApiRoute.succeed
             (\userId ->
-                DataSource.succeed
+                BackendTask.succeed
                     (Json.Encode.object
                         [ ( "id", Json.Encode.string userId )
                         , ( "name", "Data for user " ++ userId |> Json.Encode.string )
@@ -103,7 +103,7 @@ You define your ApiRoute's in `app/Api.elm`. Here's a simple example:
             |> ApiRoute.literal ".json"
             |> ApiRoute.preRender
                 (\route ->
-                    DataSource.succeed
+                    BackendTask.succeed
                         [ route "1"
                         , route "2"
                         , route "3"
@@ -144,7 +144,7 @@ You define your ApiRoute's in `app/Api.elm`. Here's a simple example:
                           )
                         ]
                         |> Response.json
-                        |> DataSource.succeed
+                        |> BackendTask.succeed
                 )
                 Server.Request.rawBody
                 Server.Request.method
@@ -168,12 +168,12 @@ You define your ApiRoute's in `app/Api.elm`. Here's a simple example:
 
 ## Internals
 
-@docs toJson, getBuildTimeRoutes, getGlobalHeadTagsDataSource
+@docs toJson, getBuildTimeRoutes, getGlobalHeadTagsBackendTask
 
 -}
 
-import DataSource exposing (DataSource)
-import DataSource.Http
+import BackendTask exposing (BackendTask)
+import Exception exposing (Throwable)
 import Head
 import Internal.ApiRoute exposing (ApiRoute(..), ApiRouteBuilder(..))
 import Json.Decode as Decode
@@ -190,28 +190,37 @@ 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 DataSource with the list of dynamic segments to pre-render because there is only a single possible route.
+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 (DataSource String) (List String) -> ApiRoute Response
+single : ApiRouteBuilder (BackendTask Throwable String) (List String) -> ApiRoute Response
 single handler =
     handler
-        |> preRender (\constructor -> DataSource.succeed [ constructor ])
+        |> preRender (\constructor -> BackendTask.succeed [ constructor ])
 
 
 {-| -}
-serverRender : ApiRouteBuilder (Server.Request.Parser (DataSource (Server.Response.Response Never Never))) constructor -> ApiRoute Response
+serverRender : ApiRouteBuilder (Server.Request.Parser (BackendTask Throwable (Server.Response.Response Never Never))) constructor -> ApiRoute Response
 serverRender ((ApiRouteBuilder patterns pattern _ _ _) as fullHandler) =
     ApiRoute
         { regex = Regex.fromString ("^" ++ pattern ++ "$") |> Maybe.withDefault Regex.never
         , matchesToResponse =
-            \path ->
+            \serverRequest path ->
                 Internal.ApiRoute.tryMatch path fullHandler
                     |> Maybe.map
-                        (\toDataSource ->
-                            DataSource.Http.get
-                                "$$elm-pages$$headers"
-                                (toDataSource |> Server.Request.getDecoder |> Decode.map Just)
-                                |> DataSource.andThen
+                        (\toBackendTask ->
+                            Server.Request.getDecoder toBackendTask
+                                |> (\decoder ->
+                                        Decode.decodeValue decoder serverRequest
+                                            |> Result.mapError Decode.errorToString
+                                            |> BackendTask.fromResult
+                                            |> BackendTask.map Just
+                                   )
+                                |> BackendTask.onError
+                                    (\stringError ->
+                                        -- TODO make error with title and better context/formatting
+                                        Exception.fromString stringError |> BackendTask.fail
+                                    )
+                                |> BackendTask.andThen
                                     (\rendered ->
                                         case rendered of
                                             Just (Ok okRendered) ->
@@ -222,21 +231,21 @@ serverRender ((ApiRouteBuilder patterns pattern _ _ _) as fullHandler) =
                                                     |> Server.Request.errorsToString
                                                     |> Server.Response.plainText
                                                     |> Server.Response.withStatusCode 400
-                                                    |> DataSource.succeed
+                                                    |> BackendTask.succeed
 
                                             Nothing ->
                                                 Server.Response.plainText "No matching request handler"
                                                     |> Server.Response.withStatusCode 400
-                                                    |> DataSource.succeed
+                                                    |> BackendTask.succeed
                                     )
                         )
-                    |> Maybe.map (DataSource.map (Server.Response.toJson >> Just))
+                    |> Maybe.map (BackendTask.map (Server.Response.toJson >> Just))
                     |> Maybe.withDefault
-                        (DataSource.succeed Nothing)
-        , buildTimeRoutes = DataSource.succeed []
+                        (BackendTask.succeed Nothing)
+        , buildTimeRoutes = BackendTask.succeed []
         , handleRoute =
             \path ->
-                DataSource.succeed
+                BackendTask.succeed
                     (case Internal.ApiRoute.tryMatch path fullHandler of
                         Just _ ->
                             True
@@ -251,26 +260,26 @@ serverRender ((ApiRouteBuilder patterns pattern _ _ _) as fullHandler) =
 
 
 {-| -}
-preRenderWithFallback : (constructor -> DataSource (List (List String))) -> ApiRouteBuilder (DataSource (Server.Response.Response Never Never)) constructor -> ApiRoute Response
+preRenderWithFallback : (constructor -> BackendTask Throwable (List (List String))) -> ApiRouteBuilder (BackendTask Throwable (Server.Response.Response Never Never)) constructor -> ApiRoute Response
 preRenderWithFallback buildUrls ((ApiRouteBuilder patterns pattern _ toString constructor) as fullHandler) =
     let
-        buildTimeRoutes__ : DataSource (List String)
+        buildTimeRoutes__ : BackendTask Throwable (List String)
         buildTimeRoutes__ =
             buildUrls (constructor [])
-                |> DataSource.map (List.map toString)
+                |> BackendTask.map (List.map toString)
     in
     ApiRoute
         { regex = Regex.fromString ("^" ++ pattern ++ "$") |> Maybe.withDefault Regex.never
         , matchesToResponse =
-            \path ->
+            \_ path ->
                 Internal.ApiRoute.tryMatch path fullHandler
-                    |> Maybe.map (DataSource.map (Server.Response.toJson >> Just))
+                    |> Maybe.map (BackendTask.map (Server.Response.toJson >> Just))
                     |> Maybe.withDefault
-                        (DataSource.succeed Nothing)
+                        (BackendTask.succeed Nothing)
         , buildTimeRoutes = buildTimeRoutes__
         , handleRoute =
             \path ->
-                DataSource.succeed
+                BackendTask.succeed
                     (case Internal.ApiRoute.tryMatch path fullHandler of
                         Just _ ->
                             True
@@ -293,42 +302,42 @@ encodeStaticFileBody fileBody =
 
 
 {-| -}
-preRender : (constructor -> DataSource (List (List String))) -> ApiRouteBuilder (DataSource String) constructor -> ApiRoute Response
+preRender : (constructor -> BackendTask Throwable (List (List String))) -> ApiRouteBuilder (BackendTask Throwable String) constructor -> ApiRoute Response
 preRender buildUrls ((ApiRouteBuilder patterns pattern _ toString constructor) as fullHandler) =
     let
-        buildTimeRoutes__ : DataSource (List String)
+        buildTimeRoutes__ : BackendTask Throwable (List String)
         buildTimeRoutes__ =
             buildUrls (constructor [])
-                |> DataSource.map (List.map toString)
+                |> BackendTask.map (List.map toString)
 
-        preBuiltMatches : DataSource (List (List String))
+        preBuiltMatches : BackendTask Throwable (List (List String))
         preBuiltMatches =
             buildUrls (constructor [])
     in
     ApiRoute
         { regex = Regex.fromString ("^" ++ pattern ++ "$") |> Maybe.withDefault Regex.never
         , matchesToResponse =
-            \path ->
+            \_ path ->
                 let
                     matches : List String
                     matches =
                         Internal.ApiRoute.pathToMatches path fullHandler
 
-                    routeFound : DataSource Bool
+                    routeFound : BackendTask Throwable Bool
                     routeFound =
                         preBuiltMatches
-                            |> DataSource.map (List.member matches)
+                            |> BackendTask.map (List.member matches)
                 in
                 routeFound
-                    |> DataSource.andThen
+                    |> BackendTask.andThen
                         (\found ->
                             if found then
                                 Internal.ApiRoute.tryMatch path fullHandler
-                                    |> Maybe.map (DataSource.map (encodeStaticFileBody >> Just))
-                                    |> Maybe.withDefault (DataSource.succeed Nothing)
+                                    |> Maybe.map (BackendTask.map (encodeStaticFileBody >> Just))
+                                    |> Maybe.withDefault (BackendTask.succeed Nothing)
 
                             else
-                                DataSource.succeed Nothing
+                                BackendTask.succeed Nothing
                         )
         , buildTimeRoutes = buildTimeRoutes__
         , handleRoute =
@@ -339,7 +348,7 @@ preRender buildUrls ((ApiRouteBuilder patterns pattern _ toString constructor) a
                         Internal.ApiRoute.pathToMatches path fullHandler
                 in
                 preBuiltMatches
-                    |> DataSource.map (List.member matches)
+                    |> BackendTask.map (List.member matches)
         , pattern = patterns
         , kind = "prerender"
         , globalHeadTags = Nothing
@@ -422,25 +431,19 @@ capture (ApiRouteBuilder patterns pattern previousHandler toString constructor)
 
 {-| For internal use by generated code. Not so useful in user-land.
 -}
-getBuildTimeRoutes : ApiRoute response -> DataSource (List String)
+getBuildTimeRoutes : ApiRoute response -> BackendTask Throwable (List String)
 getBuildTimeRoutes (ApiRoute handler) =
     handler.buildTimeRoutes
 
 
 {-| Include head tags on every page's HTML.
 -}
-withGlobalHeadTags : DataSource (List Head.Tag) -> ApiRoute response -> ApiRoute response
+withGlobalHeadTags : BackendTask Throwable (List Head.Tag) -> ApiRoute response -> ApiRoute response
 withGlobalHeadTags globalHeadTags (ApiRoute handler) =
     ApiRoute { handler | globalHeadTags = Just globalHeadTags }
 
 
 {-| -}
-getGlobalHeadTagsDataSource : ApiRoute response -> Maybe (DataSource (List Head.Tag))
-getGlobalHeadTagsDataSource (ApiRoute handler) =
+getGlobalHeadTagsBackendTask : ApiRoute response -> Maybe (BackendTask Throwable (List Head.Tag))
+getGlobalHeadTagsBackendTask (ApiRoute handler) =
     handler.globalHeadTags
-
-
-
---captureRest : ApiRouteBuilder (List String -> a) b -> ApiRouteBuilder a b
---captureRest previousHandler =
---    Debug.todo ""

package/src/BackendTask/Env.elm

@@ -0,0 +1,89 @@
+module BackendTask.Env exposing
+    ( get, expect
+    , Error(..)
+    )
+
+{-| Because BackendTask's in `elm-pages` never run in the browser (see [the BackendTask docs](BackendTask)), you can access environment variables securely. As long as the environment variable isn't sent
+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)
+
+    type alias EnvVariables =
+        { sendGridKey : String
+        , siteUrl : String
+        }
+
+    sendEmail : Email -> BackendTask Throwable ()
+    sendEmail email =
+        BackendTask.map2 EnvVariables
+            (BackendTask.Env.expect "SEND_GRID_KEY" |> BackendTask.throw)
+            (BackendTask.Env.get "BASE_URL"
+                |> BackendTask.map (Maybe.withDefault "http://localhost:1234")
+            )
+            |> BackendTask.andThen (sendEmailBackendTask email)
+
+    sendEmailBackendTask : Email -> EnvVariables -> BackendTask Throwable ()
+    sendEmailBackendTask email envVariables =
+        Debug.todo "Not defined here"
+
+@docs get, expect
+
+
+## Errors
+
+@docs Error
+
+-}
+
+import BackendTask exposing (BackendTask)
+import BackendTask.Http
+import BackendTask.Internal.Request
+import Exception exposing (Exception)
+import Json.Decode as Decode
+import Json.Encode as Encode
+import TerminalText
+
+
+{-| -}
+type Error
+    = MissingEnvVariable String
+
+
+{-| Get an environment variable, or Nothing if there is no environment variable matching that name. This `BackendTask`
+will never fail, but instead will return `Nothing` if the environment variable is missing.
+-}
+get : String -> BackendTask error (Maybe String)
+get envVariableName =
+    BackendTask.Internal.Request.request
+        { name = "env"
+        , body = BackendTask.Http.jsonBody (Encode.string envVariableName)
+        , expect =
+            BackendTask.Http.expectJson
+                (Decode.nullable Decode.string)
+        }
+
+
+{-| Get an environment variable, or a BackendTask Exception if there is no environment variable matching that name.
+-}
+expect : String -> BackendTask (Exception Error) String
+expect envVariableName =
+    envVariableName
+        |> get
+        |> BackendTask.andThen
+            (\maybeValue ->
+                maybeValue
+                    |> Result.fromMaybe
+                        (Exception.Exception (MissingEnvVariable envVariableName)
+                            { title = "Missing Env Variable"
+                            , body =
+                                [ TerminalText.text "BackendTask.Env.expect was expecting a variable `"
+                                , TerminalText.yellow envVariableName
+                                , TerminalText.text "` but couldn't find a variable with that name."
+                                ]
+                                    |> TerminalText.toString
+                            }
+                        )
+                    |> BackendTask.fromResult
+            )

package/src/{DataSource → BackendTask}/File.elm

@@ -1,9 +1,10 @@
-module DataSource.File exposing
+module BackendTask.File exposing
     ( bodyWithFrontmatter, bodyWithoutFrontmatter, onlyFrontmatter
     , jsonFile, rawFile
+    , FileReadError(..)
     )
 
-{-| This module lets you read files from the local filesystem as a [`DataSource`](DataSource#DataSource).
+{-| This module lets you read files from the local filesystem as a [`BackendTask`](BackendTask#BackendTask).
 File paths are relative to the root of your `elm-pages` project (next to the `elm.json` file and `src/` directory).
 
 
@@ -40,12 +41,19 @@ plain old JSON in Elm.
 
 @docs jsonFile, rawFile
 
+
+## Exceptions
+
+@docs FileReadError
+
 -}
 
-import DataSource exposing (DataSource)
-import DataSource.Http
-import DataSource.Internal.Request
+import BackendTask exposing (BackendTask)
+import BackendTask.Http
+import BackendTask.Internal.Request
+import Exception exposing (Exception)
 import Json.Decode as Decode exposing (Decoder)
+import TerminalText
 
 
 frontmatter : Decoder frontmatter -> Decoder frontmatter
@@ -55,11 +63,11 @@ frontmatter frontmatterDecoder =
 
 {-|
 
-    import DataSource exposing (DataSource)
-    import DataSource.File as File
+    import BackendTask exposing (BackendTask)
+    import BackendTask.File as File
     import Decode as Decode exposing (Decoder)
 
-    blogPost : DataSource BlogPostMetadata
+    blogPost : BackendTask BlogPostMetadata
     blogPost =
         File.bodyWithFrontmatter blogPostDecoder
             "blog/hello-world.md"
@@ -81,7 +89,7 @@ frontmatter frontmatterDecoder =
         Decode.map (String.split " ")
             Decode.string
 
-This will give us a DataSource that results in the following value:
+This will give us a BackendTask that results in the following value:
 
     value =
         { body = "Hey there! This is my first post :)"
@@ -91,13 +99,13 @@ This will give us a DataSource that results in the following value:
 
 It's common to parse the body with a markdown parser or other format.
 
-    import DataSource exposing (DataSource)
-    import DataSource.File as File
+    import BackendTask exposing (BackendTask)
+    import BackendTask.File as File
     import Decode as Decode exposing (Decoder)
     import Html exposing (Html)
 
     example :
-        DataSource
+        BackendTask
             { title : String
             , body : List (Html msg)
             }
@@ -133,7 +141,7 @@ It's common to parse the body with a markdown parser or other format.
                 )
 
 -}
-bodyWithFrontmatter : (String -> Decoder frontmatter) -> String -> DataSource frontmatter
+bodyWithFrontmatter : (String -> Decoder frontmatter) -> String -> BackendTask (Exception (FileReadError Decode.Error)) frontmatter
 bodyWithFrontmatter frontmatterDecoder filePath =
     read filePath
         (body
@@ -144,16 +152,23 @@ bodyWithFrontmatter frontmatterDecoder filePath =
         )
 
 
+{-| -}
+type FileReadError decoding
+    = FileDoesntExist
+    | FileReadError String
+    | DecodingError decoding
+
+
 {-| Same as `bodyWithFrontmatter` except it doesn't include the body.
 
 This is often useful when you're aggregating data, for example getting a listing of blog posts and need to extract
 just the metadata.
 
-    import DataSource exposing (DataSource)
-    import DataSource.File as File
+    import BackendTask exposing (BackendTask)
+    import BackendTask.File as File
     import Decode as Decode exposing (Decoder)
 
-    blogPost : DataSource BlogPostMetadata
+    blogPost : BackendTask BlogPostMetadata
     blogPost =
         File.onlyFrontmatter
             blogPostDecoder
@@ -171,34 +186,34 @@ just the metadata.
             (Decode.field "tags" (Decode.list Decode.string))
 
 If you wanted to use this to get this metadata for all blog posts in a folder, you could use
-the [`DataSource`](DataSource) API along with [`DataSource.Glob`](DataSource-Glob).
+the [`BackendTask`](BackendTask) API along with [`BackendTask.Glob`](BackendTask-Glob).
 
-    import DataSource exposing (DataSource)
-    import DataSource.File as File
+    import BackendTask exposing (BackendTask)
+    import BackendTask.File as File
     import Decode as Decode exposing (Decoder)
 
-    blogPostFiles : DataSource (List String)
+    blogPostFiles : BackendTask (List String)
     blogPostFiles =
         Glob.succeed identity
             |> Glob.captureFilePath
             |> Glob.match (Glob.literal "content/blog/")
             |> Glob.match Glob.wildcard
             |> Glob.match (Glob.literal ".md")
-            |> Glob.toDataSource
+            |> Glob.toBackendTask
 
-    allMetadata : DataSource (List BlogPostMetadata)
+    allMetadata : BackendTask (List BlogPostMetadata)
     allMetadata =
         blogPostFiles
-            |> DataSource.map
+            |> BackendTask.map
                 (List.map
                     (File.onlyFrontmatter
                         blogPostDecoder
                     )
                 )
-            |> DataSource.resolve
+            |> BackendTask.resolve
 
 -}
-onlyFrontmatter : Decoder frontmatter -> String -> DataSource frontmatter
+onlyFrontmatter : Decoder frontmatter -> String -> BackendTask (Exception (FileReadError Decode.Error)) frontmatter
 onlyFrontmatter frontmatterDecoder filePath =
     read filePath
         (frontmatter frontmatterDecoder)
@@ -216,16 +231,16 @@ tags: elm
 Hey there! This is my first post :)
 ```
 
-    import DataSource exposing (DataSource)
+    import BackendTask exposing (BackendTask)
 
-    data : DataSource String
+    data : BackendTask String
     data =
         bodyWithoutFrontmatter "blog/hello-world.md"
 
 Then data will yield the value `"Hey there! This is my first post :)"`.
 
 -}
-bodyWithoutFrontmatter : String -> DataSource String
+bodyWithoutFrontmatter : String -> BackendTask (Exception (FileReadError decoderError)) String
 bodyWithoutFrontmatter filePath =
     read filePath
         body
@@ -241,15 +256,15 @@ use `jsonFile` to get the benefits of the `Decode` here.
 
 You could read a file called `hello.txt` in your root project directory like this:
 
-    import DataSource exposing (DataSource)
-    import DataSource.File as File
+    import BackendTask exposing (BackendTask)
+    import BackendTask.File as File
 
-    elmJsonFile : DataSource String
+    elmJsonFile : BackendTask String
     elmJsonFile =
         File.rawFile "hello.txt"
 
 -}
-rawFile : String -> DataSource String
+rawFile : String -> BackendTask (Exception (FileReadError decoderError)) String
 rawFile filePath =
     read filePath (Decode.field "rawFile" Decode.string)
 
@@ -258,10 +273,10 @@ rawFile filePath =
 
 The Decode will strip off any unused JSON data.
 
-    import DataSource exposing (DataSource)
-    import DataSource.File as File
+    import BackendTask exposing (BackendTask)
+    import BackendTask.File as File
 
-    sourceDirectories : DataSource (List String)
+    sourceDirectories : BackendTask (List String)
     sourceDirectories =
         File.jsonFile
             (Decode.field
@@ -271,15 +286,24 @@ The Decode will strip off any unused JSON data.
             "elm.json"
 
 -}
-jsonFile : Decoder a -> String -> DataSource a
+jsonFile : Decoder a -> String -> BackendTask (Exception (FileReadError Decode.Error)) a
 jsonFile jsonFileDecoder filePath =
     rawFile filePath
-        |> DataSource.andThen
+        |> BackendTask.andThen
             (\jsonString ->
                 jsonString
                     |> Decode.decodeString jsonFileDecoder
-                    |> Result.mapError Decode.errorToString
-                    |> DataSource.fromResult
+                    |> Result.mapError
+                        (\jsonDecodeError ->
+                            Exception.Exception (DecodingError jsonDecodeError)
+                                { title = "JSON Decoding Error"
+                                , body =
+                                    [ TerminalText.text (Decode.errorToString jsonDecodeError)
+                                    ]
+                                        |> TerminalText.toString
+                                }
+                        )
+                    |> BackendTask.fromResult
             )
 
 
@@ -290,10 +314,32 @@ body =
     Decode.field "withoutFrontmatter" Decode.string
 
 
-read : String -> Decoder a -> DataSource a
+read : String -> Decoder a -> BackendTask (Exception (FileReadError error)) a
 read filePath decoder =
-    DataSource.Internal.Request.request
+    BackendTask.Internal.Request.request
         { name = "read-file"
-        , body = DataSource.Http.stringBody "" filePath
-        , expect = decoder |> DataSource.Http.expectJson
+        , body = BackendTask.Http.stringBody "" filePath
+        , expect =
+            Decode.oneOf
+                [ Decode.field "errorCode"
+                    (Decode.map Err (errorDecoder filePath))
+                , decoder |> Decode.map Ok
+                ]
+                |> BackendTask.Http.expectJson
         }
+        |> BackendTask.andThen BackendTask.fromResult
+
+
+errorDecoder : String -> Decoder (Exception (FileReadError decoding))
+errorDecoder filePath =
+    Decode.succeed
+        (Exception.Exception FileDoesntExist
+            { title = "File Doesn't Exist"
+            , body =
+                [ TerminalText.text "Couldn't find file at path `"
+                , TerminalText.yellow filePath
+                , TerminalText.text "`"
+                ]
+                    |> TerminalText.toString
+            }
+        )