@rayondigital/nest-dapr 0.10.2 → 0.10.5

package/README.md

@@ -5,23 +5,23 @@ Develop NestJs microservices using [Dapr](https://dapr.io/) pubsub, actors and b
 
 # Description
 
-Dapr Module for [Nest](https://github.com/nestjs/nest) built on top of the [Dapr JS SDK](https://github.com/dapr/js-sdk).
+Dapr Module for [Nest](https://github.com/nestjs/nest) built on top of the latest [Dapr JS SDK](https://github.com/dapr/js-sdk).
 
 
 # Supported features
 - [x] [Actors](https://docs.dapr.io/developing-applications/building-blocks/actors/actors-overview/)
 - [x] [PubSub](https://docs.dapr.io/developing-applications/building-blocks/pubsub/pubsub-overview/)
 - [x] [Bindings](https://docs.dapr.io/developing-applications/building-blocks/bindings/bindings-overview/)
+- [x] [Workflows](https://docs.dapr.io/developing-applications/building-blocks/workflow/workflow-overview/)
 - [ ] [Distributed Lock](https://docs.dapr.io/developing-applications/building-blocks/distributed-lock/)
 - [ ] [State](https://docs.dapr.io/developing-applications/building-blocks/state-management/state-management-overview/)
 - [ ] [Service Invocation](https://docs.dapr.io/developing-applications/building-blocks/service-invocation/service-invocation-overview/)
-- [ ] [Workflows](https://docs.dapr.io/developing-applications/building-blocks/workflow/workflow-overview/)
 
 
 # Installation
 
 ```bash
-npm i --save @rayondigital/nest-dapr
+npm i @rayondigital/nest-dapr
 ```
 
 # Requirements
@@ -35,8 +35,8 @@ dapr --version
 Output:
 
 ```
-CLI version: 1.12.0
-Runtime version: 1.12.2
+CLI version: 1.15.1
+Runtime version: 1.15.4
 ```
 
 # Quick start
@@ -99,6 +99,7 @@ export class AppController {
 Create actors and connect them to your NestJS application using the `@DaprActor` decorator.
 This decorator takes in the interface of the actor, and marks the Actor as transient inside the NestJS
 dependency injection container.
+Ensure your actor classes are added to the `providers` array of your NestJS module.
 
 ```typescript
 // You must expose your actors interface as an abstract class because Typescript interfaces are not available at runtime (erasure).
@@ -168,6 +169,112 @@ export class CounterController {
 }
 ```
 
+## Workflows
+
+Workflows and Activities are annotated with the `@DaprWorkflow` and `@DaprActivity` decorators respectively.
+When added to the `providers` array of a NestJS module, they are automatically registered with the Dapr server.
+
+Note: Take care to ensure that your activities are stateless, and idempotent.
+Be very careful with the state, and services you have inside your workflows.
+
+
+```typescript   
+@DaprActivity()
+export class HelloActivity implements WorkflowActivity<string, string> {
+  async run(context: WorkflowActivityContext, name: string): Promise<string> {
+    return `Hello ${name}!`;
+  }
+}
+
+@DaprActivity()
+export class CreateEntityActivity implements WorkflowActivity<string, Entity> {
+  @Inject()
+  private readonly entityService: EntityService;
+
+  constructor(private readonly cacheService: CacheService) {}
+
+  async run(context: WorkflowActivityContext, id: string): Promise<Entity> {
+    const entity: Entity = { id: id, createdAt: new Date(), lastUpdatedAt: new Date(), status: 'created', data: {} };
+    await this.entityService.update(entity);
+    console.log('entity', entity);
+    return entity;
+  }
+}
+
+@DaprActivity()
+export class GetEntityActivity implements WorkflowActivity<string, Entity> {
+  @Inject()
+  private readonly entityService: EntityService;
+
+  constructor(private readonly cacheService: CacheService) {}
+
+  async run(context: WorkflowActivityContext, id: string): Promise<Entity> {
+    const entity = await this.entityService.get(id);
+    console.log('entity', entity);
+    return entity;
+  }
+}
+
+@DaprWorkflow()
+export class HelloWorkflow implements Workflow<string[], string> {
+  async *run(ctx: WorkflowContext, input: string): AsyncGenerator<unknown, string[]> {
+    const cities: string[] = [];
+
+    let entity = expect<Entity>(yield ctx.callActivity(CreateEntityActivity, '12345'));
+    ctx.setCustomStatus('Entity');
+
+    entity = expect<Entity>(yield ctx.callActivity(GetEntityActivity, '12345'));
+    console.log('entity', entity);
+    ctx.setCustomStatus('Entity');
+
+    const result1 = expect<string>(yield ctx.callActivity(HelloActivity, 'Tokyo'));
+    ctx.setCustomStatus('Tokyo');
+
+    const event = yield ctx.waitForExternalEvent('next');
+    console.log('event', event);
+
+    const result2 = expect<string>(yield ctx.callActivity(HelloActivity, 'Seattle'));
+    ctx.setCustomStatus('Seattle');
+
+    const result3 = expect<string>(yield ctx.callActivity(HelloActivity, 'London'));
+    ctx.setCustomStatus('London');
+
+    return cities;
+  }
+}
+```
+
+### Workflow Client
+
+```typescript
+@Controller()
+export class WorkflowController {
+  constructor(
+    private readonly workflowClient: DaprWorkflowClient,
+  ) {}
+
+  @Get(":id")
+  async start(@Param("id") uuid: string): Promise<string> {
+    const id = await workflowClient.scheduleNewWorkflow(HelloWorkflow, 'Hello', uuid);
+    // Workflow is started, and the id is returned.
+    // You can wait for the workflow to start and get the initial state.
+    const initialState = await workflowClient.waitForWorkflowStart(id, undefined, 15);
+    
+    // You can raise events
+    // await workflowClient.raiseEvent(id, 'next', { input: 'next' });
+    
+    // Optionally you can also wait for it to complete.
+    // const state = await workflowClient.waitForWorkflowCompletion(id, undefined, 15);
+    // Use the workflowOutput helper to get typed variables
+    // const value = workflowOutput(HelloWorkflow, state);
+    return { 
+      id: id,
+      state: initialState
+    }
+  }
+}
+```
+
 ## PubSub
 
 Create pubsub & topic names used for pubsub operations and message interface

package/dist/actors/dapr-actor-client.service.d.ts

@@ -7,14 +7,9 @@ export declare class DaprActorClient {
     private actorProxyBuilders;
     private interfaces;
     private interfaceToActorTypeNames;
-    private prefix;
-    private delimiter;
-    private typeNamePrefix;
     private allowInternalCalls;
     constructor(moduleRef: ModuleRef, daprClient: DaprClient);
     setAllowInternalCalls(allowInternalCalls: boolean): void;
-    setPrefix(prefix: string, delimiter?: string): void;
-    setTypeNamePrefix(prefix: string): void;
     register<T>(actorTypeName: string, actorType: Type<T> | Function, daprClient?: DaprClient): void;
     registerInterface<T>(actorType: Type<T> | Function, interfaceType: Type<T> | Function, daprClient?: DaprClient): void;
     getActorId(actorId: string): ActorId;

package/dist/actors/dapr-actor-client.service.js

@@ -21,21 +21,11 @@ let DaprActorClient = class DaprActorClient {
         this.actorProxyBuilders = new Map();
         this.interfaces = new Map();
         this.interfaceToActorTypeNames = new Map();
-        this.prefix = '';
-        this.delimiter = '-';
-        this.typeNamePrefix = '';
         this.allowInternalCalls = process.env.DAPR_ACTOR_ALLOW_INTERNAL_CALLS === 'true';
     }
     setAllowInternalCalls(allowInternalCalls) {
         this.allowInternalCalls = allowInternalCalls;
     }
-    setPrefix(prefix, delimiter = '-') {
-        this.prefix = prefix;
-        this.delimiter = delimiter;
-    }
-    setTypeNamePrefix(prefix) {
-        this.typeNamePrefix = prefix;
-    }
     register(actorTypeName, actorType, daprClient) {
         this.interfaces.set(this.formatActorTypeName(actorTypeName), actorType);
         const proxyBuilder = new actor_proxy_builder_1.ActorProxyBuilder(this.moduleRef, actorType, daprClient !== null && daprClient !== void 0 ? daprClient : this.daprClient);
@@ -53,13 +43,9 @@ let DaprActorClient = class DaprActorClient {
         this.actorProxyBuilders.set(this.formatActorTypeName(interfaceTypeName), proxyBuilder);
     }
     getActorId(actorId) {
-        var _a;
         if (!actorId) {
             throw new Error('Actor id must be provided');
         }
-        if (this.prefix) {
-            return new dapr_1.ActorId(`${this.prefix}${(_a = this.delimiter) !== null && _a !== void 0 ? _a : '-'}${actorId}`);
-        }
         return new dapr_1.ActorId(actorId);
     }
     getActor(actorType, actorId) {
@@ -98,16 +84,7 @@ let DaprActorClient = class DaprActorClient {
     }
     getActorTypeName(typeName) {
         if (this.interfaceToActorTypeNames.has(typeName)) {
-            const actorTypeName = this.interfaceToActorTypeNames.get(typeName);
-            if (this.actorProxyBuilders.has(actorTypeName)) {
-                return actorTypeName;
-            }
-            else {
-                return `${this.typeNamePrefix}${actorTypeName}`;
-            }
-        }
-        if (this.typeNamePrefix) {
-            return `${this.typeNamePrefix}${typeName}`;
+            return this.interfaceToActorTypeNames.get(typeName);
         }
         return typeName;
     }

package/dist/actors/nest-actor-manager.d.ts

@@ -8,6 +8,8 @@ export declare class NestActorManager {
     setupCSLWrapper(options: DaprModuleOptions, contextService: DaprContextService, invokeWrapperFn?: (actorId: ActorId, methodName: string, data: any, method: (actorId: ActorId, methodName: string, data: any) => Promise<any>) => Promise<any>): void;
     private catchAndLogUnhandledExceptions;
     private patchToSupportSerializableError;
+    private patchFireTimer;
+    private patchFireReminder;
     private patchDeactivate;
     private resolveDependencies;
     private static extractContext;

package/dist/actors/nest-actor-manager.js

@@ -37,14 +37,11 @@ let NestActorManager = NestActorManager_1 = class NestActorManager {
         const originalCreateActor = ActorManager_1.default.prototype.createActor;
         const resolveDependencies = this.resolveDependencies;
         ActorManager_1.default.prototype.createActor = function (actorId) {
-            var _a, _b;
+            var _a;
             return __awaiter(this, void 0, void 0, function* () {
                 const instance = (yield originalCreateActor.bind(this)(actorId));
-                if ((_a = options === null || options === void 0 ? void 0 : options.actorOptions) === null || _a === void 0 ? void 0 : _a.typeNamePrefix) {
-                    instance['actorType'] = `${options.typeNamePrefix}${instance.actorType}`;
-                }
                 if (isLoggingEnabled) {
-                    const actorTypeName = (_b = this.actorCls.name) !== null && _b !== void 0 ? _b : instance.constructor.name;
+                    const actorTypeName = (_a = this.actorCls.name) !== null && _a !== void 0 ? _a : instance.constructor.name;
                     common_1.Logger.verbose(`Activating actor ${actorId}`, actorTypeName);
                 }
                 try {
@@ -65,9 +62,11 @@ let NestActorManager = NestActorManager_1 = class NestActorManager {
         };
         this.patchDeactivate(options);
         this.patchToSupportSerializableError(options);
-        const isErrorHandlerEnabled = (_c = options === null || options === void 0 ? void 0 : options.catchErrors) !== null && _c !== void 0 ? _c : false;
+        const isErrorHandlerEnabled = (_c = options === null || options === void 0 ? void 0 : options.catchErrors) !== null && _c !== void 0 ? _c : true;
         if (isErrorHandlerEnabled) {
             this.catchAndLogUnhandledExceptions();
+            this.patchFireTimer();
+            this.patchFireReminder();
         }
     }
     setupReentrancy(options) {
@@ -97,6 +96,7 @@ let NestActorManager = NestActorManager_1 = class NestActorManager {
         const isLoggingEnabled = (_b = (_a = options === null || options === void 0 ? void 0 : options.logging) === null || _a === void 0 ? void 0 : _a.enabled) !== null && _b !== void 0 ? _b : true;
         const originalCallActor = ActorManager_1.default.prototype.callActorMethod;
         ActorManager_1.default.prototype.callActorMethod = function (actorId, methodName, data) {
+            var _a;
             return __awaiter(this, void 0, void 0, function* () {
                 try {
                     if (isLoggingEnabled) {
@@ -113,12 +113,12 @@ let NestActorManager = NestActorManager_1 = class NestActorManager {
                     }
                     else {
                         return yield clsService.run(() => __awaiter(this, void 0, void 0, function* () {
-                            var _a;
+                            var _b;
                             contextService.setIdIfNotDefined();
                             const context = NestActorManager_1.extractContext(data);
                             if (context) {
                                 contextService.set(context);
-                                const correlationId = (_a = context[dapr_context_service_1.DAPR_CORRELATION_ID_KEY]) !== null && _a !== void 0 ? _a : (0, crypto_1.randomUUID)();
+                                const correlationId = (_b = context[dapr_context_service_1.DAPR_CORRELATION_ID_KEY]) !== null && _b !== void 0 ? _b : (0, crypto_1.randomUUID)();
                                 if (correlationId) {
                                     contextService.setCorrelationId(correlationId);
                                 }
@@ -142,6 +142,10 @@ let NestActorManager = NestActorManager_1 = class NestActorManager {
                     if (error.stack) {
                         common_1.Logger.error(error.stack);
                     }
+                    if (serializable_error_1.SerializableError.isSerializableError(error)) {
+                        error.statusCode = (_a = error.statusCode) !== null && _a !== void 0 ? _a : HttpStatusCode_enum_1.default.BAD_REQUEST;
+                        return error;
+                    }
                     throw error;
                 }
             });
@@ -182,6 +186,38 @@ let NestActorManager = NestActorManager_1 = class NestActorManager {
             });
         };
     }
+    patchFireTimer() {
+        const originalFireTimer = ActorManager_1.default.prototype.fireTimer;
+        if (!originalFireTimer)
+            return;
+        ActorManager_1.default.prototype.fireTimer = function (actorId, timerName, requestBody) {
+            return __awaiter(this, void 0, void 0, function* () {
+                try {
+                    return yield originalFireTimer.bind(this)(actorId, timerName, requestBody);
+                }
+                catch (error) {
+                    common_1.Logger.error(`Error firing timer ${timerName} for actor ${actorId}`);
+                    common_1.Logger.error(error);
+                }
+            });
+        };
+    }
+    patchFireReminder() {
+        const originalFireReminder = ActorManager_1.default.prototype.fireReminder;
+        if (!originalFireReminder)
+            return;
+        ActorManager_1.default.prototype.fireReminder = function (actorId, reminderName, requestBody) {
+            return __awaiter(this, void 0, void 0, function* () {
+                try {
+                    return yield originalFireReminder.bind(this)(actorId, reminderName, requestBody);
+                }
+                catch (error) {
+                    common_1.Logger.error(`Error firing reminder ${reminderName} for actor ${actorId}`);
+                    common_1.Logger.error(error);
+                }
+            });
+        };
+    }
     patchDeactivate(options) {
         var _a, _b;
         const isLoggingEnabled = (_b = (_a = options === null || options === void 0 ? void 0 : options.logging) === null || _a === void 0 ? void 0 : _a.enabled) !== null && _b !== void 0 ? _b : true;

package/dist/dapr.loader.d.ts

@@ -25,9 +25,10 @@ export declare class DaprLoader implements OnApplicationBootstrap, OnApplication
     constructor(discoveryService: DiscoveryService, metadataScanner: MetadataScanner, daprServer: DaprServer, daprMetadataAccessor: DaprMetadataAccessor, options: DaprModuleOptions, daprActorClient: DaprActorClient, moduleRef: ModuleRef, contextService: DaprContextService, pubSubClient: DaprPubSubClient, workflowClient: DaprWorkflowClient, actorManager: NestActorManager);
     onApplicationBootstrap(): Promise<void>;
     onApplicationShutdown(): Promise<void>;
-    loadDaprHandlers(isActorsEnabled: boolean, isWorkflowEnabled: boolean): void;
+    loadDaprHandlers(isActorsEnabled: boolean, isWorkflowEnabled: boolean): Promise<void>;
     private subscribeToDaprPubSubEventIfListener;
     private subscribeToDaprBindingEventIfListener;
+    private registerHandlers;
     private registerActivity;
     private registerWorkflow;
     private registerActor;

package/dist/dapr.loader.js

@@ -20,15 +20,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 var DaprLoader_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DaprLoader = void 0;
 const dapr_1 = require("@dapr/dapr");
-const ActorManager_1 = __importDefault(require("@dapr/dapr/actors/runtime/ActorManager"));
-const ActorRuntime_1 = __importDefault(require("@dapr/dapr/actors/runtime/ActorRuntime"));
 const common_1 = require("@nestjs/common");
 const core_1 = require("@nestjs/core");
 const dapr_actor_client_service_1 = require("./actors/dapr-actor-client.service");
@@ -56,45 +51,38 @@ let DaprLoader = DaprLoader_1 = class DaprLoader {
         this.logger = new common_1.Logger(DaprLoader_1.name);
     }
     onApplicationBootstrap() {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
         return __awaiter(this, void 0, void 0, function* () {
             this.logger.log('Dapr initializing');
             const isEnabled = !this.options.disabled;
             const isActorsEnabled = (_b = (_a = this.options.actorOptions) === null || _a === void 0 ? void 0 : _a.enabled) !== null && _b !== void 0 ? _b : true;
             const isWorkflowEnabled = (_d = (_c = this.options.workflowOptions) === null || _c === void 0 ? void 0 : _c.enabled) !== null && _d !== void 0 ? _d : false;
+            if (isActorsEnabled && isEnabled) {
+                this.logger.log('Registering Dapr actors');
+                yield this.daprServer.actor.init();
+            }
             if (isWorkflowEnabled) {
                 this.workflowRuntime = new dapr_1.WorkflowRuntime({
                     daprHost: this.options.serverHost,
                     daprPort: (_f = (_e = this.options.workflowOptions) === null || _e === void 0 ? void 0 : _e.daprPort) !== null && _f !== void 0 ? _f : '3501',
                 });
             }
+            if ((_g = this.options.pubsubOptions) === null || _g === void 0 ? void 0 : _g.defaultName) {
+                this.pubSubClient.setDefaultName(this.options.pubsubOptions.defaultName);
+            }
+            yield this.loadDaprHandlers(isActorsEnabled, isWorkflowEnabled);
             if (isActorsEnabled) {
                 this.actorManager.setup(this.moduleRef, this.options);
                 if (this.options.contextProvider !== dapr_module_1.DaprContextProvider.None) {
                     this.actorManager.setupCSLWrapper(this.options, this.contextService);
                 }
-                if ((_j = (_h = (_g = this.options.clientOptions) === null || _g === void 0 ? void 0 : _g.actor) === null || _h === void 0 ? void 0 : _h.reentrancy) === null || _j === void 0 ? void 0 : _j.enabled) {
+                if ((_k = (_j = (_h = this.options.clientOptions) === null || _h === void 0 ? void 0 : _h.actor) === null || _j === void 0 ? void 0 : _j.reentrancy) === null || _k === void 0 ? void 0 : _k.enabled) {
                     this.actorManager.setupReentrancy(this.options);
                 }
-            }
-            if ((_k = this.options.pubsubOptions) === null || _k === void 0 ? void 0 : _k.defaultName) {
-                this.pubSubClient.setDefaultName(this.options.pubsubOptions.defaultName);
-            }
-            if (isActorsEnabled) {
                 if (this.options.actorOptions) {
                     this.daprActorClient.setAllowInternalCalls((_m = (_l = this.options.actorOptions) === null || _l === void 0 ? void 0 : _l.allowInternalCalls) !== null && _m !== void 0 ? _m : false);
-                    this.daprActorClient.setPrefix((_p = (_o = this.options.actorOptions) === null || _o === void 0 ? void 0 : _o.prefix) !== null && _p !== void 0 ? _p : '', (_r = (_q = this.options.actorOptions) === null || _q === void 0 ? void 0 : _q.delimiter) !== null && _r !== void 0 ? _r : '-');
-                    this.daprActorClient.setTypeNamePrefix((_t = (_s = this.options.actorOptions) === null || _s === void 0 ? void 0 : _s.typeNamePrefix) !== null && _t !== void 0 ? _t : '');
-                    if ((_u = this.options.actorOptions) === null || _u === void 0 ? void 0 : _u.prefix) {
-                        this.logger.log(`Actors will be prefixed with ${(_w = (_v = this.options.actorOptions) === null || _v === void 0 ? void 0 : _v.prefix) !== null && _w !== void 0 ? _w : ''} and delimited with ${(_y = (_x = this.options.actorOptions) === null || _x === void 0 ? void 0 : _x.delimiter) !== null && _y !== void 0 ? _y : '-'}`);
-                    }
-                }
-                if (isEnabled) {
-                    this.logger.log('Registering Dapr actors');
-                    yield this.daprServer.actor.init();
                 }
             }
-            this.loadDaprHandlers(isActorsEnabled, isWorkflowEnabled);
             if (isEnabled && this.options.serverPort !== '0') {
                 this.logger.log('Starting Dapr server');
                 if (this.options.catchErrors) {
@@ -111,12 +99,12 @@ let DaprLoader = DaprLoader_1 = class DaprLoader {
                 yield this.daprServer.start();
                 this.logger.log('Dapr server started');
             }
-            if (isEnabled && this.options.workflowOptions.enabled) {
+            if (isEnabled && isWorkflowEnabled) {
                 this.logger.log('Starting Dapr workflow runtime');
                 yield this.workflowRuntime.start();
                 yield this.workflowClient.start({
                     daprHost: this.options.serverHost,
-                    daprPort: (_z = this.options.workflowOptions.daprPort) !== null && _z !== void 0 ? _z : '3501',
+                    daprPort: (_o = this.options.workflowOptions.daprPort) !== null && _o !== void 0 ? _o : '3501',
                 });
             }
             if (!isActorsEnabled || !isEnabled)
@@ -155,44 +143,34 @@ let DaprLoader = DaprLoader_1 = class DaprLoader {
         });
     }
     loadDaprHandlers(isActorsEnabled, isWorkflowEnabled) {
-        const providers = this.discoveryService.getProviders();
-        if (isActorsEnabled) {
-            providers
-                .filter((wrapper) => wrapper.isDependencyTreeStatic() &&
-                wrapper.metatype &&
-                this.daprMetadataAccessor.getDaprActorMetadata(wrapper.metatype))
-                .forEach((wrapper) => __awaiter(this, void 0, void 0, function* () {
-                yield this.registerActor(wrapper.metatype);
-            }));
-        }
-        const controllers = this.discoveryService.getControllers();
-        [...providers, ...controllers]
-            .filter((wrapper) => wrapper.isDependencyTreeStatic())
-            .filter((wrapper) => wrapper.instance)
-            .forEach((wrapper) => __awaiter(this, void 0, void 0, function* () {
-            const { instance } = wrapper;
-            const prototype = Object.getPrototypeOf(instance) || {};
-            this.metadataScanner.scanFromPrototype(instance, prototype, (methodKey) => __awaiter(this, void 0, void 0, function* () {
-                yield this.subscribeToDaprPubSubEventIfListener(instance, methodKey);
-                yield this.subscribeToDaprBindingEventIfListener(instance, methodKey);
-            }));
-        }));
-        if (isWorkflowEnabled) {
-            providers
-                .filter((wrapper) => wrapper.isDependencyTreeStatic() &&
-                wrapper.metatype &&
-                this.daprMetadataAccessor.getDaprActivityMetadata(wrapper.metatype))
-                .forEach((wrapper) => __awaiter(this, void 0, void 0, function* () {
-                yield this.registerActivity(wrapper.metatype);
-            }));
-            providers
-                .filter((wrapper) => wrapper.isDependencyTreeStatic() &&
-                wrapper.metatype &&
-                this.daprMetadataAccessor.getDaprWorkflowMetadata(wrapper.metatype))
-                .forEach((wrapper) => __awaiter(this, void 0, void 0, function* () {
-                yield this.registerWorkflow(wrapper.metatype);
-            }));
-        }
+        return __awaiter(this, void 0, void 0, function* () {
+            const providers = this.discoveryService.getProviders();
+            if (isActorsEnabled) {
+                for (const instanceWrapper of providers.filter((wrapper) => wrapper.isDependencyTreeStatic() &&
+                    wrapper.metatype &&
+                    this.daprMetadataAccessor.getDaprActorMetadata(wrapper.metatype))) {
+                    yield this.registerActor(instanceWrapper.metatype);
+                }
+            }
+            const controllers = this.discoveryService.getControllers();
+            for (const instanceWrapper of [...providers, ...controllers]
+                .filter((wrapper) => wrapper.isDependencyTreeStatic())
+                .filter((wrapper) => wrapper.instance)) {
+                yield this.registerHandlers(instanceWrapper);
+            }
+            if (isWorkflowEnabled) {
+                for (const instanceWrapper of providers.filter((wrapper) => wrapper.isDependencyTreeStatic() &&
+                    wrapper.metatype &&
+                    this.daprMetadataAccessor.getDaprActivityMetadata(wrapper.metatype))) {
+                    yield this.registerActivity(instanceWrapper.metatype);
+                }
+                for (const instanceWrapper of providers.filter((wrapper) => wrapper.isDependencyTreeStatic() &&
+                    wrapper.metatype &&
+                    this.daprMetadataAccessor.getDaprWorkflowMetadata(wrapper.metatype))) {
+                    yield this.registerWorkflow(instanceWrapper.metatype);
+                }
+            }
+        });
     }
     subscribeToDaprPubSubEventIfListener(instance, methodKey) {
         var _a, _b;
@@ -244,6 +222,16 @@ let DaprLoader = DaprLoader_1 = class DaprLoader {
             }));
         });
     }
+    registerHandlers(instanceWrapper) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const instance = instanceWrapper.instance;
+            const prototype = Object.getPrototypeOf(instance) || {};
+            this.metadataScanner.scanFromPrototype(instance, prototype, (methodKey) => __awaiter(this, void 0, void 0, function* () {
+                yield this.subscribeToDaprPubSubEventIfListener(instance, methodKey);
+                yield this.subscribeToDaprBindingEventIfListener(instance, methodKey);
+            }));
+        });
+    }
     registerActivity(activityType) {
         var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
@@ -275,29 +263,14 @@ let DaprLoader = DaprLoader_1 = class DaprLoader {
         });
     }
     registerActor(actorType) {
-        var _a, _b, _c, _d, _e;
+        var _a, _b, _c, _d;
         return __awaiter(this, void 0, void 0, function* () {
             if (!actorType)
                 return;
-            let actorTypeName = (_a = actorType.name) !== null && _a !== void 0 ? _a : actorType.constructor.name;
             const daprActorMetadata = this.daprMetadataAccessor.getDaprActorMetadata(actorType);
+            const actorTypeName = (_a = actorType.name) !== null && _a !== void 0 ? _a : actorType.constructor.name;
             const interfaceTypeName = (_c = (_b = daprActorMetadata === null || daprActorMetadata === void 0 ? void 0 : daprActorMetadata.interfaceType) === null || _b === void 0 ? void 0 : _b.name) !== null && _c !== void 0 ? _c : (_d = daprActorMetadata === null || daprActorMetadata === void 0 ? void 0 : daprActorMetadata.interfaceType) === null || _d === void 0 ? void 0 : _d.constructor.name;
-            if ((_e = this.options.actorOptions) === null || _e === void 0 ? void 0 : _e.typeNamePrefix) {
-                actorTypeName = this.options.actorOptions.typeNamePrefix + actorTypeName;
-                try {
-                    const actorManager = ActorRuntime_1.default.getInstanceByDaprClient(this.daprServer.client);
-                    const managers = actorManager['actorManagers'];
-                    if (!managers.has(actorTypeName)) {
-                        managers.set(actorTypeName, new ActorManager_1.default(actorType, this.daprServer.client));
-                    }
-                }
-                catch (err) {
-                    yield this.daprServer.actor.registerActor(actorType);
-                }
-            }
-            else {
-                yield this.daprServer.actor.registerActor(actorType);
-            }
+            yield this.daprServer.actor.registerActor(actorType);
             this.logger.log(`Registering Dapr Actor: ${actorTypeName} of type ${interfaceTypeName !== null && interfaceTypeName !== void 0 ? interfaceTypeName : 'unknown'}`);
             this.daprActorClient.register(actorTypeName, actorType, this.daprServer.client);
             if (daprActorMetadata.interfaceType) {

package/dist/dapr.module.d.ts

@@ -22,9 +22,6 @@ export interface DaprModuleLoggingOptions {
 }
 export interface DaprModuleActorOptions {
     enabled: boolean;
-    prefix?: string;
-    delimiter?: string;
-    typeNamePrefix?: string;
     allowInternalCalls?: boolean;
 }
 export interface DaprModuleWorkflowOptions {

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@rayondigital/nest-dapr",
-  "version": "0.10.2",
-  "description": "Develop NestJs microservices using Dapr pubsub, actors and other bindings",
+  "version": "0.10.5",
+  "description": "Develop NestJs microservices using Dapr pubsub, actors, workflows and other bindings",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "scripts": {
     "build": "rimraf -rf dist && tsc -p tsconfig.json",
     "lint": "eslint \"{lib,tests}/**/*.ts\" --fix",
     "test": "jest --runInBand",
-    "test:in-memory": "dapr run --app-id testing --app-protocol http --app-port 3001 --dapr-http-port 3500 --resources-path ./tests/components npm run test",
+    "test:in-memory": "dapr run --app-id testing --app-protocol http --app-port 3001 --dapr-http-port 3500 --dapr-grpc-port 3501 --resources-path ./tests/components npm run test",
     "start:test": "nodemon tests/e2e/main.ts",
     "push:version": "git push --follow-tags"
   },

package/dist/util/json.util.d.ts

@@ -1 +0,0 @@
-export declare function fromJson(json: any): any;

package/dist/util/json.util.js

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fromJson = void 0;
-function fromJson(json) {
-    try {
-        if (typeof json === 'string') {
-            const isJson = json.includes('{') || json.includes('[');
-            if (isJson)
-                return JSON.parse(json);
-        }
-        return json;
-    }
-    catch (error) {
-        return json;
-    }
-}
-exports.fromJson = fromJson;