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

package/generator/review/elm-stuff/tests-0.19.1/js/node_runner.js

@@ -75,7 +75,7 @@ console.elmlog = (str) => logs.push(str + "\n");
 const { Elm } = require("./Runner.elm.js");
 
 // Start the Elm app
-const flags = { initialSeed: 1646606691, fuzzRuns: 100, filter: null };
+const flags = { initialSeed: 1451258136, fuzzRuns: 100, filter: null };
 const app = Elm.Runner.init({ flags: flags });
 
 // Record the timing at which we received the last "runTest" message

package/generator/review/elm-stuff/tests-0.19.1/js/node_supervisor.js

@@ -75,19 +75,19 @@ let testsCount, todoTests;
 let reporter;
 let runners = [];
 let working = false;
-let workersCount = 2;
+let workersCount = 10;
 let startWorkCallback = function(){};
 const verbosity = 0;
 
 // Create a long lived reporter worker
 const { Elm } = require("./Reporter.elm.js");
 const flags = {
-  initialSeed: 1646606691,
+  initialSeed: 1451258136,
   fuzzRuns: 100,
-  mode: "consoleNoColor",
+  mode: "consoleColor",
   verbosity: verbosity,
   globs: [],
-  paths: ["/home/runner/work/elm-pages-v3-beta/elm-pages-v3-beta/generator/review/tests/Pages/Review/NoContractViolationsTest.elm"],
+  paths: ["/Users/dillonkearns/src/github.com/dillonkearns/elm-pages-v3-beta/generator/review/tests/Pages/Review/NoContractViolationsTest.elm"],
 };
 reporter = Elm.Reporter.init({ flags: flags });
 

package/generator/review/elm.json

@@ -9,26 +9,26 @@
         "direct": {
             "elm/core": "1.0.5",
             "elm/html": "1.0.0",
+            "elm/json": "1.1.3",
             "elm/regex": "1.0.0",
-            "elm-community/result-extra": "2.4.0",
-            "jfmengels/elm-review": "2.4.2",
-            "mdgriffith/elm-codegen": "2.0.0",
-            "stil4m/elm-syntax": "7.2.5",
+            "jfmengels/elm-review": "2.13.0",
+            "mdgriffith/elm-codegen": "3.0.0",
+            "stil4m/elm-syntax": "7.2.9",
             "the-sett/elm-syntax-dsl": "6.0.2"
         },
         "indirect": {
             "Chadtech/elm-bool-extra": "2.4.2",
-            "elm/json": "1.1.3",
+            "elm/bytes": "1.0.8",
             "elm/parser": "1.1.0",
             "elm/project-metadata-utils": "1.0.2",
             "elm/random": "1.0.0",
             "elm/time": "1.0.0",
-            "elm/virtual-dom": "1.0.2",
+            "elm/virtual-dom": "1.0.3",
             "elm-community/basics-extra": "4.1.0",
-            "elm-community/list-extra": "8.3.0",
+            "elm-community/list-extra": "8.7.0",
             "elm-community/maybe-extra": "5.3.0",
-            "elm-explorations/test": "1.2.2",
-            "miniBill/elm-unicode": "1.0.2",
+            "elm-explorations/test": "2.1.1",
+            "miniBill/elm-unicode": "1.0.3",
             "rtfeldman/elm-hex": "1.0.0",
             "stil4m/structured-writer": "1.0.3",
             "the-sett/elm-pretty-printer": "3.0.0"
@@ -36,7 +36,7 @@
     },
     "test-dependencies": {
         "direct": {
-            "elm-explorations/test": "1.2.2"
+            "elm-explorations/test": "2.1.1"
         },
         "indirect": {}
     }

package/generator/src/RouteBuilder.elm

