elm-pages 3.0.0-beta.4 → 3.0.0-beta.41

package/src/Server/Request.elm

@@ -86,17 +86,19 @@ 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.Handler
+import Form.Validation as Validation
 import FormData
 import Internal.Request
 import Json.Decode
 import Json.Encode
 import List.NonEmpty
-import Pages.Internal.Form exposing (Validation(..))
+import Pages.Form
 import QueryParams
 import Time
 import Url
@@ -118,17 +120,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 +143,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 +153,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 +163,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 +227,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 +652,6 @@ expectQueryParam name =
                             maybeParamValue =
                                 queryString
                                     |> QueryParams.fromString
-                                    |> QueryParams.toDict
                                     |> Dict.get name
                                     |> Maybe.andThen List.head
                         in
@@ -689,7 +690,6 @@ findFirstQueryParam : String -> String -> Maybe String
 findFirstQueryParam name queryString =
     queryString
         |> QueryParams.fromString
-        |> QueryParams.toDict
         |> Dict.get name
         |> Maybe.andThen List.head
 
@@ -704,7 +704,6 @@ queryParams =
                     |> Url.fromString
                     |> Maybe.andThen .query
                     |> Maybe.map QueryParams.fromString
-                    |> Maybe.map QueryParams.toDict
                     |> Maybe.withDefault Dict.empty
             )
 
@@ -879,94 +878,97 @@ fileField_ name =
         |> Internal.Request.Parser
 
 
+runForm : Validation.Validation error parsed kind constraints -> Form.Validated error parsed
+runForm validation =
+    Form.Handler.run []
+        (Form.Handler.init identity
+            (Form.form
+                { combine = validation
+                , view = []
+                }
+            )
+        )
+
+
 {-| -}
 formDataWithServerValidation :
