@rayondigital/nest-dapr 0.9.2

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

@@ -0,0 +1,72 @@
+"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.patchActorManagerForNest = void 0;
+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, invokeWrapperFn) {
+    const originalCreateActor = ActorManager_1.default.prototype.createActor;
+    const originalCallActor = ActorManager_1.default.prototype.callActorMethod;
+    ActorManager_1.default.prototype.createActor = function (actorId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const instance = yield originalCreateActor.bind(this)(actorId);
+            try {
+                yield resolveDependencies(moduleRef, instance);
+            }
+            catch (error) {
+                console.error(error);
+                throw error;
+            }
+            return instance;
+        });
+    };
+    if (invokeWrapperFn) {
+        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));
+            });
+        };
+    }
+}
+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;
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.error(error);
+            throw error;
+        }
+    });
+}

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

@@ -0,0 +1,6 @@
+import { StatefulActor } from './stateful.actor';
+export declare class StatefulActorOf<TState> extends StatefulActor {
+    state: TState;
+    saveStateObject(): Promise<void>;
+    getStateObject(): Promise<TState>;
+}

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

@@ -0,0 +1,27 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatefulActorOf = void 0;
+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.getStateManager().saveState();
+        });
+    }
+    getStateObject() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.getState('state');
+        });
+    }
+}
+exports.StatefulActorOf = StatefulActorOf;

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

@@ -0,0 +1,7 @@
+import { AbstractActor } from '@dapr/dapr';
+export declare class StatefulActor extends AbstractActor {
+    setState<T>(stateName: string, value: T): Promise<void>;
+    removeState(stateName: string): Promise<void>;
+    saveState(): Promise<void>;
+    getState<T>(stateName: string, defaultValue?: T): Promise<T | undefined>;
+}

package/dist/actors/stateful.actor.js

@@ -0,0 +1,49 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatefulActor = void 0;
+const dapr_1 = require("@dapr/dapr");
+class StatefulActor extends dapr_1.AbstractActor {
+    setState(stateName, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.getStateManager().setState(stateName, value);
+        });
+    }
+    removeState(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.getStateManager().saveState();
+        });
+    }
+    getState(stateName, defaultValue = undefined) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const value = yield this.getStateManager().getState(stateName);
+                if (value === undefined) {
+                    return defaultValue;
+                }
+                return value;
+            }
+            catch (e) {
+                const exists = yield this.getStateManager().containsState(stateName);
+                if (!exists) {
+                    return defaultValue;
+                }
+                throw e;
+            }
+        });
+    }
+}
+exports.StatefulActor = StatefulActor;

package/dist/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const DAPR_BINDING_METADATA = "DAPR_BINDING_METADATA";
+export declare const DAPR_PUBSUB_METADATA = "DAPR_PUBSUB_METADATA";
+export declare const DAPR_ACTOR_METADATA = "DAPR_ACTOR_METADATA";

package/dist/constants.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DAPR_ACTOR_METADATA = exports.DAPR_PUBSUB_METADATA = exports.DAPR_BINDING_METADATA = void 0;
+exports.DAPR_BINDING_METADATA = 'DAPR_BINDING_METADATA';
+exports.DAPR_PUBSUB_METADATA = 'DAPR_PUBSUB_METADATA';
+exports.DAPR_ACTOR_METADATA = 'DAPR_ACTOR_METADATA';

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

@@ -0,0 +1,6 @@
+import { Type } from '@nestjs/common';
+export interface DaprActorMetadata {
+    interfaceType: Type<any> | Function;
+    name?: string;
+}
+export declare function DaprActor(options: DaprActorMetadata): ClassDecorator;

package/dist/dapr-actor.decorator.js

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

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

@@ -0,0 +1,4 @@
+export interface DaprBindingMetadata {
+    name: string;
+}
+export declare const DaprBinding: (name: string) => MethodDecorator;

package/dist/dapr-binding.decorator.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DaprBinding = void 0;
+const common_1 = require("@nestjs/common");
+const constants_1 = require("./constants");
+const DaprBinding = (name) => (0, common_1.SetMetadata)(constants_1.DAPR_BINDING_METADATA, { name });
+exports.DaprBinding = DaprBinding;

