@rayondigital/nest-dapr 0.9.8 → 0.9.9

package/dist/actors/actor-proxy-builder.d.ts

@@ -2,10 +2,15 @@ import { ActorId, CommunicationProtocolEnum, DaprClient } from '@dapr/dapr';
 import ActorClient from '@dapr/dapr/actors/client/ActorClient/ActorClient';
 import Class from '@dapr/dapr/types/Class';
 import { DaprClientOptions } from '@dapr/dapr/types/DaprClientOptions';
+import { ModuleRef } from '@nestjs/core';
+import { DaprContextService } from '../dapr-context-service';
 export declare class ActorProxyBuilder<T> {
+    moduleRef: ModuleRef;
+    daprContextService: DaprContextService;
     actorClient: ActorClient;
     actorTypeClass: Class<T>;
-    constructor(actorTypeClass: Class<T>, daprClient: DaprClient);
-    constructor(actorTypeClass: Class<T>, host: string, port: string, communicationProtocol: CommunicationProtocolEnum, clientOptions: DaprClientOptions);
+    constructor(moduleRef: ModuleRef, actorTypeClass: Class<T>, daprClient: DaprClient);
+    constructor(moduleRef: ModuleRef, actorTypeClass: Class<T>, host: string, port: string, communicationProtocol: CommunicationProtocolEnum, clientOptions: DaprClientOptions);
     build(actorId: ActorId, actorTypeName?: string): T;
+    private prepareBody;
 }

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

@@ -14,8 +14,13 @@ var __importDefault = (this && this.__importDefault) || function (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");
 class ActorProxyBuilder {
-    constructor(actorTypeClass, ...args) {
+    constructor(moduleRef, actorTypeClass, ...args) {
+        this.moduleRef = moduleRef;
+        this.daprContextService = moduleRef.get(dapr_context_service_1.DaprContextService, {
+            strict: false,
+        });
         this.actorTypeClass = actorTypeClass;
         if (args.length == 1) {
             const [daprClient] = args;
@@ -30,18 +35,46 @@ class ActorProxyBuilder {
         const actorTypeClassName = actorTypeName !== null && actorTypeName !== void 0 ? actorTypeName : this.actorTypeClass.name;
         const actorClient = this.actorClient;
         const handler = {
-            get(_target, propKey, _receiver) {
-                return function (...args) {
-                    return __awaiter(this, void 0, void 0, function* () {
-                        const body = args.length > 0 ? args : null;
-                        const res = yield actorClient.actor.invoke(actorTypeClassName, actorId, propKey, body);
-                        return res;
-                    });
-                };
+            get: (_target, propKey, _receiver) => {
+                return (...args) => __awaiter(this, void 0, void 0, function* () {
+                    const originalBody = args.length > 0 ? args : null;
+                    const body = yield this.prepareBody(this.daprContextService, args, originalBody);
+                    const res = yield actorClient.actor.invoke(actorTypeClassName, actorId, propKey, body);
+                    return res;
+                });
             },
         };
         const proxy = new Proxy(this.actorTypeClass, handler);
         return proxy;
     }
+    prepareBody(daprContextService, args, body) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!daprContextService)
+                    return body;
+                const context = daprContextService.get();
+                if (context) {
+                    context['$t'] = 'ctx';
+                    if (Array.isArray(body)) {
+                        body.push(context);
+                        if (args.length === 0 && body.length === 2 && body[0] === null) {
+                            return [context];
+                        }
+                        return body;
+                    }
+                    else {
+                        if (args.length === 0) {
+                            return context;
+                        }
+                        return [body, context];
+                    }
+                }
+                return body;
+            }
+            catch (error) {
+                return body;
+            }
+        });
+    }
 }
 exports.ActorProxyBuilder = ActorProxyBuilder;

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

@@ -1,6 +1,8 @@
 import { ActorId, DaprClient } from '@dapr/dapr';
 import { Type } from '@nestjs/common';
