@rayondigital/nest-dapr 0.9.62 → 0.9.64

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

@@ -14,6 +14,7 @@ const common_1 = require("@nestjs/common");
 const dapr_context_service_1 = require("../dapr-context-service");
 const actor_runtime_service_1 = require("./actor-runtime.service");
 const client_cache_1 = require("./client-cache");
+const serializable_error_1 = require("./serializable-error");
 class ActorProxyBuilder {
     constructor(moduleRef, actorTypeClass, ...args) {
         this.moduleRef = moduleRef;
@@ -63,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) {
@@ -75,7 +80,14 @@ class ActorProxyBuilder {
             const correlationId = this.daprContextService.getCorrelationId(true);
             const traceId = this.daprContextService.getTraceId(true);
             const body = yield this.prepareBody(this.daprContextService, args, originalBody);
-            return yield this.actorClient.actor.invoke(actorTypeClassName, actorId, methodName, body, correlationId, traceId);
+            const result = yield this.actorClient.actor.invoke(actorTypeClassName, actorId, methodName, body, correlationId, traceId);
+            if (serializable_error_1.SerializableError.isSerializableError(result)) {
+                const error = serializable_error_1.SerializableError.fromJSON(result);
+                error.correlationId = correlationId;
+                error.traceId = traceId;
+                throw error;
+            }
+            return result;
         });
     }
     prepareBody(daprContextService, args, body) {

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,9 +1,18 @@
 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,17 +1,42 @@
 "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 = 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) {
+        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) {
+            return true;
+        }
+        return error && error.$type === 'SerializableError';
+    }
 }
 exports.SerializableError = SerializableError;

package/package.json

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