-    Form.ServerForms error (DataSource (Validation error combined kind constraints))
-    -> Parser (DataSource (Result (Form.Response error) ( Form.Response error, combined )))
+    Pages.Form.Handler error combined
+    -> Parser (BackendTask FatalError (Result (Form.ServerResponse error) ( Form.ServerResponse error, combined )))
 formDataWithServerValidation formParsers =
     rawFormData
         |> andThen
             (\rawFormData_ ->
-                let
-                    ( maybeDecoded, errors ) =
-                        Form.runOneOfServerSide
-                            rawFormData_
-                            formParsers
-                in
-                case ( maybeDecoded, errors |> Dict.toList |> List.filter (\( _, value ) -> value |> List.isEmpty |> not) |> List.NonEmpty.fromList ) of
-                    ( Just decoded, Nothing ) ->
+                case Form.Handler.run rawFormData_ formParsers of
+                    Form.Valid decoded ->
                         succeed
                             (decoded
-                                |> DataSource.map
-                                    (\(Validation _ _ ( maybeParsed, errors2 )) ->
-                                        case ( maybeParsed, errors2 |> Dict.toList |> List.filter (\( _, value ) -> value |> List.isEmpty |> not) |> List.NonEmpty.fromList ) of
-                                            ( Just decodedFinal, Nothing ) ->
+                                |> BackendTask.map
+                                    (\clientValidated ->
+                                        case runForm clientValidated of
+                                            Form.Valid decodedFinal ->
                                                 Ok
-                                                    ( Form.Response
-                                                        { fields = rawFormData_
-                                                        , errors = Dict.empty
-                                                        }
+                                                    ( { persisted =
+                                                            { fields = Just rawFormData_
+                                                            , clientSideErrors = Nothing
+                                                            }
+                                                      , serverSideErrors = Dict.empty
+                                                      }
                                                     , decodedFinal
                                                     )
 
-                                            ( _, maybeErrors ) ->
+                                            Form.Invalid _ errors2 ->
                                                 Err
-                                                    (Form.Response
-                                                        { fields = rawFormData_
-                                                        , errors =
-                                                            maybeErrors
-                                                                |> Maybe.map List.NonEmpty.toList
-                                                                |> Maybe.withDefault []
-                                                                |> Dict.fromList
+                                                    { persisted =
+                                                        { fields = Just rawFormData_
+                                                        , clientSideErrors = Just errors2
                                                         }
-                                                    )
+                                                    , serverSideErrors = Dict.empty
+                                                    }
                                     )
                             )
 
-                    ( _, maybeErrors ) ->
+                    Form.Invalid _ errors ->
                         Err
-                            (Form.Response
-                                { fields = rawFormData_
-                                , errors =
-                                    maybeErrors
-                                        |> Maybe.map List.NonEmpty.toList
-                                        |> Maybe.withDefault []
-                                        |> Dict.fromList
+                            { persisted =
+                                { fields = Just rawFormData_
+                                , clientSideErrors = Just errors
                                 }
-                            )
-                            |> DataSource.succeed
+                            , serverSideErrors = Dict.empty
+                            }
+                            |> BackendTask.succeed
                             |> succeed
             )
 
 
 {-| -}
 formData :
-    Form.ServerForms error combined
-    -> Parser (Result { fields : List ( String, String ), errors : Dict String (List error) } combined)
+    Form.Handler.Handler error combined
+    -> Parser ( Form.ServerResponse error, Form.Validated error combined )
 formData formParsers =
     rawFormData
         |> andThen
             (\rawFormData_ ->
-                let
-                    ( maybeDecoded, errors ) =
-                        Form.runOneOfServerSide
-                            rawFormData_
-                            formParsers
-                in
-                case ( maybeDecoded, errors |> Dict.toList |> List.filter (\( _, value ) -> value |> List.isEmpty |> not) |> List.NonEmpty.fromList ) of
-                    ( Just decoded, Nothing ) ->
-                        Ok decoded
+                case Form.Handler.run rawFormData_ formParsers of
+                    (Form.Valid _) as validated ->
+                        ( { persisted =
+                                { fields = Just rawFormData_
+                                , clientSideErrors = Just Dict.empty
+                                }
+                          , serverSideErrors = Dict.empty
+                          }
+                        , validated
+                        )
                             |> succeed
 
-                    ( _, maybeErrors ) ->
-                        Err
-                            { fields = rawFormData_
-                            , errors =
-                                maybeErrors
-                                    |> Maybe.map List.NonEmpty.toList
-                                    |> Maybe.withDefault []
-                                    |> Dict.fromList
-                            }
+                    (Form.Invalid _ maybeErrors) as validated ->
+                        ( { persisted =
+                                { fields = Just rawFormData_
+                                , clientSideErrors = Just maybeErrors
+                                }
+                          , serverSideErrors = Dict.empty
+                          }
+                        , validated
+                        )
                             |> succeed
             )
 

package/src/Server/Session.elm

@@ -1,5 +1,5 @@
 module Server.Session exposing
-    ( withSession
+    ( withSession, withSessionResult
     , NotLoadedReason(..)
     , Session, empty, get, insert, remove, update, withFlash
     )
@@ -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,15 +51,15 @@ 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
+        , options = Nothing
         }
 
 Then you add a second secret
@@ -67,11 +67,11 @@ 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")
-        , options = cookieOptions
+        , options = Nothing
         }
 
 The new secret (`2022-12-01`) will be used to sign all requests. This API always re-signs using the newest secret in the list
@@ -87,16 +87,16 @@ 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
+        , options = Nothing
         }
 
 And then a user makes a request but had a session signed with our old secret (`2022-09-01`), the session will be invalid
 (so `withSession` would parse the session for that request as `Nothing`). It's standard for cookies to have an expiration date,
 so there's nothing wrong with an old session expiring (and the browser will eventually delete old cookies), just be aware of that when rotating secrets.
 
-@docs withSession
+@docs withSession, withSessionResult
 
 @docs NotLoadedReason
 
@@ -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,43 @@ flashPrefix =
 {-| -}
 withSession :
     { name : String
-    , secrets : DataSource (List String)
-    , options : SetCookie.Options
+    , secrets : BackendTask error (List String)
+    , options : Maybe SetCookie.Options
     }
-    -> (request -> Result NotLoadedReason Session -> DataSource ( Session, Response data errorPage ))
+    -> (request -> 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 =
+    withSessionResult config
+        (\request session ->
+            toRequest request
+                (session
+                    |> Result.withDefault empty
+                )
+        )
+        userRequest
+
+
+{-| -}
+withSessionResult :
+    { name : String
+    , secrets : BackendTask error (List String)
+    , options : Maybe SetCookie.Options
+    }
+    -> (request -> Result NotLoadedReason Session -> BackendTask error ( Session, Response data errorPage ))
+    -> Server.Request.Parser request
+    -> Server.Request.Parser (BackendTask error (Response data errorPage))
+withSessionResult 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 +290,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,23 +302,23 @@ withSession config toRequest userRequest =
 
 encodeSessionUpdate :
     { name : String
-    , secrets : DataSource (List String)
-    , options : SetCookie.Options
+    , secrets : BackendTask error (List String)
+    , options : Maybe 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
-                                (SetCookie.setCookie config.name encoded config.options)
+                                (SetCookie.setCookie config.name encoded (config.options |> Maybe.withDefault SetCookie.options))
                     )
                     (sign config.secrets
                         (encodeNonExpiringPairs sessionUpdate)
@@ -306,11 +326,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 +351,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 +373,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 +397,6 @@ unsign getSecrets decoder input =
                         decoder
                             |> Json.Decode.nullable
                             |> Json.Decode.map (Result.fromMaybe ())
-                            |> DataSource.Http.expectJson
+                            |> BackendTask.Http.expectJson
                     }
             )