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

package/src/Server/SetCookie.elm

@@ -1,8 +1,8 @@
 module Server.SetCookie exposing
-    ( SetCookie
-    , SameSite(..)
-    , Options, initOptions
-    , withImmediateExpiration, makeVisibleToJavaScript, nonSecure, setCookie, withDomain, withExpiration, withMaxAge, withPath, withSameSite
+    ( SetCookie, setCookie
+    , Options, options
+    , SameSite(..), withSameSite
+    , withImmediateExpiration, makeVisibleToJavaScript, nonSecure, withDomain, withExpiration, withMaxAge, withPath, withoutPath
     , toString
     )
 
@@ -20,16 +20,29 @@ You can learn more about the basics of cookies in the Web Platform in these help
   - <https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie>
   - <https://developer.mozilla.org/en-US/docs/Web/HTTP/Cookies>
 
-@docs SetCookie
+@docs SetCookie, setCookie
 
-@docs SameSite
 
+## Building Options
 
-## Options
+Usually you'll want to start by creating default `Options` with `options` and then overriding defaults using the `with...` helpers.
 
-@docs Options, initOptions
+    import Server.SetCookie as SetCookie
 
-@docs withImmediateExpiration, makeVisibleToJavaScript, nonSecure, setCookie, withDomain, withExpiration, withMaxAge, withPath, withSameSite
+    options : SetCookie.Options
+    options =
+        SetCookie.options
+            |> SetCookie.nonSecure
+            |> SetCookie.withMaxAge 123
+            |> SetCookie.makeVisibleToJavaScript
+            |> SetCookie.withoutPath
+            |> SetCookie.setCookie "id" "a3fWa"
+
+@docs Options, options
+
+@docs SameSite, withSameSite
+
+@docs withImmediateExpiration, makeVisibleToJavaScript, nonSecure, withDomain, withExpiration, withMaxAge, withPath, withoutPath
 
 
 ## Internal
@@ -51,7 +64,8 @@ type alias SetCookie =
     }
 
 
-{-| -}
+{-| The set of possible configuration options. You can configure this record directly, or use the `with...` helpers.
+-}
 type alias Options =
     { expiration : Maybe Time.Posix
     , visibleToJavaScript : Bool
@@ -63,7 +77,15 @@ type alias Options =
     }
 
 
