elm-pages 3.0.0-beta.3 → 3.0.0-beta.30

package/src/Server/Request.elm

@@ -86,11 +86,12 @@ module Server.Request exposing
 
 -}
 
+import BackendTask exposing (BackendTask)
 import CookieParser
-import DataSource exposing (DataSource)
 import Dict exposing (Dict)
+import FatalError exposing (FatalError)
 import Form
-import Form.Validation exposing (Validation)
+import Form.Validation as Validation
 import FormData
 import Internal.Request
 import Json.Decode
@@ -118,17 +119,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 +142,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 +152,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 +162,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 +226,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
@@ -650,7 +651,6 @@ expectQueryParam name =
                             maybeParamValue =
                                 queryString
                                     |> QueryParams.fromString
-                                    |> QueryParams.toDict
                                     |> Dict.get name
                                     |> Maybe.andThen List.head
                         in
@@ -689,7 +689,6 @@ findFirstQueryParam : String -> String -> Maybe String
 findFirstQueryParam name queryString =
     queryString
         |> QueryParams.fromString
-        |> QueryParams.toDict
         |> Dict.get name
         |> Maybe.andThen List.head
 
@@ -704,7 +703,6 @@ queryParams =
                     |> Url.fromString
                     |> Maybe.andThen .query
                     |> Maybe.map QueryParams.fromString
-                    |> Maybe.map QueryParams.toDict
                     |> Maybe.withDefault Dict.empty
             )
 
@@ -881,8 +879,8 @@ fileField_ name =
 
 {-| -}
 formDataWithServerValidation :
-    Form.ServerForms error (DataSource (Validation error combined kind constraints))
-    -> Parser (DataSource (Result (Form.Response error) ( Form.Response error, combined )))
+    Form.ServerForms error (BackendTask FatalError (Validation.Validation error combined kind constraints))
+    -> Parser (BackendTask FatalError (Result (Form.Response error) ( Form.Response error, combined )))
 formDataWithServerValidation formParsers =
     rawFormData
         |> andThen
@@ -897,27 +895,25 @@ 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 ) ->
                                                 Ok
-                                                    ( Form.Response
+                                                    ( Pages.Internal.Form.Response
                                                         { fields = rawFormData_
                                                         , errors = Dict.empty
+                                                        , clientErrors = Dict.empty
                                                         }
                                                     , decodedFinal
                                                     )
 
-                                            ( _, maybeErrors ) ->
+                                            _ ->
                                                 Err
-                                                    (Form.Response
+                                                    (Pages.Internal.Form.Response
                                                         { fields = rawFormData_
-                                                        , errors =
-                                                            maybeErrors
-                                                                |> Maybe.map List.NonEmpty.toList
-                                                                |> Maybe.withDefault []
-                                                                |> Dict.fromList
+                                                        , errors = errors2
+                                                        , clientErrors = errors
                                                         }
                                                     )
                                     )
@@ -925,16 +921,17 @@ formDataWithServerValidation formParsers =
 
                     ( _, maybeErrors ) ->
                         Err
-                            (Form.Response
+                            (Pages.Internal.Form.Response
                                 { fields = rawFormData_
                                 , errors =
                                     maybeErrors
                                         |> Maybe.map List.NonEmpty.toList
                                         |> Maybe.withDefault []
                                         |> Dict.fromList
+                                , clientErrors = Dict.empty
                                 }
                             )
-                            |> DataSource.succeed
+                            |> BackendTask.succeed
                             |> succeed
             )
 
@@ -942,7 +939,7 @@ formDataWithServerValidation formParsers =
 {-| -}
 formData :
     Form.ServerForms error combined
-    -> Parser (Result { fields : List ( String, String ), errors : Dict String (List error) } combined)
+    -> Parser ( Form.Response error, Result { fields : List ( String, String ), errors : Dict String (List error), clientErrors : Dict String (List error) } combined )
 formData formParsers =
     rawFormData
         |> andThen
@@ -955,18 +952,27 @@ formData formParsers =
                 in
                 case ( maybeDecoded, errors |> Dict.toList |> List.filter (\( _, value ) -> value |> List.isEmpty |> not) |> List.NonEmpty.fromList ) of
                     ( Just decoded, Nothing ) ->
-                        Ok decoded
+                        ( Pages.Internal.Form.Response { fields = [], errors = Dict.empty, clientErrors = Dict.empty }
+                        , Ok decoded
+                        )
                             |> succeed
 
                     ( _, maybeErrors ) ->
-                        Err
-                            { fields = rawFormData_
-                            , errors =
-                                maybeErrors
-                                    |> Maybe.map List.NonEmpty.toList
-                                    |> Maybe.withDefault []
-                                    |> Dict.fromList
-                            }
+                        let
+                            record : { fields : List ( String, String ), errors : Dict String (List error), clientErrors : Dict String (List error) }
+                            record =
+                                { fields = rawFormData_
+                                , errors = Dict.empty
+                                , clientErrors =
+                                    maybeErrors
+                                        |> Maybe.map List.NonEmpty.toList
+                                        |> Maybe.withDefault []
+                                        |> Dict.fromList
+                                }
+                        in
+                        ( Pages.Internal.Form.Response record
+                        , Err record
+                        )
                             |> succeed
             )
 