package/dist/dapr-metadata.accessor.d.ts

@@ -0,0 +1,12 @@
+import { Type } from '@nestjs/common';
+import { Reflector } from '@nestjs/core';
+import { DaprActorMetadata } from './dapr-actor.decorator';
+import { DaprBindingMetadata } from './dapr-binding.decorator';
+import { DaprPubSubMetadata } from './dapr-pubsub.decorator';
+export declare class DaprMetadataAccessor {
+    private readonly reflector;
+    constructor(reflector: Reflector);
+    getDaprPubSubHandlerMetadata(target: Type<unknown>): DaprPubSubMetadata | undefined;
+    getDaprBindingHandlerMetadata(target: Type<unknown>): DaprBindingMetadata | undefined;
+    getDaprActorMetadata(target: Function | Type<unknown>): DaprActorMetadata | undefined;
+}

package/dist/dapr-metadata.accessor.js

@@ -0,0 +1,34 @@
+"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.DaprMetadataAccessor = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const constants_1 = require("./constants");
+let DaprMetadataAccessor = class DaprMetadataAccessor {
+    constructor(reflector) {
+        this.reflector = reflector;
+    }
+    getDaprPubSubHandlerMetadata(target) {
+        return this.reflector.get(constants_1.DAPR_PUBSUB_METADATA, target);
+    }
+    getDaprBindingHandlerMetadata(target) {
+        return this.reflector.get(constants_1.DAPR_BINDING_METADATA, target);
+    }
+    getDaprActorMetadata(target) {
+        return this.reflector.get(constants_1.DAPR_ACTOR_METADATA, target);
+    }
+};
+DaprMetadataAccessor = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [core_1.Reflector])
+], DaprMetadataAccessor);
+exports.DaprMetadataAccessor = DaprMetadataAccessor;

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

@@ -0,0 +1,6 @@
+export interface DaprPubSubMetadata {
+    name: string;
+    topicName: string;
+    route?: string;
+}
+export declare const DaprPubSub: (name: string, topicName: string, route?: string) => MethodDecorator;

package/dist/dapr-pubsub.decorator.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DaprPubSub = void 0;
+const common_1 = require("@nestjs/common");
+const constants_1 = require("./constants");
+const DaprPubSub = (name, topicName, route) => (0, common_1.SetMetadata)(constants_1.DAPR_PUBSUB_METADATA, {
+    name,
+    topicName,
+    route,
+});
+exports.DaprPubSub = DaprPubSub;

package/dist/dapr.loader.d.ts

@@ -0,0 +1,23 @@
+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 { DaprMetadataAccessor } from './dapr-metadata.accessor';
+import { DaprModuleOptions } from './dapr.module';
+export declare class DaprLoader implements OnApplicationBootstrap, OnApplicationShutdown {
+    private readonly discoveryService;
+    private readonly metadataScanner;
+    private readonly daprServer;
+    private readonly daprMetadataAccessor;
+    private readonly options;
+    private readonly daprActorClient;
+    private readonly moduleRef;
+    private readonly logger;
+    constructor(discoveryService: DiscoveryService, metadataScanner: MetadataScanner, daprServer: DaprServer, daprMetadataAccessor: DaprMetadataAccessor, options: DaprModuleOptions, daprActorClient: DaprActorClient, moduleRef: ModuleRef);
+    onApplicationBootstrap(): Promise<void>;
+    onApplicationShutdown(): Promise<void>;
+    loadDaprHandlers(): void;
+    private subscribeToDaprPubSubEventIfListener;
+    private subscribeToDaprBindingEventIfListener;
+    private registerActor;
+}

package/dist/dapr.loader.js

