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

package/src/Pages/Internal/Platform/StaticResponses.elm

@@ -1,221 +1,80 @@
-module Pages.Internal.Platform.StaticResponses exposing (FinishKind(..), NextStep(..), StaticResponses, batchUpdate, empty, nextStep, renderApiRequest, renderSingleRoute)
+module Pages.Internal.Platform.StaticResponses exposing (NextStep(..), empty, nextStep, renderApiRequest)
 
+import BackendTask exposing (BackendTask)
 import BuildError exposing (BuildError)
-import DataSource exposing (DataSource)
-import Dict exposing (Dict)
-import Dict.Extra
-import Pages.Internal.NotFoundReason exposing (NotFoundReason)
+import FatalError exposing (FatalError)
+import List.Extra
+import Pages.Internal.FatalError
 import Pages.StaticHttp.Request as HashRequest
 import Pages.StaticHttpRequest as StaticHttpRequest
 import RequestsAndPending exposing (RequestsAndPending)
-import Set exposing (Set)
+import TerminalText
 
 
-type StaticResponses
-    = ApiRequest StaticHttpResult
-    | StaticResponses StaticHttpResult
-    | CheckIfHandled (DataSource (Maybe NotFoundReason)) StaticHttpResult StaticHttpResult
-
-
-type StaticHttpResult
-    = NotFetched (DataSource ()) (Dict String (Result () String))
-
-
-empty : StaticResponses
-empty =
-    StaticResponses
-        (NotFetched (DataSource.succeed ()) Dict.empty)
-
-
-renderSingleRoute :
-    DataSource a
-    -> DataSource (Maybe NotFoundReason)
-    -> StaticResponses
-renderSingleRoute request cliData =
-    CheckIfHandled cliData
-        (NotFetched
-            (cliData
-                |> DataSource.map (\_ -> ())
-            )
-            Dict.empty
-        )
-        (NotFetched (DataSource.map (\_ -> ()) request) Dict.empty)
+empty : a -> BackendTask FatalError a
+empty a =
+    BackendTask.succeed a
 
 
 renderApiRequest :
-    DataSource response
-    -> StaticResponses
+    BackendTask FatalError response
+    -> BackendTask FatalError response
 renderApiRequest request =
-    ApiRequest
-        (NotFetched
-            (request |> DataSource.map (\_ -> ()))
-            Dict.empty
-        )
+    request
 
 
-batchUpdate :
-    List
-        { request : HashRequest.Request
-        , response : RequestsAndPending.Response
-        }
-    ->
-        { model
-            | staticResponses : StaticResponses
-            , allRawResponses : RequestsAndPending
-        }
-    ->
-        { model
-            | staticResponses : StaticResponses
-            , allRawResponses : RequestsAndPending
-        }
-batchUpdate newEntries model =
-    { model
-        | allRawResponses = insertAll newEntries model.allRawResponses
-    }
-
-
-insertAll :
-    List
-        { request : HashRequest.Request
-        , response : RequestsAndPending.Response
-        }
-    -> RequestsAndPending
-    -> RequestsAndPending
-insertAll newEntries dict =
-    case newEntries of
-        [] ->
-            dict
-
-        info :: rest ->
-            insertAll
-                rest
-                (Dict.update (HashRequest.hash info.request) (\_ -> Just (Just info.response)) dict)
-
-
-type NextStep route
-    = Continue RequestsAndPending (List HashRequest.Request) (Maybe (List route))
-    | Finish (FinishKind route)
-
-
-type FinishKind route
-    = ApiResponse
-    | Errors (List BuildError)
+type NextStep route value
+    = Continue (List HashRequest.Request) (StaticHttpRequest.RawRequest FatalError value)
+    | Finish value
+    | FinishedWithErrors (List BuildError)
 
 
 nextStep :
-    { model
-        | staticResponses : StaticResponses
-        , errors : List BuildError
-        , allRawResponses : RequestsAndPending
-    }
-    -> Maybe (List route)
-    -> ( StaticResponses, NextStep route )
-nextStep ({ allRawResponses, errors } as model) maybeRoutes =
+    RequestsAndPending
+    -> BackendTask FatalError a
+    ->
+        { model
+            | errors : List BuildError
+        }
+    -> NextStep route a
+nextStep allRawResponses staticResponses { errors } =
     let
-        staticRequestsStatus : StaticHttpRequest.Status ()
+        staticRequestsStatus : StaticHttpRequest.Status FatalError a
         staticRequestsStatus =
             allRawResponses
