elm-pages 3.0.0-beta.2 → 3.0.0-beta.20

package/src/Pages/Generate.elm

@@ -1,8 +1,37 @@
-module Pages.Generate exposing (Type(..), serverRender, buildWithLocalState, buildNoState, Builder)
+module Pages.Generate exposing
+    ( buildWithLocalState, buildWithSharedState, buildNoState, Builder
+    , Type(..)
+    , serverRender
+    , preRender, single
+    , addDeclarations
+    )
 
-{-|
+{-| This module provides some functions for scaffolding code for a new Route Module. It uses [`elm-codegen`'s API](https://package.elm-lang.org/packages/mdgriffith/elm-codegen/latest/) for generating code.
 
-@docs Type, serverRender, buildWithLocalState, buildNoState, Builder
+Typically you'll want to use this via the `elm-pages codegen` CLI command. The default starter template includes a file that uses these functions, which you can tweak to customize your scaffolding commands.
+Learn more about [the `elm-pages run` CLI command in its docs page](https://elm-pages.com/docs/run-command).
+
+
+## Initializing the Generator Builder
+
+@docs buildWithLocalState, buildWithSharedState, buildNoState, Builder
+
+@docs Type
+
+
+## Generating Server-Rendered Pages
+
+@docs serverRender
+
+
+## Generating pre-rendered pages
+
+@docs preRender, single
+
+
+## Including Additional elm-codegen Declarations
+
+@docs addDeclarations
 
 -}
 
@@ -30,12 +59,20 @@ typeToDeclaration name type_ =
 
 {-| -}
 type Builder
-    = Builder
+    = ServerRender
+        (List Elm.Declaration)
         { data : ( Type, Elm.Expression -> Elm.Expression )
         , action : ( Type, Elm.Expression -> Elm.Expression )
         , head : Elm.Expression -> Elm.Expression
         , moduleName : List String
         }
+    | PreRender
+        (List Elm.Declaration)
+        { data : ( Type, Elm.Expression -> Elm.Expression )
+        , pages : Maybe Elm.Expression
+        , head : Elm.Expression -> Elm.Expression
+        , moduleName : List String
+        }
 
 
 {-| -}
@@ -47,61 +84,409 @@ serverRender :
     }
     -> Builder
 serverRender =
-    Builder
+    ServerRender []
+
+
+{-| -}
+preRender :
+    { data : ( Type, Elm.Expression -> Elm.Expression )
+    , pages : Elm.Expression
+    , head : Elm.Expression -> Elm.Expression
+    , moduleName : List String
+    }
+    -> 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
+        }
+
+
+{-| -}
+single :
+    { data : ( Type, Elm.Expression )
+    , head : Elm.Expression -> Elm.Expression
+    , moduleName : List String
+    }
+    -> Builder
+single input =
+    PreRender []
+        { data = ( Tuple.first input.data, \_ -> Tuple.second input.data )
+        , pages = Nothing
+        , head = input.head
+        , moduleName = input.moduleName
+        }
 
 
 {-| -}
 buildNoState :
-    { view : Elm.Expression -> Elm.Expression -> Elm.Expression -> Elm.Expression
+    { view : { maybeUrl : Elm.Expression, sharedModel : Elm.Expression, app : Elm.Expression } -> Elm.Expression
     }
     -> Builder
     -> Elm.File
-buildNoState definitions (Builder builder) =
-    userFunction builder.moduleName
-        { view = \_ -> definitions.view
-        , localState = Nothing
-        , data = builder.data |> Tuple.second
-        , action = builder.action |> Tuple.second
-        , head = builder.head
-        , types =
-            { model = Alias (Elm.Annotation.record [])
-            , msg = Alias Elm.Annotation.unit
-            , data = builder.data |> Tuple.first
-            , actionData = builder.action |> Tuple.first
-            }
-        }
+buildNoState definitions builder_ =
+    case builder_ of
+        ServerRender declarations builder ->
+            userFunction builder.moduleName
+                { view =
+                    \maybeUrl sharedModel _ app ->
+                        definitions.view
+                            { maybeUrl = maybeUrl
+                            , sharedModel = sharedModel
+                            , app = app
+                            }
+                , localState = Nothing
+                , data = builder.data |> Tuple.second
+                , action = builder.action |> Tuple.second |> Action
+                , head = builder.head
+                , types =
+                    { model = Alias (Elm.Annotation.record [])
+                    , msg = Alias Elm.Annotation.unit
+                    , data = builder.data |> Tuple.first
+                    , actionData = builder.action |> Tuple.first
+                    }
+                , declarations = declarations
+                }
+
+        PreRender declarations builder ->
+            userFunction builder.moduleName
+                { view =
+                    \maybeUrl sharedModel _ app ->
+                        definitions.view
+                            { maybeUrl = maybeUrl
+                            , sharedModel = sharedModel
+                            , app = app
+                            }
+                , localState = Nothing
+                , data = builder.data |> Tuple.second
+                , action = builder.pages |> Pages
+                , head = builder.head
+                , types =
+                    { model = Alias (Elm.Annotation.record [])
+                    , msg = Alias Elm.Annotation.unit
+                    , data = builder.data |> Tuple.first
+                    , actionData =
+                        throwableTask
+                            (Elm.Annotation.list (Elm.Annotation.named [] "RouteParams"))
+                            |> Alias
+                    }
+                , declarations = declarations
+                }
+
+
+{-| -}
+addDeclarations : List Elm.Declaration -> Builder -> Builder
+addDeclarations declarations builder =
+    case builder of
+        ServerRender existingDeclarations record ->
+            ServerRender (existingDeclarations ++ declarations) record
+
+        PreRender existingDeclarations record ->
+            PreRender (existingDeclarations ++ declarations) record
 
 
 {-| -}
 buildWithLocalState :
-    { view : Elm.Expression -> Elm.Expression -> Elm.Expression -> Elm.Expression -> Elm.Expression
-    , update : Elm.Expression -> Elm.Expression -> Elm.Expression -> Elm.Expression -> Elm.Expression -> Elm.Expression
-    , init : Elm.Expression -> Elm.Expression -> Elm.Expression -> Elm.Expression
-    , subscriptions : Elm.Expression -> Elm.Expression -> Elm.Expression -> Elm.Expression -> Elm.Expression -> Elm.Expression
+    { view :
+        { maybeUrl : Elm.Expression, sharedModel : Elm.Expression, model : Elm.Expression, app : Elm.Expression } -> Elm.Expression
+    , update :
+        { pageUrl : Elm.Expression
+        , sharedModel : Elm.Expression
+        , app : Elm.Expression
+        , msg : Elm.Expression
+        , model : Elm.Expression
+        }
+        -> Elm.Expression
+    , init :
+        { pageUrl : Elm.Expression
+        , sharedModel : Elm.Expression
+        , app : Elm.Expression
+        }
+        -> Elm.Expression
+    , subscriptions :
+        { maybePageUrl : Elm.Expression
+        , routeParams : Elm.Expression
+        , path : Elm.Expression
+        , sharedModel : Elm.Expression
+        , model : Elm.Expression
+        }
+        -> Elm.Expression
     , msg : Type
     , model : Type
     }
     -> Builder
     -> Elm.File
-buildWithLocalState definitions (Builder builder) =
-    userFunction builder.moduleName
-        { view = definitions.view
-        , localState =
-            Just
-                { update = definitions.update
-                , init = definitions.init
-                , subscriptions = definitions.subscriptions
+buildWithLocalState definitions builder_ =
+    case builder_ of
+        ServerRender declarations builder ->
+            userFunction builder.moduleName
+                { view =
+                    \maybeUrl sharedModel model app ->
+                        definitions.view
+                            { maybeUrl = maybeUrl
+                            , sharedModel = sharedModel
+                            , model = model
+                            , app = app
+                            }
+                , localState =
+                    Just
+                        { update =
+                            \pageUrl sharedModel app msg model ->
+                                definitions.update
+                                    { pageUrl = pageUrl
+                                    , sharedModel = sharedModel
+                                    , app = app
+                                    , msg = msg
+                                    , model = model
+                                    }
+                        , init =
+                            \pageUrl sharedModel app ->
+                                definitions.init
+                                    { pageUrl = pageUrl
+                                    , sharedModel = sharedModel
+                                    , app = app
+                                    }
+                        , subscriptions =
+                            \maybePageUrl routeParams path sharedModel model ->
+                                definitions.subscriptions
+                                    { maybePageUrl = maybePageUrl
+                                    , routeParams = routeParams
+                                    , path = path
+                                    , sharedModel = sharedModel
+                                    , model = model
+                                    }
+                        , state = LocalState
+                        }
+                , data = builder.data |> Tuple.second
+                , action = builder.action |> Tuple.second |> Action
+                , head = builder.head
+                , types =
+                    { model = definitions.model
+                    , msg = definitions.msg
+                    , data = builder.data |> Tuple.first
+                    , actionData = builder.action |> Tuple.first
+                    }
+                , declarations = declarations
                 }
-        , data = builder.data |> Tuple.second
-        , action = builder.action |> Tuple.second
-        , head = builder.head
-        , types =
-            { model = definitions.model
-            , msg = definitions.msg
-            , data = builder.data |> Tuple.first
-            , actionData = builder.action |> Tuple.first
-            }
+
+        PreRender declarations builder ->
+            userFunction builder.moduleName
+                { view =
+                    \maybeUrl sharedModel model app ->
+                        definitions.view
+                            { maybeUrl = maybeUrl
+                            , sharedModel = sharedModel
+                            , model = model
+                            , app = app
+                            }
+                , localState =
+                    Just
+                        { update =
+                            \pageUrl sharedModel app msg model ->
+                                definitions.update
+                                    { pageUrl = pageUrl
+                                    , sharedModel = sharedModel
+                                    , app = app
+                                    , msg = msg
+                                    , model = model
+                                    }
+                        , init =
+                            \pageUrl sharedModel app ->
+                                definitions.init
+                                    { pageUrl = pageUrl
+                                    , sharedModel = sharedModel
+                                    , app = app
+                                    }
+                        , subscriptions =
+                            \maybePageUrl routeParams path sharedModel model ->
+                                definitions.subscriptions
+                                    { maybePageUrl = maybePageUrl
+                                    , routeParams = routeParams
+                                    , path = path
+                                    , sharedModel = sharedModel
+                                    , model = model
+                                    }
+                        , state = LocalState
+                        }
+                , data = builder.data |> Tuple.second
+                , action = builder.pages |> Pages
+                , head = builder.head
+                , types =
+                    { model = definitions.model
+                    , msg = definitions.msg
+                    , data = builder.data |> Tuple.first
+                    , actionData =
+                        throwableTask
+                            (Elm.Annotation.list (Elm.Annotation.named [] "RouteParams"))
+                            |> Alias
+                    }
+                , declarations = declarations
+                }
+
+
+{-| -}
+buildWithSharedState :
+    { view :
+        { maybeUrl : Elm.Expression, sharedModel : Elm.Expression, model : Elm.Expression, app : Elm.Expression } -> Elm.Expression
+    , update :
+        { pageUrl : Elm.Expression
+        , sharedModel : Elm.Expression
+        , app : Elm.Expression
+        , msg : Elm.Expression
+        , model : Elm.Expression
         }
+        -> Elm.Expression
+    , init :
+        { pageUrl : Elm.Expression
+        , sharedModel : Elm.Expression
+        , app : Elm.Expression
+        }
+        -> Elm.Expression
+    , subscriptions :
+        { maybePageUrl : Elm.Expression
+        , routeParams : Elm.Expression
+        , path : Elm.Expression
+        , sharedModel : Elm.Expression
+        , model : Elm.Expression
+        }
+        -> Elm.Expression
+    , msg : Type
+    , model : Type
+    }
+    -> Builder
+    -> Elm.File
+buildWithSharedState definitions builder_ =
+    case builder_ of
+        ServerRender declarations builder ->
+            userFunction builder.moduleName
+                { view =
+                    \maybeUrl sharedModel model app ->
+                        definitions.view
+                            { maybeUrl = maybeUrl
+                            , sharedModel = sharedModel
+                            , model = model
+                            , app = app
+                            }
+                , localState =
+                    Just
+                        { update =
+                            \pageUrl sharedModel app msg model ->
+                                definitions.update
+                                    { pageUrl = pageUrl
+                                    , sharedModel = sharedModel
+                                    , app = app
+                                    , msg = msg
+                                    , model = model
+                                    }
+                        , init =
+                            \pageUrl sharedModel app ->
+                                definitions.init
+                                    { pageUrl = pageUrl
+                                    , sharedModel = sharedModel
+                                    , app = app
+                                    }
+                        , subscriptions =
+                            \maybePageUrl routeParams path sharedModel model ->
+                                definitions.subscriptions
+                                    { maybePageUrl = maybePageUrl
+                                    , routeParams = routeParams
+                                    , path = path
+                                    , sharedModel = sharedModel
+                                    , model = model
+                                    }
+                        , state = SharedState
+                        }
+                , data = builder.data |> Tuple.second
+                , action = builder.action |> Tuple.second |> Action
+                , head = builder.head
+                , types =
+                    { model = definitions.model
+                    , msg = definitions.msg
+                    , data = builder.data |> Tuple.first
+                    , actionData = builder.action |> Tuple.first
+                    }
+                , declarations = declarations
+                }
+
+        PreRender declarations builder ->
+            userFunction builder.moduleName
+                { view =
+                    \maybeUrl sharedModel model app ->
+                        definitions.view
+                            { maybeUrl = maybeUrl
+                            , sharedModel = sharedModel
+                            , model = model
+                            , app = app
+                            }
+                , localState =
+                    Just
+                        { update =
+                            \pageUrl sharedModel app msg model ->
+                                definitions.update
+                                    { pageUrl = pageUrl
+                                    , sharedModel = sharedModel
+                                    , app = app
+                                    , msg = msg
+                                    , model = model
+                                    }
+                        , init =
+                            \pageUrl sharedModel app ->
+                                definitions.init
+                                    { pageUrl = pageUrl
+                                    , sharedModel = sharedModel
+                                    , app = app
+                                    }
+                        , subscriptions =
+                            \maybePageUrl routeParams path sharedModel model ->
+                                definitions.subscriptions
+                                    { maybePageUrl = maybePageUrl
+                                    , routeParams = routeParams
+                                    , path = path
+                                    , sharedModel = sharedModel
+                                    , model = model
+                                    }
+                        , state = SharedState
+                        }
+                , data = builder.data |> Tuple.second
+                , action = builder.pages |> Pages
+                , head = builder.head
+                , types =
+                    { model = definitions.model
+                    , msg = definitions.msg
+                    , data = builder.data |> Tuple.first
+                    , actionData =
+                        throwableTask
+                            (Elm.Annotation.list (Elm.Annotation.named [] "RouteParams"))
+                            |> Alias
+                    }
+                , declarations = declarations
+                }
+
+
+type State
+    = SharedState
+    | LocalState
+
+
+type ActionOrPages
+    = Action (Elm.Expression -> Elm.Expression)
+    | Pages (Maybe Elm.Expression)
 
 
 {-| -}
@@ -114,11 +499,13 @@ userFunction :
                 { update : Elm.Expression -> Elm.Expression -> Elm.Expression -> Elm.Expression -> Elm.Expression -> Elm.Expression
                 , init : Elm.Expression -> Elm.Expression -> Elm.Expression -> Elm.Expression
                 , subscriptions : Elm.Expression -> Elm.Expression -> Elm.Expression -> Elm.Expression -> Elm.Expression -> Elm.Expression
+                , state : State
                 }
         , data : Elm.Expression -> Elm.Expression
-        , action : Elm.Expression -> Elm.Expression
+        , action : ActionOrPages
         , head : Elm.Expression -> Elm.Expression
         , types : { model : Type, msg : Type, data : Type, actionData : Type }
+        , declarations : List Elm.Declaration
         }
     -> Elm.File
 userFunction moduleName definitions =
@@ -139,11 +526,22 @@ userFunction moduleName definitions =
                             |> Just
                         )
                         ( "sharedModel"
-                        , Nothing
+                        , Just (Elm.Annotation.named [ "Shared" ] "Model")
                         )
                         ( "model", Just (Elm.Annotation.named [] "Model") )
                         ( "app", Just appType )
-                        definitions.view
+                        (\maybeUrl sharedModel model app ->
+                            definitions.view maybeUrl sharedModel model app
+                                |> Elm.withType
+                                    (Elm.Annotation.namedWith [ "View" ]
+                                        "View"
+                                        [ Elm.Annotation.namedWith [ "Pages", "Msg" ]
+                                            "Msg"
+                                            [ localType "Msg"
+                                            ]
+                                        ]
+                                    )
+                        )
 
                 Nothing ->
                     let
@@ -161,7 +559,7 @@ userFunction moduleName definitions =
                                     |> Just
                                 )
                                 ( "sharedModel"
-                                , Nothing
+                                , Just (Elm.Annotation.named [ "Shared" ] "Model")
                                 )
                                 ( "app", Just appType )
                                 (definitions.view Elm.unit)
@@ -180,6 +578,7 @@ userFunction moduleName definitions =
                     }
                 , initFn : { declaration : Elm.Declaration, call : Elm.Expression -> Elm.Expression -> Elm.Expression -> Elm.Expression, callFrom : List String -> Elm.Expression -> Elm.Expression -> Elm.Expression -> Elm.Expression }
                 , subscriptionsFn : { declaration : Elm.Declaration, call : Elm.Expression -> Elm.Expression -> Elm.Expression -> Elm.Expression -> Elm.Expression -> Elm.Expression, callFrom : List String -> Elm.Expression -> Elm.Expression -> Elm.Expression -> Elm.Expression -> Elm.Expression -> Elm.Expression }
+                , state : State
                 }
         localDefinitions =
             definitions.localState
