List processes.

Renames notification methods to services.
Support for `if` of `notify`.

Author: jasny

nest-cli.json

@@ -3,6 +3,12 @@
   "collection": "@nestjs/schematics",
   "sourceRoot": "src",
   "compilerOptions": {
-    "deleteOutDir": true
+    "deleteOutDir": true,
+    "assets": [
+      {
+        "include": "config/*.json",
+        "outDir": "dist"
+      }
+    ]
   }
 }

package.json

@@ -48,6 +48,7 @@
     "@types/negotiator": "^0.6.3",
     "@types/node": "^20.14.8",
     "@types/supertest": "^6.0.2",
+    "@types/uuid": "^10.0.0",
     "@typescript-eslint/eslint-plugin": "^7.14.1",
     "@typescript-eslint/parser": "^7.14.1",
     "eslint": "^9.5.0",

src/common/config/config.service.ts

@@ -44,16 +44,16 @@ export class ConfigService implements OnModuleInit, OnModuleDestroy {
       .filter(fs.existsSync);
 
     config.loadFile(configFiles);
-    config.set('notificationMethods', this.loadNotificationMethodsFromEnv(config.get('notificationMethods')));
+    config.set('services', this.loadServicesFromEnv(config.get('services')));
 
     config.validate({ allowed: 'warn' });
 
     this.config = config;
   }
 
