Support Worker Function Invocation

api-gateway-examples/reusable_open_api_definition.json

@@ -20,7 +20,7 @@
         "function-name": "golem:it/api/get-cart-contents",
         "function-params": [],
         "component-id": "2696abdc-df3a-4771-8215-d6af7aa4c408",
-        "response" : "${{headers : {ContentType: 'json', userid: 'foo'}, {body: worker.response, status: 200}}"
+        "response" : "${{headers : {ContentType: 'json', userid: "foo"}, {body: worker.response, status: 200}}"
       },
       "get": {
         "summary": "Get Cart Contents",

golem-cli/tests/api_definition.rs

@@ -124,7 +124,7 @@ fn golem_def_with_response(
 }
 
 pub fn golem_def(id: &str, component_id: &str) -> HttpApiDefinition {
-    golem_def_with_response(id, component_id, Some("${{headers: {ContentType: 'json', userid: 'foo'}, body: worker.response, status: 200}}".to_string()))
+    golem_def_with_response(id, component_id, Some("${{headers: {ContentType: 'json', userid: "foo"}, body: worker.response, status: 200}}".to_string()))
 }
 
 pub fn make_golem_file(def: &HttpApiDefinition) -> Result<PathBuf, Failed> {
@@ -150,7 +150,7 @@ pub fn make_open_api_file(id: &str, component_id: &str) -> Result<PathBuf, Faile
                 "function-name": "golem:it/api/get-cart-contents",
                 "function-params": [],
                 "component-id": component_id,
-                "response" : "${{headers : {ContentType: 'json', userid: 'foo'}, body: worker.response, status: 200}}"
+                "response" : "${{headers : {ContentType: 'json', userid: "foo"}, body: worker.response, status: 200}}"
               },
               "get": {
                 "summary": "Get Cart Contents",

golem-worker-service-base/src/api/custom_http_request_api.rs

@@ -89,7 +89,7 @@ impl CustomHttpRequestApi {
             }
         };
 
-        match api_request.resolve(&api_definition) {
+        match api_request.resolve(&api_definition).await {
             Ok(resolved_worker_request) => {
                 resolved_worker_request
                     .execute_with::<poem::Response>(&self.worker_request_executor_service)

golem-worker-service-base/src/api_definition/http/http_oas_api_definition.rs

@@ -292,7 +292,7 @@ mod tests {
                 "function-params": ["${request}"],
                 "component-id": "00000000-0000-0000-0000-000000000000",
                 "idempotency-key": "test-key",
-                "response": "${{headers : {ContentType: 'json', user-id: 'foo'}, body: worker.response, status: 200}}"
+                "response": "${{headers : {ContentType: \"json\", user-id: \"foo\"}, body: worker.response, status: 200}}"
             }))]
                 .into_iter()
                 .collect(),
@@ -312,14 +312,14 @@ mod tests {
                         Expr::Literal("worker-".to_string()),
                         Expr::SelectField(
                             Box::new(Expr::SelectField(
-                                Box::new(Expr::Request()),
+                                Box::new(Expr::Identifier("request".to_string())),
                                 "body".to_string()
                             )),
                             "user".to_string()
                         )
                     ]),
                     function_name: "test".to_string(),
