ResponseType on actor definition

Author: eliasdarruda

README.md

@@ -22,12 +22,12 @@ This lib supports both Bun and NodeJS runtimes, Bun performs invocations ~2x fas
 import spawn, { ActorContext, Value } from '@eigr/spawn-sdk'
 import { UserState, ChangeUserNamePayload, ChangeUserNameStatus } from 'src/protos/examples/user_example'
 
-const system = spawn.createSystem('SpawnSystemName')
+const system = spawn.createSystem('spawn-system')
 
 // You can register multiple actors with different options
 const actor = system.buildActor({
   name: 'exampleActor',
-  stateType: UserState, // or 'json' if you don't want to use protobufs
+  stateType: UserState,
   stateful: true,
   snapshotTimeout: 10_000n,
   deactivatedTimeout: 60_000n
@@ -37,12 +37,11 @@ const actor = system.buildActor({
 const setNameHandler = async (context: ActorContext<UserState>, payload: ChangeUserNamePayload) => {
   return Value.of<UserState, ChangeUserNameResponse>()
     .state({ name: payload.newName })
-    .response(ChangeUserNameResponse, { status: ChangeUserNameStatus.OK })
+    .response({ status: ChangeUserNameStatus.OK })
 }
 
 // This is similar to a Route definition in REST
-// the default payloadType is 'json'
-actor.addAction({ name: 'setName', payloadType: ChangeUserNamePayload }, setNameHandler)
+actor.addAction({ name: 'SetName', payloadType: ChangeUserNamePayload, responseType: ChangeUserNameResponse }, setNameHandler)
 
 system.register()
   .then(() => console.log('Spawn System registered'))
@@ -59,14 +58,14 @@ import { UserState, ChangeUserNamePayload, ChangeUserNameResponse } from 'src/pr
   const response: ChangeUserNameResponse = await spawn.invoke('exampleActor', {
     action: 'setName',
     response: ChangeUserNameResponse,
-    payload: payloadFor(ChangeUserNamePayload, payload)
-    // system: 'SpawnSystemName'
+    payload: payloadFor(ChangeUserNamePayload, payload),
+    system: 'spawn-system'
   })
 
   const state: UserState = await spawn.invoke('exampleActor', {
     action: 'getState',
     response: UserState,
-    // system: 'SpawnSystemName'
+    system: 'spawn-system'
   })
 
   console.log(state) // { name: 'changedName' }
@@ -113,7 +112,7 @@ With this, it should generate a file at `src/protos/examples/user_example.ts`, w
 You'll need to make sure Spawn Proxy service is up and running.
 With `docker-compose` you can define:
 
-> **_NOTE:_** _using docker is recommended for `dev purposes only`, see [spawn deploy](https://github.com/eigr/spawn#getting-started) for production examples._
+> **_NOTE:_** _you can start the proxy using the `spawn cli`, see [spawn deploy](https://github.com/eigr/spawn#getting-started) for production examples._
 
 ```YML
 version: "3.8"

src/client-actor/value.ts

@@ -1,6 +1,8 @@
 import { Broadcast, Effect, Forward, Pipe } from './workflows'
 import { PayloadRef } from '../integration/parsers'
 import { MessageType } from '@protobuf-ts/runtime'
+import { SpawnActorError } from '../integration/errors'
+import { Noop } from '../protos/eigr/functions/protocol/actors/protocol'
 import { payloadFor } from '../spawn'
 
 export class Value<T extends object = object, K extends object = object> {
@@ -58,15 +60,43 @@ export class Value<T extends object = object, K extends object = object> {
     return this
   }
 
-  parse() {
+  parse(responseType?: MessageType<any> | 'json') {
     return {
       state: this._state,
-      value: this._response,
+      value: this.buildResponse(responseType),
       broadcast: this._broadcast,
       pipe: this._pipe,
       forward: this._forward,
       effects: this._effects,
       tags: this._tags
     }
   }
+
+  private buildResponse(responseType?: MessageType<any> | 'json') {
+    if (!this._response) {
+      return
+    }
+
+    if (Noop.is(this._response)) {
+      return this._response
+    }
+
+    if ((this._response as PayloadRef<any>).ref !== undefined && (this._response as PayloadRef<any>).instance) {
+      return this._response
+    }
+
+    if (!responseType) {
+      throw new SpawnActorError('You have to define a valid responseType in your actor action and set response with a correct type')
+    }
+  
+    if (responseType === 'json') {
+      return this._response
+    }
+
+    if (responseType && responseType.is(this._response)) {
+      return payloadFor(responseType, this._response)
+    }
+
+    throw new SpawnActorError('Specified responseType and response missmatch')
+  }
 }

src/integration/controller/invoke-actions-controller.ts

@@ -42,7 +42,7 @@ async function register(
     return sendResponse(200, res, resp)
   }
 
-  const { stateType, payloadType, callback } = callbackData
+  const { stateType, payloadType, responseType, callback } = callbackData
 
   const state = currentContext!.state && unpack(currentContext!.state, stateType)
   const context: ActorContext<any> = {
@@ -69,7 +69,7 @@ async function register(
 
   try {
     const value = await callback(context, finalPayload)
-    const parsedValue = value.parse()
+    const parsedValue = value.parse(responseType)
 
     const response = ActorInvocationResponse.create({
       actorName: actor?.name,
@@ -91,7 +91,7 @@ async function register(
 
     return sendResponse(200, res, response)
   } catch (error) {
-    console.error(error)
+    console.error(`Error when calling: ${actor?.name}.${actionName} | ${(error as any)?.message}`)
 
     return sendResponse(400, res)
   }

src/spawn.ts

@@ -36,6 +36,7 @@ import { Value } from './client-actor/value'
 export type ActorActionOpts = {
   name: string
   payloadType?: MessageType<any> | 'json'
+  responseType?: MessageType<any> | 'json'
   timer?: number
 }
 
@@ -47,6 +48,7 @@ export type ActorActionCallback<T extends object = any, K extends object = any>
 export type ActorCallbackConnector = {
   stateType: MessageType<any> | 'json'
   payloadType: MessageType<any> | 'json'
+  responseType: MessageType<any> | 'json'
   callback: ActorActionCallback
 }
 
@@ -173,22 +175,20 @@ const createSystem = (system: string = uniqueDefaultSystem): SpawnSystem => {
         addAction: (actionOpts: ActorActionOpts, callback: ActorActionCallback) => {
           if (registered) throw new SpawnSystemRegisteredError(registeredErrorMsg)
 
-          const derfaultActionOpts = { payloadType: 'json' }
-          const overridenActionOpts = { ...derfaultActionOpts, ...actionOpts } as ActorActionOpts
-
-          if (overridenActionOpts.timer) {
+          if (actionOpts.timer) {
             actor.timerActions.push({
-              action: { name: overridenActionOpts.name },
-              seconds: overridenActionOpts.timer
+              action: { name: actionOpts.name },
+              seconds: actionOpts.timer
             })
           } else {
-            actor.actions.push({ name: overridenActionOpts.name })
+            actor.actions.push({ name: actionOpts.name })
           }
 
-          registeredCallbacks.set(`${system}${actorName}${overridenActionOpts.name}`, {
+          registeredCallbacks.set(`${system}${actorName}${actionOpts.name}`, {
             callback,
             stateType: overridenOpts.stateType || Noop,
-            payloadType: overridenActionOpts.payloadType || Noop
+            payloadType: actionOpts.payloadType || Noop,
+            responseType: actionOpts.responseType || Noop
           })
         }
       }

test/stubs/actors.ts

@@ -50,13 +50,13 @@ export const createUserActor = (system: SpawnSystem) => {
   })
 
   actor.addAction(
-    { name: 'pipeTest', payloadType: ChangeUserName },
+    { name: 'pipeTest', payloadType: ChangeUserName, responseType: ChangeUserName },
     async (context: ActorContext<UserState>, payload: ChangeUserName) => {
       const name = 'pipe_initial'
 
       return Value.of<UserState, ChangeUserName>()
         .state({ ...context.state, name })
-        .response(ChangeUserName, { newName: `${payload.newName}Internal` })
+        .response({ newName: `${payload.newName}Internal` })
         .pipe({ actorName: 'userActorTransformerTest', action: 'transform' })
     }
   )
@@ -166,7 +166,7 @@ export const createJsonActor = (system: SpawnSystem) => {
   })
 
   actor.addAction(
-    { name: 'plusOne' },
+    { name: 'plusOne', responseType: 'json' },
     async (context: ActorContext<ActorState>, { value }: any) => {
       const sum = (value || 0) + 1