@rayondigital/nest-dapr 0.9.73 → 0.9.74

package/dist/constants.d.ts

@@ -4,3 +4,5 @@ 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";
+export declare const DAPR_ACTIVITY_METADATA = "DAPR_ACTIVITY_METADATA";
+export declare const DAPR_WORKFLOW_METADATA = "DAPR_WORKFLOW_METADATA";

package/dist/constants.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-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_WORKFLOW_METADATA = exports.DAPR_ACTIVITY_METADATA = 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';
+exports.DAPR_ACTIVITY_METADATA = 'DAPR_ACTIVITY_METADATA';
+exports.DAPR_WORKFLOW_METADATA = 'DAPR_WORKFLOW_METADATA';

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

@@ -0,0 +1,6 @@
+import { Type } from '@nestjs/common';
+export interface DaprActivityMetadata {
+    name?: string;
+}
+export declare function DaprActivity(options?: DaprActivityMetadata): ClassDecorator;
+export declare function getActivityMetadata(target: Type<any>): DaprActivityMetadata;

package/dist/dapr-activity.decorator.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getActivityMetadata = exports.DaprActivity = void 0;
+const common_1 = require("@nestjs/common");
+const constants_1 = require("./constants");
+function DaprActivity(options) {
+    return (target) => {
+        (0, common_1.SetMetadata)(constants_1.DAPR_ACTIVITY_METADATA, {
+            name: options === null || options === void 0 ? void 0 : options.name,
+        })(target);
+        (0, common_1.Injectable)({ scope: common_1.Scope.DEFAULT })(target);
+    };
+}
+exports.DaprActivity = DaprActivity;
+function getActivityMetadata(target) {
+    return Reflect.getMetadata(constants_1.DAPR_ACTIVITY_METADATA, target);
+}
+exports.getActivityMetadata = getActivityMetadata;

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

@@ -1,14 +1,18 @@
 import { Type } from '@nestjs/common';
 import { Reflector } from '@nestjs/core';
+import { DaprActivityMetadata } from './dapr-activity.decorator';
 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';
+import { DaprWorkflowMetadata } from './dapr-workflow.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;
+    getDaprActivityMetadata(target: Function | Type<unknown>): DaprActivityMetadata | undefined;
+    getDaprWorkflowMetadata(target: Function | Type<unknown>): DaprWorkflowMetadata | undefined;
     getDaprEventHandlerMetadata(target: Type<unknown>): DaprActorOnEventMetadata<any>[] | undefined;
 }

package/dist/dapr-metadata.accessor.js