@@ -192,7 +591,7 @@ userFunction moduleName definitions =
                                     |> Elm.Annotation.named [ "Pages", "PageUrl" ]
                                     |> Just
                                 )
-                                ( "sharedModel", Nothing )
+                                ( "sharedModel", Just (Elm.Annotation.named [ "Shared" ] "Model") )
                                 ( "app", Just appType )
                                 ( "msg", Just (Elm.Annotation.named [] "Msg") )
                                 ( "model", Just (Elm.Annotation.named [] "Model") )
@@ -205,9 +604,16 @@ userFunction moduleName definitions =
                                     |> Elm.Annotation.maybe
                                     |> Just
                                 )
-                                ( "sharedModel", Nothing )
+                                ( "sharedModel", Just (Elm.Annotation.named [ "Shared" ] "Model") )
                                 ( "app", Just appType )
-                                localState.init
+                                (\pageUrl sharedModel app ->
+                                    localState.init pageUrl sharedModel app
+                                        |> Elm.withType
+                                            (Elm.Annotation.tuple
+                                                (localType "Model")
+                                                effectType
+                                            )
+                                )
                         , subscriptionsFn =
                             Elm.Declare.fn5
                                 "subscriptions"
@@ -217,33 +623,90 @@ userFunction moduleName definitions =
                                     |> Elm.Annotation.maybe
                                     |> Just
                                 )