@@ -1,6 +1,6 @@
 module RouteBuilder exposing
     ( StatelessRoute, buildNoState
-    , StaticPayload
+    , App
     , withOnAction
     , buildWithLocalState, buildWithSharedState
     , preRender, single
@@ -14,7 +14,7 @@ module RouteBuilder exposing
 
 ## Stateless Route Modules
 
-The simplest Route Module you can build is one with no state. It still can use `DataSource`'s, but it has no `init`, `update`, or `subscriptions`.
+The simplest Route Module you can build is one with no state. It still can use `BackendTask`'s, but it has no `init`, `update`, or `subscriptions`.
 
 It can read the `Shared.Model`, but it cannot send `Shared.Msg`'s to update the `Shared.Model`. If you need a `Model`, use `buildWithLocalState`.
 
@@ -25,7 +25,7 @@ If you need to _change_ Shared state, use `buildWithSharedState`.
 
 ## Accessing Static Data
 
-With `elm-pages`, you can have HTTP data available before a page is loaded, or read in a file, etc, using the DataSource API. Since the data
+With `elm-pages`, you can have HTTP data available before a page is loaded, or read in a file, etc, using the BackendTask API. Since the data
 is available when the page is pre-rendered (as well as in the hydrated page), this is called Static Data.
 
 An example of dynamic data would be keyboard input from the user, query params, or any other data that comes from the app running in the browser.
@@ -33,11 +33,11 @@ An example of dynamic data would be keyboard input from the user, query params,
 We have the following data during pre-render:
 
   - `path` - the current path is static. In other words, we know the current path when we build an elm-pages site. Note that we **do not** know query parameters, fragments, etc. That is dynamic data. Pre-rendering occurs for paths in our app, but we don't know what possible query paremters might be used when those paths are hit.
-  - `data` - this will be the resolved `DataSource` for our page.
+  - `data` - this will be the resolved `BackendTask` for our page.
   - `sharedData` - we can access any shared data between pages. For example, you may have fetched the name of a blog ("Jane's Blog") from the API for a Content Management System (CMS).
   - `routeParams` - this is the record that includes any Dynamic Route Segments for the given page (or an empty record if there are none)
 
-@docs StaticPayload
+@docs App
 
 @docs withOnAction
 
@@ -65,7 +65,7 @@ When there are Dynamic Route Segments, you need to tell `elm-pages` which pages
             }
 
     pages =
-        DataSource.succeed
+        BackendTask.succeed
             [ { slug = "blog-post1" }
             , { slug = "blog-post2" }
             ]
@@ -85,21 +85,21 @@ When there are Dynamic Route Segments, you need to tell `elm-pages` which pages
 
 -}
 
-import Bytes exposing (Bytes)
-import DataSource exposing (DataSource)
-import DataSource.Http
+import BackendTask exposing (BackendTask)
 import Dict exposing (Dict)
 import Effect exposing (Effect)
 import ErrorPage exposing (ErrorPage)
+import FatalError exposing (FatalError)
+import Form
 import Head
 import Http
+import Json.Decode
 import Pages.Fetcher
-import Pages.FormState
 import Pages.Internal.NotFoundReason exposing (NotFoundReason)
 import Pages.Internal.RoutePattern exposing (RoutePattern)
-import Pages.Msg
 import Pages.PageUrl exposing (PageUrl)
 import Pages.Transition
+import PagesMsg exposing (PagesMsg)
 import Path exposing (Path)
 import Server.Request
 import Server.Response
@@ -109,22 +109,21 @@ import View exposing (View)
 
 {-| -}
 type alias StatefulRoute routeParams data action model msg =