@@ -26,6 +26,12 @@ let DaprMetadataAccessor = class DaprMetadataAccessor {
     getDaprActorMetadata(target) {
         return this.reflector.get(constants_1.DAPR_ACTOR_METADATA, target);
     }
+    getDaprActivityMetadata(target) {
+        return this.reflector.get(constants_1.DAPR_ACTIVITY_METADATA, target);
+    }
+    getDaprWorkflowMetadata(target) {
+        return this.reflector.get(constants_1.DAPR_WORKFLOW_METADATA, target);
+    }
     getDaprEventHandlerMetadata(target) {
         if (!target || (typeof target !== 'function' && typeof target !== 'object')) {
             return undefined;

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

@@ -0,0 +1,6 @@
+import { Type } from '@nestjs/common';
+export interface DaprWorkflowMetadata {
+    name?: string;
+}
+export declare function DaprWorkflow(options?: DaprWorkflowMetadata): ClassDecorator;
+export declare function getWorkflowMetadata(target: Type<any>): DaprWorkflowMetadata;

package/dist/dapr-workflow.decorator.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWorkflowMetadata = exports.DaprWorkflow = void 0;
+const common_1 = require("@nestjs/common");
+const constants_1 = require("./constants");
+function DaprWorkflow(options) {
+    return (target) => {
+        (0, common_1.SetMetadata)(constants_1.DAPR_WORKFLOW_METADATA, {
+            name: options === null || options === void 0 ? void 0 : options.name,
+        })(target);
+        (0, common_1.Injectable)({ scope: common_1.Scope.DEFAULT })(target);
+    };
+}
+exports.DaprWorkflow = DaprWorkflow;
+function getWorkflowMetadata(target) {
+    return Reflect.getMetadata(constants_1.DAPR_WORKFLOW_METADATA, target);
+}
+exports.getWorkflowMetadata = getWorkflowMetadata;

package/dist/dapr.loader.d.ts

@@ -7,6 +7,7 @@ import { DaprContextService } from './dapr-context-service';
 import { DaprMetadataAccessor } from './dapr-metadata.accessor';
 import { DaprModuleOptions } from './dapr.module';
 import { DaprPubSubClient } from './pubsub/dapr-pubsub-client.service';
+import { DaprWorkflowClient } from './workflow/dapr-workflow-client.service';
 export declare class DaprLoader implements OnApplicationBootstrap, OnApplicationShutdown {
     private readonly discoveryService;
     private readonly metadataScanner;
@@ -17,13 +18,17 @@ export declare class DaprLoader implements OnApplicationBootstrap, OnApplication
     private readonly moduleRef;
     private readonly contextService;
     private readonly pubSubClient;
+    private readonly workflowClient;
     private readonly actorManager;
     private readonly logger;
-    constructor(discoveryService: DiscoveryService, metadataScanner: MetadataScanner, daprServer: DaprServer, daprMetadataAccessor: DaprMetadataAccessor, options: DaprModuleOptions, daprActorClient: DaprActorClient, moduleRef: ModuleRef, contextService: DaprContextService, pubSubClient: DaprPubSubClient, actorManager: NestActorManager);
+    private workflowRuntime;
+    constructor(discoveryService: DiscoveryService, metadataScanner: MetadataScanner, daprServer: DaprServer, daprMetadataAccessor: DaprMetadataAccessor, options: DaprModuleOptions, daprActorClient: DaprActorClient, moduleRef: ModuleRef, contextService: DaprContextService, pubSubClient: DaprPubSubClient, workflowClient: DaprWorkflowClient, actorManager: NestActorManager);
     onApplicationBootstrap(): Promise<void>;
     onApplicationShutdown(): Promise<void>;
-    loadDaprHandlers(): void;
+    loadDaprHandlers(isActorsEnabled: boolean, isWorkflowEnabled: boolean): void;
     private subscribeToDaprPubSubEventIfListener;
     private subscribeToDaprBindingEventIfListener;
+    private registerActivity;
+    private registerWorkflow;
     private registerActor;
 }

package/dist/dapr.loader.js

@@ -37,8 +37,11 @@ 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");
 const dapr_pubsub_client_service_1 = require("./pubsub/dapr-pubsub-client.service");
+const dapr_workflow_client_service_1 = require("./workflow/dapr-workflow-client.service");
+const workflow_1 = require("./workflow/workflow");
+const workflow_activity_1 = require("./workflow/workflow-activity");
 let DaprLoader = DaprLoader_1 = class DaprLoader {
-    constructor(discoveryService, metadataScanner, daprServer, daprMetadataAccessor, options, daprActorClient, moduleRef, contextService, pubSubClient, actorManager) {
+    constructor(discoveryService, metadataScanner, daprServer, daprMetadataAccessor, options, daprActorClient, moduleRef, contextService, pubSubClient, workflowClient, actorManager) {
         this.discoveryService = discoveryService;
         this.metadataScanner = metadataScanner;
         this.daprServer = daprServer;
@@ -48,76 +51,120 @@ let DaprLoader = DaprLoader_1 = class DaprLoader {
         this.moduleRef = moduleRef;
         this.contextService = contextService;
         this.pubSubClient = pubSubClient;
+        this.workflowClient = workflowClient;
         this.actorManager = actorManager;
         this.logger = new common_1.Logger(DaprLoader_1.name);
     }
     onApplicationBootstrap() {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y;
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.options.disabled) {
-                this.logger.log('Dapr server is disabled');
-                return;
-            }
-            this.actorManager.setup(this.moduleRef, this.options);
-            if (this.options.contextProvider !== dapr_module_1.DaprContextProvider.None) {
-                this.actorManager.setupCSLWrapper(this.options, this.contextService);
+            this.logger.log('Dapr initializing');
+            const isEnabled = !this.options.disabled;
+            const isActorsEnabled = (_b = (_a = this.options.actorOptions) === null || _a === void 0 ? void 0 : _a.enabled) !== null && _b !== void 0 ? _b : true;
+            const isWorkflowEnabled = (_d = (_c = this.options.workflowOptions) === null || _c === void 0 ? void 0 : _c.enabled) !== null && _d !== void 0 ? _d : true;
+            if (isWorkflowEnabled) {
+                this.workflowRuntime = new dapr_1.WorkflowRuntime({
+                    daprHost: this.options.serverHost,
+                    daprPort: (_e = this.options.workflowOptions.daprPort) !== null && _e !== void 0 ? _e : '3501',
+                });
             }
-            if ((_c = (_b = (_a = this.options.clientOptions) === null || _a === void 0 ? void 0 : _a.actor) === null || _b === void 0 ? void 0 : _b.reentrancy) === null || _c === void 0 ? void 0 : _c.enabled) {
-                this.actorManager.setupReentrancy(this.options);
+            if (isActorsEnabled) {
+                this.actorManager.setup(this.moduleRef, this.options);
+                if (this.options.contextProvider !== dapr_module_1.DaprContextProvider.None) {
+                    this.actorManager.setupCSLWrapper(this.options, this.contextService);
+                }
+                if ((_h = (_g = (_f = this.options.clientOptions) === null || _f === void 0 ? void 0 : _f.actor) === null || _g === void 0 ? void 0 : _g.reentrancy) === null || _h === void 0 ? void 0 : _h.enabled) {
+                    this.actorManager.setupReentrancy(this.options);
+                }
             }
-            if ((_d = this.options.pubsubOptions) === null || _d === void 0 ? void 0 : _d.defaultName) {
+            if ((_j = this.options.pubsubOptions) === null || _j === void 0 ? void 0 : _j.defaultName) {
                 this.pubSubClient.setDefaultName(this.options.pubsubOptions.defaultName);
             }
-            if (this.options.actorOptions) {
-                this.daprActorClient.setAllowInternalCalls((_f = (_e = this.options.actorOptions) === null || _e === void 0 ? void 0 : _e.allowInternalCalls) !== null && _f !== void 0 ? _f : false);
-                this.daprActorClient.setPrefix((_h = (_g = this.options.actorOptions) === null || _g === void 0 ? void 0 : _g.prefix) !== null && _h !== void 0 ? _h : '', (_k = (_j = this.options.actorOptions) === null || _j === void 0 ? void 0 : _j.delimiter) !== null && _k !== void 0 ? _k : '-');
-                this.daprActorClient.setTypeNamePrefix((_m = (_l = this.options.actorOptions) === null || _l === void 0 ? void 0 : _l.typeNamePrefix) !== null && _m !== void 0 ? _m : '');
-                if ((_o = this.options.actorOptions) === null || _o === void 0 ? void 0 : _o.prefix) {
-                    this.logger.log(`Actors will be prefixed with ${(_q = (_p = this.options.actorOptions) === null || _p === void 0 ? void 0 : _p.prefix) !== null && _q !== void 0 ? _q : ''} and delimited with ${(_s = (_r = this.options.actorOptions) === null || _r === void 0 ? void 0 : _r.delimiter) !== null && _s !== void 0 ? _s : '-'}`);
+            if (isActorsEnabled) {
+                if (this.options.actorOptions) {
+                    this.daprActorClient.setAllowInternalCalls((_l = (_k = this.options.actorOptions) === null || _k === void 0 ? void 0 : _k.allowInternalCalls) !== null && _l !== void 0 ? _l : false);
+                    this.daprActorClient.setPrefix((_o = (_m = this.options.actorOptions) === null || _m === void 0 ? void 0 : _m.prefix) !== null && _o !== void 0 ? _o : '', (_q = (_p = this.options.actorOptions) === null || _p === void 0 ? void 0 : _p.delimiter) !== null && _q !== void 0 ? _q : '-');
+                    this.daprActorClient.setTypeNamePrefix((_s = (_r = this.options.actorOptions) === null || _r === void 0 ? void 0 : _r.typeNamePrefix) !== null && _s !== void 0 ? _s : '');
+                    if ((_t = this.options.actorOptions) === null || _t === void 0 ? void 0 : _t.prefix) {
+                        this.logger.log(`Actors will be prefixed with ${(_v = (_u = this.options.actorOptions) === null || _u === void 0 ? void 0 : _u.prefix) !== null && _v !== void 0 ? _v : ''} and delimited with ${(_x = (_w = this.options.actorOptions) === null || _w === void 0 ? void 0 : _w.delimiter) !== null && _x !== void 0 ? _x : '-'}`);
+                    }
+                }
+                if (isEnabled) {
+                    this.logger.log('Registering Dapr actors');
+                    yield this.daprServer.actor.init();
                 }
             }
-            yield this.daprServer.actor.init();
-            this.loadDaprHandlers();
-            if (this.options.serverPort === '0') {
-                this.logger.log('Dapr server will not be started');
-                return;
-            }
-            this.logger.log('Starting Dapr server');
-            if (this.options.catchErrors) {
-                const server = this.daprServer.daprServer.getServer();
-                if (server) {
-                    server.use((err, req, res, next) => {
-                        if (err) {
-                            this.logger.error(err, err.stack, 'DaprServer');
-                            res.status(500).send(err);
-                        }
-                    });
+            this.loadDaprHandlers(isActorsEnabled, isWorkflowEnabled);
+            if (isEnabled && this.options.serverPort !== '0') {
+                this.logger.log('Starting Dapr server');
+                if (this.options.catchErrors) {
+                    const server = this.daprServer.daprServer.getServer();
+                    if (server) {
+                        server.use((err, req, res, next) => {
+                            if (err) {
+                                this.logger.error(err, err.stack, 'DaprServer');
+                                res.status(500).send(err);
+                            }
+                        });
+                    }
                 }
+                yield this.daprServer.start();
+                this.logger.log('Dapr server started');
             }
-            yield this.daprServer.start();
-            this.logger.log('Dapr server started');
-            const resRegisteredActors = yield this.daprServer.actor.getRegisteredActors();
-            if (resRegisteredActors.length > 0) {
-                this.logger.log(`Registered Actors: ${resRegisteredActors.join(', ')}`);
+            if (isEnabled && this.options.workflowOptions.enabled) {
+                this.logger.log('Starting Dapr workflow runtime');
+                yield this.workflowRuntime.start();
+                yield this.workflowClient.start({
+                    daprHost: this.options.serverHost,
+                    daprPort: (_y = this.options.workflowOptions.daprPort) !== null && _y !== void 0 ? _y : '3501',
+                });
+            }
+            if (!isActorsEnabled || !isEnabled)
+                return;
+            const registeredActors = yield this.daprServer.actor.getRegisteredActors();
+            if (registeredActors.length > 0) {
+                this.logger.log(`Registered Actors: ${registeredActors.join(', ')}`);
             }
         });
     }
     onApplicationShutdown() {
         return __awaiter(this, void 0, void 0, function* () {
+            if (this.workflowRuntime && this.options.workflowOptions.enabled) {
+                this.logger.log('Stopping Dapr workflow runtime');
+                try {
+                    yield this.workflowRuntime.stop();
+                    yield this.workflowClient.stop();
+                }
+                catch (_a) {
+                }
+                finally {
+                    this.logger.log('Dapr workflow runtime stopped');
+                }
+            }
             this.logger.log('Stopping Dapr server');
-            yield this.daprServer.stop();
-            this.logger.log('Dapr server stopped');
+            try {
+                if (!this.options.disabled) {
+                    yield this.daprServer.stop();
+                }
+            }
+            catch (_b) {
+            }
+            finally {
+                this.logger.log('Dapr server stopped');
+            }
         });
     }
-    loadDaprHandlers() {
+    loadDaprHandlers(isActorsEnabled, isWorkflowEnabled) {
         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);
-        }));
+        if (isActorsEnabled) {
+            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())
@@ -130,6 +177,22 @@ let DaprLoader = DaprLoader_1 = class DaprLoader {
                 yield this.subscribeToDaprBindingEventIfListener(instance, methodKey);
             }));
         }));
+        if (isWorkflowEnabled) {
+            providers
+                .filter((wrapper) => wrapper.isDependencyTreeStatic() &&
+                wrapper.metatype &&
+                this.daprMetadataAccessor.getDaprActivityMetadata(wrapper.metatype))
+                .forEach((wrapper) => __awaiter(this, void 0, void 0, function* () {
+                yield this.registerActivity(wrapper.metatype);
+            }));
+            providers
+                .filter((wrapper) => wrapper.isDependencyTreeStatic() &&
+                wrapper.metatype &&
+                this.daprMetadataAccessor.getDaprWorkflowMetadata(wrapper.metatype))
+                .forEach((wrapper) => __awaiter(this, void 0, void 0, function* () {
+                yield this.registerWorkflow(wrapper.metatype);
+            }));
+        }
     }
     subscribeToDaprPubSubEventIfListener(instance, methodKey) {
         var _a, _b;
@@ -181,6 +244,36 @@ let DaprLoader = DaprLoader_1 = class DaprLoader {
             }));
         });
     }