@@ -0,0 +1,157 @@
+"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 __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+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 DaprLoader_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DaprLoader = 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_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) {
+        this.discoveryService = discoveryService;
+        this.metadataScanner = metadataScanner;
+        this.daprServer = daprServer;
+        this.daprMetadataAccessor = daprMetadataAccessor;
+        this.options = options;
+        this.daprActorClient = daprActorClient;
+        this.moduleRef = moduleRef;
+        this.logger = new common_1.Logger(DaprLoader_1.name);
+    }
+    onApplicationBootstrap() {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, nest_actor_manager_1.patchActorManagerForNest)(this.moduleRef);
+            yield this.daprServer.actor.init();
+            this.loadDaprHandlers();
+            this.logger.log('Starting Dapr server');
+            yield this.daprServer.start();
+            this.daprServer.invoker.listen('test', (data) => __awaiter(this, void 0, void 0, function* () {
+                console.log('data', data);
+                return { status: 200, data: { message: 'ok' } };
+            }), { method: dapr_1.HttpMethod.POST });
+            this.logger.log('Dapr server started');
+            const resRegisteredActors = yield this.daprServer.actor.getRegisteredActors();
+            this.logger.log(`Registered Actors: ${resRegisteredActors.join(', ')}`);
+        });
+    }
+    onApplicationShutdown() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.log('Stopping Dapr server');
+            yield this.daprServer.stop();
+            this.logger.log('Dapr server stopped');
+        });
+    }
+    loadDaprHandlers() {
+        const providers = this.discoveryService.getProviders();
+        providers
+            .filter((wrapper) => wrapper.isDependencyTreeStatic() &&
+            wrapper.metatype &&
+            this.daprMetadataAccessor.getDaprActorMetadata(wrapper.metatype))
+            .forEach((wrapper) => __awaiter(this, void 0, void 0, function* () {
+            yield this.registerActor(wrapper.metatype);
+        }));
+        const controllers = this.discoveryService.getControllers();
+        [...providers, ...controllers]
+            .filter((wrapper) => wrapper.isDependencyTreeStatic())
+            .filter((wrapper) => wrapper.instance)
+            .forEach((wrapper) => __awaiter(this, void 0, void 0, function* () {
+            const { instance } = wrapper;
+            const prototype = Object.getPrototypeOf(instance) || {};
+            this.metadataScanner.scanFromPrototype(instance, prototype, (methodKey) => __awaiter(this, void 0, void 0, function* () {
+                yield this.subscribeToDaprPubSubEventIfListener(instance, methodKey);
+                yield this.subscribeToDaprBindingEventIfListener(instance, methodKey);
+            }));
+        }));
+    }
+    subscribeToDaprPubSubEventIfListener(instance, methodKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const daprPubSubMetadata = this.daprMetadataAccessor.getDaprPubSubHandlerMetadata(instance[methodKey]);
+            if (!daprPubSubMetadata) {
+                return;
+            }
+            const { name, topicName, route } = daprPubSubMetadata;
+            this.logger.log(`Subscribing to Dapr: ${name}, Topic: ${topicName}${route ? ' on route ' + route : ''}`);
+            yield this.daprServer.pubsub.subscribe(name, topicName, (data) => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    yield instance[methodKey].call(instance, data);
+                }
+                catch (err) {
+                    if (this.options.onError) {
+                        const response = this.options.onError(name, topicName, err);
+                        if (response == dapr_1.DaprPubSubStatusEnum.RETRY) {
+                            this.logger.debug('Retrying pubsub handler operation');
+                        }
+                        else if (response == dapr_1.DaprPubSubStatusEnum.DROP) {
+                            this.logger.debug('Dropping message');
+                        }
+                        return response;
+                    }
+                }
+                return dapr_1.DaprPubSubStatusEnum.SUCCESS;
+            }), route);
+        });
+    }
+    subscribeToDaprBindingEventIfListener(instance, methodKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const daprBindingMetadata = this.daprMetadataAccessor.getDaprBindingHandlerMetadata(instance[methodKey]);
+            if (!daprBindingMetadata) {
+                return;
+            }
+            const { name } = daprBindingMetadata;
+            this.logger.log(`Registering Dapr binding: ${name}`);
+            yield this.daprServer.binding.receive(name, (data) => __awaiter(this, void 0, void 0, function* () {
+                yield instance[methodKey].call(instance, data);
+            }));
+        });
+    }
+    registerActor(actorType) {
+        var _a, _b, _c, _d;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!actorType)
+                return;
+            const actorTypeName = (_a = actorType.name) !== null && _a !== void 0 ? _a : actorType.constructor.name;
+            const daprActorMetadata = this.daprMetadataAccessor.getDaprActorMetadata(actorType);
+            const interfaceTypeName = (_c = (_b = daprActorMetadata === null || daprActorMetadata === void 0 ? void 0 : daprActorMetadata.interfaceType) === null || _b === void 0 ? void 0 : _b.name) !== null && _c !== void 0 ? _c : (_d = daprActorMetadata === null || daprActorMetadata === void 0 ? void 0 : daprActorMetadata.interfaceType) === null || _d === void 0 ? void 0 : _d.constructor.name;
+            this.logger.log(`Registering Dapr Actor: ${actorTypeName} of type ${interfaceTypeName !== null && interfaceTypeName !== void 0 ? interfaceTypeName : 'unknown'}`);
+            yield this.daprServer.actor.registerActor(actorType);
+            this.daprActorClient.register(actorTypeName, actorType, this.daprServer.client);
+            if (daprActorMetadata.interfaceType) {
+                this.daprActorClient.registerInterface(actorType, daprActorMetadata.interfaceType, this.daprServer.client);
+            }
+            return actorTypeName;
+        });
+    }
+};
+DaprLoader = DaprLoader_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(4, (0, common_1.Inject)(dapr_module_1.DAPR_MODULE_OPTIONS_TOKEN)),
+    __metadata("design:paramtypes", [core_1.DiscoveryService,
+        core_1.MetadataScanner,
+        dapr_1.DaprServer,
+        dapr_metadata_accessor_1.DaprMetadataAccessor, Object, dapr_actor_client_service_1.DaprActorClient,
+        core_1.ModuleRef])
+], DaprLoader);
+exports.DaprLoader = DaprLoader;

