@rayondigital/nest-dapr 0.9.13 → 0.9.15

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

@@ -4,6 +4,7 @@ import { DaprContextService } from '../dapr-context-service';
 import { DaprModuleActorOptions } from '../dapr.module';
 export declare class NestActorManager {
     setup(moduleRef: ModuleRef, options: DaprModuleActorOptions, onActivateFn?: (actorId: ActorId, instance: AbstractActor) => Promise<void>): void;
+    setupRemindersAndTimers(): void;
     setupReentrancy(): void;
     setupCSLWrapper(contextService: DaprContextService, invokeWrapperFn?: (actorId: ActorId, methodName: string, data: any, method: (actorId: ActorId, methodName: string, data: any) => Promise<any>) => Promise<any>): void;
     private resolveDependencies;

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

@@ -23,6 +23,8 @@ exports.NestActorManager = void 0;
 const crypto_1 = require("crypto");
 const ActorClientHTTP_1 = __importDefault(require("@dapr/dapr/actors/client/ActorClient/ActorClientHTTP"));
 const ActorManager_1 = __importDefault(require("@dapr/dapr/actors/runtime/ActorManager"));
+const ActorReminderData_1 = __importDefault(require("@dapr/dapr/actors/runtime/ActorReminderData"));
+const ActorTimerData_1 = __importDefault(require("@dapr/dapr/actors/runtime/ActorTimerData"));
 const common_1 = require("@nestjs/common");
 const instance_wrapper_1 = require("@nestjs/core/injector/instance-wrapper");
 const dapr_context_service_1 = require("../dapr-context-service");
@@ -50,6 +52,43 @@ let NestActorManager = NestActorManager_1 = class NestActorManager {
             });
         };
     }
+    setupRemindersAndTimers() {
+        const originalFireReminder = ActorManager_1.default.prototype.fireReminder;
+        const originalFireTimer = ActorManager_1.default.prototype.fireTimer;
+        ActorManager_1.default.prototype.fireReminder = function (actorId, reminderName, requestBody) {
+            var _a;
+            return __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const requestBodyDeserialized = this.serializer.deserialize(requestBody || Buffer.from(''));
+                    const reminderData = ActorReminderData_1.default.fromObject(reminderName, requestBodyDeserialized);
+                    const reminderState = reminderData.state;
+                    let methodName = 'receiveReminder';
+                    if (reminderState !== undefined && typeof reminderState === 'object') {
+                        methodName = (_a = reminderState === null || reminderState === void 0 ? void 0 : reminderState.callback) !== null && _a !== void 0 ? _a : reminderState.method;
+                    }
+                    return yield this.callActorMethod(actorId, methodName !== null && methodName !== void 0 ? methodName : 'receiveReminder', [reminderState, reminderName]);
+                }
+                catch (error) {
+                    common_1.Logger.error(`Error firing reminder ${actorId}/${reminderName}`);
+                    throw error;
+                }
+            });
+        };
+        ActorManager_1.default.prototype.fireTimer = function (actorId, timerName, requestBody) {
+            var _a;
+            return __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const requestBodyDeserialized = this.serializer.deserialize(requestBody || Buffer.from(''));
+                    const timerData = ActorTimerData_1.default.fromObject(timerName, requestBodyDeserialized);
+                    return yield this.callActorMethod(actorId, (_a = timerData.callback) !== null && _a !== void 0 ? _a : 'handleTimer', [timerData.state, timerName]);
+                }
+                catch (error) {
+                    common_1.Logger.error(`Error firing timer ${actorId}/${timerName}`);
+                    throw error;
+                }
+            });
+        };
+    }
     setupReentrancy() {
         ActorClientHTTP_1.default.prototype.invoke = function (actorType, actorId, methodName, body, reentrancyId) {
             return __awaiter(this, void 0, void 0, function* () {

package/dist/actors/stateful.actor.d.ts

@@ -13,5 +13,5 @@ export declare class StatefulActor extends AbstractActor {
     getAllState(): Promise<void>;
     setAllStateFromProperties(): Promise<void>;
     getState<T>(stateName: string, defaultValue?: T): Promise<T | undefined>;
-    private createInstance;
+    private createStatePropertyInstance;
 }

package/dist/actors/stateful.actor.js

@@ -59,18 +59,12 @@ class StatefulActor extends dapr_1.AbstractActor {
                         this[property.key] = property.defaultValue;
                     }
                     else {
-                        this[property.key] = this.createInstance(property.type);
+                        this[property.key] = this.createStatePropertyInstance(property);
                     }
                 }
                 else {
                     if (property.serializable) {
-                        let instance;
-                        if (typeof property.defaultValue === 'function') {
-                            instance = property.defaultValue();
-                        }
-                        else {
-                            instance = this.createInstance(property.type);
-                        }
+                        const instance = this.createStatePropertyInstance(property);
                         this[property.key] = (_a = instance.fromJSON(rawValue)) !== null && _a !== void 0 ? _a : instance;
                     }
                     else {
@@ -110,9 +104,18 @@ class StatefulActor extends dapr_1.AbstractActor {
             }
         });
     }
-    createInstance(type) {
+    createStatePropertyInstance(property) {
         try {
-            return new type();
+            if (property.defaultValue !== undefined) {
+                if (property.defaultValue instanceof Function || typeof property.defaultValue === 'function') {
+                    return property.defaultValue();
+                }
+                return property.defaultValue;
+            }
+            if (property.type || property.serializable) {
+                const type = property.type;
+                return new type();
+            }
         }
         catch (e) {
             return undefined;

package/dist/dapr-actor-state.decorator.d.ts

@@ -3,10 +3,10 @@ export interface StateProperty {
     key: string | symbol;
     name: string;
     type: Function | Type<any>;
-    defaultValue?: any;
+    defaultValue?: (() => any) | Function | Type<any>;
     serializable?: boolean;
 }
 export declare function State(options?: {
-    defaultValue?: any;
+    defaultValue?: (() => any) | Function | Type<any>;
     name?: string;
 }): PropertyDecorator;

package/dist/dapr.loader.js

@@ -57,6 +57,7 @@ let DaprLoader = DaprLoader_1 = class DaprLoader {
                 return;
             }
             this.actorManager.setup(this.moduleRef, this.options.actorOptions);
+            this.actorManager.setupRemindersAndTimers();
             if (this.options.contextProvider !== dapr_module_1.DaprContextProvider.None) {
                 this.actorManager.setupCSLWrapper(this.contextService);
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rayondigital/nest-dapr",
-  "version": "0.9.13",
+  "version": "0.9.15",
   "description": "Develop NestJs microservices using Dapr pubsub, actors and other bindings",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",