package/src/Server/Session.elm

@@ -13,13 +13,13 @@ to choose which requests to respond to and how to extract structured data from t
 Using these functions, you can store and read session data in cookies to maintain state between requests.
 For example, TODO:
 
-    action : RouteParams -> Request.Parser (DataSource (Response ActionData ErrorPage))
+    action : RouteParams -> Request.Parser (BackendTask (Response ActionData ErrorPage))
     action routeParams =
         MySession.withSession
             (Request.formDataWithServerValidation (form |> Form.initCombinedServer identity))
             (\nameResultData session ->
                 nameResultData
-                    |> DataSource.map
+                    |> BackendTask.map
                         (\nameResult ->
                             case nameResult of
                                 Err errors ->
@@ -42,7 +42,7 @@ For example, TODO:
                         )
             )
 
-The elm-pages framework will manage signing these cookies using the `secrets : DataSource (List String)` you pass in.
+The elm-pages framework will manage signing these cookies using the `secrets : BackendTask (List String)` you pass in.
 That means that the values you set in your session will be directly visible to anyone who has access to the cookie
 (so don't directly store sensitive data in your session). Since the session cookie is signed using the secret you provide,
 the cookie will be invalidated if it is tampered with because it won't match when elm-pages verifies that it has been
@@ -51,13 +51,13 @@ signed with your secrets. Of course you need to provide secure secrets and treat
 
 ### Rotating Secrets
 
-The first String in `secrets : DataSource (List String)` will be used to sign sessions, while the remaining String's will
+The first String in `secrets : BackendTask (List String)` will be used to sign sessions, while the remaining String's will
 still be used to attempt to "unsign" the cookies. So if you have a single secret:
 
     Session.withSession
         { name = "mysession"
         , secrets =
-            DataSource.map List.singleton
+            BackendTask.map List.singleton
                 (Env.expect "SESSION_SECRET2022-09-01")
         , options = cookieOptions
         }
@@ -67,7 +67,7 @@ Then you add a second secret
     Session.withSession
         { name = "mysession"
         , secrets =
-            DataSource.map2
+            BackendTask.map2
                 (\newSecret oldSecret -> [ newSecret, oldSecret ])
                 (Env.expect "SESSION_SECRET2022-12-01")
                 (Env.expect "SESSION_SECRET2022-09-01")
@@ -87,7 +87,7 @@ it will invalidate all cookies signed with that. For example, if we remove our o
     Session.withSession
         { name = "mysession"
         , secrets =
-            DataSource.map List.singleton
+            BackendTask.map List.singleton
                 (Env.expect "SESSION_SECRET2022-12-01")
         , options = cookieOptions
         }
@@ -107,9 +107,9 @@ so there's nothing wrong with an old session expiring (and the browser will even
 
 -}
 
-import DataSource exposing (DataSource)
-import DataSource.Http
-import DataSource.Internal.Request
+import BackendTask exposing (BackendTask)
+import BackendTask.Http
+import BackendTask.Internal.Request
 import Dict exposing (Dict)
 import Json.Decode
 import Json.Encode
@@ -242,23 +242,23 @@ flashPrefix =
 {-| -}
 withSession :
     { name : String
-    , secrets : DataSource (List String)
+    , secrets : BackendTask error (List String)
     , options : SetCookie.Options
     }
-    -> (request -> Result NotLoadedReason Session -> DataSource ( Session, Response data errorPage ))
+    -> (request -> Result NotLoadedReason Session -> BackendTask error ( Session, Response data errorPage ))
     -> Server.Request.Parser request
-    -> Server.Request.Parser (DataSource (Response data errorPage))
+    -> Server.Request.Parser (BackendTask error (Response data errorPage))
 withSession config toRequest userRequest =
     Server.Request.map2
         (\maybeSessionCookie userRequestData ->
             let
-                unsigned : DataSource (Result NotLoadedReason Session)
+                unsigned : BackendTask error (Result NotLoadedReason Session)
                 unsigned =
                     case maybeSessionCookie of
                         Just sessionCookie ->
                             sessionCookie
                                 |> unsignCookie config
-                                |> DataSource.map
+                                |> BackendTask.map
                                     (\unsignResult ->
                                         case unsignResult of
                                             Ok decoded ->
@@ -270,10 +270,10 @@ withSession config toRequest userRequest =
 
                         Nothing ->
                             Err NoSessionCookie
-                                |> DataSource.succeed
+                                |> BackendTask.succeed
             in
             unsigned
-                |> DataSource.andThen
+                |> BackendTask.andThen
                     (encodeSessionUpdate config toRequest userRequestData)
         )
         (Server.Request.cookie config.name)
@@ -282,19 +282,19 @@ withSession config toRequest userRequest =
 
 encodeSessionUpdate :
     { name : String
-    , secrets : DataSource (List String)
+    , secrets : BackendTask error (List String)
     , options : SetCookie.Options
     }
-    -> (c -> d -> DataSource ( Session, Response data errorPage ))
+    -> (c -> d -> BackendTask error ( Session, Response data errorPage ))
     -> c
     -> d
-    -> DataSource (Response data errorPage)
+    -> BackendTask error (Response data errorPage)
 encodeSessionUpdate config toRequest userRequestData sessionResult =
     sessionResult
         |> toRequest userRequestData
-        |> DataSource.andThen
+        |> BackendTask.andThen
             (\( sessionUpdate, response ) ->
-                DataSource.map
+                BackendTask.map
                     (\encoded ->
                         response
                             |> Server.Response.withSetCookieHeader
@@ -306,11 +306,11 @@ encodeSessionUpdate config toRequest userRequestData sessionResult =
             )
 
 
-unsignCookie : { a | secrets : DataSource (List String) } -> String -> DataSource (Result () Session)
+unsignCookie : { a | secrets : BackendTask error (List String) } -> String -> BackendTask error (Result () Session)
 unsignCookie config sessionCookie =
     sessionCookie
         |> unsign config.secrets (Json.Decode.dict Json.Decode.string)
-        |> DataSource.map
+        |> BackendTask.map
             (Result.map
                 (\dict ->
                     dict
@@ -331,15 +331,15 @@ unsignCookie config sessionCookie =
             )
 
 
-sign : DataSource (List String) -> Json.Encode.Value -> DataSource String
+sign : BackendTask error (List String) -> Json.Encode.Value -> BackendTask error String
 sign getSecrets input =
     getSecrets
-        |> DataSource.andThen
+        |> BackendTask.andThen
             (\secrets ->
-                DataSource.Internal.Request.request
+                BackendTask.Internal.Request.request
                     { name = "encrypt"
                     , body =
-                        DataSource.Http.jsonBody
+                        BackendTask.Http.jsonBody
                             (Json.Encode.object
                                 [ ( "values", input )
                                 , ( "secret"
@@ -353,21 +353,21 @@ sign getSecrets input =
                                 ]
                             )
                     , expect =
-                        DataSource.Http.expectJson
+                        BackendTask.Http.expectJson
                             Json.Decode.string
                     }
             )
 
 
-unsign : DataSource (List String) -> Json.Decode.Decoder a -> String -> DataSource (Result () a)
+unsign : BackendTask error (List String) -> Json.Decode.Decoder a -> String -> BackendTask error (Result () a)
 unsign getSecrets decoder input =
     getSecrets
-        |> DataSource.andThen
+        |> BackendTask.andThen
             (\secrets ->
-                DataSource.Internal.Request.request
+                BackendTask.Internal.Request.request
                     { name = "decrypt"
                     , body =
-                        DataSource.Http.jsonBody
+                        BackendTask.Http.jsonBody
                             (Json.Encode.object
                                 [ ( "input", Json.Encode.string input )
                                 , ( "secrets", Json.Encode.list Json.Encode.string secrets )
@@ -377,6 +377,6 @@ unsign getSecrets decoder input =
                         decoder
                             |> Json.Decode.nullable
                             |> Json.Decode.map (Result.fromMaybe ())
-                            |> DataSource.Http.expectJson
+                            |> BackendTask.Http.expectJson
                     }
             )

package/src/Server/SetCookie.elm

@@ -174,7 +174,7 @@ dynamically). In this API you opt into exposing a cookie you set to JavaScript t
 
 In general if you can accomplish your goal using HttpOnly cookies (i.e. not using `makeVisibleToJavaScript`) then
 it's a good practice. With server-rendered `elm-pages` applications you can often manage your session state by pulling
-in session data from cookies in a `DataSource` (which is resolved server-side before it ever reaches the browser).
+in session data from cookies in a `BackendTask` (which is resolved server-side before it ever reaches the browser).
 
 -}
 makeVisibleToJavaScript : Options -> Options

package/src/Test/Html/Internal/ElmHtml/ToString.elm

@@ -130,17 +130,16 @@ nodeRecordToString options { tag, children, facts } =
                 |> String.join " "
                 |> Just
 
-        boolToString b =
-            case b of
-                True ->
-                    "True"
-
-                False ->
-                    "False"
-
         boolAttributes =
             Dict.toList facts.boolAttributes
-                |> List.map (\( k, v ) -> k ++ "=" ++ (String.toLower <| boolToString v))
+                |> List.filterMap
+                    (\( k, v ) ->
+                        if v then
+                            Just k
+
+                        else
+                            Nothing
+                    )
                 |> String.join " "
                 |> Just
     in

package/src/DataSource/Env.elm

@@ -1,38 +0,0 @@
-module DataSource.Env exposing (get, expect)
-
-{-|
-
-@docs get, expect
-
--}
-
-import DataSource exposing (DataSource)
-import DataSource.Http
-import DataSource.Internal.Request
-import Json.Decode as Decode
-import Json.Encode as Encode
-
-
-{-| -}
-get : String -> DataSource (Maybe String)
-get envVariableName =
-    DataSource.Internal.Request.request
-        { name = "env"
-        , body = DataSource.Http.jsonBody (Encode.string envVariableName)
-        , expect =
-            DataSource.Http.expectJson
-                (Decode.nullable Decode.string)
-        }
-
-
-{-| -}
-expect : String -> DataSource String
-expect envVariableName =
-    envVariableName
-        |> get
-        |> DataSource.andThen
-            (\maybeValue ->
-                maybeValue
-                    |> Result.fromMaybe ("DataSource.Env.expect was expecting a variable `" ++ envVariableName ++ "` but couldn't find a variable with that name.")
-                    |> DataSource.fromResult
-            )