Update remainder of the examples and test apps to new backend API

Complete updating example project codes to the backend API introduced with version 2021-08-14.

Author: Viir

implement/example-apps/demo-backend-state/src/Backend/InterfaceToHost.elm

@@ -1,18 +1,16 @@
 module Backend.Main exposing
     ( State
-    , interfaceToHost_initState
-    , interfaceToHost_processEvent
-    , processEvent
+    , backendMain
     )
 
-import Backend.InterfaceToHost as InterfaceToHost
 import Backend.State exposing (CustomType(..), CustomTypeWithTypeParameter(..), RecursiveType(..), valueForOpaqueCustomType)
 import Base64
 import Bytes.Encode
 import Common
 import CompilationInterface.ElmMake
 import CompilationInterface.GenerateJsonCoders
 import Dict
+import ElmFullstack
 import Json.Encode
 import ListDict
 import Set
@@ -23,72 +21,71 @@ type alias State =
     Backend.State.State
 
 
-interfaceToHost_processEvent : String -> State -> ( State, String )
-interfaceToHost_processEvent =
-    InterfaceToHost.wrapForSerialInterface_processEvent processEvent
+backendMain : ElmFullstack.BackendConfig State
+backendMain =
+    { init = ( initState, [] )
+    , subscriptions = subscriptions
+    }
 
 
-processEvent : InterfaceToHost.AppEvent -> State -> ( State, InterfaceToHost.AppEventResponse )
-processEvent hostEvent stateBefore =
-    case hostEvent of
-        InterfaceToHost.HttpRequestEvent httpRequestEvent ->
-            let
-                state =
-                    { stateBefore
-                        | httpRequestsCount = stateBefore.httpRequestsCount + 1
-                        , lastHttpRequests = httpRequestEvent :: stateBefore.lastHttpRequests |> List.take 4
-                    }
+subscriptions : State -> ElmFullstack.BackendSubs State
+subscriptions _ =
+    { httpRequest = updateForHttpRequestEvent
+    , posixTimeIsPast = Nothing
+    }
 
-                httpResponse =
-                    if
-                        httpRequestEvent.request.uri
-                            |> Url.fromString
-                            |> Maybe.map urlLeadsToFrontendHtmlDocument
-                            |> Maybe.withDefault False
-                    then
-                        { statusCode = 200
-                        , bodyAsBase64 = Just CompilationInterface.ElmMake.elm_make__debug__base64____src_FrontendWeb_Main_elm
-                        , headersToAdd = []
-                        }
 
-                    else
-                        { statusCode = 200
-                        , bodyAsBase64 =
-                            [ Common.describeApp
-                            , "I received "
-                                ++ (state.httpRequestsCount |> String.fromInt)
-                                ++ " HTTP requests."
-                            , "Here is a serialized representation of the backend state:"
-                            , state |> CompilationInterface.GenerateJsonCoders.jsonEncodeBackendState |> Json.Encode.encode 4
-                            ]
-                                |> String.join "\n"
-                                |> Bytes.Encode.string
-                                |> Bytes.Encode.encode
-                                |> Base64.fromBytes
-                        , headersToAdd = []
-                        }
-            in
-            ( state
-            , InterfaceToHost.passiveAppEventResponse
-                |> InterfaceToHost.withCompleteHttpResponsesAdded
-                    [ { httpRequestId = httpRequestEvent.httpRequestId, response = httpResponse }
-                    ]
-            )
+updateForHttpRequestEvent : ElmFullstack.HttpRequestEventStruct -> State -> ( State, ElmFullstack.BackendCmds State )
+updateForHttpRequestEvent httpRequestEvent stateBefore =
+    let
+        state =
+            { stateBefore
+                | httpRequestsCount = stateBefore.httpRequestsCount + 1
+                , lastHttpRequests = httpRequestEvent :: stateBefore.lastHttpRequests |> List.take 4
+            }
 
-        InterfaceToHost.TaskCompleteEvent _ ->
-            ( stateBefore, InterfaceToHost.passiveAppEventResponse )
+        httpResponse =
+            if
+                httpRequestEvent.request.uri
+                    |> Url.fromString
+                    |> Maybe.map urlLeadsToFrontendHtmlDocument
+                    |> Maybe.withDefault False
+            then
+                { statusCode = 200
+                , bodyAsBase64 = Just CompilationInterface.ElmMake.elm_make__debug__base64____src_FrontendWeb_Main_elm
+                , headersToAdd = []
+                }
 
