@rayondigital/nest-dapr 0.9.46 → 0.9.47

package/dist/actors/stateful-actor-of.js

@@ -14,13 +14,13 @@ const stateful_actor_1 = require("./stateful.actor");
 class StatefulActorOf extends stateful_actor_1.StatefulActor {
     saveStateObject() {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.setState('state', this.state);
+            yield this.setStateValue('state', this.state);
             yield this.getStateManager().saveState();
         });
     }
     getStateObject() {
         return __awaiter(this, void 0, void 0, function* () {
-            return yield this.getState('state');
+            return yield this.getStateValue('state');
         });
     }
 }

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

@@ -1,18 +1,29 @@
+import { Logger } from '@nestjs/common';
+import { DaprContextService } from '../dapr-context-service';
 import { AbstractActor } from './abstract-actor';
+import { DaprActorClient } from './dapr-actor-client.service';
+import { ActorId, DaprClient } from '@dapr/dapr';
 export interface IState {
     fromJSON(json: any): this;
     toJSON(): any;
 }
 export declare class StatefulActor extends AbstractActor {
-    private stateProperties;
-    setState<T>(stateName: string, value: T): Promise<void>;
-    removeState(stateName: string): Promise<void>;
-    saveState(): Promise<void>;
-    clearState(): Promise<void>;
+    private statePropertiesInternal;
+    protected readonly client: DaprActorClient;
+    protected readonly contextService: DaprContextService;
+    protected logger: Logger;
+    constructor(daprClient: DaprClient, id: ActorId);
     onActivate(): Promise<void>;
-    getAllState(): Promise<void>;
-    setAllStateFromProperties(): Promise<void>;
-    getState<T>(stateName: string, defaultValue?: T): Promise<T | undefined>;
-    private createInstanceFromProperty;
-    private createInstance;
+    protected logMessage(message: any, level?: 'log' | 'error' | 'warn' | 'debug'): void;
+    protected log(message: any, ...optionalParams: [...any, string?]): void;
+    protected verbose(message: any, ...optionalParams: [...any, string?]): void;
+    protected warn(message: any, ...optionalParams: [...any, string?]): void;
+    protected setStateValue<T>(stateName: string, value: T): Promise<void>;
+    protected removeStateValue(stateName: string): Promise<void>;
+    protected saveState(): Promise<void>;
+    protected clearState(): Promise<void>;
+    protected getAllState(): Promise<void>;
+    private loadStatePropertyInternal;
+    private setAllStateFromPropertiesInternal;
+    protected getStateValue<T>(stateName: string, defaultValue?: T): Promise<T | undefined>;
 }

package/dist/actors/stateful.actor.js