-                                ( "routeParams", Nothing )
-                                ( "path", Nothing )
-                                ( "sharedModel", Nothing )
-                                ( "model", Nothing )
-                                localState.subscriptions
+                                ( "routeParams", "RouteParams" |> Elm.Annotation.named [] |> Just )
+                                ( "path", Elm.Annotation.namedWith [ "Path" ] "Path" [] |> Just )
+                                ( "sharedModel", Just (Elm.Annotation.named [ "Shared" ] "Model") )
+                                ( "model", localType "Model" |> Just )
+                                (\maybePageUrl routeParams path sharedModel model ->
+                                    localState.subscriptions maybePageUrl routeParams path sharedModel model
+                                        |> Elm.withType (Elm.Annotation.namedWith [] "Sub" [ localType "Msg" ])
+                                )
+                        , state = localState.state
                         }
                     )
 
-        dataFn : { declaration : Elm.Declaration, call : Elm.Expression -> Elm.Expression, callFrom : List String -> Elm.Expression -> Elm.Expression }
+        dataFn : { declaration : Elm.Declaration, call : List Elm.Expression -> Elm.Expression, callFrom : List String -> List Elm.Expression -> Elm.Expression }
         dataFn =
-            Elm.Declare.fn "data"
-                ( "routeParams"
-                , "RouteParams"
-                    |> Elm.Annotation.named []
-                    |> Just
-                )
-                (definitions.data >> Elm.withType (myType "Data"))
+            case definitions.action of
+                Pages Nothing ->
+                    Elm.Declare.function "data"
+                        []
+                        (\_ ->
+                            definitions.data Elm.unit
+                                |> Elm.withType
+                                    (case definitions.action of
+                                        Pages _ ->
+                                            throwableTask (Elm.Annotation.named [] "Data")
 
-        actionFn : { declaration : Elm.Declaration, call : Elm.Expression -> Elm.Expression, callFrom : List String -> Elm.Expression -> Elm.Expression }
+                                        Action _ ->
+                                            myType "Data"
+                                    )
+                        )
+
+                _ ->
+                    Elm.Declare.function "data"
+                        [ ( "routeParams"
+                          , "RouteParams"
+                                |> Elm.Annotation.named []
+                                |> Just
+                          )
+                        ]
+                        (\args ->
+                            case args of
+                                [ arg ] ->
+                                    definitions.data arg
+                                        |> 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 }
         actionFn =