package/dist/dapr.module.d.ts

@@ -0,0 +1,28 @@
+import { CommunicationProtocolEnum, DaprPubSubStatusEnum } from '@dapr/dapr';
+import { DaprClientOptions } from '@dapr/dapr/types/DaprClientOptions';
+import { DynamicModule, ModuleMetadata, Provider, Type } from '@nestjs/common';
+export declare const DAPR_MODULE_OPTIONS_TOKEN = "DAPR_MODULE_OPTIONS_TOKEN";
+export interface DaprModuleOptions {
+    serverHost?: string;
+    serverPort?: string;
+    communicationProtocol?: CommunicationProtocolEnum;
+    clientOptions?: DaprClientOptions;
+    onError?: (name: string, topicName: string, error: any) => DaprPubSubStatusEnum;
+}
+export interface DaprModuleOptionsFactory {
+    createDaprModuleOptions(): Promise<DaprModuleOptions> | DaprModuleOptions;
+}
+export declare function createOptionsProvider(options: DaprModuleOptions): any;
+export interface DaprModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
+    useExisting?: Type<DaprModuleOptionsFactory>;
+    useClass?: Type<DaprModuleOptionsFactory>;
+    useFactory?: (...args: any[]) => Promise<DaprModuleOptions> | DaprModuleOptions;
+    inject?: any[];
+    extraProviders?: Provider[];
+}
+export declare class DaprModule {
+    static register(options?: DaprModuleOptions): DynamicModule;
+    static registerAsync(options: DaprModuleAsyncOptions): DynamicModule;
+    private static createAsyncProviders;
+    private static createAsyncOptionsProvider;
+}

package/dist/dapr.module.js