-{-| -}
+{-| Possible values for [the cookie's same-site value](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie#samesitesamesite-value).
+
+The default option is [`Lax`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie#lax) (Lax does not send
+cookies in cross-origin requests so it is a good default for most cases, but [`Strict`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie#strict)
+is even more restrictive).
+
+Override the default option using [`withSameSite`](#withSameSite).
+
+-}
 type SameSite
     = Strict
     | Lax
@@ -95,24 +117,24 @@ toString builder =
             else
                 ""
 
-        options : Options
-        options =
+        options_ : Options
+        options_ =
             builder.options
 
         httpOnly : Bool
         httpOnly =
-            not options.visibleToJavaScript
+            not options_.visibleToJavaScript
     in
     builder.name
         ++ "="
         ++ Url.percentEncode builder.value
-        ++ option "Expires" (options.expiration |> Maybe.map Utc.fromTime)
-        ++ option "Max-Age" (options.maxAge |> Maybe.map String.fromInt)
-        ++ option "Path" options.path
-        ++ option "Domain" options.domain
-        ++ option "SameSite" (options.sameSite |> Maybe.map sameSiteToString)
+        ++ option "Expires" (options_.expiration |> Maybe.map Utc.fromTime)
+        ++ option "Max-Age" (options_.maxAge |> Maybe.map String.fromInt)
+        ++ option "Path" options_.path
+        ++ option "Domain" options_.domain
+        ++ option "SameSite" (options_.sameSite |> Maybe.map sameSiteToString)
         ++ boolOption "HttpOnly" httpOnly
-        ++ boolOption "Secure" options.secure
+        ++ boolOption "Secure" options_.secure
 
 
 sameSiteToString : SameSite -> String
@@ -128,22 +150,26 @@ sameSiteToString sameSite =
             "None"
 
 
-{-| -}
+{-| Create a `SetCookie` record with the given name, value, and [`Options`](Options]. To add a `Set-Cookie` header, you can
+pass this value with [`Server.Response.withSetCookieHeader`](Server-Response#withSetCookieHeader). Or for more low-level
+uses you can stringify the value manually with [`toString`](#toString).
+-}
 setCookie : String -> String -> Options -> SetCookie
-setCookie name value options =
+setCookie name value options_ =
     { name = name
     , value = value
-    , options = options
+    , options = options_
     }
 
 
-{-| -}
-initOptions : Options
-initOptions =
+{-| Initialize the default `SetCookie` `Options`. Can be configured directly through a record update, or with `withExpiration`, etc.
+-}
+options : Options
+options =
     { expiration = Nothing
     , visibleToJavaScript = False
     , maxAge = Nothing
-    , path = Nothing
+    , path = Just "/"
     , domain = Nothing
     , secure = True
     , sameSite = Nothing
@@ -158,7 +184,9 @@ withExpiration time builder =
     }
 
 
-{-| -}
+{-| Sets [`Expires`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie#expiresdate) to `Time.millisToPosix 0`,
+which effectively tells the browser to delete the cookie immediately (by giving it an expiration date in the past).
+-}
 withImmediateExpiration : Options -> Options
 withImmediateExpiration builder =
     { builder
@@ -174,7 +202,7 @@ dynamically). In this API you opt into exposing a cookie you set to JavaScript t
 
 In general if you can accomplish your goal using HttpOnly cookies (i.e. not using `makeVisibleToJavaScript`) then
 it's a good practice. With server-rendered `elm-pages` applications you can often manage your session state by pulling
-in session data from cookies in a `DataSource` (which is resolved server-side before it ever reaches the browser).
+in session data from cookies in a `BackendTask` (which is resolved server-side before it ever reaches the browser).
 
 -}
 makeVisibleToJavaScript : Options -> Options
@@ -184,7 +212,8 @@ makeVisibleToJavaScript builder =
     }
 
 
-{-| -}
+{-| Sets the `Set-Cookie`'s [`Max-Age`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie#max-agenumber).
+-}
 withMaxAge : Int -> Options -> Options
 withMaxAge maxAge builder =
     { builder
@@ -192,7 +221,11 @@ withMaxAge maxAge builder =
     }
 
 
-{-| -}
+{-| Sets the `Set-Cookie`'s [`Path`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie#pathpath-value).
+
+The default value is `/`, which will match any sub-directories or the root directory. See also [\`withoutPath](#withoutPath)
+
+-}
 withPath : String -> Options -> Options
 withPath path builder =
     { builder
@@ -200,7 +233,22 @@ withPath path builder =
     }
 
 
-{-| -}
+{-|
+
+> If the server omits the Path attribute, the user agent will use the "directory" of the request-uri's path component as the default value.
+
+Source: <https://www.rfc-editor.org/rfc/rfc6265>. See <https://stackoverflow.com/a/43336097>.
+
+-}
+withoutPath : Options -> Options
+withoutPath builder =
+    { builder
+        | path = Nothing
+    }
+
+
+{-| Sets the `Set-Cookie`'s [`Domain`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie#domaindomain-value).
+-}
 withDomain : String -> Options -> Options
 withDomain domain builder =
     { builder

package/src/Stub.elm

@@ -0,0 +1,53 @@
+module Stub exposing (Id, Model, Task(..), map2, nextId)
+
+import Json.Decode as Decode
+import Set exposing (Set)
+
+
+type alias Id =
+    Int
+
+
+type alias Model =
+    { nextId : Id
+    , sentIds : Set Id
+    }
+
+
+
+--task : Task error value
+--task =
+--    Pending
+--        (\id -> id)
+--        (\value model -> ( model, Done (Ok value) ))
+
+
+type Task error value
+    = Pending (Id -> Id) (Decode.Value -> Model -> ( Model, Task error value ))
+
+
+map2 : (value1 -> value2 -> combined) -> Task error value1 -> Task error value2 -> Task error combined
+map2 mapFn task1 task2 =
+    case ( task1, task2 ) of
+        ( Pending toId1 _, Pending toId2 _ ) ->
+            Pending
+                (\id ->
+                    max (toId1 id) (toId2 id)
+                        |> nextId
+                )
+                (\_ _ ->
+                    Debug.todo ""
+                )
+
+        _ ->
+            Debug.todo ""
+
+
+nextId : Int -> Int
+nextId id =
+    id + 1
+
+
+
+--(Task toId1 resolve1)
+--(Task toId2 resolve2)

package/src/Test/Html/Internal/ElmHtml/ToString.elm

@@ -130,17 +130,16 @@ nodeRecordToString options { tag, children, facts } =
                 |> String.join " "
                 |> Just
 
-        boolToString b =
-            case b of
-                True ->
-                    "True"
-
-                False ->
-                    "False"
-
         boolAttributes =
             Dict.toList facts.boolAttributes
-                |> List.map (\( k, v ) -> k ++ "=" ++ (String.toLower <| boolToString v))
+                |> List.filterMap
+                    (\( k, v ) ->
+                        if v then
+                            Just k
+
+                        else
+                            Nothing
+                    )
                 |> String.join " "
                 |> Just
     in

package/src/{Path.elm → UrlPath.elm}

@@ -1,5 +1,5 @@
-module Path exposing
-    ( Path, join, fromString
+module UrlPath exposing
+    ( UrlPath, join, fromString
     , toAbsolute, toRelative, toSegments
     )
 
@@ -9,27 +9,27 @@ This helper lets you combine together path parts without worrying about having t
 These two examples will result in the same URL, even though the first example has trailing and leading slashes, and the
 second does not.
 
-    Path.join [ "/blog/", "/post-1/" ]
-        |> Path.toAbsolute
+    UrlPath.join [ "/blog/", "/post-1/" ]
+        |> UrlPath.toAbsolute
     --> "/blog/post-1"
 
-    Path.join [ "blog", "post-1" ]
-        |> Path.toAbsolute
+    UrlPath.join [ "blog", "post-1" ]
+        |> UrlPath.toAbsolute
     --> "/blog/post-1"
 
 We can also safely join Strings that include multiple path parts, a single path part per string, or a mix of the two:
 
-    Path.join [ "/articles/archive/", "1977", "06", "10", "post-1" ]
-        |> Path.toAbsolute
+    UrlPath.join [ "/articles/archive/", "1977", "06", "10", "post-1" ]
+        |> UrlPath.toAbsolute
     --> "/articles/archive/1977/06/10/post-1"
 
 
-## Creating Paths
+## Creating UrlPaths
 
-@docs Path, join, fromString
+@docs UrlPath, join, fromString
 
 
-## Turning Paths to String
+## Turning UrlPaths to String
 
 @docs toAbsolute, toRelative, toSegments
 
@@ -40,54 +40,51 @@ import Pages.Internal.String exposing (chopEnd, chopStart)
 
 {-| The path portion of the URL, normalized to ensure that path segments are joined with `/`s in the right places (no doubled up or missing slashes).
 -}
-type Path
-    = Path String
+type alias UrlPath =
+    List String
 
 
-{-| Create a Path from multiple path parts. Each part can either be a single path segment, like `blog`, or a
-multi-part path part, like `blog/post-1`.
+{-| Turn a Path to a relative URL.
 -}
-join : List String -> Path
+join : UrlPath -> UrlPath
 join parts =
     parts
         |> List.filter (\segment -> segment /= "/")
         |> List.map normalize
+
+
+{-| Turn a UrlPath to a relative URL.
+-}
+toRelative : UrlPath -> String
+toRelative parts =
+    join parts
         |> String.join "/"
-        |> Path
 
 
-{-| Create a Path from a path String.
+{-| Create a UrlPath from a path String.
 
-    Path.fromString "blog/post-1/"
-        |> Path.toAbsolute
+    UrlPath.fromString "blog/post-1/"
+        |> UrlPath.toAbsolute
         |> Expect.equal "/blog/post-1"
 
 -}
-fromString : String -> Path
+fromString : String -> UrlPath
 fromString path =
     path
-        |> normalize
-        |> Path
+        |> toSegments
 
 
 {-| -}
-toSegments : Path -> List String
-toSegments (Path path) =
+toSegments : String -> List String
+toSegments path =
     path |> String.split "/" |> List.filter ((/=) "")
 
 
-{-| Turn a Path to an absolute URL (with no trailing slash).
+{-| Turn a UrlPath to an absolute URL (with no trailing slash).
 -}
-toAbsolute : Path -> String
-toAbsolute (Path path) =
-    "/" ++ path
-
-
-{-| Turn a Path to a relative URL.
--}
-toRelative : Path -> String
-toRelative (Path path) =
-    path
+toAbsolute : UrlPath -> String
+toAbsolute path =
+    "/" ++ toRelative path
 
 
 normalize : String -> String

package/src/DataSource/Env.elm

@@ -1,38 +0,0 @@
-module DataSource.Env exposing (get, expect)
-
-{-|
-
-@docs get, expect
-
--}
-
-import DataSource exposing (DataSource)
-import DataSource.Http
-import DataSource.Internal.Request
-import Json.Decode as Decode
-import Json.Encode as Encode
-
-
-{-| -}
-get : String -> DataSource (Maybe String)
-get envVariableName =
-    DataSource.Internal.Request.request
-        { name = "env"
-        , body = DataSource.Http.jsonBody (Encode.string envVariableName)
-        , expect =
-            DataSource.Http.expectJson
-                (Decode.nullable Decode.string)
-        }
-
-
-{-| -}
-expect : String -> DataSource String
-expect envVariableName =
-    envVariableName
-        |> get
-        |> DataSource.andThen
-            (\maybeValue ->
-                maybeValue
-                    |> Result.fromMaybe ("DataSource.Env.expect was expecting a variable `" ++ envVariableName ++ "` but couldn't find a variable with that name.")
-                    |> DataSource.fromResult
-            )