@@ -1,4 +1,13 @@
 "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 __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
 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) {
@@ -10,82 +19,125 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StatefulActor = void 0;
+const common_1 = require("@nestjs/common");
 const constants_1 = require("../constants");
+const dapr_context_service_1 = require("../dapr-context-service");
 const abstract_actor_1 = require("./abstract-actor");
+const dapr_actor_client_service_1 = require("./dapr-actor-client.service");
 class StatefulActor extends abstract_actor_1.AbstractActor {
-    setState(stateName, value) {
+    constructor(daprClient, id) {
+        super(daprClient, id);
+        this.logger = new common_1.Logger(this.constructor.name);
+    }
+    onActivate() {
+        const _super = Object.create(null, {
+            onActivate: { get: () => super.onActivate }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            this.statePropertiesInternal =
+                Reflect.getMetadata(constants_1.DAPR_ACTOR_STATE_METADATA, this.constructor) || [];
+            yield _super.onActivate.call(this);
+            yield this.getAllState();
+        });
+    }
+    logMessage(message, level = 'log') {
+        var _a;
+        switch (level) {
+            case 'log':
+                this.logger.log(message, this.constructor.name);
+                break;
+            case 'error': {
+                const stack = (_a = message.stack) !== null && _a !== void 0 ? _a : new Error().stack;
+                this.logger.error(message, stack, this.constructor.name);
+                break;
+            }
+            case 'warn':
+                this.logger.warn(message, this.constructor.name);
+                break;
+            case 'debug':
+                this.logger.debug(message, this.constructor.name);
+                break;
+        }
+    }
+    log(message, ...optionalParams) {
+        this.logger.log(message, ...optionalParams);
+    }
+    verbose(message, ...optionalParams) {
+        this.logger.verbose(message, ...optionalParams);
+    }
+    warn(message, ...optionalParams) {
+        this.logger.warn(message, ...optionalParams);
+    }
+    setStateValue(stateName, value) {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.getStateManager().setState(stateName, value);
         });
     }
-    removeState(stateName) {
+    removeStateValue(stateName) {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.getStateManager().removeState(stateName);
         });
     }
     saveState() {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.setAllStateFromProperties();
+            yield this.setAllStateFromPropertiesInternal();
             yield this.getStateManager().saveState();
         });
     }
     clearState() {
         return __awaiter(this, void 0, void 0, function* () {
-            for (const property of this.stateProperties) {
-                yield this.removeState(property.name);
+            for (const property of this.statePropertiesInternal) {
+                yield this.removeStateValue(property.name);
             }
         });
     }
-    onActivate() {
-        const _super = Object.create(null, {
-            onActivate: { get: () => super.onActivate }
-        });
+    getAllState() {
         return __awaiter(this, void 0, void 0, function* () {
-            this.stateProperties = Reflect.getMetadata(constants_1.DAPR_ACTOR_STATE_METADATA, this.constructor) || [];
-            yield _super.onActivate.call(this);
-            yield this.getAllState();
+            for (const property of this.statePropertiesInternal) {
+                yield this.loadStatePropertyInternal(property);
+            }
         });
     }
-    getAllState() {
+    loadStatePropertyInternal(property) {
         return __awaiter(this, void 0, void 0, function* () {
-            for (const property of this.stateProperties) {
-                const rawValue = yield this.getState(property.name);
-                if (rawValue === undefined) {
-                    if (typeof property.defaultValue === 'function') {
-                        this[property.key] = property.defaultValue();
-                    }
-                    else if (property.defaultValue !== undefined) {
-                        this[property.key] = property.defaultValue;
-                    }
-                    else {
-                        this[property.key] = this.createInstance(property.type);
-                    }
+            const rawValue = yield this.getStateValue(property.name);
+            if (rawValue === undefined) {
+                if (typeof property.defaultValue === 'function') {
+                    this[property.key] = property.defaultValue();
+                }
+                else if (property.defaultValue !== undefined) {
+                    this[property.key] = property.defaultValue;
                 }
                 else {
-                    const instance = this.createInstanceFromProperty(property, rawValue);
-                    if (instance !== undefined) {
-                        this[property.key] = instance;
-                    }
-                    else {
-                        this[property.key] = rawValue;
-                    }
+                    this[property.key] = createInstanceOfType(property.type);
+                }
+            }
+            else {
+                const instance = createInstanceFromProperty(property, rawValue);
+                if (instance !== undefined) {
+                    this[property.key] = instance;
+                }
+                else {
+                    this[property.key] = rawValue;
                 }
             }
         });
     }
-    setAllStateFromProperties() {
+    setAllStateFromPropertiesInternal() {
         return __awaiter(this, void 0, void 0, function* () {
-            for (const property of this.stateProperties) {
+            for (const property of this.statePropertiesInternal) {
                 let value = this[property.key];
                 if (value !== undefined && property.serializable) {
                     const instance = value;
-                    value = instance.toJSON();
+                    if (typeof instance.toJSON === 'function') {
+                        value = instance === null || instance === void 0 ? void 0 : instance.toJSON();
+                    }
                 }
-                yield this.setState(property.name, value);
+                yield this.setStateValue(property.name, value);
             }
         });
     }
-    getState(stateName, defaultValue = undefined) {
+    getStateValue(stateName, defaultValue) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
                 const value = yield this.getStateManager().getState(stateName);
@@ -103,54 +155,62 @@ class StatefulActor extends abstract_actor_1.AbstractActor {
             }
         });
     }
-    createInstanceFromProperty(property, rawValue) {
-        var _a;
-        try {
-            if (property.serializable) {
-                let instance;
-                if (typeof property.defaultValue === 'function') {
-                    instance = property.defaultValue();
-                }
-                else {
-                    instance = this.createInstance(property.type);
-                }
-                if (instance.fromJSON) {
-                    this[property.key] = (_a = instance.fromJSON(rawValue)) !== null && _a !== void 0 ? _a : instance;
-                }
-                else {
-                    this[property.key] = instance;
-                    for (const key of Object.keys(rawValue)) {
-                        instance[key] = rawValue[key];
-                    }
-                }
+}
+__decorate([
+    (0, common_1.Inject)(),
+    __metadata("design:type", dapr_actor_client_service_1.DaprActorClient)
+], StatefulActor.prototype, "client", void 0);
+__decorate([
+    (0, common_1.Inject)(),
+    __metadata("design:type", dapr_context_service_1.DaprContextService)
+], StatefulActor.prototype, "contextService", void 0);
+exports.StatefulActor = StatefulActor;
+function createInstanceFromProperty(property, rawValue) {
+    var _a;
+    try {
+        if (property.serializable) {
+            let instance;
+            if (typeof property.defaultValue === 'function') {
+                instance = property.defaultValue();
             }
             else {
-                let instance;
-                if (typeof property.defaultValue === 'function') {
-                    instance = property.defaultValue();
-                }
-                else if (property.type) {
-                    instance = this.createInstance(property.type);
-                }
-                if (instance !== undefined) {
-                    for (const key of Object.keys(rawValue)) {
-                        instance[key] = rawValue[key];
-                    }
-                    return instance;
+                instance = createInstanceOfType(property.type);
+            }
+            if (instance.fromJSON) {
+                return (_a = instance.fromJSON(rawValue)) !== null && _a !== void 0 ? _a : instance;
+            }
+            else {
+                for (const key of Object.keys(rawValue)) {
+                    instance[key] = rawValue[key];
                 }
+                return instance;
             }
         }
-        catch (e) {
-            return undefined;
+        else {
+            let instance;
+            if (typeof property.defaultValue === 'function') {
+                instance = property.defaultValue();
+            }
+            else if (property.type) {
+                instance = createInstanceOfType(property.type);
+            }
+            if (instance !== undefined) {
+                for (const key of Object.keys(rawValue)) {
+                    instance[key] = rawValue[key];
+                }
+                return instance;
+            }
         }
     }
-    createInstance(type) {
-        try {
-            return new type();
-        }
-        catch (e) {
-            return undefined;
-        }
+    catch (e) {
+        return undefined;
+    }
+}
+function createInstanceOfType(type) {
+    try {
+        return new type();
+    }
+    catch (e) {
+        return undefined;
     }
 }
-exports.StatefulActor = StatefulActor;

package/package.json

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