-        InterfaceToHost.ArrivedAtTimeEvent _ ->
-            ( stateBefore, InterfaceToHost.passiveAppEventResponse )
+            else
+                { statusCode = 200
+                , bodyAsBase64 =
+                    [ Common.describeApp
+                    , "I received "
+                        ++ (state.httpRequestsCount |> String.fromInt)
+                        ++ " HTTP requests."
+                    , "Here is a serialized representation of the backend state:"
+                    , state |> CompilationInterface.GenerateJsonCoders.jsonEncodeBackendState |> Json.Encode.encode 4
+                    ]
+                        |> String.join "\n"
+                        |> Bytes.Encode.string
+                        |> Bytes.Encode.encode
+                        |> Base64.fromBytes
+                , headersToAdd = []
+                }
+    in
+    ( state
+    , [ ElmFullstack.RespondToHttpRequest { httpRequestId = httpRequestEvent.httpRequestId, response = httpResponse }
+      ]
+    )
 
 
 urlLeadsToFrontendHtmlDocument : Url.Url -> Bool
 urlLeadsToFrontendHtmlDocument url =
     not (url.path == "/api" || (url.path |> String.startsWith "/api/"))
 
 
-interfaceToHost_initState : State
-interfaceToHost_initState =
+initState : State
+initState =
     { httpRequestsCount = 0
     , lastHttpRequests = []
     , tuple2 = ( 123, "second element in tuple A" )

implement/example-apps/demo-backend-state/src/Backend/Main.elm

@@ -7,16 +7,16 @@ module Backend.State exposing
     , valueForOpaqueCustomType
     )
 
-import Backend.InterfaceToHost as InterfaceToHost
 import Bytes
 import Dict
+import ElmFullstack
 import ListDict
 import Set
 
 
 type alias State =
     { httpRequestsCount : Int
-    , lastHttpRequests : List InterfaceToHost.HttpRequestEventStructure
+    , lastHttpRequests : List ElmFullstack.HttpRequestEventStruct
     , tuple2 : Tuple2
     , tuple3 : Tuple3
     , list_custom_type : List CustomType

implement/example-apps/demo-backend-state/src/Backend/State.elm

@@ -0,0 +1,113 @@
+module ElmFullstack exposing (..)
+
+
+type alias BackendConfig state =
+    { init : ( state, BackendCmds state )
+    , subscriptions : state -> BackendSubs state
+    }
+
+
+type alias BackendSubs state =
+    { httpRequest : HttpRequestEventStruct -> state -> ( state, BackendCmds state )
+    , posixTimeIsPast :
+        Maybe
+            { minimumPosixTimeMilli : Int
+            , update : { currentPosixTimeMilli : Int } -> state -> ( state, BackendCmds state )
+            }
+    }
+
+
+type alias BackendCmds state =
+    List (BackendCmd state)
+
+
+type BackendCmd state
+    = RespondToHttpRequest RespondToHttpRequestStruct
+    | CreateVolatileProcess (CreateVolatileProcessStruct state)
+    | RequestToVolatileProcess (RequestToVolatileProcessStruct state)
+    | TerminateVolatileProcess TerminateVolatileProcessStruct
+
+
+type alias HttpRequestEventStruct =
+    { httpRequestId : String
+    , posixTimeMilli : Int
+    , requestContext : HttpRequestContext
+    , request : HttpRequestProperties
+    }
+
+
+type alias HttpRequestContext =
+    { clientAddress : Maybe String
+    }
+
+
+type alias HttpRequestProperties =
+    { method : String
+    , uri : String
+    , bodyAsBase64 : Maybe String
+    , headers : List HttpHeader
+    }
+
+
+type alias RespondToHttpRequestStruct =
+    { httpRequestId : String
+    , response : HttpResponse
+    }
+
+
+type alias HttpResponse =
+    { statusCode : Int
+    , bodyAsBase64 : Maybe String
+    , headersToAdd : List HttpHeader
+    }
+
+
+type alias HttpHeader =
+    { name : String
+    , values : List String
+    }
+
+
+type alias CreateVolatileProcessStruct state =
+    { programCode : String
+    , update : CreateVolatileProcessResult -> state -> ( state, BackendCmds state )
+    }
+
+
+type alias CreateVolatileProcessResult =
+    Result CreateVolatileProcessErrorStruct CreateVolatileProcessComplete
+
+
+type alias CreateVolatileProcessErrorStruct =
+    { exceptionToString : String
+    }
+
+
+type alias CreateVolatileProcessComplete =
+    { processId : String }
+
+
+type alias RequestToVolatileProcessStruct state =
+    { processId : String
+    , request : String
+    , update : RequestToVolatileProcessResult -> state -> ( state, BackendCmds state )
+    }
+
+
+type alias RequestToVolatileProcessResult =
+    Result RequestToVolatileProcessError RequestToVolatileProcessComplete
+
+
+type RequestToVolatileProcessError
+    = ProcessNotFound
+
+
+type alias RequestToVolatileProcessComplete =
+    { exceptionToString : Maybe String
+    , returnValueToString : Maybe String
+    , durationInMilliseconds : Int
+    }
+
+
+type alias TerminateVolatileProcessStruct =
+    { processId : String }