@rayondigital/nest-dapr 0.9.17 → 0.9.18

package/dist/actors/abstract-actor.d.ts

@@ -0,0 +1,36 @@
+import ActorId from '@dapr/dapr/actors/ActorId';
+import ActorStateManager from '@dapr/dapr/actors/runtime/ActorStateManager';
+import StateProvider from '@dapr/dapr/actors/runtime/StateProvider';
+import DaprClient from '@dapr/dapr/implementation/Client/DaprClient';
+import { Temporal } from '@js-temporal/polyfill';
+export declare abstract class AbstractActor {
+    private readonly stateManager;
+    private readonly id;
+    private readonly daprClient;
+    private readonly actorClient;
+    private readonly daprStateProvider;
+    private readonly actorType;
+    private readonly daprLogger;
+    constructor(daprClient: DaprClient, id: ActorId);
+    registerActorReminder<_Type>(reminderName: string, dueTime: Temporal.Duration, period?: Temporal.Duration, ttl?: Temporal.Duration, state?: any): Promise<void>;
+    unregisterActorReminder(reminderName: string): Promise<void>;
+    registerActorTimer(timerName: string, callback: string, dueTime: Temporal.Duration, period?: Temporal.Duration, ttl?: Temporal.Duration, state?: any): Promise<void>;
+    unregisterActorTimer(timerName: string): Promise<void>;
+    onActivateInternal(): Promise<void>;
+    onDeactivateInternal(): Promise<void>;
+    onActorMethodPreInternal(): Promise<void>;
+    onActorMethodPostInternal(): Promise<void>;
+    resetStateInternal(): Promise<void>;
+    saveStateInternal(): Promise<void>;
+    onActivate(): Promise<void>;
+    onDeactivate(): Promise<void>;
+    onActorMethodPre(): Promise<void>;
+    onActorMethodPost(): Promise<void>;
+    receiveReminder(_data: string): Promise<void>;
+    getDaprClient(): DaprClient;
+    getStateProvider(): StateProvider;
+    getStateManager<T>(): ActorStateManager<T>;
+    getActorId(): ActorId;
+    getActorType(): any;
+    getId(): string;
+}

package/dist/actors/abstract-actor.js

@@ -0,0 +1,143 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        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.AbstractActor = void 0;
+const ActorStateManager_1 = __importDefault(require("@dapr/dapr/actors/runtime/ActorStateManager"));
+const Logger_1 = require("@dapr/dapr/logger/Logger");
+const polyfill_1 = require("@js-temporal/polyfill");
+const client_cache_1 = require("./client-cache");
+class AbstractActor {
+    constructor(daprClient, id) {
+        this.daprClient = daprClient;
+        this.actorClient = client_cache_1.DaprClientCache.getOrCreateActorClientFromOptions(daprClient.options);
+        this.daprLogger = new Logger_1.Logger('Actors', 'AbstractActor', daprClient.options.logger);
+        this.id = id;
+        this.stateManager = new ActorStateManager_1.default(this);
+        this.daprStateProvider = client_cache_1.DaprClientCache.getOrCreateStateProviderFromOptions(daprClient.options);
+        this.actorType = this.constructor.name;
+    }
+    registerActorReminder(reminderName, dueTime, period, ttl, state) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.actorClient.actor.registerActorReminder(this.actorType, this.id, reminderName, {
+                period: period !== null && period !== void 0 ? period : polyfill_1.Temporal.Duration.from({ hours: 1 }),
+                dueTime,
+                ttl,
+                data: state,
+            });
+        });
+    }
+    unregisterActorReminder(reminderName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.actorClient.actor.unregisterActorReminder(this.actorType, this.id, reminderName);
+        });
+    }
+    registerActorTimer(timerName, callback, dueTime, period, ttl, state) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.actorClient.actor.registerActorTimer(this.actorType, this.id, timerName, {
+                period: period !== null && period !== void 0 ? period : polyfill_1.Temporal.Duration.from({ hours: 12 }),
+                dueTime,
+                ttl,
+                data: state,
+                callback,
+            });
+        });
+    }
+    unregisterActorTimer(timerName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.actorClient.actor.unregisterActorTimer(this.actorType, this.id, timerName);
+        });
+    }
+    onActivateInternal() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.resetStateInternal();
+            yield this.onActivate();
+            yield this.saveStateInternal();
+        });
+    }
+    onDeactivateInternal() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.resetStateInternal();
+            yield this.onDeactivate();
+            yield this.saveStateInternal();
+        });
+    }
+    onActorMethodPreInternal() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.onActorMethodPre();
+        });
+    }
+    onActorMethodPostInternal() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.onActorMethodPost();
+            yield this.saveStateInternal();
+        });
+    }
+    resetStateInternal() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.stateManager.clearCache();
+        });
+    }
+    saveStateInternal() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.stateManager.saveState();
+        });
+    }
+    onActivate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return;
+        });
+    }
+    onDeactivate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return;
+        });
+    }
+    onActorMethodPre() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return;
+        });
+    }
+    onActorMethodPost() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return;
+        });
+    }
+    receiveReminder(_data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.daprLogger.warn(JSON.stringify({
+                error: 'ACTOR_METHOD_NOT_IMPLEMENTED',
+                errorMsg: `A reminder was created for the actor with id: ${this.id} but the method 'receiveReminder' was not implemented`,
+            }));
+        });
+    }
+    getDaprClient() {
+        return this.daprClient;
+    }
+    getStateProvider() {
+        return this.daprStateProvider;
+    }
+    getStateManager() {
+        return this.stateManager;
+    }
+    getActorId() {
+        return this.id;
+    }
+    getActorType() {
+        return this.actorType;
+    }
+    getId() {
+        return this.getActorId().getId();
+    }
+}
+exports.AbstractActor = AbstractActor;

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

@@ -5,6 +5,7 @@ export declare class DaprClientCache {
     private static clients;
     private static actorClients;
     private static stateProviders;
+    static getDaprClient(): DaprClient | undefined;
     static getAllClients(): DaprClient[];
     static getAllActorClients(): ActorClient[];
     static getAllStateProviders(): StateProvider[];

package/dist/actors/client-cache.js

@@ -15,6 +15,11 @@ const ActorClient_1 = __importDefault(require("@dapr/dapr/actors/client/ActorCli
 const StateProvider_1 = __importDefault(require("@dapr/dapr/actors/runtime/StateProvider"));
 const common_1 = require("@nestjs/common");
 let DaprClientCache = class DaprClientCache {
+    static getDaprClient() {
+        if (this.clients.size === 0)
+            return undefined;
+        return this.clients.entries().next().value[1];
+    }
     static getAllClients() {
         return Array.from(this.clients.values());
     }

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

@@ -1,4 +1,4 @@
-import { AbstractActor } from '@dapr/dapr';
+import { AbstractActor } from './abstract-actor';
 export interface IState {
     fromJSON(json: any): this;
     toJSON(): any;

package/dist/actors/stateful.actor.js

@@ -10,9 +10,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StatefulActor = void 0;
-const dapr_1 = require("@dapr/dapr");
 const constants_1 = require("../constants");
-class StatefulActor extends dapr_1.AbstractActor {
+const abstract_actor_1 = require("./abstract-actor");
+class StatefulActor extends abstract_actor_1.AbstractActor {
     setState(stateName, value) {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.getStateManager().setState(stateName, value);

package/package.json

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