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

package/src/Pages/Script.elm

@@ -0,0 +1,109 @@
+module Pages.Script exposing
+    ( Script
+    , withCliOptions, withoutCliOptions
+    , writeFile
+    , log
+    , Error(..)
+    )
+
+{-|
+
+@docs Script
+
+@docs withCliOptions, withoutCliOptions
+
+
+## File System Utilities
+
+@docs writeFile
+
+
+## Utilities
+
+@docs log
+
+
+## Errors
+
+@docs Error
+
+-}
+
+import BackendTask exposing (BackendTask)
+import BackendTask.Http
+import BackendTask.Internal.Request
+import Cli.OptionsParser as OptionsParser
+import Cli.Program as Program
+import FatalError exposing (FatalError)
+import Json.Decode as Decode
+import Json.Encode as Encode
+import Pages.Internal.Script
+
+
+{-| -}
+type alias Script =
+    Pages.Internal.Script.Script
+
+
+{-| -}
+type Error
+    = --TODO make more descriptive
+      FileWriteError
+
+
+{-| -}
+writeFile : { path : String, body : String } -> BackendTask { fatal : FatalError, recoverable : Error } ()
+writeFile { path, body } =
+    BackendTask.Internal.Request.request
+        { name = "write-file"
+        , body =
+            BackendTask.Http.jsonBody
+                (Encode.object
+                    [ ( "path", Encode.string path )
+                    , ( "body", Encode.string body )
+                    ]
+                )
+        , expect =
+            -- TODO decode possible error details here
+            BackendTask.Http.expectJson (Decode.succeed ())
+        }
+
+
+{-| -}
+log : String -> BackendTask error ()
+log message =
+    BackendTask.Internal.Request.request
+        { name = "log"
+        , body =
+            BackendTask.Http.jsonBody
+                (Encode.object
+                    [ ( "message", Encode.string message )
+                    ]
+                )
+        , expect = BackendTask.Http.expectJson (Decode.succeed ())
+        }
+
+
+{-| -}
+withoutCliOptions : BackendTask FatalError () -> Script
+withoutCliOptions execute =
+    Pages.Internal.Script.Script
+        (\_ ->
+            Program.config
+                |> Program.add
+                    (OptionsParser.build ())
+                |> Program.mapConfig
+                    (\() ->
+                        execute
+                    )
+        )
+
+
+{-| -}
+withCliOptions : Program.Config cliOptions -> (cliOptions -> BackendTask FatalError ()) -> Script
+withCliOptions config execute =
+    Pages.Internal.Script.Script
+        (\_ ->
+            config
+                |> Program.mapConfig execute
+        )

package/src/Pages/SiteConfig.elm

@@ -1,10 +1,11 @@
 module Pages.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/src/Pages/StaticHttp/Request.elm

@@ -11,7 +11,7 @@ type alias Request =
     , method : String
     , headers : List ( String, String )
     , body : Body
-    , useCache : Bool
+    , cacheOptions : Maybe Encode.Value
     }
 
 
@@ -40,5 +40,5 @@ codec =
         |> Codec.field "method" .method Codec.string
         |> Codec.field "headers" .headers (Codec.list (Codec.tuple Codec.string Codec.string))
         |> Codec.field "body" .body StaticHttpBody.codec
-        |> Codec.field "useCache" .useCache Codec.bool
+        |> Codec.nullableField "cacheOptions" .cacheOptions Codec.value
         |> Codec.buildObject

package/src/Pages/StaticHttpRequest.elm

@@ -1,8 +1,8 @@
-module Pages.StaticHttpRequest exposing (Error(..), MockResolver, RawRequest(..), Status(..), cacheRequestResolution, mockResolve, resolve, resolveUrls, toBuildError)
+module Pages.StaticHttpRequest exposing (Error(..), MockResolver, RawRequest(..), Status(..), cacheRequestResolution, mockResolve, toBuildError)
 
 import BuildError exposing (BuildError)
 import Dict
-import List.Extra
+import Json.Encode
 import Pages.StaticHttp.Request
 import RequestsAndPending exposing (RequestsAndPending)
 import TerminalText as Terminal
@@ -13,30 +13,19 @@ type alias MockResolver =
     -> Maybe RequestsAndPending.Response
 
 
-type RawRequest value
-    = Request (List Pages.StaticHttp.Request.Request) (Maybe MockResolver -> RequestsAndPending -> RawRequest value)
-    | RequestError Error
-    | ApiRoute value
+type RawRequest error value
+    = Request (List Pages.StaticHttp.Request.Request) (Maybe MockResolver -> RequestsAndPending -> RawRequest error value)
+    | ApiRoute (Result error value)
 
 
 type Error
-    = MissingHttpResponse String (List Pages.StaticHttp.Request.Request)
-    | DecoderError String
+    = DecoderError String
     | UserCalledStaticHttpFail String
 
 
 toBuildError : String -> Error -> BuildError
 toBuildError path error =
     case error of