+    registerActivity(activityType) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!activityType)
+                return;
+            const metadata = this.daprMetadataAccessor.getDaprActivityMetadata(activityType);
+            const activityTypeName = (_b = (_a = metadata.name) !== null && _a !== void 0 ? _a : activityType.name) !== null && _b !== void 0 ? _b : activityType.constructor.name;
+            if (!activityType.prototype.run) {
+                this.logger.error(`Activity ${activityTypeName} does not have a run method`);
+                return;
+            }
+            this.logger.log(`Registering Dapr Activity: ${activityTypeName}`);
+            this.workflowRuntime.registerActivityWithName(activityTypeName, (0, workflow_activity_1.lazyActivity)(this.moduleRef, activityType));
+        });
+    }
+    registerWorkflow(workflowType) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!workflowType)
+                return;
+            const metadata = this.daprMetadataAccessor.getDaprWorkflowMetadata(workflowType);
+            const workflowTypeName = (_b = (_a = metadata.name) !== null && _a !== void 0 ? _a : workflowType.name) !== null && _b !== void 0 ? _b : workflowType.constructor.name;
+            if (!workflowType.prototype.run) {
+                this.logger.error(`Workflow ${workflowTypeName} does not have a run method`);
+                return;
+            }
+            this.logger.log(`Registering Dapr Workflow: ${workflowTypeName}`);
+            this.workflowRuntime.registerWorkflowWithName(workflowTypeName, (0, workflow_1.lazyWorkflow)(this.moduleRef, workflowType));
+        });
+    }
     registerActor(actorType) {
         var _a, _b, _c, _d, _e;
         return __awaiter(this, void 0, void 0, function* () {
@@ -224,6 +317,7 @@ DaprLoader = DaprLoader_1 = __decorate([
         core_1.ModuleRef,
         dapr_context_service_1.DaprContextService,
         dapr_pubsub_client_service_1.DaprPubSubClient,
+        dapr_workflow_client_service_1.DaprWorkflowClient,
         nest_actor_manager_1.NestActorManager])
 ], DaprLoader);
 exports.DaprLoader = DaprLoader;

package/dist/dapr.module.d.ts

@@ -5,9 +5,11 @@ export declare const DAPR_MODULE_OPTIONS_TOKEN = "DAPR_MODULE_OPTIONS_TOKEN";
 export interface DaprModuleOptions {
     serverHost?: string;
     serverPort?: string;
+    serverGrpcPort?: string;
     communicationProtocol?: CommunicationProtocolEnum;
     clientOptions?: DaprClientOptions;
     actorOptions?: DaprModuleActorOptions;
+    workflowOptions?: DaprModuleWorkflowOptions;
     pubsubOptions?: DaprModulePubSubOptions;
     disabled?: boolean;
     contextProvider?: DaprContextProvider;
@@ -19,11 +21,16 @@ export interface DaprModuleLoggingOptions {
     enabled: boolean;
 }
 export interface DaprModuleActorOptions {
+    enabled: boolean;
     prefix?: string;
     delimiter?: string;
     typeNamePrefix?: string;
     allowInternalCalls?: boolean;
 }
+export interface DaprModuleWorkflowOptions {
+    enabled: boolean;
+    daprPort?: string;
+}
 export interface DaprModulePubSubOptions {
     defaultName?: string;
     onError?: (name: string, topicName: string, error: any) => DaprPubSubStatusEnum;

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_workflow_client_service_1 = require("./workflow/dapr-workflow-client.service");
 exports.DAPR_MODULE_OPTIONS_TOKEN = 'DAPR_MODULE_OPTIONS_TOKEN';
 var DaprContextProvider;
 (function (DaprContextProvider) {
@@ -48,6 +49,11 @@ function createOptionsProvider(options) {
             actorScanInterval: '1m',
         };
     }
+    if (!options.workflowOptions) {
+        options.workflowOptions = {
+            enabled: true,
+        };
+    }
     return { provide: exports.DAPR_MODULE_OPTIONS_TOKEN, useValue: options || {} };
 }
 exports.createOptionsProvider = createOptionsProvider;
@@ -82,6 +88,7 @@ let DaprModule = DaprModule_1 = class DaprModule {
                 dapr_context_service_1.DaprContextService,
                 dapr_actor_client_service_1.DaprActorClient,
                 dapr_pubsub_client_service_1.DaprPubSubClient,
+                dapr_workflow_client_service_1.DaprWorkflowClient,
                 dapr_event_emitter_service_1.DaprEventEmitter,
                 actor_runtime_service_1.ActorRuntimeService,
                 core_1.Reflector,
@@ -94,6 +101,7 @@ let DaprModule = DaprModule_1 = class DaprModule {
                 dapr_context_service_1.DaprContextService,
                 actor_runtime_service_1.ActorRuntimeService,
                 dapr_actor_client_service_1.DaprActorClient,
+                dapr_workflow_client_service_1.DaprWorkflowClient,
                 dapr_event_subscriber_loader_1.DaprEventSubscriberLoader,
                 dapr_event_emitter_service_1.DaprEventEmitter,
             ],
@@ -130,6 +138,7 @@ let DaprModule = DaprModule_1 = class DaprModule {
                 dapr_context_service_1.DaprContextService,
                 dapr_actor_client_service_1.DaprActorClient,
                 dapr_pubsub_client_service_1.DaprPubSubClient,
+                dapr_workflow_client_service_1.DaprWorkflowClient,
                 dapr_event_emitter_service_1.DaprEventEmitter,
                 actor_runtime_service_1.ActorRuntimeService,
                 core_1.Reflector,
@@ -142,6 +151,7 @@ let DaprModule = DaprModule_1 = class DaprModule {
                 dapr_context_service_1.DaprContextService,
                 actor_runtime_service_1.ActorRuntimeService,
                 dapr_actor_client_service_1.DaprActorClient,
+                dapr_workflow_client_service_1.DaprWorkflowClient,
                 dapr_event_subscriber_loader_1.DaprEventSubscriberLoader,
                 dapr_event_emitter_service_1.DaprEventEmitter,
             ],

package/dist/util/json.util.d.ts

@@ -0,0 +1 @@
+export declare function fromJson(json: any): any;

package/dist/util/json.util.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromJson = void 0;
+function fromJson(json) {
+    try {
+        if (typeof json === 'string') {
+            const isJson = json.includes('{') || json.includes('[');
+            if (isJson)
+                return JSON.parse(json);
+        }
+        return json;
+    }
+    catch (error) {
+        return json;
+    }
+}
+exports.fromJson = fromJson;

package/dist/workflow/dapr-workflow-client.service.d.ts

@@ -0,0 +1,19 @@
+import { DaprWorkflowClient as WorkflowClient, WorkflowState } from '@dapr/dapr';
+import { WorkflowClientOptions } from '@dapr/dapr/types/workflow/WorkflowClientOption';
+import { Type } from '@nestjs/common';
+import { WorkflowInput } from './workflow';
+export declare class DaprWorkflowClient {
+    client?: WorkflowClient;
+    start(options?: Partial<WorkflowClientOptions>): Promise<void>;
+    scheduleNewWorkflow(workflowName: string, input?: any, instanceId?: string, startAt?: Date): Promise<string>;
+    scheduleNewWorkflow<C extends Type<any>>(workflowClass: C, input: WorkflowInput<C>, instanceId?: string, startAt?: Date): Promise<string>;
+    terminateWorkflow(workflowInstanceId: string, output: any): Promise<void>;
+    getWorkflowState(workflowInstanceId: string, getInputsAndOutputs: boolean): Promise<WorkflowState | undefined>;
+    waitForWorkflowStart(workflowInstanceId: string, fetchPayloads?: boolean, timeoutInSeconds?: number): Promise<WorkflowState | undefined>;
+    waitForWorkflowCompletion(workflowInstanceId: string, fetchPayloads?: boolean, timeoutInSeconds?: number): Promise<WorkflowState | undefined>;
+    raiseEvent(workflowInstanceId: string, eventName: string, eventPayload?: any): Promise<void>;
+    purgeWorkflow(workflowInstanceId: string): Promise<boolean>;
+    suspendWorkflow(workflowInstanceId: string): Promise<void>;
+    resumeWorkflow(workflowInstanceId: string): Promise<void>;
+    stop(): Promise<void>;
+}

package/dist/workflow/dapr-workflow-client.service.js

@@ -0,0 +1,90 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DaprWorkflowClient = void 0;
+const dapr_1 = require("@dapr/dapr");
+const common_1 = require("@nestjs/common");
+let DaprWorkflowClient = class DaprWorkflowClient {
+    start(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.client = new dapr_1.DaprWorkflowClient(options);
+        });
+    }
+    scheduleNewWorkflow(wf, input, instanceId, startAt) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.client.scheduleNewWorkflow(wf, input, instanceId, startAt);
+        });
+    }
+    terminateWorkflow(workflowInstanceId, output) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            yield ((_a = this.client) === null || _a === void 0 ? void 0 : _a.terminateWorkflow(workflowInstanceId, output));
+        });
+    }
+    getWorkflowState(workflowInstanceId, getInputsAndOutputs) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            return (_a = this.client) === null || _a === void 0 ? void 0 : _a.getWorkflowState(workflowInstanceId, getInputsAndOutputs);
+        });
+    }
+    waitForWorkflowStart(workflowInstanceId, fetchPayloads, timeoutInSeconds) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            return (_a = this.client) === null || _a === void 0 ? void 0 : _a.waitForWorkflowStart(workflowInstanceId, fetchPayloads, timeoutInSeconds);
+        });
+    }
+    waitForWorkflowCompletion(workflowInstanceId, fetchPayloads, timeoutInSeconds) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            return (_a = this.client) === null || _a === void 0 ? void 0 : _a.waitForWorkflowCompletion(workflowInstanceId, fetchPayloads, timeoutInSeconds);
+        });
+    }
+    raiseEvent(workflowInstanceId, eventName, eventPayload) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            yield ((_a = this.client) === null || _a === void 0 ? void 0 : _a.raiseEvent(workflowInstanceId, eventName, eventPayload));
+        });
+    }
+    purgeWorkflow(workflowInstanceId) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            return (_a = this.client) === null || _a === void 0 ? void 0 : _a.purgeWorkflow(workflowInstanceId);
+        });
+    }
+    suspendWorkflow(workflowInstanceId) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            yield ((_a = this.client) === null || _a === void 0 ? void 0 : _a.suspendWorkflow(workflowInstanceId));
+        });
+    }
+    resumeWorkflow(workflowInstanceId) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            yield ((_a = this.client) === null || _a === void 0 ? void 0 : _a.resumeWorkflow(workflowInstanceId));
+        });
+    }
+    stop() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            yield ((_a = this.client) === null || _a === void 0 ? void 0 : _a.stop());
+        });
+    }
+};
+DaprWorkflowClient = __decorate([
+    (0, common_1.Injectable)()
+], DaprWorkflowClient);
+exports.DaprWorkflowClient = DaprWorkflowClient;

