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

package/src/Pages/Internal/StaticHttpBody.elm

@@ -1,6 +1,9 @@
 module Pages.Internal.StaticHttpBody exposing (Body(..), codec, encode)
 
+import Base64
+import Bytes exposing (Bytes)
 import Codec exposing (Codec)
+import Json.Decode
 import Json.Encode as Encode
 
 
@@ -8,6 +11,7 @@ type Body
     = EmptyBody
     | StringBody String String
     | JsonBody Encode.Value
+    | BytesBody String Bytes
 
 
 encode : Body -> Encode.Value
@@ -26,6 +30,15 @@ encode body =
                 [ ( "content", content )
                 ]
 
+        BytesBody _ content ->
+            encodeWithType "bytes"
+                [ ( "content"
+                  , Base64.fromBytes content
+                        |> Maybe.withDefault ""
+                        |> Encode.string
+                  )
+                ]
+
 
 encodeWithType : String -> List ( String, Encode.Value ) -> Encode.Value
 encodeWithType typeName otherFields =
@@ -37,7 +50,7 @@ encodeWithType typeName otherFields =
 codec : Codec Body
 codec =
     Codec.custom
-        (\vEmpty vString vJson value ->
+        (\vEmpty vString vJson vBytes value ->
             case value of
                 EmptyBody ->
                     vEmpty
@@ -47,8 +60,29 @@ codec =
 
                 JsonBody body ->
                     vJson body
+
+                BytesBody contentType body ->
+                    vBytes contentType body
         )
         |> Codec.variant0 "EmptyBody" EmptyBody
         |> Codec.variant2 "StringBody" StringBody Codec.string Codec.string
         |> Codec.variant1 "JsonBody" JsonBody Codec.value
+        |> Codec.variant2 "BytesBody" BytesBody Codec.string bytesCodec
         |> Codec.buildCustom
+
+
+bytesCodec : Codec Bytes
+bytesCodec =
+    Codec.build (Base64.fromBytes >> Maybe.withDefault "" >> Encode.string)
+        (Json.Decode.string
+            |> Json.Decode.map Base64.toBytes
+            |> Json.Decode.andThen
+                (\decodedBytes ->
+                    case decodedBytes of
+                        Just bytes ->
+                            Json.Decode.succeed bytes
+
+                        Nothing ->
+                            Json.Decode.fail "Couldn't parse bytes."
+                )
+        )

package/src/Pages/Manifest.elm

@@ -64,10 +64,11 @@ You pass your `Pages.Manifest.Config` record into the `Pages.application` functi
 -}
 
 import ApiRoute
+import BackendTask exposing (BackendTask)
 import Color exposing (Color)
 import Color.Convert
-import DataSource exposing (DataSource)
 import Dict exposing (Dict)
+import Exception exposing (Throwable)
 import Head
 import Json.Encode as Encode
 import LanguageTag exposing (LanguageTag, emptySubtags)
@@ -344,16 +345,16 @@ nonEmptyList list =
 
 {-| A generator for Api.elm to include a manifest.json.
 -}
-generator : String -> DataSource Config -> ApiRoute.ApiRoute ApiRoute.Response
+generator : String -> BackendTask Throwable Config -> ApiRoute.ApiRoute ApiRoute.Response
 generator canonicalSiteUrl config =
     ApiRoute.succeed
         (config
-            |> DataSource.map (toJson canonicalSiteUrl >> Encode.encode 0)
+            |> BackendTask.map (toJson canonicalSiteUrl >> Encode.encode 0)
         )
         |> ApiRoute.literal "manifest.json"
         |> ApiRoute.single
         |> ApiRoute.withGlobalHeadTags
