npm - elm-pages - Versions diffs - 3.0.0-beta.10 → 3.0.0-beta.12 - Mend

elm-pages 3.0.0-beta.10 → 3.0.0-beta.12

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (78) hide show

package/README.md +1 -1
package/generator/dead-code-review/elm-stuff/tests-0.19.1/elm-stuff/0.19.1/Pages-Review-DeadCodeEliminateData.elmo +0 -0
package/generator/dead-code-review/elm-stuff/tests-0.19.1/elm-stuff/0.19.1/d.dat +0 -0
package/generator/dead-code-review/elm-stuff/tests-0.19.1/elm-stuff/0.19.1/i.dat +0 -0
package/generator/dead-code-review/elm-stuff/tests-0.19.1/elm-stuff/0.19.1/o.dat +0 -0
package/generator/dead-code-review/elm-stuff/tests-0.19.1/elm.json +1 -1
package/generator/dead-code-review/elm-stuff/tests-0.19.1/js/Reporter.elm.js +1326 -121
package/generator/dead-code-review/elm-stuff/tests-0.19.1/js/Runner.elm.js +15156 -13244
package/generator/dead-code-review/elm-stuff/tests-0.19.1/js/node_runner.js +1 -1
package/generator/dead-code-review/elm-stuff/tests-0.19.1/js/node_supervisor.js +1 -1
package/generator/dead-code-review/elm.json +6 -5
package/generator/dead-code-review/src/Pages/Review/DeadCodeEliminateData.elm +1 -0
package/generator/review/elm-stuff/tests-0.19.1/elm-stuff/0.19.1/d.dat +0 -0
package/generator/review/elm-stuff/tests-0.19.1/elm-stuff/0.19.1/i.dat +0 -0
package/generator/review/elm-stuff/tests-0.19.1/elm-stuff/0.19.1/o.dat +0 -0
package/generator/review/elm-stuff/tests-0.19.1/elm.json +1 -1
package/generator/review/elm-stuff/tests-0.19.1/js/Reporter.elm.js +1326 -121
package/generator/review/elm-stuff/tests-0.19.1/js/Runner.elm.js +14574 -12631
package/generator/review/elm-stuff/tests-0.19.1/js/node_runner.js +1 -1
package/generator/review/elm-stuff/tests-0.19.1/js/node_supervisor.js +1 -1
package/generator/review/elm.json +6 -6
package/generator/src/build.js +6 -9
package/generator/src/cli.js +120 -42
package/generator/src/codegen.js +11 -10
package/generator/src/compatibility-key.js +1 -1
package/generator/src/elm-codegen.js +3 -0
package/generator/src/render-worker.js +1 -1
package/generator/src/render.js +222 -37
package/generator/src/request-cache.js +1 -0
package/generator/src/rewrite-elm-json.js +3 -3
package/package.json +12 -12
package/src/ApiRoute.elm +147 -9
package/src/DataSource/Env.elm +27 -3
package/src/DataSource.elm +11 -22
package/src/Form.elm +32 -32
package/src/Head.elm +112 -8
package/src/MultiDict.elm +49 -0
package/src/Pages/Generate.elm +4 -1
package/src/Pages/GeneratorProgramConfig.elm +15 -0
package/src/Pages/Internal/Platform/CompatibilityKey.elm +1 -1
package/src/Pages/Internal/Platform/GeneratorApplication.elm +455 -0
package/src/Pages/Manifest.elm +24 -0
package/src/Pages/Script.elm +100 -0
package/src/PairingHeap.elm +137 -0
package/src/Parser/Extra/String.elm +33 -0
package/src/Parser/Extra.elm +69 -0
package/src/ProgramTest/ComplexQuery.elm +360 -0
package/src/ProgramTest/EffectSimulation.elm +122 -0
package/src/ProgramTest/Failure.elm +367 -0
package/src/ProgramTest/HtmlHighlighter.elm +116 -0
package/src/ProgramTest/HtmlParserHacks.elm +58 -0
package/src/ProgramTest/HtmlRenderer.elm +73 -0
package/src/ProgramTest/Program.elm +30 -0
package/src/ProgramTest/StringLines.elm +26 -0
package/src/ProgramTest/TestHtmlHacks.elm +132 -0
package/src/ProgramTest/TestHtmlParser.elm +201 -0
package/src/ProgramTest.elm +2339 -0
package/src/Query/Extra.elm +55 -0
package/src/Result/Extra.elm +21 -0
package/src/Server/Request.elm +2 -2
package/src/SimulatedEffect/Cmd.elm +69 -0
package/src/SimulatedEffect/Http.elm +330 -0
package/src/SimulatedEffect/Navigation.elm +69 -0
package/src/SimulatedEffect/Ports.elm +62 -0
package/src/SimulatedEffect/Process.elm +24 -0
package/src/SimulatedEffect/Sub.elm +48 -0
package/src/SimulatedEffect/Task.elm +252 -0
package/src/SimulatedEffect/Time.elm +25 -0
package/src/SimulatedEffect.elm +42 -0
package/src/String/Extra.elm +6 -0
package/src/Test/Http.elm +145 -0
package/src/TestResult.elm +35 -0
package/src/TestState.elm +305 -0
package/src/Url/Extra.elm +100 -0
package/src/Vendored/Diff.elm +321 -0
package/src/Vendored/Failure.elm +217 -0
package/src/Vendored/FormatMonochrome.elm +44 -0
package/src/Vendored/Highlightable.elm +53 -0