-                    function_params: vec![Expr::Request()],
+                    function_params: vec![Expr::Identifier("request".to_string())],
                     component_id: ComponentId(Uuid::nil()),
                     idempotency_key: Some(Expr::Literal("test-key".to_string())),
                     response: Some(ResponseMapping(Expr::Record(
@@ -340,7 +340,7 @@ mod tests {
                             (
                                 "body".to_string(),
                                 Box::new(Expr::SelectField(
-                                    Box::new(Expr::Worker()),
+                                    Box::new(Expr::Identifier("worker".to_string())),
                                     "response".to_string(),
                                 )),
                             ),

golem-worker-service-base/src/api_definition/http/http_response_mapping.rs

@@ -102,7 +102,7 @@ mod tests {
             vec![
                 (
                     "body".to_string(),
-                    Box::new(Expr::Variable("function.return".to_string())),
+                    Box::new(Expr::Identifier("function.return".to_string())),
                 ),
                 (
                     "status".to_string(),
@@ -124,7 +124,7 @@ mod tests {
 
         assert_eq!(
             http_response_mapping.body,
-            Expr::Variable("function.return".to_string())
+            Expr::Identifier("function.return".to_string())
         );
         assert_eq!(
             http_response_mapping.status,
@@ -171,7 +171,7 @@ mod tests {
             vec![
                 (
                     "body".to_string(),
-                    Box::new(Expr::Variable("function.return".to_string())),
+                    Box::new(Expr::Identifier("function.return".to_string())),
                 ),
                 (
                     "headers".to_string(),
@@ -199,7 +199,7 @@ mod tests {
             vec![
                 (
                     "body".to_string(),
-                    Box::new(Expr::Variable("worker.response".to_string())),
+                    Box::new(Expr::Identifier("worker.response".to_string())),
                 ),
                 (
                     "status".to_string(),

golem-worker-service-base/src/evaluator/evaluator_context.rs

@@ -4,26 +4,20 @@ use crate::evaluator::Getter;
 use crate::merge::Merge;
 use crate::worker_binding::RequestDetails;
 use crate::worker_bridge_execution::{RefinedWorkerResponse, WorkerRequest};
+use golem_wasm_ast::analysis::AnalysedFunction;
 use golem_wasm_rpc::TypeAnnotatedValue;
 
-// Evaluator of an expression doesn't necessarily need a context all the time, and can be empty.
-// or contain worker details, request details, worker_response or all of them.
-
 #[derive(Clone)]
 pub struct EvaluationContext {
-    pub worker_request: Option<WorkerRequest>,
-    pub worker_response: Option<RefinedWorkerResponse>,
     pub variables: Option<TypeAnnotatedValue>,
-    pub request_data: Option<RequestDetails>,
+    pub analysed_functions: Vec<AnalysedFunction>,
 }
 
 impl EvaluationContext {
     pub fn empty() -> Self {
         EvaluationContext {
-            worker_request: None,
-            worker_response: None,
             variables: None,
-            request_data: None,
+            analysed_functions: vec![],
         }
     }
 
@@ -46,11 +40,28 @@ impl EvaluationContext {
     }
 
     pub fn from_request_data(request: &RequestDetails) -> Self {
+        let variables = internal::request_type_annotated_value(request);
+
         EvaluationContext {
-            worker_request: None,
-            worker_response: None,
-            variables: None,
-            request_data: Some(request.clone()),
+            variables: Some(variables),
+            analysed_functions: vec![],
+        }
+    }
+
+    #[allow(unused)]
+    pub fn from_refined_worker_response(worker_response: &RefinedWorkerResponse) -> Self {
+        let type_annoated_value = worker_response.to_type_annotated_value();
+
+        if let Some(typed_res) = type_annoated_value {
+            let response_data = internal::create_record("response", typed_res);
+            let worker_data = internal::create_record("worker", response_data);
+
+            EvaluationContext {
+                variables: Some(worker_data),
+                analysed_functions: vec![],
+            }
+        } else {
+            EvaluationContext::empty()
         }
     }
 
@@ -59,11 +70,62 @@ impl EvaluationContext {
         worker_response: &RefinedWorkerResponse,
         request: &RequestDetails,
     ) -> Self {
-        EvaluationContext {
-            worker_request: Some(worker_request.clone()),
-            worker_response: Some(worker_response.clone()),
-            variables: None,
-            request_data: Some(request.clone()),
+        let mut worker_request_data = internal::worker_request_type_annotated_value(worker_request);
+
+        let worker_response_data = internal::worker_response_type_annotated_value(worker_response);
+
+        if let Some(worker_response) = worker_response_data {
+            let worker_data = worker_request_data.merge(&worker_response);
+            let request_data = internal::request_type_annotated_value(request);
+
+            let variables = worker_data.merge(&request_data).clone();
+
+            EvaluationContext {
+                variables: Some(variables),
+                analysed_functions: vec![],
+            }
+        } else {
+            EvaluationContext::from_request_data(request)
+        }
+    }
+}
+
+mod internal {
+    use crate::worker_bridge_execution::{RefinedWorkerResponse, WorkerRequest};
+    use golem_wasm_ast::analysis::AnalysedType;
+    use golem_wasm_rpc::TypeAnnotatedValue;
+
+    use crate::worker_binding::RequestDetails;
+
+    pub(crate) fn request_type_annotated_value(
+        request_details: &RequestDetails,
+    ) -> TypeAnnotatedValue {
+        let type_annoated_value = request_details.to_type_annotated_value();
+        create_record("request", type_annoated_value)
+    }
+
+    pub(crate) fn worker_request_type_annotated_value(
+        worker_request: &WorkerRequest,
+    ) -> TypeAnnotatedValue {
+        let typed_value = worker_request.clone().to_type_annotated_value();
+        create_record("worker", typed_value)
+    }
+
+    pub(crate) fn worker_response_type_annotated_value(
+        worker_response: &RefinedWorkerResponse,
+    ) -> Option<TypeAnnotatedValue> {
+        let typed_value = worker_response.to_type_annotated_value();
+
+        typed_value.map(|typed_value| {
+            let response = create_record("response", typed_value);
+            create_record("worker", response)
+        })
+    }
+
+    pub(crate) fn create_record(name: &str, value: TypeAnnotatedValue) -> TypeAnnotatedValue {
+        TypeAnnotatedValue::Record {
+            typ: vec![(name.to_string(), AnalysedType::from(&value))],
+            value: vec![(name.to_string(), value)].into_iter().collect(),
         }
     }
 }