@rayondigital/nest-dapr 0.9.15 → 0.9.17

package/dist/actors/actor-proxy-builder.js

@@ -8,14 +8,11 @@ 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 };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ActorProxyBuilder = void 0;
-const ActorClient_1 = __importDefault(require("@dapr/dapr/actors/client/ActorClient/ActorClient"));
-const dapr_context_service_1 = require("../dapr-context-service");
 const common_1 = require("@nestjs/common");
+const dapr_context_service_1 = require("../dapr-context-service");
+const client_cache_1 = require("./client-cache");
 class ActorProxyBuilder {
     constructor(moduleRef, actorTypeClass, ...args) {
         this.moduleRef = moduleRef;
@@ -25,11 +22,12 @@ class ActorProxyBuilder {
         this.actorTypeClass = actorTypeClass;
         if (args.length == 1) {
             const [daprClient] = args;
-            this.actorClient = new ActorClient_1.default(daprClient.options.daprHost, daprClient.options.daprPort, daprClient.options.communicationProtocol, daprClient.options);
+            this.actorClient = client_cache_1.DaprClientCache.getOrCreateActorClientFromClient(daprClient);
         }
         else {
             const [host, port, communicationProtocol, clientOptions] = args;
-            this.actorClient = new ActorClient_1.default(host, port, communicationProtocol, clientOptions);
+            const options = Object.assign({ daprHost: host, daprPort: port, communicationProtocol: communicationProtocol }, clientOptions);
+            this.actorClient = client_cache_1.DaprClientCache.getOrCreateActorClientFromOptions(options);
         }
     }
     build(actorId, actorTypeName) {

package/dist/actors/client-cache.d.ts

@@ -0,0 +1,18 @@
+import { DaprClient, DaprClientOptions } from '@dapr/dapr';
+import ActorClient from '@dapr/dapr/actors/client/ActorClient/ActorClient';
+import StateProvider from '@dapr/dapr/actors/runtime/StateProvider';
+export declare class DaprClientCache {
+    private static clients;
+    private static actorClients;
+    private static stateProviders;
+    static getAllClients(): DaprClient[];
+    static getAllActorClients(): ActorClient[];
+    static getAllStateProviders(): StateProvider[];
+    static getClientByHost(host: string): DaprClient | undefined;
+    static getActorClientByHost(host: string): ActorClient | undefined;
+    static getStateProviderByHost(host: string): StateProvider | undefined;
+    static getOrCreateActorClientFromClient(daprClient: DaprClient): ActorClient;
+    static getOrCreateStateProviderFromOptions(options: DaprClientOptions): StateProvider;
+    static getOrCreateActorClientFromOptions(options: DaprClientOptions): ActorClient;
+    static getOrCreateClientFromOptions(options: DaprClientOptions): DaprClient;
+}

package/dist/actors/client-cache.js

@@ -0,0 +1,77 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DaprClientCache = void 0;
+const dapr_1 = require("@dapr/dapr");
+const ActorClient_1 = __importDefault(require("@dapr/dapr/actors/client/ActorClient/ActorClient"));
+const StateProvider_1 = __importDefault(require("@dapr/dapr/actors/runtime/StateProvider"));
+const common_1 = require("@nestjs/common");
+let DaprClientCache = class DaprClientCache {
+    static getAllClients() {
+        return Array.from(this.clients.values());
+    }
+    static getAllActorClients() {
+        return Array.from(this.actorClients.values());
+    }
+    static getAllStateProviders() {
+        return Array.from(this.stateProviders.values());
+    }
+    static getClientByHost(host) {
+        return this.clients.get(host);
+    }
+    static getActorClientByHost(host) {
+        return this.actorClients.get(host);
+    }
+    static getStateProviderByHost(host) {
+        return this.stateProviders.get(host);
+    }
+    static getOrCreateActorClientFromClient(daprClient) {
+        if (this.actorClients.has(daprClient.options.daprHost)) {
+            return this.actorClients.get(daprClient.options.daprHost);
+        }
+        if (!this.clients.has(daprClient.options.daprHost)) {
+            this.clients.set(daprClient.options.daprHost, daprClient);
+        }
+        return this.getOrCreateActorClientFromOptions(daprClient.options);
+    }
+    static getOrCreateStateProviderFromOptions(options) {
+        if (this.stateProviders.has(options.daprHost)) {
+            return this.stateProviders.get(options.daprHost);
+        }
+        const actorClient = this.getOrCreateActorClientFromOptions(options);
+        const stateProvider = new StateProvider_1.default(actorClient);
+        this.stateProviders.set(options.daprHost, stateProvider);
+        return stateProvider;
+    }
+    static getOrCreateActorClientFromOptions(options) {
+        if (this.actorClients.has(options.daprHost)) {
+            return this.actorClients.get(options.daprHost);
+        }
+        const client = new ActorClient_1.default(options.daprHost, options.daprPort, options.communicationProtocol, options);
+        this.actorClients.set(options.daprHost, client);
+        return client;
+    }
+    static getOrCreateClientFromOptions(options) {
+        if (this.clients.has(options.daprHost)) {
+            return this.clients.get(options.daprHost);
+        }
+        const client = new dapr_1.DaprClient(options);
+        this.clients.set(options.daprHost, client);
+        return client;
+    }
+};
+DaprClientCache.clients = new Map();
+DaprClientCache.actorClients = new Map();
+DaprClientCache.stateProviders = new Map();
+DaprClientCache = __decorate([
+    (0, common_1.Injectable)()
+], DaprClientCache);
+exports.DaprClientCache = DaprClientCache;

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

@@ -4,7 +4,7 @@ import { ModuleRef } from '@nestjs/core';
 export declare class DaprActorClient {
     private readonly moduleRef;
     private readonly daprClient;
-    private actorClients;
+    private actorProxyBuilders;
     private interfaces;
     private interfaceToActorTypeNames;
     private prefix;
@@ -21,5 +21,5 @@ export declare class DaprActorClient {
     getActorTypeName(typeName: string): string;
     contains(actorTypeName: string): boolean;
     private formatActorTypeName;
-    private getActorClient;
+    private getActorClientProxyBuilder;
 }

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

@@ -18,7 +18,7 @@ let DaprActorClient = class DaprActorClient {
     constructor(moduleRef, daprClient) {
         this.moduleRef = moduleRef;
         this.daprClient = daprClient;
-        this.actorClients = new Map();
+        this.actorProxyBuilders = new Map();
         this.interfaces = new Map();
         this.interfaceToActorTypeNames = new Map();
         this.prefix = '';
@@ -34,7 +34,7 @@ let DaprActorClient = class DaprActorClient {
     }
     register(actorTypeName, actorType, daprClient) {
         this.interfaces.set(this.formatActorTypeName(actorTypeName), actorType);
-        this.actorClients.set(this.formatActorTypeName(actorTypeName), new actor_proxy_builder_1.ActorProxyBuilder(this.moduleRef, actorType, daprClient !== null && daprClient !== void 0 ? daprClient : this.daprClient));
+        this.actorProxyBuilders.set(this.formatActorTypeName(actorTypeName), new actor_proxy_builder_1.ActorProxyBuilder(this.moduleRef, actorType, daprClient !== null && daprClient !== void 0 ? daprClient : this.daprClient));
     }
     registerInterface(actorType, interfaceType, daprClient) {
         var _a, _b;
@@ -42,7 +42,7 @@ let DaprActorClient = class DaprActorClient {
         const actorTypeName = (_b = actorType.name) !== null && _b !== void 0 ? _b : actorType.constructor.name;
         this.interfaceToActorTypeNames.set(interfaceTypeName, actorTypeName);
         this.interfaces.set(this.formatActorTypeName(interfaceTypeName), actorType);
-        this.actorClients.set(this.formatActorTypeName(interfaceTypeName), new actor_proxy_builder_1.ActorProxyBuilder(this.moduleRef, actorType, daprClient !== null && daprClient !== void 0 ? daprClient : this.daprClient));
+        this.actorProxyBuilders.set(this.formatActorTypeName(interfaceTypeName), new actor_proxy_builder_1.ActorProxyBuilder(this.moduleRef, actorType, daprClient !== null && daprClient !== void 0 ? daprClient : this.daprClient));
     }
     getActorId(actorId) {
         var _a;
@@ -62,7 +62,7 @@ let DaprActorClient = class DaprActorClient {
             throw new Error(`Actor ${actorTypeName} not found`);
         }
         const fullActorId = this.getActorId(actorId);
-        const actorClient = this.getActorClient(actorTypeName);
+        const actorClient = this.getActorClientProxyBuilder(actorTypeName);
         return actorClient.build(fullActorId, actorTypeName);
     }
     getActorByTypeName(actorTypeName, actorId) {
@@ -76,13 +76,13 @@ let DaprActorClient = class DaprActorClient {
             throw new Error(`Actor ${actorTypeName} not found`);
         }
         const fullActorId = this.getActorId(actorId);
-        const actorClient = this.getActorClient(actorTypeName);
+        const actorClient = this.getActorClientProxyBuilder(actorTypeName);
         return actorClient.build(fullActorId, actorTypeName);
     }
     getActorTypeName(typeName) {
         if (this.interfaceToActorTypeNames.has(typeName)) {
             const actorTypeName = this.interfaceToActorTypeNames.get(typeName);
-            if (this.actorClients.has(actorTypeName)) {
+            if (this.actorProxyBuilders.has(actorTypeName)) {
                 return actorTypeName;
             }
             else {
@@ -95,18 +95,17 @@ let DaprActorClient = class DaprActorClient {
         return typeName;
     }
     contains(actorTypeName) {
-        return this.actorClients.has(this.formatActorTypeName(actorTypeName));
+        return this.actorProxyBuilders.has(this.formatActorTypeName(actorTypeName));
     }
     formatActorTypeName(actorTypeName) {
         return actorTypeName.toLowerCase();
     }
-    getActorClient(actorTypeName) {
-        return this.actorClients.get(this.formatActorTypeName(actorTypeName));
+    getActorClientProxyBuilder(actorTypeName) {
+        return this.actorProxyBuilders.get(this.formatActorTypeName(actorTypeName));
     }
 };
 DaprActorClient = __decorate([
     (0, common_1.Injectable)(),
-    __metadata("design:paramtypes", [core_1.ModuleRef,
-        dapr_1.DaprClient])
+    __metadata("design:paramtypes", [core_1.ModuleRef, dapr_1.DaprClient])
 ], DaprActorClient);
 exports.DaprActorClient = DaprActorClient;

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

@@ -4,7 +4,6 @@ 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,8 +23,6 @@ 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");
@@ -51,40 +49,18 @@ let NestActorManager = NestActorManager_1 = class NestActorManager {
                 return instance;
             });
         };
-    }
-    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;
+        const originalDeactivateActor = ActorManager_1.default.prototype.deactivateActor;
+        ActorManager_1.default.prototype.deactivateActor = function (actorId) {
             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;
+                    if (!this.actors.has(actorId.getId())) {
+                        return;
                     }
-                    return yield this.callActorMethod(actorId, methodName !== null && methodName !== void 0 ? methodName : 'receiveReminder', [reminderState, reminderName]);
+                    yield originalDeactivateActor.bind(this)(actorId);
                 }
                 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;
+                    common_1.Logger.error(`Error deactivating actor ${actorId}`);
+                    common_1.Logger.error(error);
                 }
             });
         };

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 createStatePropertyInstance;
+    private createInstance;
 }

package/dist/actors/stateful.actor.js

@@ -59,12 +59,18 @@ class StatefulActor extends dapr_1.AbstractActor {
                         this[property.key] = property.defaultValue;
                     }
                     else {
-                        this[property.key] = this.createStatePropertyInstance(property);
+                        this[property.key] = this.createInstance(property.type);
                     }
                 }
                 else {
                     if (property.serializable) {
-                        const instance = this.createStatePropertyInstance(property);
+                        let instance;
+                        if (typeof property.defaultValue === 'function') {
+                            instance = property.defaultValue();
+                        }
+                        else {
+                            instance = this.createInstance(property.type);
+                        }
                         this[property.key] = (_a = instance.fromJSON(rawValue)) !== null && _a !== void 0 ? _a : instance;
                     }
                     else {
@@ -104,18 +110,9 @@ class StatefulActor extends dapr_1.AbstractActor {
             }
         });
     }
-    createStatePropertyInstance(property) {
+    createInstance(type) {
         try {
-            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();
-            }
+            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) | Function | Type<any>;
+    defaultValue?: any;
     serializable?: boolean;
 }
 export declare function State(options?: {
-    defaultValue?: (() => any) | Function | Type<any>;
+    defaultValue?: any;
     name?: string;
 }): PropertyDecorator;

package/dist/dapr.loader.js

@@ -57,7 +57,6 @@ 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/dist/index.d.ts

@@ -1,3 +1,4 @@
+import { DaprClientCache } from './actors/client-cache';
 import { DaprActorClient } from './actors/dapr-actor-client.service';
 import { StatefulActorOf } from './actors/stateful-actor-of';
 import { IState, StatefulActor } from './actors/stateful.actor';
@@ -10,4 +11,4 @@ import { DaprMetadataAccessor } from './dapr-metadata.accessor';
 import { DaprPubSub, DaprPubSubMetadata } from './dapr-pubsub.decorator';
 import { DaprLoader } from './dapr.loader';
 import { DaprModule } from './dapr.module';
-export { DAPR_BINDING_METADATA, DAPR_PUBSUB_METADATA, DAPR_ACTOR_METADATA, DAPR_ACTOR_STATE_METADATA, DaprMetadataAccessor, DaprBindingMetadata, DaprBinding, DaprPubSubMetadata, DaprPubSub, DaprActorMetadata, State, DaprActor, DaprLoader, DaprModule, DaprActorClient, DaprContextService, StatefulActor, StatefulActorOf, IState, };
+export { DAPR_BINDING_METADATA, DAPR_PUBSUB_METADATA, DAPR_ACTOR_METADATA, DAPR_ACTOR_STATE_METADATA, DaprMetadataAccessor, DaprBindingMetadata, DaprBinding, DaprPubSubMetadata, DaprPubSub, DaprActorMetadata, State, DaprActor, DaprLoader, DaprModule, DaprActorClient, DaprContextService, DaprClientCache, StatefulActor, StatefulActorOf, IState, };

package/dist/index.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.StatefulActorOf = exports.StatefulActor = exports.DaprContextService = exports.DaprActorClient = exports.DaprModule = exports.DaprLoader = exports.DaprActor = exports.State = exports.DaprPubSub = exports.DaprBinding = exports.DaprMetadataAccessor = exports.DAPR_ACTOR_STATE_METADATA = exports.DAPR_ACTOR_METADATA = exports.DAPR_PUBSUB_METADATA = exports.DAPR_BINDING_METADATA = void 0;
+exports.StatefulActorOf = exports.StatefulActor = exports.DaprClientCache = exports.DaprContextService = exports.DaprActorClient = exports.DaprModule = exports.DaprLoader = exports.DaprActor = exports.State = exports.DaprPubSub = exports.DaprBinding = exports.DaprMetadataAccessor = exports.DAPR_ACTOR_STATE_METADATA = exports.DAPR_ACTOR_METADATA = exports.DAPR_PUBSUB_METADATA = exports.DAPR_BINDING_METADATA = void 0;
+const client_cache_1 = require("./actors/client-cache");
+Object.defineProperty(exports, "DaprClientCache", { enumerable: true, get: function () { return client_cache_1.DaprClientCache; } });
 const dapr_actor_client_service_1 = require("./actors/dapr-actor-client.service");
 Object.defineProperty(exports, "DaprActorClient", { enumerable: true, get: function () { return dapr_actor_client_service_1.DaprActorClient; } });
 const stateful_actor_of_1 = require("./actors/stateful-actor-of");

package/package.json

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