-  private loadNotificationMethodsFromEnv(methods: Record<string, Record<string, any>>) {
+  private loadServicesFromEnv(methods: Record<string, Record<string, any>>) {
     Object.keys(process.env).forEach((key) => {
-      if (key.startsWith('NOTIFICATION_')) {
+      if (key.startsWith('SERVICE_')) {
         const [_, id, envProp] = key.split('_', 3);
         const prop = envProp.toLowerCase().replace(/_([a-z])/g, (_, group1) => group1.toUpperCase());
 

src/config/schema.ts

@@ -1,3 +1,12 @@
+import convict from 'convict';
+
+// Define custom format to handle comma-separated lists
+convict.addFormat({
+  name: 'comma-separated-list',
+  validate: () => undefined,
+  coerce: (val) => val.split(',').map((item: string) => item.trim()),
+});
+
 export default {
   env: {
     format: ['production', 'staging', 'development', 'test'],
@@ -18,6 +27,20 @@ export default {
     default: 'mongodb://localhost:27017/letsflow',
     env: 'DB',
   },
+  summeryFields: {
+    scenario: {
+      doc: 'Custom fields of a scenario that should be returned when listing',
+      default: [] as string[],
+      format: 'comma-separated-list',
+      env: 'ADDITIONAL_SCENARIO_SUMMERY_FIELDS',
+    },
+    process: {
+      doc: 'Custom fields of a process that should be returned when listing',
+      default: [] as string[],
+      format: 'comma-separated-list',
+      env: 'ADDITIONAL_PROCESS_SUMMERY_FIELDS',
+    },
+  },
   jwt: {
     issuer: {
       default: '',
@@ -38,8 +61,8 @@ export default {
       env: 'DEFAULT_ACCOUNT',
     },
   },
-  notificationMethods: {
-    doc: 'Dictionary of notification methods',
+  services: {
+    doc: 'Dictionary of services and workers',
     format: Object,
     default: {},
   },

src/config/test.json

@@ -1,3 +1,7 @@
 {
-  "db": "mongodb://localhost:27017/letsflow-test"
+  "db": "mongodb://localhost:27017/letsflow-test",
+  "summeryFields": {
+    "scenario": ["extraScenarioField"],
+    "process": ["extraProcessField"]
+  }
 }

src/notify/interfaces.ts

@@ -3,8 +3,3 @@ import { Process } from '@letsflow/core/process';
 export interface NotifyProvider {
   notify: (process: Process, args: Record<string, any>) => Promise<void>;
 }
-
-export interface NotifyArgs {
-  method: string;
-  [_: string]: any;
-}

src/notify/notify.service.ts

@@ -1,8 +1,8 @@
 import { Injectable, Logger } from '@nestjs/common';
 import { ZeromqService } from './zeromq/zeromq.service';
-import { Process } from '@letsflow/core/process';
+import { Process, Notify } from '@letsflow/core/process';
 import { ConfigService } from '../common/config/config.service';
-import { NotifyArgs, NotifyProvider } from './interfaces';
+import { NotifyProvider } from './interfaces';
 
 @Injectable()
 export class NotifyService implements NotifyProvider {
@@ -14,29 +14,30 @@ export class NotifyService implements NotifyProvider {
 
   async invoke(process: Process): Promise<void> {
     for (const args of process.current.notify) {
+      if ('if' in args && !args.if) continue;
       await this.notify(process, args);
     }
   }
 
-  async notify(process: Process, args: NotifyArgs): Promise<void> {
+  async notify(process: Process, args: Notify): Promise<void> {
     try {
       await this.getProvider(args.method).notify(process, args);
     } catch (err) {
       this.logger.error(err.message);
     }
   }
 
-  private getProvider(method: string): NotifyProvider {
-    const settings = this.config.get('notificationMethods')[method];
+  private getProvider(service: string): NotifyProvider {
+    const settings = this.config.get('services')[service];
 
-    if (!settings) throw new Error(`Notification method '${method}' not configured`);
-    if (!settings.provider) throw new Error(`Provider not specified for notification method '${method}'`);
+    if (!settings) throw new Error(`Service '${service}' not configured`);
+    if (!settings.provider) throw new Error(`Provider not specified for service '${service}'`);
 
     switch (settings.provider) {
       case 'zeromq':
         return this.zeromq;
       default:
-        throw new Error(`Unsupported provider ${settings.provider} for notification method '${method}'`);
+        throw new Error(`Unsupported provider ${settings.provider} for service '${service}'`);
     }
   }
 }

src/notify/zeromq/zeromq.service.ts

@@ -1,6 +1,6 @@
-import { Logger, Injectable, OnModuleDestroy } from '@nestjs/common';
-import { NotifyArgs, NotifyProvider } from '../interfaces';
-import { Process } from '@letsflow/core/process';
+import { Injectable, OnModuleDestroy } from '@nestjs/common';
+import { NotifyProvider } from '../interfaces';
+import { Process, Notify } from '@letsflow/core/process';
 import { Push } from 'zeromq';
 import { ConfigService } from '../../common/config/config.service';
 import { NotifyMessageService } from '../notify-message/notify-message.service';
@@ -32,13 +32,13 @@ export class ZeromqService implements NotifyProvider, OnModuleDestroy {
     return socket;
   }
 
-  async notify(process: Process, args: NotifyArgs): Promise<void> {
-    if (!args.action) {
+  async notify(process: Process, args: Notify): Promise<void> {
+    if ('action' in args && !args.action) {
       return; // No action to notify
     }
 
-    const settings = this.config.get('notificationMethods')[args.method];
-    if (!settings.address) throw new Error(`ZeroMQ address not configured notification method ${args.method}`);
+    const settings = this.config.get('services')[args.service];
+    if (!settings.address) throw new Error(`ZeroMQ address not configured for service '${args.method}'`);
 
     const message = this.message.create(process, args.action);
     const socket = this.getSocket(settings.address);

src/process/process.controller.ts

@@ -26,6 +26,15 @@ export class ProcessController {
     private validation: ValidationService,
   ) {}
 
+  @ApiOperation({ summary: 'List all processes' })
+  @ApiResponse({ status: 200, description: 'Success' })
+  @ApiProduces('application/json')
+  @Get()
+  public async list(@Res() res: Response): Promise<void> {
+    const processes = await this.service.list();
+    res.status(200).json(processes);
+  }
+
   @ApiOperation({ summary: 'Start a process' })
   @ApiConsumes('application/json')
   @ApiBody({ required: true, type: StartInstructions })

src/process/process.dto.ts

@@ -1,4 +1,25 @@
 import { ApiExtraModels, ApiProperty, ApiPropertyOptional, getSchemaPath } from '@nestjs/swagger';
+import { ScenarioSummary } from '../scenario/scenario.dto';
+
+export class ProcessSummary {
+  @ApiProperty()
+  id: string;
+
+  @ApiProperty()
+  title: string;
+
+  @ApiProperty()
+  scenario: ScenarioSummary;
+
+  @ApiProperty()
+  actors: Array<ProcessActor>;
+
+  @ApiProperty()
+  created: Date;
+
+  @ApiProperty()
+  lastUpdated: Date;
+}
 
 export class ProcessActor {
   @ApiProperty()

src/process/process.module.ts

@@ -6,9 +6,11 @@ import { ValidationService } from './validation/validation.service';
 import { MongoModule } from '../common/mongo/mongo.module';
 import { AuthModule } from '../common/auth/auth.module';
 import { AjvModule } from '../common/ajv/ajv.module';
+import { NotifyModule } from '../notify/notify.module';
+import { ConfigModule } from '../common/config/config.module';
 
 @Module({
-  imports: [ScenarioModule, MongoModule, AuthModule, AjvModule],
+  imports: [ScenarioModule, MongoModule, AuthModule, AjvModule, NotifyModule, ConfigModule],
   providers: [ProcessService, ValidationService],
   controllers: [ProcessController],
 })