-            Elm.Declare.fn "action"
-                ( "routeParams"
-                , "RouteParams"
-                    |> Elm.Annotation.named []
-                    |> Just
-                )
-                (definitions.action >> Elm.withType (myType "ActionData"))
+            case definitions.action of
+                Action action_ ->
+                    Elm.Declare.function "action"
+                        [ ( "routeParams"
+                          , "RouteParams"
+                                |> Elm.Annotation.named []
+                                |> Just
+                          )
+                        ]
+                        (\args ->
+                            case args of
+                                [ arg ] ->
+                                    action_ arg |> Elm.withType (myType "ActionData")
+
+                                _ ->
+                                    Elm.unit
+                        )
+                        |> Just
+
+                Pages pages_ ->
+                    pages_
+                        |> Maybe.map
+                            (\justPagesExpression ->
+                                Elm.Declare.function "pages"
+                                    []
+                                    (\_ -> justPagesExpression)
+                            )
 
         headFn : { declaration : Elm.Declaration, call : Elm.Expression -> Elm.Expression, callFrom : List String -> Elm.Expression -> Elm.Expression }
         headFn =
@@ -257,8 +720,8 @@ userFunction moduleName definitions =
                 )
     in
     Elm.file ("Route" :: moduleName)
-        ([ definitions.types.model |> typeToDeclaration "Model"
-         , definitions.types.msg |> typeToDeclaration "Msg"
+        ([ definitions.types.model |> typeToDeclaration "Model" |> Elm.expose
+         , definitions.types.msg |> typeToDeclaration "Msg" |> Elm.expose
          , Elm.alias "RouteParams"
             (Elm.Annotation.record
                 (RoutePattern.fromModuleName moduleName
@@ -267,18 +730,51 @@ userFunction moduleName definitions =
                     |> Maybe.withDefault []
                 )
             )
+            |> Elm.expose
          , Elm.declaration "route"
-            (serverRender_
-                { action =
-                    \routeParams ->
-                        actionFn.call routeParams
-                            |> Elm.withType (myType "ActionData")
-                , data =
-                    \routeParams ->
-                        dataFn.call routeParams
-                            |> Elm.withType (myType "Data")
-                , head = headFn.call
-                }
+            ((case definitions.action of
+                Action _ ->
+                    serverRender_
+                        { action =
+                            \routeParams ->
+                                actionFn
+                                    |> Maybe.map
+                                        (\justActionFn ->
+                                            justActionFn.call [ routeParams ]
+                                                |> Elm.withType (myType "ActionData")
+                                        )
+                                    |> Maybe.withDefault Elm.unit
+                        , data =
+                            \routeParams ->
+                                dataFn.call [ routeParams ]
+                                    |> Elm.withType (myType "Data")
+                        , head = headFn.call
+                        }
+
+                Pages _ ->
+                    case actionFn of
+                        Nothing ->
+                            single_
+                                { data =
+                                    dataFn.call []
+                                        |> Elm.withType
+                                            (throwableTask
+                                                (Elm.Annotation.named [] "Data")
+                                            )
+                                , head = headFn.call
+                                }
+
+                        Just justActionFn ->
+                            preRender_
+                                { pages = justActionFn.call []
+                                , data =
+                                    \routeParams ->
+                                        dataFn.call [ routeParams ]
+                                            |> Elm.withType
+                                                (throwableTask (Elm.Annotation.named [] "Data"))
+                                , head = headFn.call
+                                }
+             )
                 |> (case localDefinitions of
                         Just local ->
                             buildWithLocalState_
@@ -286,6 +782,7 @@ userFunction moduleName definitions =
                                 , update = local.updateFn.call
                                 , init = local.initFn.call
                                 , subscriptions = local.subscriptionsFn.call
+                                , state = local.state
                                 }
                                 >> Elm.withType
                                     (Elm.Annotation.namedWith [ "RouteBuilder" ]
@@ -312,6 +809,7 @@ userFunction moduleName definitions =
                                     )
                    )
             )
+            |> Elm.expose
          ]
             ++ (case localDefinitions of
                     Just local ->
@@ -323,13 +821,17 @@ userFunction moduleName definitions =
                     Nothing ->
                         []
                )
-            ++ [ definitions.types.data |> typeToDeclaration "Data"
-               , definitions.types.actionData |> typeToDeclaration "ActionData"
+            ++ [ definitions.types.data |> typeToDeclaration "Data" |> Elm.expose
+               , definitions.types.actionData |> typeToDeclaration "ActionData" |> Elm.expose
                , dataFn.declaration
-               , actionFn.declaration
                , headFn.declaration
                , viewFn.declaration
                ]
+            ++ ([ actionFn |> Maybe.map .declaration
+                ]
+                    |> List.filterMap identity
+               )
+            ++ definitions.declarations
         )
 
 
@@ -342,14 +844,13 @@ myType : String -> Elm.Annotation.Annotation
 myType dataType =
     Elm.Annotation.namedWith [ "Server", "Request" ]
         "Parser"
-        [ Elm.Annotation.namedWith [ "DataSource" ]
-            "DataSource"
-            [ Elm.Annotation.namedWith [ "Server", "Response" ]
+        [ throwableTask
+            (Elm.Annotation.namedWith [ "Server", "Response" ]
                 "Response"
                 [ Elm.Annotation.named [] dataType
                 , Elm.Annotation.named [ "ErrorPage" ] "ErrorPage"
                 ]
-            ]
+            )
         ]
 
 
@@ -384,10 +885,8 @@ serverRender_ serverRenderArg =
                                     (Elm.Annotation.namedWith
                                         [ "Server", "Request" ]
                                         "Parser"
-                                        [ Elm.Annotation.namedWith
-                                            [ "DataSource" ]
-                                            "DataSource"
-                                            [ Elm.Annotation.namedWith
+                                        [ throwableTask
+                                            (Elm.Annotation.namedWith
                                                 [ "Server", "Response" ]
                                                 "Response"
                                                 [ Elm.Annotation.var "data"
@@ -396,7 +895,7 @@ serverRender_ serverRenderArg =
                                                     "ErrorPage"
                                                     []
                                                 ]
-                                            ]
+                                            )
                                         ]
                                     )
                               )
@@ -406,10 +905,8 @@ serverRender_ serverRenderArg =
                                     (Elm.Annotation.namedWith
                                         [ "Server", "Request" ]
                                         "Parser"
-                                        [ Elm.Annotation.namedWith
-                                            [ "DataSource" ]
-                                            "DataSource"
-                                            [ Elm.Annotation.namedWith
+                                        [ throwableTask
+                                            (Elm.Annotation.namedWith
                                                 [ "Server", "Response" ]
                                                 "Response"
                                                 [ Elm.Annotation.var "action"
@@ -418,7 +915,7 @@ serverRender_ serverRenderArg =
                                                     "ErrorPage"
                                                     []
                                                 ]
-                                            ]
+                                            )
                                         ]
                                     )
                               )
@@ -463,6 +960,116 @@ serverRender_ serverRenderArg =
         ]
 
 
+preRender_ :
+    { data : Elm.Expression -> Elm.Expression
+    , pages : Elm.Expression
+    , head : Elm.Expression -> Elm.Expression
+    }
+    -> Elm.Expression
+preRender_ serverRenderArg =
+    Elm.apply
+        (Elm.value
+            { importFrom = [ "RouteBuilder" ]
+            , name = "preRender"
+            , annotation =
+                Just
+                    (Elm.Annotation.function
+                        [ Elm.Annotation.record
+                            [ ( "data"
+                              , Elm.Annotation.function
+                                    [ Elm.Annotation.var "routeParams" ]
+                                    (throwableTask (Elm.Annotation.var "data"))
+                              )
+                            , ( "pages"
+                              , throwableTask
+                                    (Elm.Annotation.list (Elm.Annotation.named [] "RouteParams"))
+                              )
+                            , ( "head"
+                              , Elm.Annotation.function
+                                    [ Elm.Annotation.namedWith
+                                        [ "RouteBuilder" ]
+                                        "StaticPayload"
+                                        [ Elm.Annotation.var "data"
+                                        , Elm.Annotation.var "action"
+                                        , Elm.Annotation.var "routeParams"
+                                        ]
+                                    ]
+                                    (Elm.Annotation.list
+                                        (Elm.Annotation.namedWith [ "Head" ] "Tag" [])
+                                    )
+                              )
+                            ]
+                        ]
+                        (Elm.Annotation.namedWith
+                            [ "RouteBuilder" ]
+                            "Builder"
+                            [ Elm.Annotation.named [] "RouteParams"
+                            , Elm.Annotation.named [] "Data"
+                            , Elm.Annotation.named [] "Action"
+                            ]
+                        )
+                    )
+            }
+        )
+        [ Elm.record
+            [ Tuple.pair "data" (Elm.functionReduced "serverRenderUnpack" serverRenderArg.data)
+            , Tuple.pair "pages" serverRenderArg.pages
+            , Tuple.pair "head" (Elm.functionReduced "serverRenderUnpack" serverRenderArg.head)
+            ]
+        ]
+
+
+single_ :
+    { data : Elm.Expression
+    , head : Elm.Expression -> Elm.Expression
+    }
+    -> Elm.Expression
+single_ serverRenderArg =
+    Elm.apply
+        (Elm.value
+            { importFrom = [ "RouteBuilder" ]
+            , name = "single"
+            , annotation =
+                Just
+                    (Elm.Annotation.function
+                        [ Elm.Annotation.record
+                            [ ( "data"
+                              , throwableTask (Elm.Annotation.var "data")
+                              )
+                            , ( "head"
+                              , Elm.Annotation.function
+                                    [ Elm.Annotation.namedWith
+                                        [ "RouteBuilder" ]
+                                        "StaticPayload"
+                                        [ Elm.Annotation.var "data"
+                                        , Elm.Annotation.var "action"
+                                        , Elm.Annotation.var "routeParams"
+                                        ]
+                                    ]
+                                    (Elm.Annotation.list
+                                        (Elm.Annotation.namedWith [ "Head" ] "Tag" [])
+                                    )
+                              )
+                            ]
+                        ]
+                        (Elm.Annotation.namedWith
+                            [ "RouteBuilder" ]
+                            "Builder"
+                            [ Elm.Annotation.named [] "RouteParams"
+                            , Elm.Annotation.named [] "Data"
+                            , Elm.Annotation.named [] "Action"
+                            ]
+                        )
+                    )
+            }
+        )
+        [ Elm.record
+            [ Tuple.pair "data" serverRenderArg.data
+            , Tuple.pair "head" (Elm.functionReduced "serverRenderUnpack" serverRenderArg.head)
+            ]
+        ]
+
+
 buildWithLocalState_ :
     { view :
         Elm.Expression
@@ -486,6 +1093,7 @@ buildWithLocalState_ :
         -> Elm.Expression
         -> Elm.Expression
         -> Elm.Expression
+    , state : State
     }
     -> Elm.Expression
     -> Elm.Expression
@@ -493,7 +1101,13 @@ buildWithLocalState_ buildWithLocalStateArg buildWithLocalStateArg0 =
     Elm.apply
         (Elm.value
             { importFrom = [ "RouteBuilder" ]
-            , name = "buildWithLocalState"
+            , name =
+                case buildWithLocalStateArg.state of
+                    LocalState ->
+                        "buildWithLocalState"
+
+                    SharedState ->
+                        "buildWithSharedState"
             , annotation =
                 Just
                     (Elm.Annotation.function
@@ -544,11 +1158,11 @@ buildWithLocalState_ buildWithLocalStateArg buildWithLocalStateArg0 =
                                         ]
                                     ]
                                     (Elm.Annotation.tuple
-                                        (Elm.Annotation.var "model")
+                                        (Elm.Annotation.named [] "Model")
                                         (Elm.Annotation.namedWith
                                             [ "Effect" ]
                                             "Effect"
-                                            [ Elm.Annotation.var "msg" ]
+                                            [ Elm.Annotation.named [] "Msg" ]
                                         )
                                     )
                               )
@@ -562,20 +1176,32 @@ buildWithLocalState_ buildWithLocalStateArg buildWithLocalStateArg0 =
                                     , Elm.Annotation.namedWith
                                         [ "RouteBuilder" ]
                                         "StaticPayload"
-                                        [ Elm.Annotation.var "data"
-                                        , Elm.Annotation.var "action"
-                                        , Elm.Annotation.var "routeParams"
+                                        [ localType "Data"
+                                        , localType "ActionData"
+                                        , localType "RouteParams"
                                         ]
-                                    , Elm.Annotation.var "msg"
-                                    , Elm.Annotation.var "model"
+                                    , Elm.Annotation.named [] "Msg"
+                                    , Elm.Annotation.named [] "Model"
                                     ]
-                                    (Elm.Annotation.tuple
-                                        (Elm.Annotation.var "model")
-                                        (Elm.Annotation.namedWith
-                                            [ "Effect" ]
-                                            "Effect"
-                                            [ Elm.Annotation.var "msg" ]
-                                        )
+                                    (case buildWithLocalStateArg.state of
+                                        LocalState ->
+                                            Elm.Annotation.tuple
+                                                (localType "Model")
+                                                (Elm.Annotation.namedWith
+                                                    [ "Effect" ]
+                                                    "Effect"
+                                                    [ localType "Msg" ]
+                                                )
+
+                                        SharedState ->
+                                            Elm.Annotation.triple
+                                                (localType "Model")
+                                                (Elm.Annotation.namedWith
+                                                    [ "Effect" ]
+                                                    "Effect"
+                                                    [ localType "Msg" ]
+                                                )
+                                                (Elm.Annotation.maybe (Elm.Annotation.named [ "Shared" ] "Msg"))
                                     )
                               )
                             , ( "subscriptions"
@@ -591,25 +1217,25 @@ buildWithLocalState_ buildWithLocalStateArg buildWithLocalStateArg0 =
                                     , Elm.Annotation.namedWith [ "Shared" ] "Model" []
                                     , Elm.Annotation.var "model"
                                     ]
-                                    (Elm.Annotation.namedWith [] "Sub" [ Elm.Annotation.var "msg" ])
+                                    (Elm.Annotation.namedWith [] "Sub" [ localType "Msg" ])
                               )
                             ]
                         , Elm.Annotation.namedWith
                             [ "RouteBuilder" ]
                             "Builder"
-                            [ Elm.Annotation.var "routeParams"
-                            , Elm.Annotation.var "data"
-                            , Elm.Annotation.var "action"
+                            [ localType "RouteParams"
+                            , localType "Data"
+                            , localType "ActionData"
                             ]
                         ]
                         (Elm.Annotation.namedWith
                             [ "RouteBuilder" ]
                             "StatefulRoute"
-                            [ Elm.Annotation.var "routeParams"
-                            , Elm.Annotation.var "data"
-                            , Elm.Annotation.var "action"
-                            , Elm.Annotation.var "model"
-                            , Elm.Annotation.var "msg"
+                            [ localType "RouteParams"
+                            , localType "Data"
+                            , localType "ActionData"
+                            , localType "Model"
+                            , localType "Msg"
                             ]
                         )
                     )
@@ -741,9 +1367,9 @@ buildNoState_ buildNoStateArg buildNoStateArg0 =
                                     , Elm.Annotation.namedWith
                                         [ "RouteBuilder" ]
                                         "StaticPayload"
-                                        [ Elm.Annotation.var "data"
-                                        , Elm.Annotation.var "action"
-                                        , Elm.Annotation.var "routeParams"
+                                        [ Elm.Annotation.named [] "Data"
+                                        , Elm.Annotation.named [] "ActionData"
+                                        , Elm.Annotation.named [] "RouteParams"
                                         ]
                                     ]
                                     (Elm.Annotation.namedWith
@@ -760,17 +1386,17 @@ buildNoState_ buildNoStateArg buildNoStateArg0 =
                         , Elm.Annotation.namedWith
                             [ "RouteBuilder" ]
                             "Builder"
-                            [ Elm.Annotation.var "routeParams"
-                            , Elm.Annotation.var "data"
-                            , Elm.Annotation.var "action"
+                            [ Elm.Annotation.named [] "RouteParams"
+                            , Elm.Annotation.named [] "Data"
+                            , Elm.Annotation.named [] "ActionData"
                             ]
                         ]
                         (Elm.Annotation.namedWith
                             [ "RouteBuilder" ]
                             "StatefulRoute"
-                            [ Elm.Annotation.var "routeParams"
-                            , Elm.Annotation.var "data"
-                            , Elm.Annotation.var "action"
+                            [ Elm.Annotation.named [] "RouteParams"
+                            , Elm.Annotation.named [] "Data"
+                            , Elm.Annotation.named [] "ActionData"
                             , Elm.Annotation.record []
                             , Elm.Annotation.unit
                             ]
@@ -798,3 +1424,20 @@ buildNoState_ buildNoStateArg buildNoStateArg0 =
             ]
         , buildNoStateArg0
         ]
+
+
+effectType : Elm.Annotation.Annotation
+effectType =
+    Elm.Annotation.namedWith
+        [ "Effect" ]
+        "Effect"
+        [ Elm.Annotation.named [] "Msg" ]
+
+
+throwableTask : Elm.Annotation.Annotation -> Elm.Annotation.Annotation
+throwableTask dataType =
+    Elm.Annotation.namedWith [ "BackendTask" ]
+        "BackendTask"
+        [ Elm.Annotation.named [ "FatalError" ] "FatalError"
+        , dataType
+        ]