@rayondigital/nest-dapr 0.9.64 → 0.9.66

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/dapr-actor-providers.module.d.ts

@@ -0,0 +1,5 @@
+import { DynamicModule } from '@nestjs/common';
+export declare class DaprActorProvidersModule {
+    static forRoot(): DynamicModule;
+    private static discoverAndCreateProviders;
+}

package/dist/dapr-actor-providers.module.js

@@ -0,0 +1,61 @@
+"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 DaprActorProvidersModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DaprActorProvidersModule = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const constants_1 = require("./constants");
+let DaprActorProvidersModule = DaprActorProvidersModule_1 = class DaprActorProvidersModule {
+    static forRoot() {
+        const providerBuilder = {
+            provide: 'DAPR_ACTOR_PROVIDER_BUILDER',
+            useFactory: (discoveryService, reflector) => {
+                return this.discoverAndCreateProviders(discoveryService, reflector);
+            },
+            inject: [core_1.DiscoveryService, core_1.Reflector],
+        };
+        return {
+            module: DaprActorProvidersModule_1,
+            global: true,
+            imports: [core_1.DiscoveryModule],
+            providers: [providerBuilder],
+            exports: [providerBuilder],
+        };
+    }
+    static discoverAndCreateProviders(discoveryService, reflector) {
+        const providers = [];
+        const processedProviders = new Set();
+        const actorWrappers = discoveryService
+            .getProviders()
+            .filter((wrapper) => wrapper.isDependencyTreeStatic() &&
+            wrapper.metatype &&
+            reflector.get(constants_1.DAPR_ACTOR_METADATA, wrapper.metatype));
+        actorWrappers.forEach((wrapper) => {
+            const metadata = reflector.get(constants_1.DAPR_ACTOR_METADATA, wrapper.metatype);
+            if (metadata && metadata.providers) {
+                metadata.providers.forEach((providerType) => {
+                    if (!processedProviders.has(providerType)) {
+                        providers.push({
+                            provide: providerType,
+                            useClass: providerType,
+                        });
+                        processedProviders.add(providerType);
+                    }
+                });
+            }
+        });
+        return providers;
+    }
+};
+DaprActorProvidersModule = DaprActorProvidersModule_1 = __decorate([
+    (0, common_1.Module)({
+        imports: [core_1.DiscoveryModule],
+    })
+], DaprActorProvidersModule);
+exports.DaprActorProvidersModule = DaprActorProvidersModule;

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

@@ -5,8 +5,12 @@ export interface StateProperty {
     type: Function | Type<any>;
     defaultValue?: any;
     serializable?: boolean;
+    serializeFn?: (value: any) => object | string | number | boolean | null | undefined;
+    deserializeFn?: (value: any) => any;
 }
 export declare function State(options?: {
     defaultValue?: any;
     name?: string;
+    serialize?: (value: any) => any;
+    deserialize?: (value: any) => any;
 }): PropertyDecorator;

package/dist/dapr-actor-state.decorator.js

@@ -14,6 +14,8 @@ function State(options) {
             type,
             defaultValue: options === null || options === void 0 ? void 0 : options.defaultValue,
             serializable,
+            deserializeFn: options === null || options === void 0 ? void 0 : options.deserialize,
+            serializeFn: options === null || options === void 0 ? void 0 : options.serialize,
         });
         Reflect.defineMetadata(constants_1.DAPR_ACTOR_STATE_METADATA, properties, target.constructor);
     };

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

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

package/dist/dapr-actor.decorator.js

@@ -1,16 +1,22 @@
 "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) {
     return (target) => {
-        var _a;
+        var _a, _b;
         (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,
+            providers: (_b = options.providers) !== null && _b !== void 0 ? _b : [],
         })(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/dist/dapr.module.js

@@ -30,6 +30,7 @@ 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_actor_providers_module_1 = require("./dapr-actor-providers.module");
 exports.DAPR_MODULE_OPTIONS_TOKEN = 'DAPR_MODULE_OPTIONS_TOKEN';
 var DaprContextProvider;
 (function (DaprContextProvider) {
@@ -56,7 +57,7 @@ let DaprModule = DaprModule_1 = class DaprModule {
         return {
             global: true,
             module: DaprModule_1,
-            imports: [core_1.DiscoveryModule, nestjs_cls_1.ClsModule],
+            imports: [core_1.DiscoveryModule, nestjs_cls_1.ClsModule, dapr_actor_providers_module_1.DaprActorProvidersModule],
             providers: [
                 createOptionsProvider(options),
                 {
@@ -169,7 +170,7 @@ let DaprModule = DaprModule_1 = class DaprModule {
 };
 DaprModule = DaprModule_1 = __decorate([
     (0, common_1.Module)({
-        imports: [nestjs_cls_1.ClsModule, core_1.DiscoveryModule],
+        imports: [nestjs_cls_1.ClsModule, core_1.DiscoveryModule, dapr_actor_providers_module_1.DaprActorProvidersModule],
         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],
     })

package/package.json

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