Merge pull request #165 from XavierGeerinck/actor_add_abstraction

feat: Actor add abstraction for calling through DaprClient

Author: XavierGeerinck

CHANGELOG.md

@@ -2,6 +2,29 @@
 
 ## 2.x release
 
+### v2.1.0
+
+#### Actors
+
+To make development easier, Actors can now be called in 2 ways:
+
+1. By creating an actor through a helper method in the `DaprClient` class, removing the need of needing to know how a builder works.
+
+```javascript
+const actor = await client.actor.create<DemoActorSayImpl>(DemoActorSayImpl);
+const res = await actor.sayMulti(123, "123", { hello: "world 123" }, [1, 2, 3]);
+```
+
+2. By utilizing the Actor builder, where we create a Proxy object that does this for us.
+
+```javascript
+const builder = new ActorProxyBuilder<DemoActorSayImpl>(DemoActorSayImpl, client);
+const actor = builder.build(ActorId.createRandomId());
+const res = await actor.sayMulti(123, "123", { hello: "world 123" }, [1, 2, 3]);
+```
+
+Behind the hoods, method #1 will utilize method #2
+
 ### v2.0.0
 
 Version 2.0.0 brings a lot of changes to the Dapr JS SDK that were long due. Below an overview of the major contributions can be found, with a more detailed overview of the **Breaking Changes** under it.

examples/http/actor/src/actor/DemoActorCounterImpl.ts

@@ -8,7 +8,7 @@ export default class DemoActorCounterImpl extends AbstractActor implements DemoA
     this.counter++;
   }
 
-  async countBy(amount: number, multiplier: number = 1): Promise<void> {
+  async countBy(amount: number, multiplier = 1): Promise<void> {
     this.counter += (amount * multiplier);
   }
 }

examples/http/actor/src/index.ts

@@ -10,10 +10,6 @@ const serverHost = "127.0.0.1"; // App Host of this Example Server
 const serverPort = "50001"; // App Port of this Example Server
 const daprAppId = "example-hello-world";
 
