backwards compatibility

Signed-off-by: Xavier Geerinck <xavier.geerinck@gmail.com>

Author: XavierGeerinck

src/actors/client/ActorProxyBuilder.ts

@@ -22,30 +22,57 @@ export default class ActorProxyBuilder<T> {
   actorClient: ActorClient;
   actorAbstractClass: Class<T>;
 
-  constructor(actorTypeName: string, actorTypeClass: Class<T>, daprClient: DaprClient);
+  constructor(actorTypeClass: Class<T>, daprClient: DaprClient);
+  constructor(
+    actorTypeClass: Class<T>,
+    host: string,
+    port: string,
+    communicationProtocol: CommunicationProtocolEnum,
+    clientOptions: DaprClientOptions,
+  );
   constructor(
     actorTypeName: string,
-    abstractClass: Class<T>,
+    actorTypeClass: Class<T>,
+    daprClient: DaprClient
+  );
+  constructor(
+    actorTypeName: string,
+    actorTypeClass: Class<T>,
     host: string,
     port: string,
     communicationProtocol: CommunicationProtocolEnum,
     clientOptions: DaprClientOptions,
   );
-  constructor(actorTypeName: string, abstractClass: Class<T>, ...args: any[]) {
+  constructor(...args: any[]) {
+    let actorTypeName: string;
+    let actorTypeClass: Class<T>;
+    let rest: any[];
+
+    // Determine if the first argument is a string (actorTypeName) or a class
+    if (typeof args[0] === "string") {
+      actorTypeName = args[0];
+      actorTypeClass = args[1];
+      rest = args.slice(2);
+    } else {
+      actorTypeClass = args[0];
+      actorTypeName = actorTypeClass.name;
+      rest = args.slice(1);
+    }
+
     this.actorTypeName = actorTypeName;
-    this.actorAbstractClass = abstractClass;
+    this.actorAbstractClass = actorTypeClass;
 
     // Create the actor client based on the provided arguments
-    if (args.length == 1) {
-      const [daprClient] = args;
+    if (rest.length == 1) {
+      const [daprClient] = rest;
       this.actorClient = new ActorClient(
         daprClient.options.daprHost,
         daprClient.options.daprPort,
         daprClient.options.communicationProtocol,
         daprClient.options,
       );
     } else {
-      const [host, port, communicationProtocol, clientOptions] = args;
+      const [host, port, communicationProtocol, clientOptions] = rest;
       this.actorClient = new ActorClient(host, port, communicationProtocol, clientOptions);
     }
   }

test/e2e/http/actors.test.ts

@@ -161,6 +161,22 @@ describe("http/actors", () => {
       expect(c3).toEqual(11);
     });
 
+    it("should be able to create an actor object through the proxy and the deprecated way of working (when we have the implementation)", async () => {
+      const builder = new ActorProxyBuilder<DemoActorCounterInterface>(DemoActorCounterImpl, client);
+      const actor = builder.build(ActorId.createRandomId());
+
+      const c1 = await actor.getCounter();
+      expect(c1).toEqual(0);
+
+      await actor.countBy(1, 1);
+      const c2 = await actor.getCounter();
+      expect(c2).toEqual(1);
+
+      await actor.countBy(1, 10);
+      const c3 = await actor.getCounter();
+      expect(c3).toEqual(11);
+    });
+
     it("should be able to create an actor object through the proxy (without requiring the implementation)", async () => {
       const builder = new ActorProxyBuilder<DemoActorCounterContract>("DemoActorCounterImpl", DemoActorCounterContract, client);
       const actor = builder.build(ActorId.createRandomId());