Revert change to proxy.ts

Author: slinkydeveloper

packages/restate-e2e-services/src/proxy.ts

@@ -25,50 +25,75 @@ type ManyCallRequest = {
   awaitAtTheEnd: boolean;
 };
 
-function rawCall(
+async function rawCall(
   ctx: restate.Context,
-  request: ProxyRequest
-): Promise<Uint8Array> {
-  return ctx.genericCall({
-    service: request.serviceName,
-    method: request.handlerName,
-    key: request.virtualObjectKey,
+  serviceName: string,
+  handlerName: string,
+  message: Array<number>,
+  key?: string
+) {
+  const input = new Uint8Array(message);
+  const response: Uint8Array = await ctx.genericCall({
+    service: serviceName,
+    method: handlerName,
+    key: key,
     inputSerde: restate.serde.binary,
     outputSerde: restate.serde.binary,
-    parameter: new Uint8Array(request.message),
+    parameter: input,
   });
+
+  return Array.from(response);
 }
 
-function rawSend(ctx: restate.Context, request: ProxyRequest) {
+async function rawSend(
+  ctx: restate.Context,
+  serviceName: string,
+  handlerName: string,
+  message: Array<number>,
+  key?: string
+) {
+  const input = new Uint8Array(message);
   ctx.genericSend({
-    service: request.serviceName,
-    method: request.handlerName,
-    key: request.virtualObjectKey,
+    service: serviceName,
+    method: handlerName,
+    key: key,
     inputSerde: restate.serde.binary,
-    parameter: new Uint8Array(request.message),
+    parameter: input,
   });
 }
 
 const o = restate.service({
   name: "Proxy",
   handlers: {
     async call(ctx: restate.Context, request: ProxyRequest) {
-      return Array.from(await rawCall(ctx, request));
+      return await rawCall(
+        ctx,
+        request.serviceName,
+        request.handlerName,
+        request.message,
+        request.virtualObjectKey
+      );
     },
 
     async oneWayCall(ctx: restate.Context, request: ProxyRequest) {
-      rawSend(ctx, request);
+      return await rawSend(
+        ctx,
+        request.serviceName,
+        request.handlerName,
+        request.message,
+        request.virtualObjectKey
+      );
     },
 
     async manyCalls(ctx: restate.Context, request: ManyCallRequest[]) {
       const toAwait = [];
 
       for (const r of request) {
         if (r.oneWayCall) {
-          rawSend(ctx, r.proxyRequest);
+          await this.oneWayCall(ctx, r.proxyRequest);
           continue;
         }
-        const promise = rawCall(ctx, r.proxyRequest);
+        const promise = this.call(ctx, r.proxyRequest);
         if (r.awaitAtTheEnd) {
           toAwait.push(promise);
         }