+import { ModuleRef } from '@nestjs/core';
 export declare class DaprActorClient {
+    private readonly moduleRef;
     private readonly daprClient;
     private actorClients;
     private interfaces;
@@ -8,7 +10,7 @@ export declare class DaprActorClient {
     private prefix;
     private delimiter;
     private typeNamePrefix;
-    constructor(daprClient: DaprClient);
+    constructor(moduleRef: ModuleRef, daprClient: DaprClient);
     setPrefix(prefix: string, delimiter?: string): void;
     setTypeNamePrefix(prefix: string): void;
     register<T>(actorTypeName: string, actorType: Type<T> | Function, daprClient?: DaprClient): void;

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

@@ -12,9 +12,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DaprActorClient = void 0;
 const dapr_1 = require("@dapr/dapr");
 const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
 const actor_proxy_builder_1 = require("./actor-proxy-builder");
 let DaprActorClient = class DaprActorClient {
-    constructor(daprClient) {
+    constructor(moduleRef, daprClient) {
+        this.moduleRef = moduleRef;
         this.daprClient = daprClient;
         this.actorClients = new Map();
         this.interfaces = new Map();
@@ -32,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(actorType, daprClient !== null && daprClient !== void 0 ? daprClient : this.daprClient));
+        this.actorClients.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;
@@ -40,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(actorType, daprClient !== null && daprClient !== void 0 ? daprClient : this.daprClient));
+        this.actorClients.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;
@@ -104,6 +106,7 @@ let DaprActorClient = class DaprActorClient {
 };
 DaprActorClient = __decorate([
     (0, common_1.Injectable)(),
-    __metadata("design:paramtypes", [dapr_1.DaprClient])
+    __metadata("design:paramtypes", [core_1.ModuleRef,
+        dapr_1.DaprClient])
 ], DaprActorClient);
 exports.DaprActorClient = DaprActorClient;

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

@@ -1,7 +1,14 @@
-import { ActorId } from '@dapr/dapr';
+import { AbstractActor, ActorId } from '@dapr/dapr';
 import { ModuleRef } from '@nestjs/core';
+import { DaprContextService } from '../dapr-context-service';
 import { DaprModuleActorOptions } from '../dapr.module';
-export declare function patchActorManagerForNest(moduleRef: ModuleRef, options: DaprModuleActorOptions, invokeWrapperFn?: (actorId: ActorId, methodName: string, data: any, method: (actorId: ActorId, methodName: string, data: any) => Promise<any>) => Promise<any>): void;
+export declare class NestActorManager {
+    setup(moduleRef: ModuleRef, options: DaprModuleActorOptions, onActivateFn?: (actorId: ActorId, instance: AbstractActor) => Promise<void>): void;
+    private resolveDependencies;
+    setupCSLWrapper(contextService: DaprContextService, invokeWrapperFn?: (actorId: ActorId, methodName: string, data: any, method: (actorId: ActorId, methodName: string, data: any) => Promise<any>) => Promise<any>): void;
+    private static extractContext;
+    private static removeContext;
+}
 export interface ActorMethodInvocation {
     actorId: ActorId;
     method: string;

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

@@ -1,4 +1,10 @@
 "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 __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) {
@@ -11,65 +17,132 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
+var NestActorManager_1;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.patchActorManagerForNest = void 0;
+exports.NestActorManager = void 0;
+const crypto_1 = require("crypto");
 const ActorManager_1 = __importDefault(require("@dapr/dapr/actors/runtime/ActorManager"));
 const common_1 = require("@nestjs/common");
 const instance_wrapper_1 = require("@nestjs/core/injector/instance-wrapper");
-function patchActorManagerForNest(moduleRef, options, invokeWrapperFn) {
-    const originalCreateActor = ActorManager_1.default.prototype.createActor;
-    const originalCallActor = ActorManager_1.default.prototype.callActorMethod;
-    ActorManager_1.default.prototype.createActor = function (actorId) {
+const nestjs_cls_1 = require("nestjs-cls");
+let NestActorManager = NestActorManager_1 = class NestActorManager {
+    setup(moduleRef, options, onActivateFn) {
+        const originalCreateActor = ActorManager_1.default.prototype.createActor;
+        const resolveDependencies = this.resolveDependencies;
+        ActorManager_1.default.prototype.createActor = function (actorId) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const instance = (yield originalCreateActor.bind(this)(actorId));
+                if (options === null || options === void 0 ? void 0 : options.typeNamePrefix) {
+                    instance['actorType'] = `${options.typeNamePrefix}${instance.actorType}`;
+                }
+                try {
+                    yield resolveDependencies(moduleRef, instance);
+                    if (onActivateFn) {
+                        yield onActivateFn(actorId, instance);
+                    }
+                }
+                catch (error) {
+                    console.error(error);
+                    throw error;
+                }
+                return instance;
+            });
+        };
+    }
+    resolveDependencies(moduleRef, instance) {
         return __awaiter(this, void 0, void 0, function* () {
-            const instance = (yield originalCreateActor.bind(this)(actorId));
-            if (options === null || options === void 0 ? void 0 : options.typeNamePrefix) {
-                instance['actorType'] = `${options.typeNamePrefix}${instance.actorType}`;
-            }
+            const type = instance.constructor;
             try {
-                yield resolveDependencies(moduleRef, instance);
+                const injector = moduleRef['injector'];
+                const wrapper = new instance_wrapper_1.InstanceWrapper({
+                    name: type && type.name,
+                    metatype: type,
+                    isResolved: false,
+                    scope: common_1.Scope.TRANSIENT,
+                    durable: true,
+                });
+                const properties = injector.reflectProperties(wrapper.metatype);
+                for (const item of properties) {
+                    if ('type' in item && item.type) {
+                        const propertyType = item.type;
+                        const resolved = yield moduleRef.get(propertyType, { strict: false });
+                        if (resolved) {
+                            instance[item.key] = resolved;
+                        }
+                    }
+                }
             }
             catch (error) {
                 console.error(error);
                 throw error;
             }
-            return instance;
         });
-    };
-    if (invokeWrapperFn) {
+    }
+    setupCSLWrapper(contextService, invokeWrapperFn) {
+        const clsService = contextService.getService();
+        if (!clsService) {
+            throw new Error(`Unable to resolve a CLS from the NestJS DI container`);
+        }
+        const originalCallActor = ActorManager_1.default.prototype.callActorMethod;
         ActorManager_1.default.prototype.callActorMethod = function (actorId, methodName, data) {
             return __awaiter(this, void 0, void 0, function* () {
-                return yield invokeWrapperFn(actorId, methodName, data, originalCallActor.bind(this));
+                try {
+                    return yield clsService.run(() => __awaiter(this, void 0, void 0, function* () {
+                        clsService.setIfUndefined(nestjs_cls_1.CLS_ID, (0, crypto_1.randomUUID)());
+                        const context = NestActorManager_1.extractContext(data);
+                        if (context) {
+                            contextService.set(context);
+                            data = NestActorManager_1.removeContext(data);
+                        }
+                        if (invokeWrapperFn) {
+                            return yield invokeWrapperFn(actorId, methodName, data, originalCallActor.bind(this));
+                        }
+                        else {
+                            return yield originalCallActor.bind(this)(actorId, methodName, data);
+                        }
+                    }));
+                }
+                catch (error) {
+                    common_1.Logger.error(`Error invoking actor method ${actorId}/${methodName}`);
+                    common_1.Logger.error(error);
+                    throw error;
+                }
             });
         };
     }
-}
-exports.patchActorManagerForNest = patchActorManagerForNest;
-function resolveDependencies(moduleRef, instance) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const type = instance.constructor;
-        try {
-            const injector = moduleRef['injector'];
-            const wrapper = new instance_wrapper_1.InstanceWrapper({
-                name: type && type.name,
-                metatype: type,
-                isResolved: false,
-                scope: common_1.Scope.TRANSIENT,
-                durable: true,
-            });
-            const properties = injector.reflectProperties(wrapper.metatype);
-            for (const item of properties) {
-                if ('type' in item && item.type) {
-                    const propertyType = item.type;
-                    const resolved = yield moduleRef.get(propertyType, { strict: false });
-                    if (resolved) {
-                        instance[item.key] = resolved;
-                    }
-                }
+    static extractContext(data) {
+        if (!data)
+            return undefined;
+        if (Array.isArray(data)) {
+            const lastItem = data[data.length - 1];
+            if (lastItem['$t'] === 'ctx') {
+                return lastItem;
             }
         }
-        catch (error) {
-            console.error(error);
-            throw error;
+        if (data['$t'] === 'ctx') {
+            return data;
         }
-    });
-}
+        return data['$ctx'];
+    }
+    static removeContext(data) {
+        if (!data)
+            return undefined;
+        if (Array.isArray(data)) {
+            const lastItem = data[data.length - 1];
+            if (lastItem['$t'] === 'ctx') {
+                return data.slice(0, data.length - 1);
+            }
+        }
+        if (data['$t'] === 'ctx') {
+            return undefined;
+        }
+        if (data['$ctx']) {
+            data['$ctx'] = undefined;
+        }
+        return data;
+    }
+};
+NestActorManager = NestActorManager_1 = __decorate([
+    (0, common_1.Injectable)()
+], NestActorManager);
+exports.NestActorManager = NestActorManager;

package/dist/dapr-context-service.d.ts

@@ -0,0 +1,11 @@
+import { ClsService } from 'nestjs-cls';
+export declare const DAPR_CONTEXT_KEY = "context";
+export declare class DaprContextService {
+    private readonly cls;
+    constructor(cls: ClsService);
+    getService(): ClsService;
+    setByKey<T>(key: string, value: T): void;
+    set<T>(value: T): void;
+    getByKey<T>(key: string): T | undefined;
+    get<T>(): T | undefined;
+}

package/dist/dapr-context-service.js

@@ -0,0 +1,52 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DaprContextService = exports.DAPR_CONTEXT_KEY = void 0;
+const common_1 = require("@nestjs/common");
+const nestjs_cls_1 = require("nestjs-cls");
+exports.DAPR_CONTEXT_KEY = 'context';
+let DaprContextService = class DaprContextService {
+    constructor(cls) {
+        this.cls = cls;
+    }
+    getService() {
+        var _a;
+        return (_a = this.cls) !== null && _a !== void 0 ? _a : nestjs_cls_1.ClsServiceManager.getClsService();
+    }
+    setByKey(key, value) {
+        this.getService().set(key, value);
+    }
+    set(value) {
+        this.setByKey(exports.DAPR_CONTEXT_KEY, value);
+    }
+    getByKey(key) {
+        var _a;
+        try {
+            return (_a = this.getService().get(key)) !== null && _a !== void 0 ? _a : undefined;
+        }
+        catch (error) {
+            return undefined;
+        }
+    }
+    get() {
+        try {
+            return this.getByKey(exports.DAPR_CONTEXT_KEY);
+        }
+        catch (error) {
+            return undefined;
+        }
+    }
+};
+DaprContextService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [nestjs_cls_1.ClsService])
+], DaprContextService);
+exports.DaprContextService = DaprContextService;