-                |> StaticHttpRequest.cacheRequestResolution request
-
-        request : DataSource ()
-        request =
-            case staticResponses of
-                NotFetched request_ _ ->
-                    request_
-
-        staticResponses : StaticHttpResult
-        staticResponses =
-            case model.staticResponses of
-                StaticResponses s ->
-                    s
-
-                ApiRequest staticHttpResult ->
-                    staticHttpResult
-
-                CheckIfHandled _ staticHttpResult _ ->
-                    staticHttpResult
-
-        pendingRequests : Bool
-        pendingRequests =
-            case staticResponses of
-                NotFetched _ rawResponses ->
-                    let
-                        hasPermanentError : Bool
-                        hasPermanentError =
-                            case staticRequestsStatus of
-                                StaticHttpRequest.HasPermanentError _ ->
-                                    True
-
-                                _ ->
-                                    False
-
-                        hasPermanentHttpError : Bool
-                        hasPermanentHttpError =
-                            not (List.isEmpty errors)
-
-                        ( allUrlsKnown, knownUrlsToFetch ) =
-                            case staticRequestsStatus of
-                                StaticHttpRequest.Incomplete newUrlsToFetch ->
-                                    ( False, newUrlsToFetch )
-
-                                _ ->
-                                    ( True, [] )
-
-                        fetchedAllKnownUrls : Bool
-                        fetchedAllKnownUrls =
-                            (rawResponses
-                                |> Dict.keys
-                                |> Set.fromList
-                                |> Set.union (allRawResponses |> Dict.keys |> Set.fromList)
-                            )
-                                |> Set.diff
-                                    (knownUrlsToFetch
-                                        |> List.map HashRequest.hash
-                                        |> Set.fromList
-                                    )
-                                |> Set.isEmpty
-                    in
-                    not (hasPermanentHttpError || hasPermanentError || (allUrlsKnown && fetchedAllKnownUrls))
+                |> StaticHttpRequest.cacheRequestResolution staticResponses
+
+        ( ( pendingRequests, completedValue ), urlsToPerform, progressedBackendTask ) =
+            case staticRequestsStatus of
+                StaticHttpRequest.Incomplete newUrlsToFetch nextReq ->
+                    ( ( True, Nothing ), newUrlsToFetch, nextReq )
+
+                StaticHttpRequest.Complete (Err error) ->
+                    ( ( False, Just (Err error) )
+                    , []
+                    , BackendTask.fail error
+                    )
+
+                StaticHttpRequest.Complete (Ok value) ->
+                    ( ( False, Just (Ok value) )
+                    , []
+                    , BackendTask.succeed value
+                    )
+
+                StaticHttpRequest.HasPermanentError _ ->
+                    ( ( False, Nothing )
+                    , []
+                    , BackendTask.fail (FatalError.fromString "TODO this shouldn't happen")
+                    )
     in
     if pendingRequests then
         let
-            urlsToPerform : List HashRequest.Request
-            urlsToPerform =
-                -- TODO is this redundant with cacheRequestResolution?
-                StaticHttpRequest.resolveUrls request allRawResponses
-
-            newAllRawResponses : RequestsAndPending
-            newAllRawResponses =
-                Dict.union allRawResponses dictOfNewUrlsToPerform
-
-            dictOfNewUrlsToPerform : RequestsAndPending
-            dictOfNewUrlsToPerform =
-                urlsToPerform
-                    |> List.map (\url -> ( HashRequest.hash url, Nothing ))
-                    |> Dict.fromList
-
-            maskedToUnmasked : Dict String HashRequest.Request
-            maskedToUnmasked =
-                urlsToPerform
-                    |> List.map
-                        (\secureUrl ->
-                            ( HashRequest.hash secureUrl, secureUrl )
-                        )
-                    |> Dict.fromList
-
-            alreadyPerformed : Set String
-            alreadyPerformed =
-                allRawResponses
-                    |> Dict.keys
-                    |> Set.fromList
-
             newThing : List HashRequest.Request
             newThing =
-                maskedToUnmasked
-                    |> Dict.Extra.removeMany alreadyPerformed
-                    |> Dict.values
+                urlsToPerform
+                    |> List.Extra.uniqueBy HashRequest.hash
         in
-        ( model.staticResponses, Continue newAllRawResponses newThing maybeRoutes )
+        Continue newThing progressedBackendTask
 
     else
         let
@@ -245,80 +104,24 @@ nextStep ({ allRawResponses, errors } as model) maybeRoutes =
                 in
                 errors ++ failedRequests
         in