package/src/Head.elm CHANGED Viewed

@@ -9,14 +9,118 @@ module Head exposing
     , toJson, canonicalLink
     )
-{-| This module contains low-level functions for building up
-values that will be rendered into the page's `<head>` tag
-when you run `elm-pages build`. Most likely the `Head.Seo` module
-will do everything you need out of the box, and you will just need to import `Head`
-so you can use the `Tag` type in your type annotations.
-But this module might be useful if you have a special use case, or if you are
-writing a plugin package to extend `elm-pages`.
+{-| This module contains functions for building up
+tags with metadata that will be rendered into the page's `<head>` tag
+when your page is pre-rendered (or server-rendered, in the case of your server-rendered Route Modules). See also [`Head.Seo`](Head-Seo),
+which has some helper functions for defining OpenGraph and Twitter tags.
+One of the unique benefits of using `elm-pages` is that all of your routes (both pre-rendered and server-rendered) fully
+render the HTML of your page. That includes the full initial `view` (with the DataSource resolved, and the `Model` from `init`).
+The HTML response also includes all of the `Head` tags, which are defined in two places:
+1.  `app/Site.elm` - there is a `head` definition in `Site.elm` where you define global head tags that will be included on every rendered page.
+2.  In each Route Module - there is a `head` function where you have access to both the resolved `DataSource` and the `RouteParams` for the page and can return head tags based on that.
+Here is a common set of global head tags that we can define in `Site.elm`:
+    module Site exposing (canonicalUrl, config)
+    import DataSource exposing (DataSource)
+    import Head
+    import MimeType
+    import SiteConfig exposing (SiteConfig)
+    config : SiteConfig
+    config =
+    { canonicalUrl = "<https://elm-pages.com">
+    , head = head
+    }
+    head : DataSource (List Head.Tag)
+    head =
+    [ Head.metaName "viewport" (Head.raw "width=device-width,initial-scale=1")
+    , Head.metaName "mobile-web-app-capable" (Head.raw "yes")
+    , Head.metaName "theme-color" (Head.raw "#ffffff")
+    , Head.metaName "apple-mobile-web-app-capable" (Head.raw "yes")
+    , Head.metaName "apple-mobile-web-app-status-bar-style" (Head.raw "black-translucent")
+    , Head.icon [ ( 32, 32 ) ] MimeType.Png (cloudinaryIcon MimeType.Png 32)
+    , Head.icon [ ( 16, 16 ) ] MimeType.Png (cloudinaryIcon MimeType.Png 16)
+    , Head.appleTouchIcon (Just 180) (cloudinaryIcon MimeType.Png 180)
+    , Head.appleTouchIcon (Just 192) (cloudinaryIcon MimeType.Png 192)
+    ]
+    |> DataSource.succeed
+And here is a `head` function for a Route Module for a blog post. Note that we have access to our `DataSource` Data and
+are using it to populate article metadata like the article's image, publish date, etc.
+    import Article
+    import DataSource
+    import Date
+    import Head
+    import Head.Seo
+    import Path
+    import Route exposing (Route)
+    import RouteBuilder exposing (StatelessRoute, StaticPayload)
+    type alias RouteParams =
+        { slug : String }
+    type alias Data =
+        { metadata : ArticleMetadata
+        , body : List Markdown.Block.Block
+        }
+    route : StatelessRoute RouteParams Data ActionData
+    route =
+        RouteBuilder.preRender
+            { data = data
+            , head = head
+            , pages = pages
+            }
+            |> RouteBuilder.buildNoState { view = view }
+    head :
+        StaticPayload Data ActionData RouteParams
+        -> List Head.Tag
+    head static =
+        let
+            metadata =
+                static.data.metadata
+        in
+        Head.Seo.summaryLarge
+            { canonicalUrlOverride = Nothing
+            , siteName = "elm-pages"
+            , image =
+                { url = metadata.image
+                , alt = metadata.description
+                , dimensions = Nothing
+                , mimeType = Nothing
+                }
+            , description = metadata.description
+            , locale = Nothing
+            , title = metadata.title
+            }
+            |> Head.Seo.article
+                { tags = []
+                , section = Nothing
+                , publishedTime = Just (DateOrDateTime.Date metadata.published)
+                , modifiedTime = Nothing
+                , expirationTime = Nothing
+                }
+## Why is pre-rendered HTML important? Does it still matter for SEO?
+Many search engines are able to execute JavaScript now. However, not all are, and even with crawlers like Google, there
+is a longer lead time for your pages to be indexed when you have HTML with a blank page that is only visible after the JavaScript executes.
+But most importantly, many tools that unfurl links will not execute JavaScript at all, but rather simply do a simple pass to parse your `<head>` tags.
+It is not viable or reliable to add `<head>` tags for metadata on the client-side, it must be present in the initial HTML payload. Otherwise you may not
+get unfurling preview content when you share a link to your site on Slack, Twitter, etc.
+## Building up Head Tags
 @docs Tag, metaName, metaProperty, metaRedirect
 @docs rssLink, sitemapLink, rootLanguage, manifestLink

package/src/MultiDict.elm ADDED Viewed

@@ -0,0 +1,49 @@
+module MultiDict exposing (MultiDict, empty, get, insert, keys, remove, set)
+import Dict exposing (Dict)
+import List.Extra
+import List.Nonempty as NonEmpty
+type alias NonEmpty a =
+    NonEmpty.Nonempty a
+type MultiDict k v
+    = MultiDict (Dict k (NonEmpty v))
+empty : MultiDict k v
+empty =
+    MultiDict Dict.empty
+insert : comparable -> v -> MultiDict comparable v -> MultiDict comparable v
+insert key value (MultiDict dict) =
+    MultiDict
+        (Dict.update key (Maybe.map (NonEmpty.cons value) >> Maybe.withDefault (NonEmpty.fromElement value) >> Just) dict)
+get : comparable -> MultiDict comparable v -> List v
+get key (MultiDict dict) =
+    Dict.get key dict
+        |> Maybe.map NonEmpty.toList
+        |> Maybe.withDefault []
+keys : MultiDict k v -> List k
+keys (MultiDict dict) =
+    Dict.toList dict
+        |> List.concatMap (\( k, vs ) -> List.repeat (NonEmpty.length vs) k)
+remove : comparable -> v -> MultiDict comparable v -> MultiDict comparable v
+remove key value (MultiDict dict) =
+    MultiDict
+        (Dict.update key (Maybe.andThen (NonEmpty.toList >> List.Extra.remove value >> NonEmpty.fromList)) dict)
+set : comparable -> List v -> MultiDict comparable v -> MultiDict comparable v
+set key values (MultiDict dict) =
+    MultiDict
+        (Dict.update key (\_ -> NonEmpty.fromList values) dict)

package/src/Pages/Generate.elm CHANGED Viewed

@@ -5,7 +5,10 @@ module Pages.Generate exposing
     , preRender, single
     )
-{-|
+{-| 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.
+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

package/src/Pages/GeneratorProgramConfig.elm ADDED Viewed

@@ -0,0 +1,15 @@
+module Pages.GeneratorProgramConfig exposing (GeneratorProgramConfig)
+import Json.Decode as Decode
+import Json.Encode
+import Pages.Internal.Platform.ToJsPayload
+import Pages.Script exposing (Script)
+type alias GeneratorProgramConfig =
+    { data : Script
+    , toJsPort : Json.Encode.Value -> Cmd Never
+    , fromJsPort : Sub Decode.Value
+    , gotBatchSub : Sub Decode.Value
+    , sendPageData : Pages.Internal.Platform.ToJsPayload.NewThingForPort -> Cmd Never
+    }

package/src/Pages/Internal/Platform/CompatibilityKey.elm CHANGED Viewed

@@ -3,4 +3,4 @@ module Pages.Internal.Platform.CompatibilityKey exposing (currentCompatibilityKe
 currentCompatibilityKey : Int
 currentCompatibilityKey =
-    1
+    2

package/src/Pages/Internal/Platform/GeneratorApplication.elm ADDED Viewed

@@ -0,0 +1,455 @@
+module Pages.Internal.Platform.GeneratorApplication exposing (Flags, Model, Msg(..), init, requestDecoder, update, app)
+{-| Exposed for internal use only (used in generated code).
+@docs Flags, Model, Msg, init, requestDecoder, update, app
+-}
+import BuildError exposing (BuildError)
+import Cli.Program as Program exposing (FlagsIncludingArgv)
+import Codec
+import DataSource exposing (DataSource)
+import Dict
+import HtmlPrinter
+import Json.Decode as Decode
+import Json.Encode
+import Pages.GeneratorProgramConfig exposing (GeneratorProgramConfig)
+import Pages.Internal.Platform.CompatibilityKey
+import Pages.Internal.Platform.Effect as Effect exposing (Effect)
+import Pages.Internal.Platform.StaticResponses as StaticResponses exposing (StaticResponses)
+import Pages.Internal.Platform.ToJsPayload as ToJsPayload
+import Pages.Script exposing (Script(..))
+import Pages.StaticHttp.Request
+import Pages.StaticHttpRequest as StaticHttpRequest
+import RequestsAndPending exposing (RequestsAndPending)
+import TerminalText as Terminal
+{-| -}
+type alias Flags =
+    { compatibilityKey : Int
+    }
+{-| -}
+type alias Model =
+    { staticResponses : StaticResponses
+    , errors : List BuildError
+    , allRawResponses : RequestsAndPending
+    , done : Bool
+    }
+{-| -}
+type Msg
+    = GotDataBatch
+        (List
+            { request : Pages.StaticHttp.Request.Request
+            , response : RequestsAndPending.Response
+            }
+        )
+    | GotBuildError BuildError
+{-| -}
+app :
+    GeneratorProgramConfig
+    -> Program.StatefulProgram Model Msg (DataSource ()) Flags
+app config =
+    let
+        cliConfig : Program.Config (DataSource ())
+        cliConfig =
+            case config.data of
+                Generator theCliConfig ->
+                    theCliConfig HtmlPrinter.htmlToString
+    in
+    Program.stateful
+        { init =
+            \flags cliOptions ->
+                init cliOptions flags
+                    |> Tuple.mapSecond (perform config)
+        , update =
+            \cliOptions msg model ->
+                update cliOptions msg model
+                    |> Tuple.mapSecond (perform config)
+        , subscriptions =
+            \_ ->
+                Sub.batch
+                    [ config.fromJsPort
+                        |> Sub.map
+                            (\jsonValue ->
+                                let
+                                    decoder : Decode.Decoder Msg
+                                    decoder =
+                                        Decode.field "tag" Decode.string
+                                            |> Decode.andThen
+                                                (\tag ->
+                                                    case tag of
+                                                        "BuildError" ->
+                                                            Decode.field "data"
+                                                                (Decode.map2
+                                                                    (\message title ->
+                                                                        { title = title
+                                                                        , message = message
+                                                                        , fatal = True
+                                                                        , path = "" -- TODO wire in current path here
+                                                                        }
+                                                                    )
+                                                                    (Decode.field "message" Decode.string |> Decode.map Terminal.fromAnsiString)
+                                                                    (Decode.field "title" Decode.string)
+                                                                )
+                                                                |> Decode.map GotBuildError
+                                                        _ ->
+                                                            Decode.fail "Unhandled msg"
+                                                )
+                                in
+                                Decode.decodeValue decoder jsonValue
+                                    |> Result.mapError
+                                        (\error ->
+                                            ("From location 1: "
+                                                ++ (error
+                                                        |> Decode.errorToString
+                                                   )
+                                            )
+                                                |> BuildError.internal
+                                                |> GotBuildError
+                                        )
+                                    |> mergeResult
+                            )
+                    , config.gotBatchSub
+                        |> Sub.map
+                            (\newBatch ->
+                                Decode.decodeValue batchDecoder newBatch
+                                    |> Result.map GotDataBatch
+                                    |> Result.mapError
+                                        (\error ->
+                                            ("From location 2: "
+                                                ++ (error
+                                                        |> Decode.errorToString
+                                                   )
+                                            )
+                                                |> BuildError.internal
+                                                |> GotBuildError
+                                        )
+                                    |> mergeResult
+                            )
+                    ]
+        , config = cliConfig
+        , printAndExitFailure =
+            \string ->
+                ToJsPayload.Errors
+                    [ { title = "Invalid CLI arguments"
+                      , path = ""
+                      , message =
+                            [ Terminal.text string
+                            ]
+                      , fatal = True
+                      }
+                    ]
+                    |> Codec.encodeToValue (ToJsPayload.successCodecNew2 "" "")
+                    |> config.toJsPort
+                    |> Cmd.map never
+        , printAndExitSuccess = \string -> config.toJsPort (Json.Encode.string string) |> Cmd.map never
+        }
+batchDecoder : Decode.Decoder (List { request : Pages.StaticHttp.Request.Request, response : RequestsAndPending.Response })
+batchDecoder =
+    Decode.map2 (\request response -> { request = request, response = response })
+        (Decode.field "request" requestDecoder)
+        (Decode.field "response" RequestsAndPending.decoder)
+        |> Decode.list
+mergeResult : Result a a -> a
+mergeResult r =
+    case r of
+        Ok rr ->
+            rr
+        Err rr ->
+            rr
+{-| -}
+requestDecoder : Decode.Decoder Pages.StaticHttp.Request.Request
+requestDecoder =
+    Pages.StaticHttp.Request.codec
+        |> Codec.decoder
+flatten : GeneratorProgramConfig -> List Effect -> Cmd Msg
+flatten config list =
+    Cmd.batch (flattenHelp [] config list)
+flattenHelp : List (Cmd Msg) -> GeneratorProgramConfig -> List Effect -> List (Cmd Msg)
+flattenHelp soFar config list =
+    case list of
+        first :: rest ->
+            flattenHelp
+                (perform config first :: soFar)
+                config
+                rest
+        [] ->
+            soFar
+perform :
+    GeneratorProgramConfig
+    -> Effect
+    -> Cmd Msg
+perform config effect =
+    let
+        canonicalSiteUrl : String
+        canonicalSiteUrl =
+            ""
+    in
+    case effect of
+        Effect.NoEffect ->
+            Cmd.none
+        Effect.Batch list ->
+            flatten config list
+        Effect.FetchHttp unmasked ->
+            ToJsPayload.DoHttp unmasked unmasked.useCache
+                |> Codec.encoder (ToJsPayload.successCodecNew2 canonicalSiteUrl "")
+                |> config.toJsPort
+                |> Cmd.map never
+        Effect.SendSinglePage info ->
+            let
+                currentPagePath : String
+                currentPagePath =
+                    case info of
+                        ToJsPayload.PageProgress toJsSuccessPayloadNew ->
+                            toJsSuccessPayloadNew.route
+                        _ ->
+                            ""
+            in
+            info
+                |> Codec.encoder (ToJsPayload.successCodecNew2 canonicalSiteUrl currentPagePath)
+                |> config.toJsPort
+                |> Cmd.map never
+        Effect.SendSinglePageNew rawBytes info ->
+            let
+                currentPagePath : String
+                currentPagePath =
+                    case info of
+                        ToJsPayload.PageProgress toJsSuccessPayloadNew ->
+                            toJsSuccessPayloadNew.route
+                        _ ->
+                            ""
+            in
+            { oldThing =
+                info
+                    |> Codec.encoder (ToJsPayload.successCodecNew2 canonicalSiteUrl currentPagePath)
+            , binaryPageData = rawBytes
+            }
+                |> config.sendPageData
+                |> Cmd.map never
+        Effect.Continue ->
+            Cmd.none
+-- TODO use Json.Decode.Value for flagsDecoder instead of hardcoded record flags
+--flagsDecoder :
+--    Decode.Decoder
+--        { staticHttpCache : RequestsAndPending
+--        , compatibilityKey : Int
+--        }
+--flagsDecoder =
+--    Decode.map3
+--        (\staticHttpCache compatibilityKey ->
+--            { staticHttpCache = staticHttpCache
+--            , isDevServer = isDevServer
+--            , compatibilityKey = compatibilityKey
+--            }
+--        )
+--        (Decode.succeed Dict.empty)
+--        (Decode.field "compatibilityKey" Decode.int)
+{-| -}
+init :
+    DataSource ()
+    -> FlagsIncludingArgv Flags
+    -> ( Model, Effect )
+init execute flags =
+    if flags.compatibilityKey == Pages.Internal.Platform.CompatibilityKey.currentCompatibilityKey then
+        initLegacy execute { staticHttpCache = Dict.empty }
+    else
+        let
+            elmPackageAheadOfNpmPackage : Bool
+            elmPackageAheadOfNpmPackage =
+                Pages.Internal.Platform.CompatibilityKey.currentCompatibilityKey > flags.compatibilityKey
+            message : String
+            message =
+                "The NPM package and Elm package you have installed are incompatible. If you are updating versions, be sure to update both the elm-pages Elm and NPM package.\n\n"
+                    ++ (if elmPackageAheadOfNpmPackage then
+                            "The elm-pages Elm package is ahead of the elm-pages NPM package. Try updating the elm-pages NPM package?"
+                        else
+                            "The elm-pages NPM package is ahead of the elm-pages Elm package. Try updating the elm-pages Elm package?"
+                       )
+        in
+        updateAndSendPortIfDone execute
+            { staticResponses = StaticResponses.empty
+            , errors =
+                [ { title = "Incompatible NPM and Elm package versions"
+                  , message = [ Terminal.text <| message ]
+                  , fatal = True
+                  , path = ""
+                  }
+                ]
+            , allRawResponses = Dict.empty
+            , done = False
+            }
+initLegacy :
+    DataSource ()
+    -> { staticHttpCache : RequestsAndPending }
+    -> ( Model, Effect )
+initLegacy execute { staticHttpCache } =
+    let
+        staticResponses : StaticResponses
+        staticResponses =
+            StaticResponses.renderApiRequest execute
+        initialModel : Model
+        initialModel =
+            { staticResponses = staticResponses
+            , errors = []
+            , allRawResponses = staticHttpCache
+            , done = False
+            }
+    in
+    StaticResponses.nextStep initialModel Nothing
+        |> nextStepToEffect execute
+            initialModel
+updateAndSendPortIfDone :
+    DataSource ()
+    -> Model
+    -> ( Model, Effect )
+updateAndSendPortIfDone execute model =
+    StaticResponses.nextStep
+        model
+        Nothing
+        |> nextStepToEffect execute model
+{-| -}
+update :
+    DataSource ()
+    -> Msg
+    -> Model
+    -> ( Model, Effect )
+update execute msg model =
+    case msg of
+        GotDataBatch batch ->
+            let
+                updatedModel : Model
+                updatedModel =
+                    model
+                        |> StaticResponses.batchUpdate batch
+            in
+            StaticResponses.nextStep
+                updatedModel
+                Nothing
+                |> nextStepToEffect execute updatedModel
+        GotBuildError buildError ->
+            let
+                updatedModel : Model
+                updatedModel =
+                    { model
+                        | errors =
+                            buildError :: model.errors
+                    }
+            in
+            StaticResponses.nextStep
+                updatedModel
+                Nothing
+                |> nextStepToEffect execute updatedModel
+nextStepToEffect :
+    DataSource ()
+    -> Model
+    -> ( StaticResponses, StaticResponses.NextStep route )
+    -> ( Model, Effect )
+nextStepToEffect execute model ( updatedStaticResponsesModel, nextStep ) =
+    case nextStep of
+        StaticResponses.Continue updatedAllRawResponses httpRequests _ ->
+            let
+                updatedModel : Model
+                updatedModel =
+                    { model
+                        | allRawResponses = updatedAllRawResponses
+                        , staticResponses = updatedStaticResponsesModel
+                    }
+            in
+            if List.isEmpty httpRequests then
+                nextStepToEffect execute
+                    updatedModel
+                    (StaticResponses.nextStep
+                        updatedModel
+                        Nothing
+                    )
+            else
+                ( updatedModel
+                , (httpRequests
+                    |> List.map Effect.FetchHttp
+                  )
+                    |> Effect.Batch
+                )
+        StaticResponses.Finish toJsPayload ->
+            case toJsPayload of
+                StaticResponses.ApiResponse ->
+                    let
+                        apiResponse : Effect
+                        apiResponse =
+                            StaticHttpRequest.resolve
+                                execute
+                                model.allRawResponses
+                                |> Result.mapError (StaticHttpRequest.toBuildError "TODO - path from request")
+                                |> (\response ->
+                                        case response of
+                                            Ok () ->
+                                                { body = Json.Encode.null
+                                                , staticHttpCache = Dict.empty
+                                                , statusCode = 200
+                                                }
+                                                    |> ToJsPayload.SendApiResponse
+                                                    |> Effect.SendSinglePage
+                                            Err error ->
+                                                [ error ]
+                                                    |> ToJsPayload.Errors
+                                                    |> Effect.SendSinglePage
+                                   )
+                    in
+                    ( model
+                    , apiResponse
+                    )
+                StaticResponses.Errors errors ->
+                    ( model
+                    , errors |> ToJsPayload.Errors |> Effect.SendSinglePage
+                    )