elm-pages 3.0.12 → 3.0.14

package/src/BackendTask.elm

@@ -6,6 +6,8 @@ module BackendTask exposing
     , andMap
     , map2, map3, map4, map5, map6, map7, map8, map9
     , allowFatal, mapError, onError, toResult
+    , do, doEach, sequence, failIf
+    , inDir, quiet, withEnv
     )
 
 {-| In an `elm-pages` app, each Route Module can define a value `data` which is a `BackendTask` that will be resolved **before** `init` is called. That means it is also available
@@ -84,8 +86,29 @@ Any place in your `elm-pages` app where the framework lets you pass in a value o
 
 @docs allowFatal, mapError, onError, toResult
 
+
+## Scripting
+
+@docs do, doEach, sequence, failIf
+
+
+## BackendTask Context
+
+You can set the following context for a `BackendTask`:
+
+  - `inDir` - Set the working directory
+  - `quiet` - Silence the output
+  - `withEnv` - Set an environment variable
+
+It's important to understand that a `BackendTask` does not run until it is passed to the `elm-pages` runtime (it is _not_ run as soon as it is defined,
+like you may be familiar with in other languages like JavaScript). So you can use these functions to set the context
+of a `BackendTask` at any point before you pass it to and it will be applied when the `BackendTask` is run.
+
+@docs inDir, quiet, withEnv
+
 -}
 
+import Dict
 import FatalError exposing (FatalError)
 import Json.Encode
 import List.Chunks
@@ -102,16 +125,19 @@ type alias BackendTask error value =
 {-| Transform a request into an arbitrary value. The same underlying task will be performed,
 but mapping allows you to change the resulting values by applying functions to the results.
 
-    import BackendTask
+    import BackendTask exposing (BackendTask)
     import BackendTask.Http
-    import Json.Decode as Decode exposing (Decoder)
+    import FatalError exposing (FatalError)
+    import Json.Decode as Decode
 
+    starsMessage : BackendTask FatalError String
     starsMessage =
         BackendTask.Http.getJson
             "https://api.github.com/repos/dillonkearns/elm-pages"
             (Decode.field "stargazers_count" Decode.int)
             |> BackendTask.map
                 (\stars -> "⭐️ " ++ String.fromInt stars)
+            |> BackendTask.allowFatal
 
 -}
 map : (a -> b) -> BackendTask error a -> BackendTask error b
@@ -126,6 +152,125 @@ map fn requestInfo =
                 (mapLookupFn fn lookupFn)
 
 