-        case model.staticResponses of
-            StaticResponses _ ->
-                ( model.staticResponses
-                , if List.length allErrors > 0 then
-                    allErrors
-                        |> Errors
-                        |> Finish
-
-                  else
-                    Finish ApiResponse
-                )
-
-            ApiRequest _ ->
-                ( model.staticResponses
-                , if List.length allErrors > 0 then
-                    allErrors
-                        |> Errors
-                        |> Finish
-
-                  else
-                    ApiResponse
-                        |> Finish
-                )
-
-            CheckIfHandled pageFoundDataSource (NotFetched _ _) andThenRequest ->
-                let
-                    pageFoundResult : Result StaticHttpRequest.Error (Maybe NotFoundReason)
-                    pageFoundResult =
-                        StaticHttpRequest.resolve
-                            pageFoundDataSource
-                            allRawResponses
-                in
-                case pageFoundResult of
-                    Ok Nothing ->
-                        nextStep { model | staticResponses = StaticResponses andThenRequest } maybeRoutes
-
-                    Ok (Just _) ->
-                        ( empty
-                        , Finish ApiResponse
-                          -- TODO change data type here so you can avoid running `resolve` again from `Cli.elm` since it can be expensive
-                        )
-
-                    Err error_ ->
-                        let
-                            failedRequests : List BuildError
-                            failedRequests =
-                                let
-                                    maybePermanentError : Maybe StaticHttpRequest.Error
-                                    maybePermanentError =
-                                        case staticRequestsStatus of
-                                            StaticHttpRequest.HasPermanentError theError ->
-                                                Just theError
-
-                                            _ ->
-                                                Nothing
-
-                                    decoderErrors : List BuildError
-                                    decoderErrors =
-                                        maybePermanentError
-                                            |> Maybe.map (StaticHttpRequest.toBuildError "TODO PATH")
-                                            |> Maybe.map List.singleton
-                                            |> Maybe.withDefault []
-                                in
-                                decoderErrors
-                        in
-                        ( model.staticResponses
-                        , Finish
-                            (Errors <|
-                                (StaticHttpRequest.toBuildError
-                                    -- TODO give more fine-grained error reference
-                                    "get static routes"
-                                    error_
-                                    :: failedRequests
-                                    ++ errors
-                                )
-                            )
-                        )
+        if List.length allErrors > 0 then
+            FinishedWithErrors allErrors
+
+        else
+            case completedValue of
+                Just (Ok completed) ->
+                    Finish completed
+
+                Just (Err (Pages.Internal.FatalError.FatalError buildError)) ->
+                    FinishedWithErrors
+                        [ { title = buildError.title |> String.toUpper
+                          , path = "" -- TODO include path here
+                          , message = buildError.body |> TerminalText.fromAnsiString
+                          , fatal = True
+                          }
+                        ]
+
+                Nothing ->
+                    FinishedWithErrors
+                        [ BuildError.internal "TODO error message"
+                        ]

package/src/Pages/Internal/Platform/ToJsPayload.elm

@@ -89,7 +89,7 @@ headCodec canonicalSiteUrl currentPagePath =
 type ToJsSuccessPayloadNewCombined
     = PageProgress ToJsSuccessPayloadNew
     | SendApiResponse { body : Json.Encode.Value, staticHttpCache : Dict String String, statusCode : Int }
-    | DoHttp Pages.StaticHttp.Request.Request Bool
+    | DoHttp (List ( String, Pages.StaticHttp.Request.Request ))
     | Port String
     | Errors (List BuildError)
     | ApiResponse
@@ -109,8 +109,8 @@ successCodecNew2 canonicalSiteUrl currentPagePath =
                 PageProgress payload ->
                     success payload
 
-                DoHttp requestUrl _ ->
-                    vDoHttp requestUrl requestUrl.useCache
+                DoHttp hashRequestPairs ->
+                    vDoHttp hashRequestPairs
 
                 SendApiResponse record ->
                     vSendApiResponse record
@@ -121,10 +121,7 @@ successCodecNew2 canonicalSiteUrl currentPagePath =
         |> Codec.variant1 "Errors" Errors errorCodec
         |> Codec.variant0 "ApiResponse" ApiResponse
         |> Codec.variant1 "PageProgress" PageProgress (successCodecNew canonicalSiteUrl currentPagePath)
-        |> Codec.variant2 "DoHttp"
-            DoHttp
-            Pages.StaticHttp.Request.codec
-            Codec.bool
+        |> Codec.variant1 "DoHttp" DoHttp (Codec.list (Codec.tuple Codec.string Pages.StaticHttp.Request.codec))
         |> Codec.variant1 "ApiResponse"
             SendApiResponse
             (Codec.object (\body staticHttpCache statusCode -> { body = body, staticHttpCache = staticHttpCache, statusCode = statusCode })