app/server/syntax/file_map/examples/elm_example.elm

module Example exposing (..)

import Browser
import Html exposing (..)
import Html.Attributes exposing (..)
import Html.Events exposing (..)
import Http
import Json.Decode as Decode exposing (Decoder)
import Json.Encode as Encode

-- MODEL

type alias Model =
    { users : List User
    , inputText : String
    , error : Maybe String
    }

type alias User =
    { id : Int
    , name : String
    , email : String
    }

init : () -> (Model, Cmd Msg)
init _ =
    ( { users = []
      , inputText = ""
      , error = Nothing
      }
    , fetchUsers
    )

-- UPDATE

type Msg
    = GotUsers (Result Http.Error (List User))
    | InputChanged String
    | AddUser
    | UserAdded (Result Http.Error User)

update : Msg -> Model -> (Model, Cmd Msg)
update msg model =
    case msg of
        GotUsers result ->
            case result of
                Ok users ->
                    ( { model | users = users, error = Nothing }
                    , Cmd.none
                    )
                Err _ ->
                    ( { model | error = Just "Failed to fetch users" }
                    , Cmd.none
                    )

        InputChanged text ->
            ( { model | inputText = text }
            , Cmd.none
            )

        AddUser ->
            ( model
            , addUser model.inputText
            )

        UserAdded result ->
            case result of
                Ok user ->
                    ( { model 
                      | users = user :: model.users
                      , inputText = ""
                      , error = Nothing
                      }
                    , Cmd.none
                    )
                Err _ ->
                    ( { model | error = Just "Failed to add user" }
                    , Cmd.none
                    )

-- HTTP

fetchUsers : Cmd Msg
fetchUsers =
    Http.get
        { url = "/api/users"
        , expect = Http.expectJson GotUsers usersDecoder
        }

addUser : String -> Cmd Msg
addUser name =
    Http.post
        { url = "/api/users"
        , body = Http.jsonBody (userEncoder name)
        , expect = Http.expectJson UserAdded userDecoder
        }

-- JSON

userEncoder : String -> Encode.Value
userEncoder name =
    Encode.object
        [ ("name", Encode.string name)
        ]

userDecoder : Decoder User
userDecoder =
    Decode.map3 User
        (Decode.field "id" Decode.int)
        (Decode.field "name" Decode.string)
        (Decode.field "email" Decode.string)

usersDecoder : Decoder (List User)
usersDecoder =
    Decode.list userDecoder

-- VIEW

view : Model -> Html Msg
view model =
    div []
        [ h1 [] [ text "User Management" ]
        , viewError model.error
        , viewInput model.inputText
        , viewUsers model.users
        ]

viewError : Maybe String -> Html Msg
viewError maybeError =
    case maybeError of
        Just error ->
            div [ class "error" ] [ text error ]
        Nothing ->
            text ""

viewInput : String -> Html Msg
viewInput inputText =
    div []
        [ input
            [ value inputText
            , onInput InputChanged
            , placeholder "Enter user name"
            ] []
        , button [ onClick AddUser ] [ text "Add User" ]
        ]

viewUsers : List User -> Html Msg
viewUsers users =
    div []
        [ h2 [] [ text "Users" ]
        , ul [] (List.map viewUser users)
        ]

viewUser : User -> Html Msg
viewUser user =
    li []
        [ text (user.name ++ " (" ++ user.email ++ ")")
        ]

-- MAIN

main : Program () Model Msg
main =
    Browser.element
        { init = init
        , update = update
        , view = view
        , subscriptions = \_ -> Sub.none
        }