-async function sleep(ms: number): Promise<void> {
-  return new Promise(resolve => setTimeout(resolve, ms));
-}
-
 async function start() {
   const server = new DaprServer(serverHost, serverPort, daprHost, daprPort);
   const client = new DaprClient(daprHost, daprPort);
@@ -39,43 +35,13 @@ async function start() {
   console.log("===============================================================");
   const actorId = "MyActorId1";
 
-
   const resRegisteredActors = await server.actor.getRegisteredActors();
   console.log(`Registered Actor Types: ${JSON.stringify(resRegisteredActors)}`);
 
   console.log("[Dapr-JS][Example][Actors] Trying to invoke method 'say' with msg 'hello world'");
-  const resActorInvokeSay = await client.actor.invoke("PUT", DemoActorSayImpl.name, actorId, "sayString", "Hello World");
+  const actor = client.actor.create<DemoActorSayImpl>(DemoActorSayImpl);
+  const resActorInvokeSay = await actor.sayString("Hello World");
   console.log(`[Dapr-JS][Example][Actors] Invoked Method and got data: ${resActorInvokeSay}`);
-
-  let resActorStateGet = await client.actor.stateGet(DemoActorSayImpl.name, actorId, "PropertyA");
-  await client.actor.stateTransaction(DemoActorSayImpl.name, actorId, [
-    {
-      operation: "upsert",
-      request: {
-        key: "key-1",
-        value: "my-new-data-1"
-      }
-    },
-    {
-      operation: "upsert",
-      request: {
-        key: "key-to-delete",
-        value: "my-new-data-1"
-      }
-    },
-    {
-      operation: "delete",
-      request: {
-        key: "key-to-delete"
-      }
-    }
-  ]);
-
-  resActorStateGet = await client.actor.stateGet(DemoActorSayImpl.name, actorId, "key-to-delete");
-  console.log(`[Dapr-JS][Example][Actors] Get State (should be empty): ${JSON.stringify(resActorStateGet)}`);
-
-  const resActorStateGet2 = await client.actor.stateGet(DemoActorSayImpl.name, actorId, "key-1");
-  console.log(`[Dapr-JS][Example][Actors] Get State (should be my-new-data-1): ${JSON.stringify(resActorStateGet2)}`);
 }
 
 start().catch((e) => {

package.json

@@ -1,6 +1,6 @@
 {
     "name": "dapr-client",
-    "version": "2.0.0",
+    "version": "2.1.0",
     "description": "The official Dapr (https://dapr.io) SDK for Node.js",
     "types": "http/index.d.ts",
     "scripts": {

src/actors/client/ActorProxyBuilder.ts

@@ -1,17 +1,25 @@
-import { DaprClient } from "../..";
+import { CommunicationProtocolEnum, DaprClient } from "../..";
 import Class from "../../types/Class";
 import ActorClient from "./ActorClient/ActorClient";
 import ActorId from "../ActorId";
+import { DaprClientOptions } from "../../types/DaprClientOptions";
 
 export default class ActorProxyBuilder<T> {
   actorClient: ActorClient;
-  daprClient: DaprClient;
   actorTypeClass: Class<T>;
 
-  constructor(actorTypeClass: Class<T>, daprClient: DaprClient) {
+  constructor(actorTypeClass: Class<T>, daprClient: DaprClient);
+  constructor(actorTypeClass: Class<T>, host: string, port: string, communicationProtocol: CommunicationProtocolEnum, clientOptions: DaprClientOptions);
+  constructor(actorTypeClass: Class<T>, ...args: any[]) {
     this.actorTypeClass = actorTypeClass;
-    this.daprClient = daprClient;
-    this.actorClient = new ActorClient(daprClient.getDaprHost(), daprClient.getDaprPort(), daprClient.getCommunicationProtocol(), daprClient.getOptions());
+
+    if (args.length == 1) {
+      const [daprClient] = args;
+      this.actorClient = new ActorClient(daprClient.getDaprHost(), daprClient.getDaprPort(), daprClient.getCommunicationProtocol(), daprClient.getOptions());
+    } else {
+      const [host, port, communicationProtocol, clientOptions] = args;
+      this.actorClient = new ActorClient(host, port, communicationProtocol, clientOptions);
+    }
   }
 
   build(actorId: ActorId): T {

src/implementation/Client/DaprClient.ts

@@ -6,6 +6,7 @@ import IClientSecret from '../../interfaces/Client/IClientSecret';
 import IClientHealth from '../../interfaces/Client/IClientHealth';
 import IClientMetadata from '../../interfaces/Client/IClientMetadata';
 import IClientSidecar from '../../interfaces/Client/IClientSidecar';
+import IClientActorBuilder from '../../interfaces/Client/IClientActorBuilder';
 import IClient from '../../interfaces/Client/IClient';
 
 import GRPCClientBinding from './GRPCClient/binding';
@@ -16,6 +17,7 @@ import GRPCClientSecret from './GRPCClient/secret';
 import GRPCClientHealth from './GRPCClient/health';
 import GRPCClientMetadata from './GRPCClient/metadata';
 import GRPCClientSidecar from './GRPCClient/sidecar';
+import GRPCClientActor from './GRPCClient/actor';
 import GRPCClient from './GRPCClient/GRPCClient';
 
 import HTTPClientBinding from './HTTPClient/binding';
@@ -26,6 +28,7 @@ import HTTPClientSecret from './HTTPClient/secret';
 import HTTPClientHealth from './HTTPClient/health';
 import HTTPClientMetadata from './HTTPClient/metadata';
 import HTTPClientSidecar from './HTTPClient/sidecar';
+import HTTPClientActor from './HTTPClient/actor';
 import HTTPClient from './HTTPClient/HTTPClient';
 
 import CommunicationProtocolEnum from '../../enum/CommunicationProtocol.enum';
@@ -46,6 +49,7 @@ export default class DaprClient {
   readonly health: IClientHealth;
   readonly metadata: IClientMetadata;
   readonly sidecar: IClientSidecar;
+  readonly actor: IClientActorBuilder;
 
   constructor(
     daprHost: string
@@ -79,6 +83,7 @@ export default class DaprClient {
         this.health = new GRPCClientHealth(client);
         this.metadata = new GRPCClientMetadata(client);
         this.sidecar = new GRPCClientSidecar(client);
+        this.actor = new GRPCClientActor(client); // we use a abstractor here since we interface through a builder with the Actor Runtime
         break;
       }
       case CommunicationProtocolEnum.HTTP:
@@ -94,6 +99,7 @@ export default class DaprClient {
         this.health = new HTTPClientHealth(client);
         this.metadata = new HTTPClientMetadata(client);
         this.sidecar = new HTTPClientSidecar(client);
+        this.actor = new HTTPClientActor(client); // we use a abstractor here since we interface through a builder with the Actor Runtime
         break;
       }
     }