@rayondigital/nest-dapr 0.9.43 → 0.9.44

package/dist/constants.d.ts

@@ -1,5 +1,6 @@
 export declare const DAPR_BINDING_METADATA = "DAPR_BINDING_METADATA";
 export declare const DAPR_PUBSUB_METADATA = "DAPR_PUBSUB_METADATA";
 export declare const DAPR_ACTOR_PUBSUB_METADATA = "DAPR_PUBSUB_METADATA";
+export declare const DAPR_ACTOR_EVENT_METADATA = "DAPR_ACTOR_EVENT_METADATA";
 export declare const DAPR_ACTOR_METADATA = "DAPR_ACTOR_METADATA";
 export declare const DAPR_ACTOR_STATE_METADATA = "DAPR_ACTOR_STATE_METADATA";

package/dist/constants.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DAPR_ACTOR_STATE_METADATA = exports.DAPR_ACTOR_METADATA = exports.DAPR_ACTOR_PUBSUB_METADATA = exports.DAPR_PUBSUB_METADATA = exports.DAPR_BINDING_METADATA = void 0;
+exports.DAPR_ACTOR_STATE_METADATA = exports.DAPR_ACTOR_METADATA = exports.DAPR_ACTOR_EVENT_METADATA = exports.DAPR_ACTOR_PUBSUB_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_PUBSUB_METADATA = 'DAPR_PUBSUB_METADATA';
+exports.DAPR_ACTOR_EVENT_METADATA = 'DAPR_ACTOR_EVENT_METADATA';
 exports.DAPR_ACTOR_METADATA = 'DAPR_ACTOR_METADATA';
 exports.DAPR_ACTOR_STATE_METADATA = 'DAPR_ACTOR_STATE_METADATA';

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

@@ -0,0 +1,7 @@
+export interface DaprActorOnEventMetadata<T> {
+    event: DaprActorEventType;
+    actorId: (payload: T) => string;
+    ignoreErrors?: boolean;
+}
+export type DaprActorEventType = string | symbol | string[] | symbol[];
+export declare function DaprActorOnEvent<T>(event: DaprActorEventType, actorId: (payload: T) => string, ignoreErrors?: boolean): MethodDecorator;

package/dist/dapr-actor-on-event.decorator.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DaprActorOnEvent = void 0;
+const extend_metadata_util_1 = require("@nestjs/common/utils/extend-metadata.util");
+const constants_1 = require("./constants");
+function DaprActorOnEvent(event, actorId, ignoreErrors) {
+    const decoratorFactory = (target, key, descriptor) => {
+        (0, extend_metadata_util_1.extendArrayMetadata)(constants_1.DAPR_ACTOR_EVENT_METADATA, [{ event, actorId, ignoreErrors }], descriptor.value);
+        return descriptor;
+    };
+    decoratorFactory.KEY = constants_1.DAPR_ACTOR_EVENT_METADATA;
+    return decoratorFactory;
+}
+exports.DaprActorOnEvent = DaprActorOnEvent;

package/dist/dapr-event-emitter.service.d.ts

@@ -0,0 +1,14 @@
+import { OnOptions } from 'eventemitter2';
+export declare class DaprEventEmitter {
+    private readonly logger;
+    private readonly eventEmitter;
+    emit(event: string, ...args: any[]): void;
+    emitAsync(event: string, ...args: any[]): Promise<any[]>;
+    on(event: string | symbol | string[] | symbol[], listener: (...args: any[]) => void, options?: boolean | OnOptions): void;
+    off(event: string, listener: (...args: any[]) => void): void;
+    prependListener(event: string, listener: (...args: any[]) => void): void;
+    once(event: string, listener: (...args: any[]) => void): void;
+    hasListeners(event: string): boolean;
+    listeners(event: string): import("eventemitter2").ListenerFn[];
+    removeAllListeners(event?: string): void;
+}

package/dist/dapr-event-emitter.service.js

