elm-pages 2.1.10 → 3.0.0-beta.0

package/generator/template/style.css

@@ -0,0 +1,4 @@
+body {
+  font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial,
+    sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}

package/package.json

@@ -1,15 +1,16 @@
 {
   "name": "elm-pages",
-  "version": "2.1.10",
+  "version": "3.0.0-beta.0",
   "homepage": "https://elm-pages.com",
   "moduleResolution": "node",
   "description": "Type-safe static sites, written in pure elm with your own custom elm-markup syntax.",
   "main": "index.js",
   "scripts": {
-    "start": "cd examples/end-to-end && npm start",
-    "test": "npx elmi-to-json --version && elm-verify-examples --run-tests && elm-test && (cd generator && mocha) && (cd examples/routing && npm i && npm run build -- --debug && elm-test) && npm run test:snapshot",
-    "test:snapshot": "(cd examples/escaping && npm install && npm test && cd ../..) && (cd examples/base-path && npm install && npm test && cd ../..)",
-    "cypress": "npm start & cypress run --spec cypress/integration/elm-pages-dev.spec.js",
+    "start": "cd examples/end-to-end && npm i && npx elm-pages dev",
+    "test": "./test.sh",
+    "test:snapshot": "(cd examples/escaping && npm install && npm test) && (cd examples/base-path && npm install && npm test)",
+    "cypress": "npm start & cypress run",
+    "prepare": "elm-codegen install",
     "review": "elm-review"
   },
   "repository": "https://github.com/dillonkearns/elm-pages",
@@ -23,40 +24,46 @@
   "author": "Dillon Kearns",
   "license": "BSD-3-Clause",
   "dependencies": {
-    "chokidar": "3.5.2",
-    "commander": "^8.1.0",
+    "busboy": "^1.0.0",
+    "chokidar": "^3.5.3",
+    "commander": "^9.4.0",
     "connect": "^3.7.0",
+    "cookie-signature": "^1.1.0",
     "cross-spawn": "7.0.3",
-    "devcert": "^1.2.0",
+    "devcert": "^1.2.2",
     "elm-doc-preview": "^5.0.5",
     "elm-hot": "^1.1.6",
-    "fs-extra": "^10.0.0",
+    "esbuild": "^0.15.5",
+    "fs-extra": "^10.1.0",
     "globby": "11.0.4",
     "gray-matter": "^4.0.3",
     "jsesc": "^3.0.2",
-    "kleur": "^4.1.4",
-    "micromatch": "^4.0.4",
+    "kleur": "^4.1.5",
+    "memfs": "^3.4.7",
+    "micromatch": "^4.0.5",
+    "node-fetch": "^2.6.7",
     "object-hash": "^2.2.0",
-    "serve-static": "^1.14.1",
-    "terser": "^5.7.2",
-    "undici": "^4.4.7",
+    "serve-static": "^1.15.0",
+    "terser": "^5.14.2",
+    "vite": "^3.0.9",
     "which": "^2.0.2"
   },
   "devDependencies": {
     "@types/cross-spawn": "^6.0.2",
-    "@types/fs-extra": "9.0.12",
+    "@types/fs-extra": "^9.0.13",
     "@types/micromatch": "^4.0.2",
     "@types/node": "12.20.12",
-    "@types/serve-static": "1.13.10",
-    "cypress": "^8.3.0",
+    "@types/serve-static": "^1.15.0",
+    "cypress": "^10.6.0",
+    "elm-codegen": "^0.2.0",
     "elm-optimize-level-2": "^0.1.5",
-    "elm-review": "^2.5.3",
-    "elm-test": "^0.19.1-revision7",
-    "elm-tooling": "^1.3.0",
-    "elm-verify-examples": "^5.0.0",
+    "elm-review": "^2.7.4",
+    "elm-test": "^0.19.1-revision9",
+    "elm-tooling": "^1.8.0",
+    "elm-verify-examples": "^5.2.0",
     "elmi-to-json": "^1.2.0",
-    "mocha": "^9.1.0",
-    "typescript": "4.3.5"
+    "mocha": "^10.0.0",
+    "typescript": "^4.7.4"
   },
   "files": [
     "generator/src/",

package/src/ApiRoute.elm

@@ -1,4 +1,11 @@
-module ApiRoute exposing (ApiRoute, ApiRouteBuilder, Response, buildTimeRoutes, capture, int, literal, single, slash, succeed, getBuildTimeRoutes)
+module ApiRoute exposing
+    ( ApiRoute, ApiRouteBuilder, Response
+    , capture, literal, slash, succeed
+    , single, preRender
+    , preRenderWithFallback, serverRender
+    , withGlobalHeadTags
+    , toJson, getBuildTimeRoutes, getGlobalHeadTagsDataSource
+    )
 
 {-| ApiRoute's are defined in `src/Api.elm` and are a way to generate files, like RSS feeds, sitemaps, or any text-based file that you output with an Elm function! You get access
 to a DataSource so you can pull in HTTP data, etc. Because ApiRoutes don't hydrate into Elm apps (like pages in elm-pages do), you can pull in as much data as you want in
@@ -7,13 +14,42 @@ the DataSource for your ApiRoutes, and it won't effect the payload size. Instead
 In a future release, ApiRoutes may be able to run at request-time in a serverless function, allowing you to use pure Elm code to create dynamic APIs, and even pulling in data from
 DataSources dynamically.
 
-@docs ApiRoute, ApiRouteBuilder, Response, buildTimeRoutes, capture, int, literal, single, slash, succeed, getBuildTimeRoutes
+@docs ApiRoute, ApiRouteBuilder, Response
+
+@docs capture, literal, slash, succeed
+
+
+## Pre-Rendering
+
+@docs single, preRender
+
+
+## Server Rendering
+
+@docs preRenderWithFallback, serverRender
+
+
+## Including Head Tags
+
+@docs withGlobalHeadTags
+
+
+## Internals
+
+@docs toJson, getBuildTimeRoutes, getGlobalHeadTagsDataSource
 
 -}
 
 import DataSource exposing (DataSource)
+import DataSource.Http
+import Head
 import Internal.ApiRoute exposing (ApiRoute(..), ApiRouteBuilder(..))
+import Json.Decode as Decode
+import Json.Encode
+import Pattern
 import Regex
+import Server.Request
+import Server.Response
 
 
 {-| -}
@@ -22,15 +58,109 @@ type alias ApiRoute response =
 
 
 {-| -}
-single : ApiRouteBuilder (DataSource Response) (List String) -> ApiRoute Response
+single : ApiRouteBuilder (DataSource String) (List String) -> ApiRoute Response
 single handler =
     handler
-        |> buildTimeRoutes (\constructor -> DataSource.succeed [ constructor ])
+        |> preRender (\constructor -> DataSource.succeed [ constructor ])
+
+
+{-| -}
+serverRender : ApiRouteBuilder (Server.Request.Parser (DataSource (Server.Response.Response Never Never))) constructor -> ApiRoute Response
+serverRender ((ApiRouteBuilder patterns pattern _ _ _) as fullHandler) =
+    ApiRoute
+        { regex = Regex.fromString ("^" ++ pattern ++ "$") |> Maybe.withDefault Regex.never
+        , matchesToResponse =
+            \path ->
+                Internal.ApiRoute.tryMatch path fullHandler
+                    |> Maybe.map
+                        (\toDataSource ->
+                            DataSource.Http.get
+                                "$$elm-pages$$headers"
+                                (toDataSource |> Server.Request.getDecoder |> Decode.map Just)
+                                |> DataSource.andThen
+                                    (\rendered ->
+                                        case rendered of
+                                            Just (Ok okRendered) ->
+                                                okRendered
+
+                                            Just (Err errors) ->
+                                                errors
+                                                    |> Server.Request.errorsToString
+                                                    |> Server.Response.plainText
+                                                    |> Server.Response.withStatusCode 400
+                                                    |> DataSource.succeed
+
+                                            Nothing ->
+                                                Server.Response.plainText "No matching request handler"
+                                                    |> Server.Response.withStatusCode 400
+                                                    |> DataSource.succeed
+                                    )
+                        )
+                    |> Maybe.map (DataSource.map (Server.Response.toJson >> Just))
+                    |> Maybe.withDefault
+                        (DataSource.succeed Nothing)
+        , buildTimeRoutes = DataSource.succeed []
+        , handleRoute =
+            \path ->
+                DataSource.succeed
+                    (case Internal.ApiRoute.tryMatch path fullHandler of
+                        Just _ ->
+                            True
+
+                        Nothing ->
+                            False
+                    )
+        , pattern = patterns
+        , kind = "serverless"
+        , globalHeadTags = Nothing
+        }
+
+
+{-| -}
+preRenderWithFallback : (constructor -> DataSource (List (List String))) -> ApiRouteBuilder (DataSource (Server.Response.Response Never Never)) constructor -> ApiRoute Response
+preRenderWithFallback buildUrls ((ApiRouteBuilder patterns pattern _ toString constructor) as fullHandler) =
+    let
+        buildTimeRoutes__ : DataSource (List String)
+        buildTimeRoutes__ =
+            buildUrls (constructor [])
+                |> DataSource.map (List.map toString)
+    in
+    ApiRoute
+        { regex = Regex.fromString ("^" ++ pattern ++ "$") |> Maybe.withDefault Regex.never
+        , matchesToResponse =
+            \path ->
+                Internal.ApiRoute.tryMatch path fullHandler
+                    |> Maybe.map (DataSource.map (Server.Response.toJson >> Just))
+                    |> Maybe.withDefault
+                        (DataSource.succeed Nothing)
+        , buildTimeRoutes = buildTimeRoutes__
+        , handleRoute =
+            \path ->
+                DataSource.succeed
+                    (case Internal.ApiRoute.tryMatch path fullHandler of
+                        Just _ ->
+                            True
+
+                        Nothing ->
+                            False
+                    )
+        , pattern = patterns
+        , kind = "prerender-with-fallback"
+        , globalHeadTags = Nothing
+        }
+
+
+encodeStaticFileBody : String -> Response
+encodeStaticFileBody fileBody =
+    Json.Encode.object
+        [ ( "body", fileBody |> Json.Encode.string )
+        , ( "kind", Json.Encode.string "static-file" )
+        ]
 
 
 {-| -}
-buildTimeRoutes : (constructor -> DataSource (List (List String))) -> ApiRouteBuilder (DataSource Response) constructor -> ApiRoute Response
-buildTimeRoutes buildUrls ((ApiRouteBuilder pattern _ toString constructor) as fullHandler) =
+preRender : (constructor -> DataSource (List (List String))) -> ApiRouteBuilder (DataSource String) constructor -> ApiRoute Response
+preRender buildUrls ((ApiRouteBuilder patterns pattern _ toString constructor) as fullHandler) =
     let
         buildTimeRoutes__ : DataSource (List String)
         buildTimeRoutes__ =
@@ -60,7 +190,7 @@ buildTimeRoutes buildUrls ((ApiRouteBuilder pattern _ toString constructor) as f
                         (\found ->
                             if found then
                                 Internal.ApiRoute.tryMatch path fullHandler
-                                    |> Maybe.map (DataSource.map Just)
+                                    |> Maybe.map (DataSource.map (encodeStaticFileBody >> Just))
                                     |> Maybe.withDefault (DataSource.succeed Nothing)
 
                             else
@@ -76,6 +206,9 @@ buildTimeRoutes buildUrls ((ApiRouteBuilder pattern _ toString constructor) as f
                 in
                 preBuiltMatches
                     |> DataSource.map (List.member matches)
+        , pattern = patterns
+        , kind = "prerender"
+        , globalHeadTags = Nothing
         }
 
 
@@ -86,33 +219,49 @@ type alias ApiRouteBuilder a constructor =
 
 {-| -}
 type alias Response =
-    { body : String }
+    Json.Encode.Value
 
 
 {-| -}
 succeed : a -> ApiRouteBuilder a (List String)
 succeed a =
-    ApiRouteBuilder "" (\_ -> a) (\_ -> "") (\list -> list)
+    ApiRouteBuilder Pattern.empty "" (\_ -> a) (\_ -> "") (\list -> list)
+
+
+{-| Turn the route into a pattern in JSON format. For internal uses.
+-}
+toJson : ApiRoute response -> Json.Encode.Value
+toJson ((ApiRoute { kind }) as apiRoute) =
+    Json.Encode.object
+        [ ( "pathPattern", apiRoute |> Internal.ApiRoute.toPattern |> Pattern.toJson )
+        , ( "kind", Json.Encode.string kind )
+        ]
 
 
 {-| -}
 literal : String -> ApiRouteBuilder a constructor -> ApiRouteBuilder a constructor
-literal segment (ApiRouteBuilder pattern handler toString constructor) =
-    ApiRouteBuilder (pattern ++ segment) handler (\values -> toString values ++ segment) constructor
+literal segment (ApiRouteBuilder patterns pattern handler toString constructor) =
+    ApiRouteBuilder
+        (Pattern.addLiteral segment patterns)
+        (pattern ++ segment)
+        handler
+        (\values -> toString values ++ segment)
+        constructor
 
 
 {-| -}
 slash : ApiRouteBuilder a constructor -> ApiRouteBuilder a constructor
-slash (ApiRouteBuilder pattern handler toString constructor) =
-    ApiRouteBuilder (pattern ++ "/") handler (\arg -> toString arg ++ "/") constructor
+slash (ApiRouteBuilder patterns pattern handler toString constructor) =
+    ApiRouteBuilder (patterns |> Pattern.addSlash) (pattern ++ "/") handler (\arg -> toString arg ++ "/") constructor
 
 
 {-| -}
 capture :
     ApiRouteBuilder (String -> a) constructor
     -> ApiRouteBuilder a (String -> constructor)
-capture (ApiRouteBuilder pattern previousHandler toString constructor) =
+capture (ApiRouteBuilder patterns pattern previousHandler toString constructor) =
     ApiRouteBuilder
+        (patterns |> Pattern.addCapture)
         (pattern ++ "(.*)")
         (\matches ->
             case matches of
@@ -136,35 +285,6 @@ capture (ApiRouteBuilder pattern previousHandler toString constructor) =
         )
 
 
-{-| -}
-int :
-    ApiRouteBuilder (Int -> a) constructor
-    -> ApiRouteBuilder a (Int -> constructor)
-int (ApiRouteBuilder pattern previousHandler toString constructor) =
-    ApiRouteBuilder
-        (pattern ++ "(\\d+)")
-        (\matches ->
-            case matches of
-                first :: rest ->
-                    previousHandler rest (String.toInt first |> Maybe.withDefault -1)
-
-                _ ->
-                    previousHandler [] -1
-        )
-        (\s ->
-            case s of
-                first :: rest ->
-                    toString rest ++ first
-
-                _ ->
-                    ""
-        )
-        (\matches ->
-            \string ->
-                constructor (String.fromInt string :: matches)
-        )
-
-
 {-| For internal use by generated code. Not so useful in user-land.
 -}
 getBuildTimeRoutes : ApiRoute response -> DataSource (List String)
@@ -172,6 +292,19 @@ getBuildTimeRoutes (ApiRoute handler) =
     handler.buildTimeRoutes
 
 
+{-| Include head tags on every page's HTML.
+-}
+withGlobalHeadTags : DataSource (List Head.Tag) -> ApiRoute response -> ApiRoute response
+withGlobalHeadTags globalHeadTags (ApiRoute handler) =
+    ApiRoute { handler | globalHeadTags = Just globalHeadTags }
+
+
+{-| -}
+getGlobalHeadTagsDataSource : ApiRoute response -> Maybe (DataSource (List Head.Tag))
+getGlobalHeadTagsDataSource (ApiRoute handler) =
+    handler.globalHeadTags
+
+
 
 --captureRest : ApiRouteBuilder (List String -> a) b -> ApiRouteBuilder a b
 --captureRest previousHandler =

package/src/BuildError.elm

@@ -1,4 +1,4 @@
-module BuildError exposing (BuildError, encode, errorToString, errorsToString)
+module BuildError exposing (BuildError, encode, errorToString, errorsToString, internal)
 
 import Json.Encode as Encode
 import TerminalText as Terminal
@@ -12,6 +12,15 @@ type alias BuildError =
     }
 
 
+internal : String -> { title : String, path : String, message : List Terminal.Text, fatal : Bool }
+internal string =
+    { title = "Internal Error"
+    , path = ""
+    , message = [ Terminal.text string ]
+    , fatal = True
+    }
+
+
 errorsToString : List BuildError -> String
 errorsToString errors =
     errors

package/src/CookieParser.elm

@@ -0,0 +1,84 @@
+module CookieParser exposing (parse)
+
+import Dict exposing (Dict)
+import Parser exposing ((|.), (|=), Parser, Step(..))
+import Url
+
+
+parse : String -> Dict String String
+parse input =
+    Parser.run parser input
+        |> Result.withDefault Dict.empty
+
+
+parser : Parser (Dict String String)
+parser =
+    Parser.loop [] keyValuePair
+        |> Parser.map Dict.fromList
+
+
+keyValuePair : List ( String, String ) -> Parser (Step (List ( String, String )) (List ( String, String )))
+keyValuePair revChunks =
+    Parser.oneOf
+        [ Parser.end
+            |> Parser.map (\_ -> Done (List.reverse revChunks))
+        , Parser.succeed (Loop revChunks)
+            |. Parser.chompIf isSpace
+            |. Parser.chompWhile isSpace
+        , Parser.succeed Tuple.pair
+            |= parseKey
+            |= Parser.oneOf
+                [ Parser.succeed Nothing
+                    |. Parser.token ";"
+                , Parser.succeed Just
+                    |. Parser.token "="
+                    |= valueParser
+                    |. Parser.oneOf
+                        [ Parser.token ";"
+                        , Parser.succeed ()
+                        ]
+                ]
+            |> Parser.andThen
+                (\( key, maybeValue ) ->
+                    case maybeValue of
+                        Just value ->
+                            Parser.succeed (Loop (( key, value ) :: revChunks))
+
+                        Nothing ->
+                            Parser.succeed (Loop revChunks)
+                )
+        ]
+
+
+valueParser : Parser String
+valueParser =
+    Parser.succeed identity
+        |. Parser.chompWhile isSpace
+        |= Parser.oneOf
+            [ Parser.succeed ""
+                |. Parser.token ";"
+            , Parser.succeed identity
+                |. Parser.token "\""
+                |= (Parser.chompUntil "\""
+                        |> Parser.getChompedString
+                   )
+                |. Parser.token "\""
+            , Parser.chompWhile (\c -> c /= ';')
+                |> Parser.getChompedString
+            ]
+        |> Parser.map String.trim
+        |> Parser.map (\value -> value |> Url.percentDecode |> Maybe.withDefault "")
+
+
+parseKey : Parser String
+parseKey =
+    Parser.succeed identity
+        |= (Parser.chompWhile (\c -> c /= '=' && c /= ';')
+                |> Parser.getChompedString
+                |> Parser.map String.trim
+           )
+
+
+isSpace : Char -> Bool
+isSpace c =
+    c == ' '

package/src/DataSource/Env.elm

@@ -0,0 +1,38 @@
+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
+            )

package/src/DataSource/File.elm

@@ -30,7 +30,7 @@ The frontmatter is in the [YAML format](https://en.wikipedia.org/wiki/YAML) here
 Hey there! This is my first post :)
 ```
 
-Whether it's YAML or JSON, you use an `OptimizedDecoder` to decode your frontmatter, so it feels just like using
+Whether it's YAML or JSON, you use an `Decode` to decode your frontmatter, so it feels just like using
 plain old JSON in Elm.
 
 @docs bodyWithFrontmatter, bodyWithoutFrontmatter, onlyFrontmatter
@@ -44,20 +44,20 @@ plain old JSON in Elm.
 
 import DataSource exposing (DataSource)
 import DataSource.Http
-import OptimizedDecoder exposing (Decoder)
-import Secrets
+import DataSource.Internal.Request
+import Json.Decode as Decode exposing (Decoder)
 
 
 frontmatter : Decoder frontmatter -> Decoder frontmatter
 frontmatter frontmatterDecoder =
-    OptimizedDecoder.field "parsedFrontmatter" frontmatterDecoder
+    Decode.field "parsedFrontmatter" frontmatterDecoder
 
 
 {-|
 
     import DataSource exposing (DataSource)
     import DataSource.File as File
-    import OptimizedDecoder as Decode exposing (Decoder)
+    import Decode as Decode exposing (Decoder)
 
     blogPost : DataSource BlogPostMetadata
     blogPost =
@@ -93,8 +93,8 @@ It's common to parse the body with a markdown parser or other format.
 
     import DataSource exposing (DataSource)
     import DataSource.File as File
+    import Decode as Decode exposing (Decoder)
     import Html exposing (Html)
-    import OptimizedDecoder as Decode exposing (Decoder)
 
     example :
         DataSource
@@ -137,7 +137,7 @@ bodyWithFrontmatter : (String -> Decoder frontmatter) -> String -> DataSource fr
 bodyWithFrontmatter frontmatterDecoder filePath =
     read filePath
         (body
-            |> OptimizedDecoder.andThen
+            |> Decode.andThen
                 (\bodyString ->
                     frontmatter (frontmatterDecoder bodyString)
                 )
@@ -151,7 +151,7 @@ just the metadata.
 
     import DataSource exposing (DataSource)
     import DataSource.File as File
-    import OptimizedDecoder as Decode exposing (Decoder)
+    import Decode as Decode exposing (Decoder)
 
     blogPost : DataSource BlogPostMetadata
     blogPost =
@@ -175,7 +175,7 @@ the [`DataSource`](DataSource) API along with [`DataSource.Glob`](DataSource.Glo
 
     import DataSource exposing (DataSource)
     import DataSource.File as File
-    import OptimizedDecoder as Decode exposing (Decoder)
+    import Decode as Decode exposing (Decoder)
 
     blogPostFiles : DataSource (List String)
     blogPostFiles =
@@ -237,7 +237,7 @@ This is the function you want if you are reading in a file directly. For example
 have frontmatter.
 
 There's a special function for reading in JSON files, [`jsonFile`](#jsonFile). If you're reading a JSON file then be sure to
-use `jsonFile` to get the benefits of the `OptimizedDecoder` here.
+use `jsonFile` to get the benefits of the `Decode` here.
 
 You could read a file called `hello.txt` in your root project directory like this:
 
@@ -251,12 +251,12 @@ You could read a file called `hello.txt` in your root project directory like thi
 -}
 rawFile : String -> DataSource String
 rawFile filePath =
-    read filePath (OptimizedDecoder.field "rawFile" OptimizedDecoder.string)
+    read filePath (Decode.field "rawFile" Decode.string)
 
 
 {-| Read a file as JSON.
 
-The OptimizedDecoder will strip off any unused JSON data.
+The Decode will strip off any unused JSON data.
 
     import DataSource exposing (DataSource)
     import DataSource.File as File
@@ -273,16 +273,27 @@ The OptimizedDecoder will strip off any unused JSON data.
 -}
 jsonFile : Decoder a -> String -> DataSource a
 jsonFile jsonFileDecoder filePath =
-    read filePath (OptimizedDecoder.field "jsonFile" jsonFileDecoder)
+    rawFile filePath
+        |> DataSource.andThen
+            (\jsonString ->
+                jsonString
+                    |> Decode.decodeString jsonFileDecoder
+                    |> Result.mapError Decode.errorToString
+                    |> DataSource.fromResult
+            )
 
 
 {-| Gives us the file's content without stripping off frontmatter.
 -}
 body : Decoder String
 body =
-    OptimizedDecoder.field "withoutFrontmatter" OptimizedDecoder.string
+    Decode.field "withoutFrontmatter" Decode.string
 
 
 read : String -> Decoder a -> DataSource a
-read filePath =
-    DataSource.Http.get (Secrets.succeed <| "file://" ++ filePath)
+read filePath decoder =
+    DataSource.Internal.Request.request
+        { name = "read-file"
+        , body = DataSource.Http.stringBody "" filePath
+        , expect = decoder |> DataSource.Http.expectJson
+        }