@rayondigital/nest-dapr 0.9.63 → 0.9.65

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

@@ -10,6 +10,7 @@ export declare abstract class AbstractActor {
     private readonly actorClient;
     private readonly daprStateProvider;
     private readonly actorType;
+    private readonly stateName;
     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>;

package/dist/actors/abstract-actor.js

@@ -19,13 +19,14 @@ const polyfill_1 = require("@js-temporal/polyfill");
 const client_cache_1 = require("./client-cache");
 class AbstractActor {
     constructor(daprClient, id) {
+        this.actorType = this.constructor.name;
+        this.stateName = this.constructor.name;
         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* () {
@@ -134,7 +135,8 @@ class AbstractActor {
         return this.id;
     }
     getActorType() {
-        return this.actorType;
+        var _a;
+        return (_a = this.stateName) !== null && _a !== void 0 ? _a : this.actorType;
     }
     getId() {
         return this.getActorId().getId();

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

@@ -64,7 +64,11 @@ class ActorProxyBuilder {
         return __awaiter(this, void 0, void 0, function* () {
             const actorManager = this.actorRuntimeService.getActorManager(actorTypeClassName);
             const requestBody = JSON.stringify(args);
-            return yield actorManager.invoke(actorId, methodName, Buffer.from(requestBody));
+            const result = yield actorManager.invoke(actorId, methodName, Buffer.from(requestBody));
+            if (serializable_error_1.SerializableError.isSerializableError(result)) {
+                throw serializable_error_1.SerializableError.fromJSON(result);
+            }
+            return result;
         });
     }
     callExternalActorMethod(actorTypeClassName, actorId, methodName, args) {
@@ -78,7 +82,10 @@ class ActorProxyBuilder {
             const body = yield this.prepareBody(this.daprContextService, args, originalBody);
             const result = yield this.actorClient.actor.invoke(actorTypeClassName, actorId, methodName, body, correlationId, traceId);
             if (serializable_error_1.SerializableError.isSerializableError(result)) {
-                throw serializable_error_1.SerializableError.fromJSON(result);
+                const error = serializable_error_1.SerializableError.fromJSON(result);
+                error.correlationId = correlationId;
+                error.traceId = traceId;
+                throw error;
             }
             return result;
         });

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

@@ -161,10 +161,10 @@ let NestActorManager = NestActorManager_1 = class NestActorManager {
         actor_1.default.prototype.handlerMethod = function (req, res) {
             var _a;
             return __awaiter(this, void 0, void 0, function* () {
-                const { actorTypeName, actorId, methodName } = req.params;
-                const body = req.body;
-                const dataSerialized = this.serializer.serialize(body);
                 try {
+                    const { actorTypeName, actorId, methodName } = req.params;
+                    const body = req.body;
+                    const dataSerialized = this.serializer.serialize(body);
                     const result = yield ActorRuntime_1.default.getInstance(this.client.daprClient).invoke(actorTypeName, actorId, methodName, dataSerialized);
                     res.statusCode = HttpStatusCode_enum_1.default.OK;
                     return this.handleResult(res, result);

package/dist/actors/serializable-error.d.ts

@@ -1,11 +1,17 @@
 export declare class SerializableError extends Error {
     statusCode: number;
     $type: string;
+    correlationId?: string;
+    traceId?: string;
     constructor(message: string, statusCode?: number);
     toJSON(): {
         name: string;
         message: string;
         statusCode: number;
+        correlationId: string;
+        traceId: string;
+        stack: string;
+        $type: string;
     };
     static fromJSON(json: any): SerializableError;
     static isSerializableError(error: any): error is SerializableError;

package/dist/actors/serializable-error.js

@@ -1,21 +1,36 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SerializableError = void 0;
+const serializableErrorTypeName = 'SerializableError';
 class SerializableError extends Error {
     constructor(message, statusCode = 400) {
         super(message);
         this.statusCode = statusCode;
-        this.$type = 'SerializableError';
+        this.$type = serializableErrorTypeName;
     }
     toJSON() {
+        if (!this.stack) {
+            Error.captureStackTrace(this, SerializableError);
+        }
         return {
             name: this.name,
             message: this.message,
             statusCode: this.statusCode,
+            correlationId: this.correlationId,
+            traceId: this.traceId,
+            stack: this.stack,
+            $type: serializableErrorTypeName,
         };
     }
     static fromJSON(json) {
-        return new SerializableError(json.message, json.statusCode);
+        var _a;
+        const error = new SerializableError(json.message, json.statusCode);
+        error.$type = (_a = json.$type) !== null && _a !== void 0 ? _a : serializableErrorTypeName;
+        error.correlationId = json.correlationId;
+        error.traceId = json.traceId;
+        error.stack = json.stack;
+        error.name = json.name;
+        return error;
     }
     static isSerializableError(error) {
         if (error instanceof SerializableError) {

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

@@ -2,5 +2,7 @@ import { Type } from '@nestjs/common';
 export interface DaprActorMetadata {
     interfaceType: Type<any> | Function;
     name?: string;
+    stateName?: string;
 }
 export declare function DaprActor(options: DaprActorMetadata): ClassDecorator;
+export declare function getActorMetadata(target: Type<any>): DaprActorMetadata;

package/dist/dapr-actor.decorator.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DaprActor = void 0;
+exports.getActorMetadata = exports.DaprActor = void 0;
 const common_1 = require("@nestjs/common");
 const constants_1 = require("./constants");
 function DaprActor(options) {
@@ -8,9 +8,14 @@ function DaprActor(options) {
         var _a;
         (0, common_1.SetMetadata)(constants_1.DAPR_ACTOR_METADATA, {
             name: (_a = options.name) !== null && _a !== void 0 ? _a : target.constructor.name,
+            stateName: options.stateName,
             interfaceType: options.interfaceType,
         })(target);
         (0, common_1.Injectable)({ scope: common_1.Scope.TRANSIENT })(target);
     };
 }
 exports.DaprActor = DaprActor;
+function getActorMetadata(target) {
+    return Reflect.getMetadata(constants_1.DAPR_ACTOR_METADATA, target);
+}
+exports.getActorMetadata = getActorMetadata;

package/package.json

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