-        MissingHttpResponse missingKey _ ->
-            { title = "Missing Http Response"
-            , message =
-                [ Terminal.text missingKey
-                ]
-            , path = path
-            , fatal = True
-            }
-
         DecoderError decodeErrorMessage ->
             { title = "Static Http Decoding Error"
             , message =
@@ -49,107 +38,43 @@ toBuildError path error =
         UserCalledStaticHttpFail decodeErrorMessage ->
             { title = "Called Static Http Fail"
             , message =
-                [ Terminal.text <| "I ran into a call to `DataSource.fail` with message: " ++ decodeErrorMessage
+                [ Terminal.text <| "I ran into a call to `BackendTask.fail` with message: " ++ decodeErrorMessage
                 ]
             , path = path
             , fatal = True
             }
 
 
-resolve : RawRequest value -> RequestsAndPending -> Result Error value
-resolve request rawResponses =
-    case request of
-        RequestError error ->
-            Err error
-
-        Request _ lookupFn ->
-            case lookupFn Nothing rawResponses of
-                nextRequest ->
-                    resolve nextRequest rawResponses
-
-        ApiRoute value ->
-            Ok value
-
-
-mockResolve : RawRequest value -> MockResolver -> Result Error value
+mockResolve : RawRequest error value -> MockResolver -> Result error value
 mockResolve request mockResolver =
     case request of
-        RequestError error ->
-            Err error
-
         Request _ lookupFn ->
-            case lookupFn (Just mockResolver) Dict.empty of
+            case lookupFn (Just mockResolver) (Json.Encode.object []) of
                 nextRequest ->
                     mockResolve nextRequest mockResolver
 
         ApiRoute value ->
-            Ok value
-
-
-resolveUrls : RawRequest value -> RequestsAndPending -> List Pages.StaticHttp.Request.Request
-resolveUrls request rawResponses =
-    resolveUrlsHelp rawResponses [] request
-
-
-resolveUrlsHelp : RequestsAndPending -> List Pages.StaticHttp.Request.Request -> RawRequest value -> List Pages.StaticHttp.Request.Request
-resolveUrlsHelp rawResponses soFar request =
-    case request of
-        RequestError error ->
-            case error of
-                MissingHttpResponse _ next ->
-                    (soFar ++ next)
-                        |> List.Extra.uniqueBy Pages.StaticHttp.Request.hash
-
-                _ ->
-                    soFar
-
-        Request urlList lookupFn ->
-            resolveUrlsHelp
-                rawResponses
-                (soFar ++ urlList)
-                (lookupFn Nothing rawResponses)
-
-        ApiRoute _ ->
-            soFar
+            value
 
 
 cacheRequestResolution :
-    RawRequest value
+    RawRequest error value
     -> RequestsAndPending
-    -> Status value
+    -> Status error value
 cacheRequestResolution request rawResponses =
-    cacheRequestResolutionHelp [] rawResponses request
-
-
-type Status value
-    = Incomplete (List Pages.StaticHttp.Request.Request)
-    | HasPermanentError Error
-    | Complete
-
-
-cacheRequestResolutionHelp :
-    List Pages.StaticHttp.Request.Request
-    -> RequestsAndPending
-    -> RawRequest value
-    -> Status value
-cacheRequestResolutionHelp foundUrls rawResponses request =
     case request of
-        RequestError error ->
-            case error of
-                MissingHttpResponse _ _ ->
-                    -- TODO do I need to pass through continuation URLs here? -- Incomplete (urlList ++ foundUrls)
-                    Incomplete foundUrls
+        Request urlList lookupFn ->
+            if List.isEmpty urlList then
+                cacheRequestResolution (lookupFn Nothing rawResponses) rawResponses
 
-                DecoderError _ ->
-                    HasPermanentError error
+            else
+                Incomplete urlList (Request [] lookupFn)
 
-                UserCalledStaticHttpFail _ ->
-                    HasPermanentError error
+        ApiRoute value ->
+            Complete value
 
-        Request urlList lookupFn ->
-            cacheRequestResolutionHelp urlList
-                rawResponses
-                (lookupFn Nothing rawResponses)
 
-        ApiRoute _ ->
-            Complete
+type Status error value
+    = Incomplete (List Pages.StaticHttp.Request.Request) (RawRequest error value)
+    | HasPermanentError Error
+    | Complete (Result error value)

package/src/RequestsAndPending.elm

@@ -1,16 +1,14 @@
-module RequestsAndPending exposing (RequestsAndPending, Response(..), ResponseBody(..), batchDecoder, bodyEncoder, decoder, get)
+module RequestsAndPending exposing (RawResponse, RequestsAndPending, Response(..), ResponseBody(..), bodyEncoder, get)
 
 import Base64
 import Bytes exposing (Bytes)
-import Codec
 import Dict exposing (Dict)
 import Json.Decode as Decode exposing (Decoder)
 import Json.Encode as Encode
-import Pages.StaticHttp.Request
 
 
 type alias RequestsAndPending =
-    Dict String (Maybe Response)
+    Decode.Value
 
 
 type ResponseBody
@@ -20,18 +18,6 @@ type ResponseBody
     | WhateverBody
 
 
-batchDecoder : Decoder (List { request : Pages.StaticHttp.Request.Request, response : Response })
-batchDecoder =
-    Decode.map2 (\request response -> { request = request, response = response })
-        (Decode.field "request"
-            (Pages.StaticHttp.Request.codec
-                |> Codec.decoder
-            )
-        )
-        (Decode.field "response" decoder)
-        |> Decode.list
-
-
 decoder : Decoder Response
 decoder =
     Decode.map2 Response
@@ -117,6 +103,9 @@ responseDecoder =
 
 get : String -> RequestsAndPending -> Maybe Response
 get key requestsAndPending =
-    requestsAndPending
-        |> Dict.get key
-        |> Maybe.andThen identity
+    Decode.decodeValue
+        (Decode.field key
+            (Decode.field "response" decoder)
+        )
+        requestsAndPending
+        |> Result.toMaybe

package/src/Result/Extra.elm

@@ -0,0 +1,26 @@
+module Result.Extra exposing (combine, isOk, merge)
+
+
+isOk : Result x a -> Bool
+isOk result =
+    case result of
+        Ok _ ->
+            True
+
+        Err _ ->
+            False
+
+
+merge : Result a a -> a
+merge r =
+    case r of
+        Ok rr ->
+            rr
+
+        Err rr ->
+            rr
+
+
+combine : List (Result x a) -> Result x (List a)
+combine =
+    List.foldr (Result.map2 (::)) (Ok [])