elm-pages 3.0.8 → 3.0.10

package/src/Scaffold/Route.elm

@@ -118,7 +118,15 @@ serverRender =
     ServerRender []
 
 
-{-| -}
+{-| Will scaffold using `RouteBuilder.preRender` if there are any dynamic segments (as in `Company.Team.Name_`),
+or using `RouteBuilder.single` if there are no dynamic segments (as in `Company.AboutUs`).
+
+When there are no dynamic segments, the `pages` field will be ignored as it is only relevant for Routes with dynamic segments.
+
+For dynamic segments, the `routeParams` parameter in the `data` function will be an `Elm.Expression` with the `RouteParams` parameter in the `data` function.
+For static segments, it will be a hardcoded empty record (`{}`).
+
+-}
 preRender :
     { data : ( Type, Elm.Expression -> Elm.Expression )
     , pages : Elm.Expression
@@ -127,29 +135,41 @@ preRender :
     }
     -> Builder
 preRender input =
-    --let
-    --    hasDynamicRouteSegments : Bool
-    --    hasDynamicRouteSegments =
-    --        RoutePattern.fromModuleName input.moduleName
-    --            -- TODO give error if not parseable here
-    --            |> Maybe.map RoutePattern.hasRouteParams
-    --            |> Maybe.withDefault False
-    --in
-    PreRender []
-        { data = input.data
-        , pages =
-            input.pages
-                |> Elm.withType
-                    (throwableTask
-                        (Elm.Annotation.list <| Elm.Annotation.named [] "RouteParams")
-                    )
-                |> Just
-        , head = input.head
-        , moduleName = input.moduleName
-        }
+    let
+        hasDynamicRouteSegments : Bool
+        hasDynamicRouteSegments =
+            RoutePattern.fromModuleName input.moduleName
+                |> Maybe.map RoutePattern.hasRouteParams
+                |> Maybe.withDefault False
+    in
+    if hasDynamicRouteSegments then
+        PreRender []
+            { data = input.data
+            , pages =
+                input.pages
+                    |> Elm.withType
+                        (throwableTask
+                            (Elm.Annotation.list <| Elm.Annotation.named [] "RouteParams")
+                        )
+                    |> Just
+            , head = input.head
+            , moduleName = input.moduleName
+            }
 
+    else
+        PreRender []
+            { data = input.data
+            , pages = Nothing
+            , head = input.head
+            , moduleName = input.moduleName
+            }
 
-{-| -}
+
+{-| @depreacted. This is obsolete and will be removed in a future release. Use [`preRender`](#preRender) instead.
+
+If you pass in only static route segments as the `moduleName` to `preRender` it will yield the same result as `single`.
+
+-}
 single :
     { data : ( Type, Elm.Expression )
     , head : Elm.Expression -> Elm.Expression
@@ -656,7 +676,7 @@ userFunction moduleName definitions =
                     Elm.Declare.function "data"
                         []
                         (\_ ->
-                            definitions.data Elm.unit Elm.unit
+                            definitions.data Elm.unit (Elm.record [])
                                 |> Elm.withType
                                     (case definitions.action of
                                         Pages _ ->
@@ -668,34 +688,60 @@ userFunction moduleName definitions =
                         )
 
                 _ ->
-                    Elm.Declare.function "data"
-                        [ ( "routeParams"
-                          , "RouteParams"
-                                |> Elm.Annotation.named []
-                                |> Just
-                          )
-                        , ( "request"
-                          , "Request"
-                                |> Elm.Annotation.named [ "Server", "Request" ]
-                                |> Just
-                          )
-                        ]
-                        (\args ->
-                            case args of
-                                [ arg, arg2 ] ->
-                                    definitions.data arg arg2
-                                        |> Elm.withType
-                                            (case definitions.action of
-                                                Pages _ ->
-                                                    throwableTask (Elm.Annotation.named [] "Data")
+                    case definitions.action of
+                        Pages _ ->
+                            Elm.Declare.function "data"
+                                [ ( "routeParams"
+                                  , "RouteParams"
+                                        |> Elm.Annotation.named []
+                                        |> Just
+                                  )
+                                ]
+                                (\args ->
+                                    case args of
+                                        [ arg ] ->
+                                            definitions.data
+                                                (arg
+                                                    |> Elm.withType
+                                                        (throwableTask
+                                                            (Elm.Annotation.named [] "Data")
+                                                        )
+                                                )
+                                                Elm.unit
 
-                                                Action _ ->
-                                                    myType "Data"
-                                            )
+                                        _ ->
+                                            Elm.unit
+                                )
 
-                                _ ->
-                                    Elm.unit
-                        )
+                        Action _ ->
+                            Elm.Declare.function "data"
+                                [ ( "routeParams"
+                                  , "RouteParams"
+                                        |> Elm.Annotation.named []
+                                        |> Just
+                                  )
+                                , ( "request"
+                                  , "Request"
+                                        |> Elm.Annotation.named [ "Server", "Request" ]
+                                        |> Just
+                                  )
+                                ]
+                                (\args ->
+                                    case args of
+                                        [ arg, arg2 ] ->
+                                            definitions.data arg arg2
+                                                |> Elm.withType
+                                                    (case definitions.action of
+                                                        Pages _ ->
+                                                            throwableTask (Elm.Annotation.named [] "Data")
+
+                                                        Action _ ->
+                                                            myType "Data"
+                                                    )
+
+                                        _ ->
+                                            Elm.unit
+                                )
 
         actionFn : Maybe { declaration : Elm.Declaration, call : List Elm.Expression -> Elm.Expression, callFrom : List String -> List Elm.Expression -> Elm.Expression, value : List String -> Elm.Expression }
         actionFn =

package/src/Server/Session.elm

@@ -27,7 +27,7 @@ Using these functions, you can store and read session data in cookies to maintai
     type alias Data =
         { darkMode : Bool }
 
-    data : RouteParams -> Request -> BackendTask (Response Data ErrorPage)
+    data : RouteParams -> Request -> BackendTask FatalError (Response Data ErrorPage)
     data routeParams request =
         request
             |> Session.withSession
@@ -42,12 +42,15 @@ Using these functions, you can store and read session data in cookies to maintai
                             (session |> Session.get "mode" |> Maybe.withDefault "light")
                                 == "dark"
                     in
-                    ( session
-                    , { darkMode = darkMode }
-                    )
+                    BackendTask.succeed
+                        ( session
+                        , Response.render
+                            { darkMode = darkMode
+                            }
+                        )
                 )
 
-The elm-pages framework will manage signing these cookies using the `secrets : BackendTask (List String)` you pass in.
+The elm-pages framework will manage signing these cookies using the `secrets : BackendTask FatalError (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
@@ -56,7 +59,7 @@ signed with your secrets. Of course you need to provide secure secrets and treat
 
 ### Rotating Secrets
 
-The first String in `secrets : BackendTask (List String)` will be used to sign sessions, while the remaining String's will
+The first String in `secrets : BackendTask FatalError (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