@@ -0,0 +1,57 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var DaprEventEmitter_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DaprEventEmitter = void 0;
+const common_1 = require("@nestjs/common");
+const eventemitter2_1 = __importDefault(require("eventemitter2"));
+let DaprEventEmitter = DaprEventEmitter_1 = class DaprEventEmitter {
+    constructor() {
+        this.logger = new common_1.Logger(DaprEventEmitter_1.name);
+        this.eventEmitter = new eventemitter2_1.default({
+            maxListeners: 50,
+            ignoreErrors: true,
+            wildcard: true,
+            verboseMemoryLeak: true,
+        });
+    }
+    emit(event, ...args) {
+        this.eventEmitter.emit(event, ...args);
+    }
+    emitAsync(event, ...args) {
+        return this.eventEmitter.emitAsync(event, ...args);
+    }
+    on(event, listener, options) {
+        this.eventEmitter.on(event, listener, options);
+    }
+    off(event, listener) {
+        this.eventEmitter.off(event, listener);
+    }
+    prependListener(event, listener) {
+        this.eventEmitter.prependListener(event, listener);
+    }
+    once(event, listener) {
+        this.eventEmitter.once(event, listener);
+    }
+    hasListeners(event) {
+        return this.eventEmitter.listeners(event).length > 0;
+    }
+    listeners(event) {
+        return this.eventEmitter.listeners(event);
+    }
+    removeAllListeners(event) {
+        this.eventEmitter.removeAllListeners(event);
+    }
+};
+DaprEventEmitter = DaprEventEmitter_1 = __decorate([
+    (0, common_1.Injectable)()
+], DaprEventEmitter);
+exports.DaprEventEmitter = DaprEventEmitter;

package/dist/dapr-event-subscriber.loader.d.ts

@@ -0,0 +1,19 @@
+import { OnApplicationBootstrap, OnApplicationShutdown } from '@nestjs/common';
+import { DiscoveryService, MetadataScanner } from '@nestjs/core';
+import { DaprActorClient } from './actors/dapr-actor-client.service';
+import { DaprEventEmitter } from './dapr-event-emitter.service';
+import { DaprMetadataAccessor } from './dapr-metadata.accessor';
+export declare class DaprEventSubscriberLoader implements OnApplicationBootstrap, OnApplicationShutdown {
+    private readonly discoveryService;
+    private readonly metadataAccessor;
+    private readonly metadataScanner;
+    private readonly eventEmitter;
+    private readonly actorClient;
+    private readonly logger;
+    constructor(discoveryService: DiscoveryService, metadataAccessor: DaprMetadataAccessor, metadataScanner: MetadataScanner, eventEmitter: DaprEventEmitter, actorClient: DaprActorClient);
+    onApplicationBootstrap(): void;
+    onApplicationShutdown(): void;
+    loadEventListeners(): void;
+    private subscribeToEventIfListener;
+    private registerActorEventListener;
+}

package/dist/dapr-event-subscriber.loader.js

@@ -0,0 +1,97 @@
+"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) {
+        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.DaprEventSubscriberLoader = void 0;
+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_event_emitter_service_1 = require("./dapr-event-emitter.service");
+const dapr_metadata_accessor_1 = require("./dapr-metadata.accessor");
+let DaprEventSubscriberLoader = class DaprEventSubscriberLoader {
+    constructor(discoveryService, metadataAccessor, metadataScanner, eventEmitter, actorClient) {
+        this.discoveryService = discoveryService;
+        this.metadataAccessor = metadataAccessor;
+        this.metadataScanner = metadataScanner;
+        this.eventEmitter = eventEmitter;
+        this.actorClient = actorClient;
+        this.logger = new common_1.Logger('DaprEventSubscriber');
+    }
+    onApplicationBootstrap() {
+        this.loadEventListeners();
+    }
+    onApplicationShutdown() {
+        this.eventEmitter.removeAllListeners();
+    }
+    loadEventListeners() {
+        const providers = this.discoveryService.getProviders();
+        const controllers = this.discoveryService.getControllers();
+        [...providers, ...controllers]
+            .filter((wrapper) => wrapper.instance && !wrapper.isAlias)
+            .forEach((wrapper) => {
+            const { instance } = wrapper;
+            const prototype = Object.getPrototypeOf(instance) || {};
+            this.metadataScanner.scanFromPrototype(instance, prototype, (methodKey) => this.subscribeToEventIfListener(instance, methodKey));
+        });
+    }
+    subscribeToEventIfListener(instance, methodKey) {
+        const actorMetadata = this.metadataAccessor.getDaprActorMetadata(instance.constructor);
+        if (!actorMetadata) {
+            return;
+        }
+        const eventListenerMetadatas = this.metadataAccessor.getDaprEventHandlerMetadata(instance[methodKey]);
+        if (!eventListenerMetadatas) {
+            return;
+        }
+        for (const eventListenerMetadata of eventListenerMetadatas) {
+            if (!eventListenerMetadata.actorId)
+                continue;
+            this.registerActorEventListener(actorMetadata, eventListenerMetadata, methodKey, eventListenerMetadata.ignoreErrors);
+        }
+    }
+    registerActorEventListener(actorMetadata, eventMetadata, methodKey, ignoreErrors = false) {
+        this.eventEmitter.on(eventMetadata.event, (data) => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                const actorId = eventMetadata.actorId(data);
+                const actorType = (_a = actorMetadata.interfaceType.name) !== null && _a !== void 0 ? _a : actorMetadata.interfaceType.constructor.name;
+                const actor = this.actorClient.getActorByTypeName(actorType, actorId);
+                return yield actor[methodKey].call(actor, data);
+            }
+            catch (e) {
+                this.logger.error(e);
+                if (!ignoreErrors) {
+                    throw e;
+                }
+            }
+        }), {
+            async: true,
+            promisify: true,
+        });
+    }
+};
+DaprEventSubscriberLoader = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [core_1.DiscoveryService,
+        dapr_metadata_accessor_1.DaprMetadataAccessor,
+        core_1.MetadataScanner,
+        dapr_event_emitter_service_1.DaprEventEmitter,
+        dapr_actor_client_service_1.DaprActorClient])
+], DaprEventSubscriberLoader);
+exports.DaprEventSubscriberLoader = DaprEventSubscriberLoader;

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