package/dist/dapr.loader.d.ts

@@ -2,6 +2,8 @@ import { DaprServer } from '@dapr/dapr';
 import { OnApplicationBootstrap, OnApplicationShutdown } from '@nestjs/common';
 import { DiscoveryService, MetadataScanner, ModuleRef } from '@nestjs/core';
 import { DaprActorClient } from './actors/dapr-actor-client.service';
+import { NestActorManager } from './actors/nest-actor-manager';
+import { DaprContextService } from './dapr-context-service';
 import { DaprMetadataAccessor } from './dapr-metadata.accessor';
 import { DaprModuleOptions } from './dapr.module';
 export declare class DaprLoader implements OnApplicationBootstrap, OnApplicationShutdown {
@@ -12,8 +14,10 @@ export declare class DaprLoader implements OnApplicationBootstrap, OnApplication
     private readonly options;
     private readonly daprActorClient;
     private readonly moduleRef;
+    private readonly contextService;
+    private readonly actorManager;
     private readonly logger;
-    constructor(discoveryService: DiscoveryService, metadataScanner: MetadataScanner, daprServer: DaprServer, daprMetadataAccessor: DaprMetadataAccessor, options: DaprModuleOptions, daprActorClient: DaprActorClient, moduleRef: ModuleRef);
+    constructor(discoveryService: DiscoveryService, metadataScanner: MetadataScanner, daprServer: DaprServer, daprMetadataAccessor: DaprMetadataAccessor, options: DaprModuleOptions, daprActorClient: DaprActorClient, moduleRef: ModuleRef, contextService: DaprContextService, actorManager: NestActorManager);
     onApplicationBootstrap(): Promise<void>;
     onApplicationShutdown(): Promise<void>;
     loadDaprHandlers(): void;

package/dist/dapr.loader.js

@@ -33,10 +33,11 @@ const common_1 = require("@nestjs/common");
 const core_1 = require("@nestjs/core");
 const dapr_actor_client_service_1 = require("./actors/dapr-actor-client.service");
 const nest_actor_manager_1 = require("./actors/nest-actor-manager");
+const dapr_context_service_1 = require("./dapr-context-service");
 const dapr_metadata_accessor_1 = require("./dapr-metadata.accessor");
 const dapr_module_1 = require("./dapr.module");
 let DaprLoader = DaprLoader_1 = class DaprLoader {
-    constructor(discoveryService, metadataScanner, daprServer, daprMetadataAccessor, options, daprActorClient, moduleRef) {
+    constructor(discoveryService, metadataScanner, daprServer, daprMetadataAccessor, options, daprActorClient, moduleRef, contextService, actorManager) {
         this.discoveryService = discoveryService;
         this.metadataScanner = metadataScanner;
         this.daprServer = daprServer;
@@ -44,6 +45,8 @@ let DaprLoader = DaprLoader_1 = class DaprLoader {
         this.options = options;
         this.daprActorClient = daprActorClient;
         this.moduleRef = moduleRef;
+        this.contextService = contextService;
+        this.actorManager = actorManager;
         this.logger = new common_1.Logger(DaprLoader_1.name);
     }
     onApplicationBootstrap() {
@@ -53,7 +56,10 @@ let DaprLoader = DaprLoader_1 = class DaprLoader {
                 this.logger.log('Dapr server is disabled');
                 return;
             }
-            (0, nest_actor_manager_1.patchActorManagerForNest)(this.moduleRef, this.options.actorOptions);
+            this.actorManager.setup(this.moduleRef, this.options.actorOptions);
+            if (this.options.contextProvider !== dapr_module_1.DaprContextProvider.None) {
+                this.actorManager.setupCSLWrapper(this.contextService);
+            }
             yield this.daprServer.actor.init();
             this.loadDaprHandlers();
             if (this.options.serverPort === '0') {
@@ -186,6 +192,8 @@ DaprLoader = DaprLoader_1 = __decorate([
         core_1.MetadataScanner,
         dapr_1.DaprServer,
         dapr_metadata_accessor_1.DaprMetadataAccessor, Object, dapr_actor_client_service_1.DaprActorClient,
-        core_1.ModuleRef])
+        core_1.ModuleRef,
+        dapr_context_service_1.DaprContextService,
+        nest_actor_manager_1.NestActorManager])
 ], DaprLoader);
 exports.DaprLoader = DaprLoader;

package/dist/dapr.module.d.ts

@@ -10,12 +10,18 @@ export interface DaprModuleOptions {
     onError?: (name: string, topicName: string, error: any) => DaprPubSubStatusEnum;
     actorOptions?: DaprModuleActorOptions;
     disabled?: boolean;
+    contextProvider?: DaprContextProvider;
 }
 export interface DaprModuleActorOptions {
     prefix?: string;
     delimiter?: string;
     typeNamePrefix?: string;
 }
+export declare enum DaprContextProvider {
+    None = "none",
+    ALS = "als",
+    NestCLS = "nest-cls"
+}
 export interface DaprModuleOptionsFactory {
     createDaprModuleOptions(): Promise<DaprModuleOptions> | DaprModuleOptions;
 }

package/dist/dapr.module.js

@@ -16,14 +16,22 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 var DaprModule_1;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DaprModule = exports.createOptionsProvider = exports.DAPR_MODULE_OPTIONS_TOKEN = void 0;
+exports.DaprModule = exports.createOptionsProvider = exports.DaprContextProvider = exports.DAPR_MODULE_OPTIONS_TOKEN = void 0;
 const dapr_1 = require("@dapr/dapr");
 const common_1 = require("@nestjs/common");
 const core_1 = require("@nestjs/core");
 const dapr_actor_client_service_1 = require("./actors/dapr-actor-client.service");
+const nest_actor_manager_1 = require("./actors/nest-actor-manager");
+const dapr_context_service_1 = require("./dapr-context-service");
 const dapr_metadata_accessor_1 = require("./dapr-metadata.accessor");
 const dapr_loader_1 = require("./dapr.loader");
 exports.DAPR_MODULE_OPTIONS_TOKEN = 'DAPR_MODULE_OPTIONS_TOKEN';
+var DaprContextProvider;
+(function (DaprContextProvider) {
+    DaprContextProvider["None"] = "none";
+    DaprContextProvider["ALS"] = "als";
+    DaprContextProvider["NestCLS"] = "nest-cls";
+})(DaprContextProvider = exports.DaprContextProvider || (exports.DaprContextProvider = {}));
 function createOptionsProvider(options) {
     if (!options.clientOptions.actor) {
         options.clientOptions.actor = {
@@ -62,6 +70,7 @@ let DaprModule = DaprModule_1 = class DaprModule {
                 },
                 dapr_loader_1.DaprLoader,
                 dapr_metadata_accessor_1.DaprMetadataAccessor,
+                dapr_context_service_1.DaprContextService,
                 core_1.Reflector,
             ],
             exports: [dapr_1.DaprClient],
@@ -91,6 +100,7 @@ let DaprModule = DaprModule_1 = class DaprModule {
                 },
                 dapr_loader_1.DaprLoader,
                 dapr_metadata_accessor_1.DaprMetadataAccessor,
+                dapr_context_service_1.DaprContextService,
                 core_1.Reflector,
                 ...(options.extraProviders || []),
             ],
@@ -126,8 +136,8 @@ let DaprModule = DaprModule_1 = class DaprModule {
 };
 DaprModule = DaprModule_1 = __decorate([
     (0, common_1.Module)({
-        providers: [dapr_actor_client_service_1.DaprActorClient],
-        exports: [dapr_actor_client_service_1.DaprActorClient],
+        providers: [dapr_actor_client_service_1.DaprActorClient, nest_actor_manager_1.NestActorManager, dapr_context_service_1.DaprContextService],
+        exports: [dapr_actor_client_service_1.DaprActorClient, dapr_context_service_1.DaprContextService],
     })
 ], DaprModule);
 exports.DaprModule = DaprModule;

package/dist/index.d.ts

@@ -5,8 +5,9 @@ import { DAPR_BINDING_METADATA, DAPR_PUBSUB_METADATA, DAPR_ACTOR_METADATA, DAPR_
 import { State } from './dapr-actor-state.decorator';
 import { DaprActor, DaprActorMetadata } from './dapr-actor.decorator';
 import { DaprBinding, DaprBindingMetadata } from './dapr-binding.decorator';
+import { DaprContextService } from './dapr-context-service';
 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, StatefulActor, StatefulActorOf, };
+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, };

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.StatefulActorOf = exports.StatefulActor = 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.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 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");
@@ -18,6 +18,8 @@ const dapr_actor_decorator_1 = require("./dapr-actor.decorator");
 Object.defineProperty(exports, "DaprActor", { enumerable: true, get: function () { return dapr_actor_decorator_1.DaprActor; } });
 const dapr_binding_decorator_1 = require("./dapr-binding.decorator");
 Object.defineProperty(exports, "DaprBinding", { enumerable: true, get: function () { return dapr_binding_decorator_1.DaprBinding; } });
+const dapr_context_service_1 = require("./dapr-context-service");
+Object.defineProperty(exports, "DaprContextService", { enumerable: true, get: function () { return dapr_context_service_1.DaprContextService; } });
 const dapr_metadata_accessor_1 = require("./dapr-metadata.accessor");
 Object.defineProperty(exports, "DaprMetadataAccessor", { enumerable: true, get: function () { return dapr_metadata_accessor_1.DaprMetadataAccessor; } });
 const dapr_pubsub_decorator_1 = require("./dapr-pubsub.decorator");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rayondigital/nest-dapr",
-  "version": "0.9.8",
+  "version": "0.9.9",
   "description": "Develop NestJs microservices using Dapr pubsub, actors and other bindings",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -23,7 +23,8 @@
   "homepage": "https://github.com/rayondigital/nest-dapr#readme",
   "peerDependencies": {
     "@nestjs/common": "^10.0.0",
-    "@nestjs/core": "^10.0.0"
+    "@nestjs/core": "^10.0.0",
+    "nestjs-cls": "^3.0.0"
   },
   "devDependencies": {
     "@nestjs/platform-express": "^10.0.0",
@@ -46,6 +47,9 @@
   "dependencies": {
     "@dapr/dapr": "^3.2.0"
   },
+  "optionalDependencies": {
+    "nestjs-cls": "^3.6.0"
+  },
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org/"