package/dist/workflow/workflow-activity.d.ts

@@ -0,0 +1,10 @@
+import { WorkflowActivityContext } from '@dapr/dapr';
+import { TWorkflowActivity } from '@dapr/dapr/types/workflow/Activity.type';
+import { Type } from '@nestjs/common';
+import { ModuleRef } from '@nestjs/core';
+export interface WorkflowActivity<TInput = unknown, TResult = unknown> {
+    run(context: WorkflowActivityContext, input: TInput): Promise<TResult>;
+}
+export declare function lazyActivity<TInput = unknown, TResult = unknown, TClass extends {
+    run(ctx: WorkflowActivityContext, input: TInput): Promise<TResult>;
+} = any>(moduleRef: ModuleRef, klass: Type<TClass>): TWorkflowActivity<TInput, TResult>;

package/dist/workflow/workflow-activity.js

@@ -0,0 +1,24 @@
+"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.lazyActivity = void 0;
+function lazyActivity(moduleRef, klass) {
+    let instance;
+    return function (ctx, input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!instance) {
+                instance = moduleRef.get(klass, { strict: false });
+            }
+            return instance.run(ctx, input);
+        });
+    };
+}
+exports.lazyActivity = lazyActivity;

package/dist/workflow/workflow.d.ts

@@ -0,0 +1,22 @@
+import { TWorkflow, WorkflowContext, WorkflowState } from '@dapr/dapr';
+import { Type } from '@nestjs/common';
+import { ModuleRef } from '@nestjs/core';
+import { WorkflowActivity } from './workflow-activity';
+export interface Workflow<TResult = unknown, TInput = unknown> {
+    run(context: WorkflowContext, input: TInput): AsyncGenerator<unknown, TResult> | TResult;
+}
+export declare function lazyWorkflow<TInput = unknown, TResult = unknown, TClass extends {
+    run(context: WorkflowContext, input: TInput): AsyncGenerator<unknown, TResult> | TResult;
+} = any>(moduleRef: ModuleRef, klass: Type<TClass>): TWorkflow;
+export type WorkflowInput<C extends Type<any>> = Parameters<InstanceType<C>['run']> extends [any, infer P, ...any[]] ? P : void;
+export type WorkflowReturn<C extends Type<any>> = ReturnType<InstanceType<C>['run']> extends AsyncGenerator<any, infer R, any> ? R : Awaited<ReturnType<InstanceType<C>['run']>>;
+export type ActivityInput<C extends Type<WorkflowActivity>> = Parameters<InstanceType<C>['run']>[1];
+export type ActivityOutput<C extends Type<WorkflowActivity>> = Awaited<ReturnType<InstanceType<C>['run']>>;
+declare module '@dapr/dapr' {
+    interface WorkflowContext {
+        callActivity<C extends Type<WorkflowActivity>>(activityClass: C, input: ActivityInput<C>): Promise<ActivityOutput<C>>;
+    }
+}
+export declare function expect<T>(value: unknown): T;
+export declare function workflowOutput<C extends Type<any>>(workflowType: C, state: WorkflowState): WorkflowReturn<C>;
+export declare function workflowInput<C extends Type<any>>(workflowType: C, state: WorkflowState): WorkflowInput<C>;