@@ -1,5 +1,6 @@
 import { Type } from '@nestjs/common';
 import { Reflector } from '@nestjs/core';
+import { DaprActorOnEventMetadata } from './dapr-actor-on-event.decorator';
 import { DaprActorMetadata } from './dapr-actor.decorator';
 import { DaprBindingMetadata } from './dapr-binding.decorator';
 import { DaprPubSubMetadata } from './dapr-pubsub.decorator';
@@ -9,4 +10,5 @@ export declare class DaprMetadataAccessor {
     getDaprPubSubHandlerMetadata(target: Type<unknown>): DaprPubSubMetadata | undefined;
     getDaprBindingHandlerMetadata(target: Type<unknown>): DaprBindingMetadata | undefined;
     getDaprActorMetadata(target: Function | Type<unknown>): DaprActorMetadata | undefined;
+    getDaprEventHandlerMetadata(target: Type<unknown>): DaprActorOnEventMetadata<any>[] | undefined;
 }

package/dist/dapr-metadata.accessor.js

@@ -26,6 +26,16 @@ let DaprMetadataAccessor = class DaprMetadataAccessor {
     getDaprActorMetadata(target) {
         return this.reflector.get(constants_1.DAPR_ACTOR_METADATA, target);
     }
+    getDaprEventHandlerMetadata(target) {
+        if (!target || (typeof target !== 'function' && typeof target !== 'object')) {
+            return undefined;
+        }
+        const metadata = this.reflector.get(constants_1.DAPR_ACTOR_EVENT_METADATA, target);
+        if (!metadata) {
+            return undefined;
+        }
+        return Array.isArray(metadata) ? metadata : [metadata];
+    }
 };
 DaprMetadataAccessor = __decorate([
     (0, common_1.Injectable)(),

package/dist/dapr.module.js

@@ -25,9 +25,11 @@ const actor_runtime_service_1 = require("./actors/actor-runtime.service");
 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_event_subscriber_loader_1 = require("./dapr-event-subscriber.loader");
 const dapr_metadata_accessor_1 = require("./dapr-metadata.accessor");
 const dapr_loader_1 = require("./dapr.loader");
 const dapr_pubsub_client_service_1 = require("./pubsub/dapr-pubsub-client.service");
+const dapr_event_emitter_service_1 = require("./dapr-event-emitter.service");
 exports.DAPR_MODULE_OPTIONS_TOKEN = 'DAPR_MODULE_OPTIONS_TOKEN';
 var DaprContextProvider;
 (function (DaprContextProvider) {
@@ -75,12 +77,22 @@ let DaprModule = DaprModule_1 = class DaprModule {
                 },
                 dapr_loader_1.DaprLoader,
                 dapr_metadata_accessor_1.DaprMetadataAccessor,
+                dapr_event_subscriber_loader_1.DaprEventSubscriberLoader,
                 dapr_context_service_1.DaprContextService,
                 dapr_actor_client_service_1.DaprActorClient,
                 dapr_pubsub_client_service_1.DaprPubSubClient,
+                dapr_event_emitter_service_1.DaprEventEmitter,
                 core_1.Reflector,
             ],
-            exports: [dapr_1.DaprClient, dapr_pubsub_client_service_1.DaprPubSubClient, dapr_context_service_1.DaprContextService, actor_runtime_service_1.ActorRuntimeService, dapr_actor_client_service_1.DaprActorClient],
+            exports: [
+                dapr_1.DaprClient,
+                dapr_pubsub_client_service_1.DaprPubSubClient,
+                dapr_context_service_1.DaprContextService,
+                actor_runtime_service_1.ActorRuntimeService,
+                dapr_actor_client_service_1.DaprActorClient,
+                dapr_event_subscriber_loader_1.DaprEventSubscriberLoader,
+                dapr_event_emitter_service_1.DaprEventEmitter,
+            ],
         };
     }
     static registerAsync(options) {
@@ -109,13 +121,23 @@ let DaprModule = DaprModule_1 = class DaprModule {
                 },
                 dapr_loader_1.DaprLoader,
                 dapr_metadata_accessor_1.DaprMetadataAccessor,
+                dapr_event_subscriber_loader_1.DaprEventSubscriberLoader,
                 dapr_context_service_1.DaprContextService,
                 dapr_actor_client_service_1.DaprActorClient,
                 dapr_pubsub_client_service_1.DaprPubSubClient,
+                dapr_event_emitter_service_1.DaprEventEmitter,
                 core_1.Reflector,
                 ...(options.extraProviders || []),
             ],
-            exports: [dapr_1.DaprClient, dapr_pubsub_client_service_1.DaprPubSubClient, dapr_context_service_1.DaprContextService, actor_runtime_service_1.ActorRuntimeService, dapr_actor_client_service_1.DaprActorClient],
+            exports: [
+                dapr_1.DaprClient,
+                dapr_pubsub_client_service_1.DaprPubSubClient,
+                dapr_context_service_1.DaprContextService,
+                actor_runtime_service_1.ActorRuntimeService,
+                dapr_actor_client_service_1.DaprActorClient,
+                dapr_event_subscriber_loader_1.DaprEventSubscriberLoader,
+                dapr_event_emitter_service_1.DaprEventEmitter,
+            ],
         };
     }
     static createAsyncProviders(options) {
@@ -147,9 +169,9 @@ let DaprModule = DaprModule_1 = class DaprModule {
 };
 DaprModule = DaprModule_1 = __decorate([
     (0, common_1.Module)({
-        imports: [nestjs_cls_1.ClsModule],
-        providers: [dapr_actor_client_service_1.DaprActorClient, nest_actor_manager_1.NestActorManager, dapr_context_service_1.DaprContextService, actor_runtime_service_1.ActorRuntimeService],
-        exports: [dapr_actor_client_service_1.DaprActorClient, dapr_context_service_1.DaprContextService, actor_runtime_service_1.ActorRuntimeService],
+        imports: [nestjs_cls_1.ClsModule, core_1.DiscoveryModule],
+        providers: [dapr_actor_client_service_1.DaprActorClient, nest_actor_manager_1.NestActorManager, dapr_context_service_1.DaprContextService, dapr_event_subscriber_loader_1.DaprEventSubscriberLoader, actor_runtime_service_1.ActorRuntimeService],
+        exports: [dapr_actor_client_service_1.DaprActorClient, dapr_context_service_1.DaprContextService, dapr_event_subscriber_loader_1.DaprEventSubscriberLoader, actor_runtime_service_1.ActorRuntimeService],
     })
 ], DaprModule);
 exports.DaprModule = DaprModule;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rayondigital/nest-dapr",
-  "version": "0.9.43",
+  "version": "0.9.44",
   "description": "Develop NestJs microservices using Dapr pubsub, actors and other bindings",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -25,7 +25,12 @@
     "@nestjs/common": "^10.0.0",
     "@nestjs/core": "^10.0.0",
     "nestjs-cls": "^3.0.0",
-    "rxjs": "^7.1.0"
+    "rxjs": "^7.1.0",
+    "eventemitter2": "^6.0.0"
+  },
+  "dependencies": {
+    "@dapr/dapr": "^3.2.0",
+    "async-lock": "^1.4.1"
   },
   "devDependencies": {
     "@nestjs/platform-express": "^10.0.0",
@@ -45,10 +50,6 @@
     "ts-node": "^10.9.1",
     "typescript": "^4.7.4"
   },
-  "dependencies": {
-    "@dapr/dapr": "^3.2.0",
-    "async-lock": "^1.4.1"
-  },
   "optionalDependencies": {
     "nestjs-cls": "^3.6.0"
   },