+{-| `inDir` sets the working directory for a `BackendTask`. The working directory of a `BackendTask` will be used to resolve relative paths
+and is relevant for the following types of `BackendTask`s:
+
+  - Reading files ([`BackendTask.File`](BackendTask-File))
+  - Running glob patterns ([`BackendTask.Glob`](BackendTask-Glob))
+  - Executing shell commands ([`BackendTask.Stream.command`](BackendTask-Stream#command)) and [`Pages.Script.sh`](Pages-Script#command)
+
+See the BackendTask Context section for more about how setting context works.
+
+For example, these two values will produce the same result:
+
+    import BackendTask.Glob as Glob
+
+    example1 : BackendTask error (List String)
+    example1 =
+        Glob.fromString "src/**/*.elm"
+
+    example2 : BackendTask error (List String)
+    example2 =
+        BackendTask.inDir "src" (Glob.fromString "**/*.elm")
+
+You can also nest the working directory by using `inDir` multiple times:
+
+    import BackendTask.Glob as Glob
+
+    example3 : BackendTask error (List String)
+    example3 =
+        BackendTask.map2
+            (\routeModules specialModules ->
+                { routeModules = routeModules
+                , specialModules = specialModules
+                }
+            )
+            (BackendTask.inDir "Route" (Glob.fromString "**/*.elm"))
+            (Glob.fromString "*.elm")
+            |> BackendTask.inDir "app"
+
+The above example will list out files from `app/Route/**/*.elm` and `app/*.elm` because `inDir "app"` is applied to the `BackendTask.map2` which combines together both of the Glob tasks.
+
+`inDir` supports absolute paths. In this example, we apply a relative path on top of an absolute path, so the relative path will be resolved relative to the absolute path.
+
+    import BackendTask.Glob as Glob
+
+    example3 : BackendTask error (List String)
+    example3 =
+        BackendTask.map2
+            (\routeModules specialModules ->
+                { routeModules = routeModules
+                , specialModules = specialModules
+                }
+            )
+            -- same as `Glob.fromString "/projects/my-elm-pages-blog/app/Route/**/*.elm"`
+            (BackendTask.inDir "Route" (Glob.fromString "**/*.elm"))
+            (Glob.fromString "*.elm")
+            |> BackendTask.inDir "/projects/my-elm-pages-blog/app"
+
+You can also use `BackendTask.inDir ".."` to go up a directory, or \`BackendTask.inDir "../.." to go up two directories, etc.
+
+Use of trailing slashes is optional and does not change the behavior of `inDir`. Leading slashes distinguish between
+absolute and relative paths, so `BackendTask.inDir "./src"` is exactly the same as `BackendTask.inDir "src"`, etc.
+
+Each level of nesting with `inDir` will resolve using [NodeJS's `path.resolve`](https://nodejs.org/api/path.html#pathresolvepaths).
+
+-}
+inDir : String -> BackendTask error value -> BackendTask error value
+inDir dir backendTask =
+    -- elm-review: known-unoptimized-recursion
+    -- TODO try to find a way to optimize tail-call recursion here
+    case backendTask of
+        ApiRoute _ ->
+            backendTask
+
+        Request urls lookupFn ->
+            Request
+                (urls
+                    |> List.map (\req -> { req | dir = dir :: req.dir })
+                )
+                (\a b -> lookupFn a b |> inDir dir)
+
+
+{-| Sets the verbosity level to `quiet` in the context of the given `BackendTask` (including all nested `BackendTask`s and continuations within it).
+
+This will turn off performance timing logs. It will also prevent shell commands from printing their output to the console when they are run
+(see [`BackendTask.Stream.command`](BackendTask-Stream#command)).
+
+-}
+quiet : BackendTask error value -> BackendTask error value
+quiet backendTask =
+    -- elm-review: known-unoptimized-recursion
+    -- TODO try to find a way to optimize tail-call recursion here
+    case backendTask of
+        ApiRoute _ ->
+            backendTask
+
+        Request urls lookupFn ->
+            Request
+                (urls
+                    |> List.map (\req -> { req | quiet = True })
+                )
+                (\a b -> lookupFn a b |> quiet)
+
+
+{-| -}
+withEnv : String -> String -> BackendTask error value -> BackendTask error value
+withEnv key value backendTask =
+    -- elm-review: known-unoptimized-recursion
+    -- TODO try to find a way to optimize tail-call recursion here
+    case backendTask of
+        ApiRoute _ ->
+            backendTask
+
+        Request urls lookupFn ->
+            Request
+                (urls
+                    |> List.map (\req -> { req | env = req.env |> Dict.insert key value })
+                )
+                (\a b -> lookupFn a b |> withEnv key value)
+
+
 mapLookupFn : (a -> b) -> (d -> c -> BackendTask error a) -> d -> c -> BackendTask error b
 mapLookupFn fn lookupFn maybeMock requests =
     map fn (lookupFn maybeMock requests)
@@ -140,9 +285,10 @@ resolve =
 
 {-| Turn a list of `BackendTask`s into a single one.
 
-    import BackendTask
+    import BackendTask exposing (BackendTask)
+    import BackendTask.Http
     import FatalError exposing (FatalError)
-    import Json.Decode as Decode exposing (Decoder)
+    import Json.Decode as Decode
 
     type alias Pokemon =
         { name : String
@@ -199,6 +345,54 @@ combineHelp items =
     List.foldl (map2 (::)) (succeed []) items |> map List.reverse
 
 
+{-| Perform a List of `BackendTask`s with no output, one-by-one sequentially.
+
+Same as [`sequence`](#sequence), except it ignores the resulting value of each `BackendTask`.
+
+-}
+doEach : List (BackendTask error ()) -> BackendTask error ()
+doEach items =
+    items
+        |> sequenceHelp
+        |> map (\_ -> ())
+
+
+{-| Ignore the resulting value of the BackendTask.
+-}
+do : BackendTask error value -> BackendTask error ()
+do backendTask =
+    backendTask
+        |> map (\_ -> ())
+
+
+{-| Perform a List of `BackendTask`s one-by-one sequentially. [`combine`](#combine) will perform them all in parallel, which is
+typically a better default when you aren't sure which you want.
+
+Same as [`doEach`](#doEach), except it ignores the resulting value of each `BackendTask`.
+
+-}
+sequence : List (BackendTask error value) -> BackendTask error (List value)
+sequence items =
+    items
+        |> sequenceHelp
+
+
+sequenceHelp : List (BackendTask error value) -> BackendTask error (List value)
+sequenceHelp items =
+    List.foldl
+        (\item accumulator ->
+            accumulator
+                |> andThen
+                    (\accValue ->
+                        item
+                            |> map (\itemValue -> itemValue :: accValue)
+                    )
+        )
+        (succeed [])
+        items
+        |> map List.reverse
+
+
 {-| Like map, but it takes in two `BackendTask`s.
 
     import BackendTask exposing (BackendTask)
@@ -262,9 +456,10 @@ map2 fn request1 request2 =
 {-| Build off of the response from a previous `BackendTask` request to build a follow-up request. You can use the data
 from the previous response to build up the URL, headers, etc. that you send to the subsequent request.
 
-    import BackendTask
+    import BackendTask exposing (BackendTask)
+    import BackendTask.Http
     import FatalError exposing (FatalError)
-    import Json.Decode as Decode exposing (Decoder)
+    import Json.Decode as Decode
 
     licenseData : BackendTask FatalError String
     licenseData =
@@ -339,7 +534,8 @@ andMap =
 
     import BackendTask exposing (BackendTask)
 
-    type alias RouteParams = { name : String }
+    type alias RouteParams =
+        { name : String }
 
     pages : BackendTask error (List RouteParams)
     pages =
@@ -542,3 +738,14 @@ toResult backendTask =
     backendTask
         |> andThen (Ok >> succeed)
         |> onError (Err >> succeed)
+
+
+{-| If the condition is true, fail with the given `FatalError`. Otherwise, succeed with `()`.
+-}
+failIf : Bool -> FatalError -> BackendTask FatalError ()
+failIf condition fatalError =
+    if condition then
+        fail fatalError
+
+    else
+        succeed ()

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

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

package/src/Pages/Internal/Platform.elm

@@ -502,8 +502,17 @@ update config appMsg model =
         ProcessFetchResponse transitionId response toMsg ->
             case response of
                 Ok ( _, ResponseSketch.Redirect redirectTo ) ->
-                    ( model, NoEffect )
-                        |> startNewGetLoad (currentUrlWithPath redirectTo model) toMsg
+                    let
+                        isAbsoluteUrl : Bool
+                        isAbsoluteUrl =
+                            Url.fromString redirectTo /= Nothing
+                    in
+                    if isAbsoluteUrl then
+                        ( model, BrowserLoadUrl redirectTo )
+
+                    else
+                        ( model, NoEffect )
+                            |> startNewGetLoad (currentUrlWithPath redirectTo model) toMsg
 
                 _ ->
                     update config (toMsg response) (clearLoadingFetchersAfterDataLoad transitionId model)