-    { data : routeParams -> DataSource (Server.Response.Response data ErrorPage)
-    , action : routeParams -> DataSource (Server.Response.Response action ErrorPage)
-    , staticRoutes : DataSource (List routeParams)
+    { data : Json.Decode.Value -> routeParams -> BackendTask FatalError (Server.Response.Response data ErrorPage)
+    , action : Json.Decode.Value -> routeParams -> BackendTask FatalError (Server.Response.Response action ErrorPage)
+    , staticRoutes : BackendTask FatalError (List routeParams)
     , view :
-        Maybe PageUrl
-        -> Shared.Model
+        Shared.Model
         -> model
-        -> StaticPayload data action routeParams
-        -> View (Pages.Msg.Msg msg)
+        -> App data action routeParams
+        -> View (PagesMsg msg)
     , head :
-        StaticPayload data action routeParams
+        App data action routeParams
         -> List Head.Tag
-    , init : Maybe PageUrl -> Shared.Model -> StaticPayload data action routeParams -> ( model, Effect msg )
-    , update : PageUrl -> StaticPayload data action routeParams -> msg -> model -> Shared.Model -> ( model, Effect msg, Maybe Shared.Msg )
-    , subscriptions : Maybe PageUrl -> routeParams -> Path -> model -> Shared.Model -> Sub msg
-    , handleRoute : { moduleName : List String, routePattern : RoutePattern } -> (routeParams -> List ( String, String )) -> routeParams -> DataSource (Maybe NotFoundReason)
+    , init : Shared.Model -> App data action routeParams -> ( model, Effect msg )
+    , update : App data action routeParams -> msg -> model -> Shared.Model -> ( model, Effect msg, Maybe Shared.Msg )
+    , subscriptions : routeParams -> Path -> model -> Shared.Model -> Sub msg
+    , handleRoute : { moduleName : List String, routePattern : RoutePattern } -> (routeParams -> List ( String, String )) -> routeParams -> BackendTask FatalError (Maybe NotFoundReason)
     , kind : String
     , onAction : Maybe (action -> msg)
     }
@@ -136,36 +135,37 @@ type alias StatelessRoute routeParams data action =
 
 
 {-| -}
-type alias StaticPayload data action routeParams =
+type alias App data action routeParams =
     { data : data
     , sharedData : Shared.Data
     , routeParams : routeParams
     , path : Path
+    , url : Maybe PageUrl
     , action : Maybe action
     , submit :
         { fields : List ( String, String ), headers : List ( String, String ) }
         -> Pages.Fetcher.Fetcher (Result Http.Error action)
     , transition : Maybe Pages.Transition.Transition
     , fetchers : Dict String (Pages.Transition.FetcherState (Maybe action))
-    , pageFormState : Pages.FormState.PageFormState
+    , pageFormState : Form.Model
     }
 
 
 {-| -}
 type Builder routeParams data action
     = WithData
-        { data : routeParams -> DataSource (Server.Response.Response data ErrorPage)
-        , action : routeParams -> DataSource (Server.Response.Response action ErrorPage)
-        , staticRoutes : DataSource (List routeParams)
+        { data : Json.Decode.Value -> routeParams -> BackendTask FatalError (Server.Response.Response data ErrorPage)
+        , action : Json.Decode.Value -> routeParams -> BackendTask FatalError (Server.Response.Response action ErrorPage)
+        , staticRoutes : BackendTask FatalError (List routeParams)
         , head :
-            StaticPayload data action routeParams
+            App data action routeParams
             -> List Head.Tag
         , serverless : Bool
         , handleRoute :
             { moduleName : List String, routePattern : RoutePattern }
             -> (routeParams -> List ( String, String ))
             -> routeParams
-            -> DataSource (Maybe NotFoundReason)
+            -> BackendTask FatalError (Maybe NotFoundReason)
         , kind : String
         }
 
@@ -173,24 +173,23 @@ type Builder routeParams data action
 {-| -}
 buildNoState :
     { view :
-        Maybe PageUrl
+        App data action routeParams
         -> Shared.Model
-        -> StaticPayload data action routeParams
-        -> View (Pages.Msg.Msg ())
+        -> View (PagesMsg ())
     }
     -> Builder routeParams data action
     -> StatefulRoute routeParams data action {} ()
 buildNoState { view } builderState =
     case builderState of
         WithData record ->
-            { view = \maybePageUrl sharedModel _ -> view maybePageUrl sharedModel
+            { view = \shared model app -> view app shared
             , head = record.head
             , data = record.data
             , action = record.action
             , staticRoutes = record.staticRoutes
-            , init = \_ _ _ -> ( {}, Effect.none )
-            , update = \_ _ _ _ _ -> ( {}, Effect.none, Nothing )
-            , subscriptions = \_ _ _ _ _ -> Sub.none
+            , init = \_ _ -> ( {}, Effect.none )
+            , update = \_ _ _ _ -> ( {}, Effect.none, Nothing )
+            , subscriptions = \_ _ _ _ -> Sub.none
             , handleRoute = record.handleRoute
             , kind = record.kind
             , onAction = Nothing
@@ -208,14 +207,13 @@ withOnAction toMsg config =
 {-| -}
 buildWithLocalState :
     { view :
-        Maybe PageUrl
+        App data action routeParams
         -> Shared.Model
         -> model
-        -> StaticPayload data action routeParams
-        -> View (Pages.Msg.Msg msg)
-    , init : Maybe PageUrl -> Shared.Model -> StaticPayload data action routeParams -> ( model, Effect msg )
-    , update : PageUrl -> Shared.Model -> StaticPayload data action routeParams -> msg -> model -> ( model, Effect msg )
-    , subscriptions : Maybe PageUrl -> routeParams -> Path -> Shared.Model -> model -> Sub msg
+        -> View (PagesMsg msg)
+    , init : App data action routeParams -> Shared.Model -> ( model, Effect msg )
+    , update : App data action routeParams -> Shared.Model -> msg -> model -> ( model, Effect msg )
+    , subscriptions : routeParams -> Path -> Shared.Model -> model -> Sub msg
     }
     -> Builder routeParams data action
     -> StatefulRoute routeParams data action model msg
@@ -223,28 +221,23 @@ buildWithLocalState config builderState =
     case builderState of
         WithData record ->
             { view =
-                \model sharedModel staticPayload ->
-                    config.view model sharedModel staticPayload
+                \model sharedModel app ->
+                    config.view app model sharedModel
             , head = record.head
             , data = record.data
             , action = record.action
             , staticRoutes = record.staticRoutes
-            , init = config.init
+            , init = \shared app -> config.init app shared
             , update =
-                \pageUrl staticPayload msg model sharedModel ->
+                \app msg model sharedModel ->
                     let
                         ( updatedModel, cmd ) =
-                            config.update
-                                pageUrl
-                                sharedModel
-                                staticPayload
-                                msg
-                                model
+                            config.update app sharedModel msg model
                     in
                     ( updatedModel, cmd, Nothing )
             , subscriptions =
-                \maybePageUrl routeParams path model sharedModel ->
-                    config.subscriptions maybePageUrl routeParams path sharedModel model
+                \routeParams path model sharedModel ->
+                    config.subscriptions routeParams path sharedModel model
             , handleRoute = record.handleRoute
             , kind = record.kind
             , onAction = Nothing
@@ -254,36 +247,35 @@ buildWithLocalState config builderState =
 {-| -}
 buildWithSharedState :
     { view :
-        Maybe PageUrl
+        App data action routeParams
         -> Shared.Model
         -> model
-        -> StaticPayload data action routeParams
-        -> View (Pages.Msg.Msg msg)
-    , init : Maybe PageUrl -> Shared.Model -> StaticPayload data action routeParams -> ( model, Effect msg )
-    , update : PageUrl -> Shared.Model -> StaticPayload data action routeParams -> msg -> model -> ( model, Effect msg, Maybe Shared.Msg )
-    , subscriptions : Maybe PageUrl -> routeParams -> Path -> Shared.Model -> model -> Sub msg
+        -> View (PagesMsg msg)
+    , init : App data action routeParams -> Shared.Model -> ( model, Effect msg )
+    , update : App data action routeParams -> Shared.Model -> msg -> model -> ( model, Effect msg, Maybe Shared.Msg )
+    , subscriptions : routeParams -> Path -> Shared.Model -> model -> Sub msg
     }
     -> Builder routeParams data action
     -> StatefulRoute routeParams data action model msg
 buildWithSharedState config builderState =
     case builderState of
         WithData record ->
-            { view = config.view
+            { view = \shared model app -> config.view app shared model
             , head = record.head
             , data = record.data
             , action = record.action
             , staticRoutes = record.staticRoutes
-            , init = config.init
+            , init = \shared app -> config.init app shared
             , update =
-                \pageUrl staticPayload msg model sharedModel ->
-                    config.update pageUrl
+                \app msg model sharedModel ->
+                    config.update
+                        app
                         sharedModel
-                        staticPayload
                         msg
                         model
             , subscriptions =
-                \maybePageUrl routeParams path model sharedModel ->
-                    config.subscriptions maybePageUrl routeParams path sharedModel model
+                \routeParams path model sharedModel ->
+                    config.subscriptions routeParams path sharedModel model
             , handleRoute = record.handleRoute
             , kind = record.kind
             , onAction = Nothing
@@ -292,40 +284,40 @@ buildWithSharedState config builderState =
 
 {-| -}
 single :
-    { data : DataSource data
-    , head : StaticPayload data action {} -> List Head.Tag
+    { data : BackendTask FatalError data
+    , head : App data action {} -> List Head.Tag
     }
     -> Builder {} data action
 single { data, head } =
     WithData
-        { data = \_ -> data |> DataSource.map Server.Response.render
-        , action = \_ -> DataSource.fail "Internal Error - actions should never be called for statically generated pages."
-        , staticRoutes = DataSource.succeed [ {} ]
+        { data = \_ _ -> data |> BackendTask.map Server.Response.render
+        , action = \_ _ -> BackendTask.fail (FatalError.fromString "Internal Error - actions should never be called for statically generated pages.")
+        , staticRoutes = BackendTask.succeed [ {} ]
         , head = head
         , serverless = False
-        , handleRoute = \_ _ _ -> DataSource.succeed Nothing
+        , handleRoute = \_ _ _ -> BackendTask.succeed Nothing
         , kind = "static"
         }
 
 
 {-| -}
 preRender :
-    { data : routeParams -> DataSource data
-    , pages : DataSource (List routeParams)
-    , head : StaticPayload data action routeParams -> List Head.Tag
+    { data : routeParams -> BackendTask FatalError data
+    , pages : BackendTask FatalError (List routeParams)
+    , head : App data action routeParams -> List Head.Tag
     }
     -> Builder routeParams data action
 preRender { data, head, pages } =
     WithData
-        { data = data >> DataSource.map Server.Response.render
-        , action = \_ -> DataSource.fail "Internal Error - actions should never be called for statically generated pages."
+        { data = \_ -> data >> BackendTask.map Server.Response.render
+        , action = \_ _ -> BackendTask.fail (FatalError.fromString "Internal Error - actions should never be called for statically generated pages.")
         , staticRoutes = pages
         , head = head
         , serverless = False
         , handleRoute =
             \moduleContext toRecord routeParams ->
                 pages
-                    |> DataSource.map
+                    |> BackendTask.map
                         (\allRoutes ->
                             if allRoutes |> List.member routeParams then
                                 Nothing
@@ -348,73 +340,87 @@ preRender { data, head, pages } =
 
 {-| -}
 preRenderWithFallback :
-    { data : routeParams -> DataSource (Server.Response.Response data ErrorPage)
-    , pages : DataSource (List routeParams)
-    , head : StaticPayload data action routeParams -> List Head.Tag
+    { data : routeParams -> BackendTask FatalError (Server.Response.Response data ErrorPage)
+    , pages : BackendTask FatalError (List routeParams)
+    , head : App data action routeParams -> List Head.Tag
     }
     -> Builder routeParams data action
 preRenderWithFallback { data, head, pages } =
     WithData
-        { data = data
-        , action = \_ -> DataSource.fail "Internal Error - actions should never be called for statically generated pages."
+        { data = \_ -> data
+        , action = \_ _ -> BackendTask.fail (FatalError.fromString "Internal Error - actions should never be called for statically generated pages.")
         , staticRoutes = pages
         , head = head
         , serverless = False
         , handleRoute =
             \moduleContext toRecord routeParams ->
-                DataSource.succeed Nothing
+                BackendTask.succeed Nothing
         , kind = "prerender-with-fallback"
         }
 
 
 {-| -}
 serverRender :
-    { data : routeParams -> Server.Request.Parser (DataSource (Server.Response.Response data ErrorPage))
-    , action : routeParams -> Server.Request.Parser (DataSource (Server.Response.Response action ErrorPage))
-    , head : StaticPayload data action routeParams -> List Head.Tag
+    { data : routeParams -> Server.Request.Parser (BackendTask FatalError (Server.Response.Response data ErrorPage))
+    , action : routeParams -> Server.Request.Parser (BackendTask FatalError (Server.Response.Response action ErrorPage))
+    , head : App data action routeParams -> List Head.Tag
     }
     -> Builder routeParams data action
 serverRender { data, action, head } =
     WithData
         { data =
-            \routeParams ->
-                DataSource.Http.get
-                    "$$elm-pages$$headers"
-                    (routeParams
-                        |> data
-                        |> Server.Request.getDecoder
-                    )
-                    |> DataSource.andThen
+            \requestPayload routeParams ->
+                (routeParams
+                    |> data
+                    |> Server.Request.getDecoder
+                    |> (\decoder ->
+                            Json.Decode.decodeValue decoder requestPayload
+                                |> Result.mapError Json.Decode.errorToString
+                                |> BackendTask.fromResult
+                                -- TODO include title and better error context and formatting
+                                |> BackendTask.onError (\error -> BackendTask.fail (FatalError.fromString error))
+                       )
+                )
+                    |> BackendTask.andThen
                         (\rendered ->
                             case rendered of
                                 Ok okRendered ->
                                     okRendered
 
                                 Err error ->
-                                    Server.Request.errorsToString error |> DataSource.fail
+                                    Server.Request.errorsToString error
+                                        |> FatalError.fromString
+                                        |> BackendTask.fail
                         )
         , action =
-            \routeParams ->
-                DataSource.Http.get
-                    "$$elm-pages$$headers"
-                    (routeParams
-                        |> action
-                        |> Server.Request.getDecoder
-                    )
-                    |> DataSource.andThen
+            \requestPayload routeParams ->
+                (routeParams
+                    |> action
+                    |> Server.Request.getDecoder
+                    |> (\decoder ->
+                            Json.Decode.decodeValue decoder requestPayload
+                                |> Result.mapError Json.Decode.errorToString
+                                |> BackendTask.fromResult
+                                -- TODO include title and better error context and formatting
+                                |> BackendTask.onError (\error -> BackendTask.fail (FatalError.fromString error))
+                       )
+                )
+                    |> BackendTask.andThen
                         (\rendered ->
                             case rendered of
                                 Ok okRendered ->
                                     okRendered
 
                                 Err error ->
-                                    Server.Request.errorsToString error |> DataSource.fail
+                                    Server.Request.errorsToString error
+                                        |> FatalError.fromString
+                                        |> BackendTask.fail
                         )
-        , staticRoutes = DataSource.succeed []
+        , staticRoutes = BackendTask.succeed []
         , head = head
         , serverless = True
         , handleRoute =
             \moduleContext toRecord routeParams ->
-                DataSource.succeed Nothing
+                BackendTask.succeed Nothing
         , kind = "serverless"
         }

package/generator/src/SharedTemplate.elm

@@ -1,7 +1,8 @@
 module SharedTemplate exposing (SharedTemplate)
 
-import DataSource
+import BackendTask
 import Effect exposing (Effect)
+import FatalError exposing (FatalError)
 import Html exposing (Html)
 import Pages.Flags exposing (Flags)
 import Pages.PageUrl exposing (PageUrl)
@@ -35,7 +36,7 @@ type alias SharedTemplate msg sharedModel sharedData mappedMsg =
         -> (msg -> mappedMsg)
         -> View mappedMsg
         -> { body : List (Html mappedMsg), title : String }
-    , data : DataSource.DataSource sharedData
+    , data : BackendTask.BackendTask FatalError sharedData
     , subscriptions : Path -> sharedModel -> Sub msg
     , onPageChange :
         Maybe

package/generator/src/SiteConfig.elm

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

package/generator/src/basepath-middleware.js

@@ -1,6 +1,6 @@
 // this middleware is only active when (config.base !== '/')
 
-module.exports = function baseMiddleware(base) {
+export function baseMiddleware(base) {
   // Keep the named function. The name is visible in debug logs via `DEBUG=connect:dispatcher ...`
   return function viteBaseMiddleware(req, res, next) {
     // `req.url` only contains the path, since that is what gets passed in the HTTP request.
@@ -34,11 +34,11 @@ module.exports = function baseMiddleware(base) {
       const suggestionUrl = `${base}/${path.slice(1)}`;
       res.end(
         `The server is configured with a public base URL of ${base} - ` +
-        `did you mean to visit ${suggestionUrl} instead?`
+          `did you mean to visit ${suggestionUrl} instead?`
       );
       return;
     }
 
     next();
   };
-};
+}