@@ -0,0 +1,133 @@
+"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) {
+        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 DaprModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DaprModule = exports.createOptionsProvider = 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 dapr_metadata_accessor_1 = require("./dapr-metadata.accessor");
+const dapr_loader_1 = require("./dapr.loader");
+exports.DAPR_MODULE_OPTIONS_TOKEN = 'DAPR_MODULE_OPTIONS_TOKEN';
+function createOptionsProvider(options) {
+    if (!options.clientOptions.actor) {
+        options.clientOptions.actor = {
+            reentrancy: {
+                enabled: true,
+                maxStackDepth: 6,
+            },
+            actorIdleTimeout: '15m',
+            actorScanInterval: '1m',
+        };
+    }
+    return { provide: exports.DAPR_MODULE_OPTIONS_TOKEN, useValue: options || {} };
+}
+exports.createOptionsProvider = createOptionsProvider;
+let DaprModule = DaprModule_1 = class DaprModule {
+    static register(options) {
+        return {
+            global: true,
+            module: DaprModule_1,
+            imports: [core_1.DiscoveryModule],
+            providers: [
+                createOptionsProvider(options),
+                {
+                    provide: dapr_1.DaprServer,
+                    useValue: new dapr_1.DaprServer({
+                        serverHost: options.serverHost,
+                        serverPort: options.serverPort,
+                        clientOptions: options.clientOptions,
+                        communicationProtocol: options.communicationProtocol,
+                    }),
+                },
+                {
+                    provide: dapr_1.DaprClient,
+                    useFactory: (daprServer) => daprServer.client,
+                    inject: [dapr_1.DaprServer],
+                },
+                dapr_loader_1.DaprLoader,
+                dapr_metadata_accessor_1.DaprMetadataAccessor,
+                core_1.Reflector,
+            ],
+            exports: [dapr_1.DaprClient],
+        };
+    }
+    static registerAsync(options) {
+        return {
+            global: true,
+            module: DaprModule_1,
+            imports: [...options.imports, core_1.DiscoveryModule],
+            providers: [
+                ...this.createAsyncProviders(options),
+                {
+                    provide: dapr_1.DaprServer,
+                    useFactory: ({ serverHost, serverPort, communicationProtocol, clientOptions, }) => new dapr_1.DaprServer({
+                        serverHost,
+                        serverPort,
+                        clientOptions,
+                        communicationProtocol,
+                    }),
+                    inject: [exports.DAPR_MODULE_OPTIONS_TOKEN],
+                },
+                {
+                    provide: dapr_1.DaprClient,
+                    useFactory: (daprServer) => daprServer.client,
+                    inject: [dapr_1.DaprServer],
+                },
+                dapr_loader_1.DaprLoader,
+                dapr_metadata_accessor_1.DaprMetadataAccessor,
+                core_1.Reflector,
+                ...(options.extraProviders || []),
+            ],
+            exports: [dapr_1.DaprClient],
+        };
+    }
+    static createAsyncProviders(options) {
+        if (options.useExisting || options.useFactory) {
+            return [this.createAsyncOptionsProvider(options)];
+        }
+        return [
+            this.createAsyncOptionsProvider(options),
+            {
+                provide: options.useClass,
+                useClass: options.useClass,
+            },
+        ];
+    }
+    static createAsyncOptionsProvider(options) {
+        if (options.useFactory) {
+            return {
+                provide: exports.DAPR_MODULE_OPTIONS_TOKEN,
+                useFactory: options.useFactory,
+                inject: options.inject || [],
+            };
+        }
+        return {
+            provide: exports.DAPR_MODULE_OPTIONS_TOKEN,
+            useFactory: (optionsFactory) => __awaiter(this, void 0, void 0, function* () { return optionsFactory.createDaprModuleOptions(); }),
+            inject: [options.useExisting || options.useClass],
+        };
+    }
+};
+DaprModule = DaprModule_1 = __decorate([
+    (0, common_1.Module)({
+        providers: [dapr_actor_client_service_1.DaprActorClient],
+        exports: [dapr_actor_client_service_1.DaprActorClient],
+    })
+], DaprModule);
+exports.DaprModule = DaprModule;

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+import { DaprActorClient } from './actors/dapr-actor-client.service';
+import { StatefulActorOf } from './actors/stateful-actor-of';
+import { StatefulActor } from './actors/stateful.actor';
+import { DAPR_BINDING_METADATA, DAPR_PUBSUB_METADATA } from './constants';
+import { DaprActor, DaprActorMetadata } from './dapr-actor.decorator';
+import { DaprBinding, DaprBindingMetadata } from './dapr-binding.decorator';
+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, DaprMetadataAccessor, DaprBindingMetadata, DaprBinding, DaprPubSubMetadata, DaprPubSub, DaprActorMetadata, DaprActor, DaprLoader, DaprModule, DaprActorClient, StatefulActor, StatefulActorOf, };