package/dist/workflow/workflow.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.workflowInput = exports.workflowOutput = exports.expect = exports.lazyWorkflow = void 0;
+function lazyWorkflow(moduleRef, klass) {
+    let instance;
+    return function (ctx, input) {
+        if (!instance) {
+            instance = moduleRef.get(klass, { strict: false });
+        }
+        return instance.run(ctx, input);
+    };
+}
+exports.lazyWorkflow = lazyWorkflow;
+function expect(value) {
+    return value;
+}
+exports.expect = expect;
+function workflowOutput(workflowType, state) {
+    const raw = state.serializedOutput;
+    return raw
+        ? JSON.parse(raw)
+        : undefined;
+}
+exports.workflowOutput = workflowOutput;
+function workflowInput(workflowType, state) {
+    const raw = state.serializedInput;
+    return raw
+        ? JSON.parse(raw)
+        : undefined;
+}
+exports.workflowInput = workflowInput;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rayondigital/nest-dapr",
-  "version": "0.9.73",
+  "version": "0.9.74",
   "description": "Develop NestJs microservices using Dapr pubsub, actors and other bindings",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -30,12 +30,12 @@
     "@opentelemetry/core": "^1.0.0",
     "@opentelemetry/sdk-trace-base": "^1.0.0",
     "eventemitter2": "^6.0.0",
-    "nestjs-cls": "^3.6.0",
+    "nestjs-cls": "^5.0.0",
     "rxjs": "^7.1.0",
     "node-fetch": "^3.0.0"
   },
   "dependencies": {
-    "@dapr/dapr": "^3.4.1",
+    "@dapr/dapr": "^3.5.2",
     "async-lock": "^1.4.1",
     "node-fetch": "^3.0.0",
     "whatwg-url": "^14.0.0"
@@ -62,7 +62,7 @@
     "typescript": "^4.8.4"
   },
   "optionalDependencies": {
-    "nestjs-cls": "^3.6.0",
+    "nestjs-cls": "^5.0.0",
     "eventemitter2": "^6.0.0"
   },
   "publishConfig": {