@rayondigital/nest-dapr 0.10.3 → 0.10.5

package/README.md

@@ -5,23 +5,23 @@ Develop NestJs microservices using [Dapr](https://dapr.io/) pubsub, actors and b
 
 # Description
 
-Dapr Module for [Nest](https://github.com/nestjs/nest) built on top of the [Dapr JS SDK](https://github.com/dapr/js-sdk).
+Dapr Module for [Nest](https://github.com/nestjs/nest) built on top of the latest [Dapr JS SDK](https://github.com/dapr/js-sdk).
 
 
 # Supported features
 - [x] [Actors](https://docs.dapr.io/developing-applications/building-blocks/actors/actors-overview/)
 - [x] [PubSub](https://docs.dapr.io/developing-applications/building-blocks/pubsub/pubsub-overview/)
 - [x] [Bindings](https://docs.dapr.io/developing-applications/building-blocks/bindings/bindings-overview/)
+- [x] [Workflows](https://docs.dapr.io/developing-applications/building-blocks/workflow/workflow-overview/)
 - [ ] [Distributed Lock](https://docs.dapr.io/developing-applications/building-blocks/distributed-lock/)
 - [ ] [State](https://docs.dapr.io/developing-applications/building-blocks/state-management/state-management-overview/)
 - [ ] [Service Invocation](https://docs.dapr.io/developing-applications/building-blocks/service-invocation/service-invocation-overview/)
-- [ ] [Workflows](https://docs.dapr.io/developing-applications/building-blocks/workflow/workflow-overview/)
 
 
 # Installation
 
 ```bash
-npm i --save @rayondigital/nest-dapr
+npm i @rayondigital/nest-dapr
 ```
 
 # Requirements
@@ -35,8 +35,8 @@ dapr --version
 Output:
 
 ```
-CLI version: 1.12.0
-Runtime version: 1.12.2
+CLI version: 1.15.1
+Runtime version: 1.15.4
 ```
 
 # Quick start
@@ -99,6 +99,7 @@ export class AppController {
 Create actors and connect them to your NestJS application using the `@DaprActor` decorator.
 This decorator takes in the interface of the actor, and marks the Actor as transient inside the NestJS
 dependency injection container.
+Ensure your actor classes are added to the `providers` array of your NestJS module.
 
 ```typescript
 // You must expose your actors interface as an abstract class because Typescript interfaces are not available at runtime (erasure).
@@ -168,6 +169,112 @@ export class CounterController {
 }
 ```
 
+## Workflows
+
+Workflows and Activities are annotated with the `@DaprWorkflow` and `@DaprActivity` decorators respectively.
+When added to the `providers` array of a NestJS module, they are automatically registered with the Dapr server.
+
+Note: Take care to ensure that your activities are stateless, and idempotent.
+Be very careful with the state, and services you have inside your workflows.
+
+
+```typescript   
+@DaprActivity()
+export class HelloActivity implements WorkflowActivity<string, string> {
+  async run(context: WorkflowActivityContext, name: string): Promise<string> {
+    return `Hello ${name}!`;
+  }
+}
+
+@DaprActivity()
+export class CreateEntityActivity implements WorkflowActivity<string, Entity> {
+  @Inject()
+  private readonly entityService: EntityService;
+
+  constructor(private readonly cacheService: CacheService) {}
+
+  async run(context: WorkflowActivityContext, id: string): Promise<Entity> {
+    const entity: Entity = { id: id, createdAt: new Date(), lastUpdatedAt: new Date(), status: 'created', data: {} };
+    await this.entityService.update(entity);
+    console.log('entity', entity);
+    return entity;
+  }
+}
+
+@DaprActivity()
+export class GetEntityActivity implements WorkflowActivity<string, Entity> {
+  @Inject()
+  private readonly entityService: EntityService;
+
+  constructor(private readonly cacheService: CacheService) {}
+
+  async run(context: WorkflowActivityContext, id: string): Promise<Entity> {
+    const entity = await this.entityService.get(id);
+    console.log('entity', entity);
+    return entity;
+  }
+}
+
+@DaprWorkflow()
+export class HelloWorkflow implements Workflow<string[], string> {
+  async *run(ctx: WorkflowContext, input: string): AsyncGenerator<unknown, string[]> {
+    const cities: string[] = [];
+
+    let entity = expect<Entity>(yield ctx.callActivity(CreateEntityActivity, '12345'));
+    ctx.setCustomStatus('Entity');
+
+    entity = expect<Entity>(yield ctx.callActivity(GetEntityActivity, '12345'));
+    console.log('entity', entity);
+    ctx.setCustomStatus('Entity');
+
+    const result1 = expect<string>(yield ctx.callActivity(HelloActivity, 'Tokyo'));
+    ctx.setCustomStatus('Tokyo');
+
+    const event = yield ctx.waitForExternalEvent('next');
+    console.log('event', event);
+
+    const result2 = expect<string>(yield ctx.callActivity(HelloActivity, 'Seattle'));
+    ctx.setCustomStatus('Seattle');
+
+    const result3 = expect<string>(yield ctx.callActivity(HelloActivity, 'London'));
+    ctx.setCustomStatus('London');
+
+    return cities;
+  }
+}
+```
+
+### Workflow Client
+
+```typescript
+@Controller()
+export class WorkflowController {
+  constructor(
+    private readonly workflowClient: DaprWorkflowClient,
+  ) {}
+
+  @Get(":id")
+  async start(@Param("id") uuid: string): Promise<string> {
+    const id = await workflowClient.scheduleNewWorkflow(HelloWorkflow, 'Hello', uuid);
+    // Workflow is started, and the id is returned.
+    // You can wait for the workflow to start and get the initial state.
+    const initialState = await workflowClient.waitForWorkflowStart(id, undefined, 15);
+    
+    // You can raise events
+    // await workflowClient.raiseEvent(id, 'next', { input: 'next' });
+    
+    // Optionally you can also wait for it to complete.
+    // const state = await workflowClient.waitForWorkflowCompletion(id, undefined, 15);
+    // Use the workflowOutput helper to get typed variables
+    // const value = workflowOutput(HelloWorkflow, state);
+    return { 
+      id: id,
+      state: initialState
+    }
+  }
+}
+```
+
 ## PubSub
 
 Create pubsub & topic names used for pubsub operations and message interface

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

@@ -96,6 +96,7 @@ let NestActorManager = NestActorManager_1 = class NestActorManager {
         const isLoggingEnabled = (_b = (_a = options === null || options === void 0 ? void 0 : options.logging) === null || _a === void 0 ? void 0 : _a.enabled) !== null && _b !== void 0 ? _b : true;
         const originalCallActor = ActorManager_1.default.prototype.callActorMethod;
         ActorManager_1.default.prototype.callActorMethod = function (actorId, methodName, data) {
+            var _a;
             return __awaiter(this, void 0, void 0, function* () {
                 try {
                     if (isLoggingEnabled) {
@@ -112,12 +113,12 @@ let NestActorManager = NestActorManager_1 = class NestActorManager {
                     }
                     else {
                         return yield clsService.run(() => __awaiter(this, void 0, void 0, function* () {
-                            var _a;
+                            var _b;
                             contextService.setIdIfNotDefined();
                             const context = NestActorManager_1.extractContext(data);
                             if (context) {
                                 contextService.set(context);
-                                const correlationId = (_a = context[dapr_context_service_1.DAPR_CORRELATION_ID_KEY]) !== null && _a !== void 0 ? _a : (0, crypto_1.randomUUID)();
+                                const correlationId = (_b = context[dapr_context_service_1.DAPR_CORRELATION_ID_KEY]) !== null && _b !== void 0 ? _b : (0, crypto_1.randomUUID)();
                                 if (correlationId) {
                                     contextService.setCorrelationId(correlationId);
                                 }
@@ -141,6 +142,10 @@ let NestActorManager = NestActorManager_1 = class NestActorManager {
                     if (error.stack) {
                         common_1.Logger.error(error.stack);
                     }
+                    if (serializable_error_1.SerializableError.isSerializableError(error)) {
+                        error.statusCode = (_a = error.statusCode) !== null && _a !== void 0 ? _a : HttpStatusCode_enum_1.default.BAD_REQUEST;
+                        return error;
+                    }
                     throw error;
                 }
             });

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@rayondigital/nest-dapr",
-  "version": "0.10.3",
-  "description": "Develop NestJs microservices using Dapr pubsub, actors and other bindings",
+  "version": "0.10.5",
+  "description": "Develop NestJs microservices using Dapr pubsub, actors, workflows and other bindings",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "scripts": {
     "build": "rimraf -rf dist && tsc -p tsconfig.json",
     "lint": "eslint \"{lib,tests}/**/*.ts\" --fix",
     "test": "jest --runInBand",
-    "test:in-memory": "dapr run --app-id testing --app-protocol http --app-port 3001 --dapr-http-port 3500 --resources-path ./tests/components npm run test",
+    "test:in-memory": "dapr run --app-id testing --app-protocol http --app-port 3001 --dapr-http-port 3500 --dapr-grpc-port 3501 --resources-path ./tests/components npm run test",
     "start:test": "nodemon tests/e2e/main.ts",
     "push:version": "git push --follow-tags"
   },