-            (DataSource.succeed
+            (BackendTask.succeed
                 [ Head.manifestLink "/manifest.json"
                 ]
             )

package/src/Pages/ProgramConfig.elm

@@ -1,12 +1,13 @@
 module Pages.ProgramConfig exposing (ProgramConfig)
 
 import ApiRoute
+import BackendTask exposing (BackendTask)
 import Browser.Navigation
 import Bytes exposing (Bytes)
 import Bytes.Decode
 import Bytes.Encode
-import DataSource exposing (DataSource)
 import Dict exposing (Dict)
+import Exception exposing (Throwable)
 import Form.FormData exposing (FormData)
 import Head
 import Html exposing (Html)
@@ -48,9 +49,9 @@ type alias ProgramConfig userMsg userModel route pageData actionData sharedData
         -> ( userModel, effect )
     , update : Pages.FormState.PageFormState -> Dict String (Pages.Transition.FetcherState actionData) -> Maybe Pages.Transition.Transition -> sharedData -> pageData -> Maybe Browser.Navigation.Key -> userMsg -> userModel -> ( userModel, effect )
     , subscriptions : route -> Path -> userModel -> Sub userMsg
-    , sharedData : DataSource sharedData
-    , data : route -> DataSource (PageServerResponse pageData errorPage)
-    , action : route -> DataSource (PageServerResponse actionData errorPage)
+    , sharedData : BackendTask Throwable sharedData
+    , data : Decode.Value -> route -> BackendTask Throwable (PageServerResponse pageData errorPage)
+    , action : Decode.Value -> route -> BackendTask Throwable (PageServerResponse actionData errorPage)
     , onActionData : actionData -> Maybe userMsg
     , view :
         Pages.FormState.PageFormState
@@ -68,8 +69,8 @@ type alias ProgramConfig userMsg userModel route pageData actionData sharedData
             { view : userModel -> { title : String, body : List (Html (Pages.Msg.Msg userMsg)) }
             , head : List Head.Tag
             }
-    , handleRoute : route -> DataSource (Maybe NotFoundReason)
-    , getStaticRoutes : DataSource (List route)
+    , handleRoute : route -> BackendTask Throwable (Maybe NotFoundReason)
+    , getStaticRoutes : BackendTask Throwable (List route)
     , urlToRoute : Url -> route
     , routeToPath : route -> List String
     , site : Maybe SiteConfig
@@ -101,7 +102,7 @@ type alias ProgramConfig userMsg userModel route pageData actionData sharedData
     , encodeResponse : ResponseSketch pageData actionData sharedData -> Bytes.Encode.Encoder
     , encodeAction : actionData -> Bytes.Encode.Encoder
     , decodeResponse : Bytes.Decode.Decoder (ResponseSketch pageData actionData sharedData)
-    , globalHeadTags : Maybe ((Maybe { indent : Int, newLines : Bool } -> Html Never -> String) -> DataSource (List Head.Tag))
+    , globalHeadTags : Maybe ((Maybe { indent : Int, newLines : Bool } -> Html Never -> String) -> BackendTask Throwable (List Head.Tag))
     , cmdToEffect : Cmd userMsg -> effect
     , perform :
         { fetchRouteData :

package/src/Pages/Script.elm

@@ -3,6 +3,7 @@ module Pages.Script exposing
     , withCliOptions, withoutCliOptions
     , writeFile
     , log
+    , Error(..)
     )
 
 {-|
@@ -21,13 +22,19 @@ module Pages.Script exposing
 
 @docs log
 
+
+## Errors
+
+@docs Error
+
 -}
 
+import BackendTask exposing (BackendTask)
+import BackendTask.Http
+import BackendTask.Internal.Request
 import Cli.OptionsParser as OptionsParser
 import Cli.Program as Program
-import DataSource exposing (DataSource)
-import DataSource.Http
-import DataSource.Internal.Request
+import Exception exposing (Catchable, Throwable)
 import Json.Decode as Decode
 import Json.Encode as Encode
 import Pages.Internal.Script
@@ -39,38 +46,46 @@ type alias Script =
 
 
 {-| -}
-writeFile : { path : String, body : String } -> DataSource ()
+type Error
+    = --TODO make more descriptive
+      FileWriteError
+
+
+{-| -}
+writeFile : { path : String, body : String } -> BackendTask (Catchable Error) ()
 writeFile { path, body } =
-    DataSource.Internal.Request.request
+    BackendTask.Internal.Request.request
         { name = "write-file"
         , body =
-            DataSource.Http.jsonBody
+            BackendTask.Http.jsonBody
                 (Encode.object
                     [ ( "path", Encode.string path )
                     , ( "body", Encode.string body )
                     ]
                 )
-        , expect = DataSource.Http.expectJson (Decode.succeed ())
+        , expect =
+            -- TODO decode possible error details here
+            BackendTask.Http.expectJson (Decode.succeed ())
         }
 
 
 {-| -}
-log : String -> DataSource ()
+log : String -> BackendTask error ()
 log message =
-    DataSource.Internal.Request.request
+    BackendTask.Internal.Request.request
         { name = "log"
         , body =
-            DataSource.Http.jsonBody
+            BackendTask.Http.jsonBody
                 (Encode.object
                     [ ( "message", Encode.string message )
                     ]
                 )
-        , expect = DataSource.Http.expectJson (Decode.succeed ())
+        , expect = BackendTask.Http.expectJson (Decode.succeed ())
         }
 
 
 {-| -}
-withoutCliOptions : DataSource () -> Script
+withoutCliOptions : BackendTask Throwable () -> Script
 withoutCliOptions execute =
     Pages.Internal.Script.Script
         (\_ ->
@@ -85,7 +100,7 @@ withoutCliOptions execute =
 
 
 {-| -}
-withCliOptions : Program.Config cliOptions -> (cliOptions -> DataSource ()) -> Script
+withCliOptions : Program.Config cliOptions -> (cliOptions -> BackendTask Throwable ()) -> Script
 withCliOptions config execute =
     Pages.Internal.Script.Script
         (\_ ->

package/src/Pages/SiteConfig.elm

@@ -1,10 +1,11 @@
 module Pages.SiteConfig exposing (SiteConfig)
 
-import DataSource exposing (DataSource)
+import BackendTask exposing (BackendTask)
+import Exception exposing (Throwable)
 import Head
 
 
 type alias SiteConfig =
     { canonicalUrl : String
-    , head : DataSource (List Head.Tag)
+    , head : BackendTask Throwable (List Head.Tag)
     }

package/src/Pages/StaticHttp/Request.elm

@@ -11,7 +11,7 @@ type alias Request =
     , method : String
     , headers : List ( String, String )
     , body : Body
-    , useCache : Bool
+    , cacheOptions : Maybe Encode.Value
     }
 
 
@@ -40,5 +40,5 @@ codec =
         |> Codec.field "method" .method Codec.string
         |> Codec.field "headers" .headers (Codec.list (Codec.tuple Codec.string Codec.string))
         |> Codec.field "body" .body StaticHttpBody.codec
-        |> Codec.field "useCache" .useCache Codec.bool
+        |> Codec.nullableField "cacheOptions" .cacheOptions Codec.value
         |> Codec.buildObject

package/src/Pages/StaticHttpRequest.elm

@@ -1,8 +1,8 @@
-module Pages.StaticHttpRequest exposing (Error(..), MockResolver, RawRequest(..), Status(..), cacheRequestResolution, mockResolve, resolve, resolveUrls, toBuildError)
+module Pages.StaticHttpRequest exposing (Error(..), MockResolver, RawRequest(..), Status(..), cacheRequestResolution, mockResolve, toBuildError)
 
 import BuildError exposing (BuildError)
 import Dict
-import List.Extra
+import Json.Encode
 import Pages.StaticHttp.Request
 import RequestsAndPending exposing (RequestsAndPending)
 import TerminalText as Terminal
@@ -13,30 +13,19 @@ type alias MockResolver =
     -> Maybe RequestsAndPending.Response
 
 
-type RawRequest value
-    = Request (List Pages.StaticHttp.Request.Request) (Maybe MockResolver -> RequestsAndPending -> RawRequest value)
-    | RequestError Error
-    | ApiRoute value
+type RawRequest error value
+    = Request (List Pages.StaticHttp.Request.Request) (Maybe MockResolver -> RequestsAndPending -> RawRequest error value)
+    | ApiRoute (Result error value)
 
 
 type Error
-    = MissingHttpResponse String (List Pages.StaticHttp.Request.Request)
-    | DecoderError String
+    = DecoderError String
     | UserCalledStaticHttpFail String
 
 
 toBuildError : String -> Error -> BuildError
 toBuildError path error =
     case error of
-        MissingHttpResponse missingKey _ ->
-            { title = "Missing Http Response"
-            , message =
-                [ Terminal.text missingKey
-                ]
-            , path = path
-            , fatal = True
-            }
-
         DecoderError decodeErrorMessage ->
             { title = "Static Http Decoding Error"
             , message =
@@ -49,109 +38,65 @@ toBuildError path error =
         UserCalledStaticHttpFail decodeErrorMessage ->
             { title = "Called Static Http Fail"
             , message =
-                [ Terminal.text <| "I ran into a call to `DataSource.fail` with message: " ++ decodeErrorMessage
+                [ Terminal.text <| "I ran into a call to `BackendTask.fail` with message: " ++ decodeErrorMessage
                 ]
             , path = path
             , fatal = True
             }
 
 
-resolve : RawRequest value -> RequestsAndPending -> Result Error value
-resolve request rawResponses =
-    case request of
-        RequestError error ->
-            Err error
-
-        Request _ lookupFn ->
-            case lookupFn Nothing rawResponses of
-                nextRequest ->
-                    resolve nextRequest rawResponses
-
-        ApiRoute value ->
-            Ok value
-
-
-mockResolve : RawRequest value -> MockResolver -> Result Error value
+mockResolve : RawRequest error value -> MockResolver -> Result error value
 mockResolve request mockResolver =
     case request of
-        RequestError error ->
-            Err error
-
         Request _ lookupFn ->
-            case lookupFn (Just mockResolver) Dict.empty of
+            case lookupFn (Just mockResolver) (Json.Encode.object []) of
                 nextRequest ->
                     mockResolve nextRequest mockResolver
 
         ApiRoute value ->
-            Ok value
-
+            value
 
-resolveUrls : RawRequest value -> RequestsAndPending -> List Pages.StaticHttp.Request.Request
-resolveUrls request rawResponses =
-    resolveUrlsHelp rawResponses [] request
 
-
-resolveUrlsHelp : RequestsAndPending -> List Pages.StaticHttp.Request.Request -> RawRequest value -> List Pages.StaticHttp.Request.Request
-resolveUrlsHelp rawResponses soFar request =
+cacheRequestResolution :
+    RawRequest error value
+    -> RequestsAndPending
+    -> Status error value
+cacheRequestResolution request rawResponses =
     case request of
-        RequestError error ->
-            case error of
-                MissingHttpResponse _ next ->
-                    (soFar ++ next)
-                        |> List.Extra.uniqueBy Pages.StaticHttp.Request.hash
-
-                _ ->
-                    soFar
-
         Request urlList lookupFn ->
-            resolveUrlsHelp
-                rawResponses
-                (soFar ++ urlList)
-                (lookupFn Nothing rawResponses)
+            if List.isEmpty urlList then
+                cacheRequestResolutionHelp urlList rawResponses (lookupFn Nothing rawResponses)
 
-        ApiRoute _ ->
-            soFar
+            else
+                Incomplete urlList (Request [] lookupFn)
 
-
-cacheRequestResolution :
-    RawRequest value
-    -> RequestsAndPending
-    -> Status value
-cacheRequestResolution request rawResponses =
-    cacheRequestResolutionHelp [] rawResponses request request
+        ApiRoute value ->
+            Complete value
 
 
-type Status value
-    = Incomplete (List Pages.StaticHttp.Request.Request) (RawRequest value)
-    | HasPermanentError Error (RawRequest value)
-    | Complete
+type Status error value
+    = Incomplete (List Pages.StaticHttp.Request.Request) (RawRequest error value)
+    | HasPermanentError Error
+    | Complete (Result error value)
 
 
 cacheRequestResolutionHelp :
     List Pages.StaticHttp.Request.Request
     -> RequestsAndPending
-    -> RawRequest value
-    -> RawRequest value
-    -> Status value
-cacheRequestResolutionHelp foundUrls rawResponses parentRequest request =
+    -> RawRequest error value
+    -> Status error value
+cacheRequestResolutionHelp foundUrls rawResponses request =
     case request of
-        RequestError error ->
-            case error of
-                MissingHttpResponse _ _ ->
-                    -- TODO do I need to pass through continuation URLs here? -- Incomplete (urlList ++ foundUrls)
-                    Incomplete foundUrls parentRequest
-
-                DecoderError _ ->
-                    HasPermanentError error parentRequest
-
-                UserCalledStaticHttpFail _ ->
-                    HasPermanentError error parentRequest
-
         Request urlList lookupFn ->
-            cacheRequestResolutionHelp urlList
-                rawResponses
-                request
-                (lookupFn Nothing rawResponses)
+            if (urlList ++ foundUrls) |> List.isEmpty then
+                cacheRequestResolutionHelp
+                    []
+                    rawResponses
+                    (lookupFn Nothing rawResponses)
 
-        ApiRoute _ ->
-            Complete
+            else
+                Incomplete (urlList ++ foundUrls)
+                    (Request [] lookupFn)
+
+        ApiRoute value ->
+            Complete value

package/src/RequestsAndPending.elm

@@ -1,16 +1,14 @@
-module RequestsAndPending exposing (RequestsAndPending, Response(..), ResponseBody(..), batchDecoder, bodyEncoder, decoder, get)
+module RequestsAndPending exposing (RawResponse, RequestsAndPending, Response(..), ResponseBody(..), bodyEncoder, get)
 
 import Base64
 import Bytes exposing (Bytes)
-import Codec
 import Dict exposing (Dict)
 import Json.Decode as Decode exposing (Decoder)
 import Json.Encode as Encode
-import Pages.StaticHttp.Request
 
 
 type alias RequestsAndPending =
-    Dict String (Maybe Response)
+    Decode.Value
 
 
 type ResponseBody
@@ -20,18 +18,6 @@ type ResponseBody
     | WhateverBody
 
 
-batchDecoder : Decoder (List { request : Pages.StaticHttp.Request.Request, response : Response })
-batchDecoder =
-    Decode.map2 (\request response -> { request = request, response = response })
-        (Decode.field "request"
-            (Pages.StaticHttp.Request.codec
-                |> Codec.decoder
-            )
-        )
-        (Decode.field "response" decoder)
-        |> Decode.list
-
-
 decoder : Decoder Response
 decoder =
     Decode.map2 Response
@@ -117,6 +103,9 @@ responseDecoder =
 
 get : String -> RequestsAndPending -> Maybe Response
 get key requestsAndPending =
-    requestsAndPending
-        |> Dict.get key
-        |> Maybe.andThen identity
+    Decode.decodeValue
+        (Decode.field key
+            (Decode.field "response" decoder)
+        )
+        requestsAndPending
+        |> Result.toMaybe

package/src/Server/Request.elm

@@ -86,8 +86,8 @@ module Server.Request exposing
 
 -}
 
+import BackendTask exposing (BackendTask)
 import CookieParser
-import DataSource exposing (DataSource)
 import Dict exposing (Dict)
 import Form
 import Form.Validation as Validation
@@ -118,17 +118,17 @@ Note that this data is not available for pre-rendered pages or pre-rendered API
 This is because when a page is pre-rendered, there _is_ no incoming HTTP request to respond to, it is rendered before a user
 requests the page and then the pre-rendered page is served as a plain file (without running your Route Module).
 
-That's why `RouteBuilder.preRender` has `data : RouteParams -> DataSource Data`:
+That's why `RouteBuilder.preRender` has `data : RouteParams -> BackendTask Data`:
 
-    import DataSource exposing (DataSource)
+    import BackendTask exposing (BackendTask)
     import RouteBuilder exposing (StatelessRoute)
 
     type alias Data =
         {}
 
-    data : RouteParams -> DataSource Data
+    data : RouteParams -> BackendTask Data
     data routeParams =
-        DataSource.succeed Data
+        BackendTask.succeed Data
 
     route : StatelessRoute RouteParams Data ActionData
     route =
@@ -141,7 +141,7 @@ That's why `RouteBuilder.preRender` has `data : RouteParams -> DataSource Data`:
 
 A server-rendered Route Module _does_ have access to a user's incoming HTTP request because it runs every time the page
 is loaded. That's why `data` is a `Request.Parser` in server-rendered Route Modules. Since you have an incoming HTTP request for server-rendered routes,
-`RouteBuilder.serverRender` has `data : RouteParams -> Request.Parser (DataSource (Response Data))`. That means that you
+`RouteBuilder.serverRender` has `data : RouteParams -> Request.Parser (BackendTask (Response Data))`. That means that you
 can use the incoming HTTP request data to choose how to respond. For example, you could check for a dark-mode preference
 cookie and render a light- or dark-themed page and render a different page.
 
@@ -151,7 +151,7 @@ That's a mouthful, so let's unpack what it means.
 
 data from the request payload using a Server Request Parser.
 
-    import DataSource exposing (DataSource)
+    import BackendTask exposing (BackendTask)
     import RouteBuilder exposing (StatelessRoute)
     import Server.Request as Request exposing (Request)
     import Server.Response as Response exposing (Response)
@@ -161,11 +161,11 @@ data from the request payload using a Server Request Parser.
 
     data :
         RouteParams
-        -> Request.Parser (DataSource (Response Data))
+        -> Request.Parser (BackendTask (Response Data))
     data routeParams =
         {}
             |> Server.Response.render
-            |> DataSource.succeed
+            |> BackendTask.succeed
             |> Request.succeed
 
     route : StatelessRoute RouteParams Data ActionData
@@ -225,7 +225,7 @@ succeed value =
 
 {-| TODO internal only
 -}
-getDecoder : Parser (DataSource response) -> Json.Decode.Decoder (Result ( ValidationError, List ValidationError ) (DataSource response))
+getDecoder : Parser (BackendTask error response) -> Json.Decode.Decoder (Result ( ValidationError, List ValidationError ) (BackendTask error response))
 getDecoder (Internal.Request.Parser decoder) =
     decoder
         |> Json.Decode.map
@@ -881,8 +881,8 @@ fileField_ name =
 
 {-| -}
 formDataWithServerValidation :
-    Form.ServerForms error (DataSource (Validation.Validation error combined kind constraints))
-    -> Parser (DataSource (Result (Form.Response error) ( Form.Response error, combined )))
+    Form.ServerForms error (BackendTask error (Validation.Validation error combined kind constraints))
+    -> Parser (BackendTask error (Result (Form.Response error) ( Form.Response error, combined )))
 formDataWithServerValidation formParsers =
     rawFormData
         |> andThen
@@ -897,7 +897,7 @@ formDataWithServerValidation formParsers =
                     ( Just decoded, Nothing ) ->
                         succeed
                             (decoded
-                                |> DataSource.map
+                                |> BackendTask.map
                                     (\(Validation _ _ ( maybeParsed, errors2 )) ->
                                         case ( maybeParsed, errors2 |> Dict.toList |> List.filter (\( _, value ) -> value |> List.isEmpty |> not) |> List.NonEmpty.fromList ) of
                                             ( Just decodedFinal, Nothing ) ->
@@ -934,7 +934,7 @@ formDataWithServerValidation formParsers =
                                         |> Dict.fromList
                                 }
                             )
-                            |> DataSource.succeed
+                            |> BackendTask.succeed
                             |> succeed
             )