Implemented /scenarios endpoint.

- List scenarios.
- Add scenario.
- Get scenario (as json or yaml).
- Disable scenario.

TODO: tests

Author: jasny

.gitignore

@@ -32,4 +32,7 @@ lerna-debug.log*
 !.vscode/settings.json
 !.vscode/tasks.json
 !.vscode/launch.json
-!.vscode/extensions.json
+!.vscode/extensions.json
+
+# Runtime data
+/storage

.prettierrc

@@ -1,4 +1,5 @@
 {
   "singleQuote": true,
-  "trailingComma": "all"
-}
+  "trailingComma": "all",
+  "printWidth": 120
+}

package.json

@@ -20,13 +20,18 @@
     "test:e2e": "jest --config ./test/jest-e2e.json"
   },
   "dependencies": {
+    "@letsflow/api": "../api",
     "@nestjs/common": "^9.0.0",
     "@nestjs/core": "^9.0.0",
+    "@nestjs/mongoose": "^9.2.2",
     "@nestjs/platform-express": "^9.0.0",
     "@nestjs/swagger": "^6.3.0",
     "convict": "^6.2.4",
+    "mongoose": "^7.2.2",
+    "negotiator": "^0.6.3",
     "reflect-metadata": "^0.1.13",
-    "rxjs": "^7.2.0"
+    "rxjs": "^7.2.0",
+    "uuid": "^9.0.0"
   },
   "devDependencies": {
     "@nestjs/cli": "^9.0.0",
@@ -35,6 +40,7 @@
     "@types/convict": "^6.1.2",
     "@types/express": "^4.17.13",
     "@types/jest": "29.5.1",
+    "@types/negotiator": "^0.6.1",
     "@types/node": "18.16.12",
     "@types/supertest": "^2.0.11",
     "@typescript-eslint/eslint-plugin": "^5.0.0",

src/app.controller.spec.ts

@@ -1,11 +1,28 @@
-import { Module } from '@nestjs/common';
+import { MiddlewareConsumer, Module, RequestMethod } from '@nestjs/common';
 import { AppController } from './app.controller';
 import { AppService } from './app.service';
 import { ConfigModule } from './common/config/config.module';
+import { ScenarioModule } from './scenario/scenario.module';
+import { YamlBodyParserMiddleware } from './middleware/yamlBodyParser.middleware';
 
 @Module({
-  imports: [ConfigModule],
+  imports: [
+    ConfigModule,
+    ScenarioModule,
+    /*MongooseModule.forRootAsync({
+      imports: [ConfigModule],
+      useFactory: async (config: ConfigService) => {
+        await config.onModuleInit(); // Why is this necessary?
+        return { uri: config.get('db') };
+      },
+      inject: [ConfigService],
+    }),*/
+  ],
   controllers: [AppController],
   providers: [AppService],
 })
-export class AppModule {}
+export class AppModule {
+  configure(consumer: MiddlewareConsumer) {
+    consumer.apply(YamlBodyParserMiddleware).forRoutes({ path: '/scenarios', method: RequestMethod.POST });
+  }
+}

src/app.module.ts

@@ -14,4 +14,14 @@ export default {
       env: 'LOG_LEVEL',
     },
   },
+  db: {
+    default: 'mongodb://localhost:27017/letsflow',
+    env: 'DB',
+  },
+  paths: {
+    scenarios: {
+      default: 'storage/scenarios',
+      env: 'SCENARIO_PATH',
+    },
+  },
 };

src/config/schema.ts

@@ -4,6 +4,7 @@ import { INestApplication } from '@nestjs/common';
 import { DocumentBuilder, SwaggerModule } from '@nestjs/swagger';
 import { ConfigService } from './common/config/config.service';
 import bodyParser from 'body-parser';
+import { NestExpressApplication } from '@nestjs/platform-express';
 
 async function swagger(app: INestApplication, config: ConfigService) {
   // eslint-disable-next-line @typescript-eslint/no-var-requires
@@ -21,15 +22,12 @@ async function swagger(app: INestApplication, config: ConfigService) {
 }
 
 async function bootstrap() {
-  const app = await NestFactory.create(AppModule, {
-    bodyParser: false,
-  });
+  const app = await NestFactory.create<NestExpressApplication>(AppModule);
+  app.disable('x-powered-by');
 
   const config = await app.get<ConfigService>(ConfigService);
   await config.load();
 
-  app.use(bodyParser.json({}), bodyParser.urlencoded({ extended: false }));
-
   app.enableShutdownHooks();
 
   await swagger(app, config);

src/main.ts

@@ -0,0 +1,29 @@
+import { Injectable, NestMiddleware } from '@nestjs/common';
+import { Request, Response, NextFunction } from 'express';
+import { yaml } from '@letsflow/api';
+
+@Injectable()
+export class YamlBodyParserMiddleware implements NestMiddleware {
+  use(req: Request, res: Response, next: NextFunction) {
+    if (!req.is('application/yaml')) {
+      next();
+      return;
+    }
+
+    let data = '';
+
+    req.setEncoding('utf8');
+    req.on('data', (chunk) => {
+      data += chunk;
+    });
+
+    req.on('end', () => {
+      try {
+        req.body = yaml.parse(data);
+        next();
+      } catch (error) {
+        next(error);
+      }
+    });
+  }
+}

src/middleware/yamlBodyParser.middleware.ts

@@ -0,0 +1,77 @@
+import { Body, Controller, Delete, Get, Param, Post, Req, Res, UseInterceptors } from '@nestjs/common';
+import { ApiTags, ApiResponse, ApiOperation, ApiParam, ApiBody, ApiConsumes, ApiProduces } from '@nestjs/swagger';
+import { ScenarioService } from './scenario.service';
+import { ScenarioSummary } from './scenario.dto';
+import { Request, Response } from 'express';
+import { Scenario, validate, yaml } from '@letsflow/api';
+import Negotiator from 'negotiator';
+
+//const scenarioSchema = 'https://schemas.letsflow.io/v1.0.0/scenario';
+
+@ApiTags('Scenario')
+@Controller('scenarios')
+export class ScenarioController {
+  constructor(private service: ScenarioService) {}
+
+  @ApiOperation({ summary: 'Get all scenarios' })
+  @ApiResponse({ status: 200, description: 'Success', type: ScenarioSummary, isArray: true })
+  @Get()
+  list(): ScenarioSummary[] {
+    return this.service.list();
+  }
+
+  private contentNegotiation(req: Request, ext?: string): string | null {
+    if (ext === 'json') return 'application/json';
+    if (ext === 'yaml') return 'application/yaml';
+    if (!ext) return new Negotiator(req).mediaType(['application/json', 'application/yaml']);
+
+    return null;
+  }
+
+  @ApiOperation({ summary: 'Get scenario by ID' })
+  @ApiParam({ name: 'id', description: 'Scenario ID', format: 'uuid' })
+  @ApiResponse({ status: 200, description: 'Success' })
+  @ApiProduces('application/json', 'application/x-yaml')
+  @Get(':filename')
+  get(@Param('filename') filename: string, @Req() req: Request, @Res() res: Response): void {
+    const [id, ext] = filename.split('.');
+
+    if (!this.service.has(id)) {
+      res.status(404).send('Scenario not found');
+      return;
+    }
+
+    const scenario = this.service.get(id);
+
+    if (this.contentNegotiation(req, ext) === 'application/yaml') {
+      res.status(200).header('Content-Type', 'application/yaml').send(yaml.stringify(scenario));
+    } else {
+      res.status(200).json(scenario);
+    }
+  }
+
+  @ApiOperation({ summary: 'Store a scenario' })
+  @ApiConsumes('application/json', 'application/yaml')
+  @ApiBody({ required: true, schema: { type: 'object' } })
+  @ApiResponse({ status: 201, description: 'Created' })
+  @Post()
+  async store(@Body() scenario: Scenario, @Req() req: Request, @Res() res: Response): Promise<void> {
+    if (!validate(scenario)) {
+      res.status(400).json(validate.errors);
+      return;
+    }
+
+    const id = await this.service.store(scenario);
+
+    res.status(201).setHeader('Location', `${req.url}/${id}`).send();
+  }
+
+  @ApiOperation({ summary: 'Disable a scenario' })
+  @ApiParam({ name: 'id', description: 'Scenario ID', format: 'uuid' })
+  @ApiResponse({ status: 204, description: 'No Content' })
+  @Delete()
+  async disable(@Param('id') id: string, @Res() res: Response): Promise<void> {
+    await this.service.disable(id);
+    res.status(201).send();
+  }
+}

src/scenario/scenario.controller.ts

@@ -0,0 +1,15 @@
+import { ApiProperty } from '@nestjs/swagger';
+
+export class ScenarioSummary {
+  @ApiProperty()
+  id: string;
+
+  @ApiProperty()
+  title: string;
+
+  @ApiProperty()
+  description: string;
+
+  @ApiProperty()
+  disabled: boolean;
+}

src/scenario/scenario.dto.ts

@@ -0,0 +1,11 @@
+import { Module } from '@nestjs/common';
+import { ScenarioService } from './scenario.service';
+import { ScenarioController } from './scenario.controller';
+import { ConfigModule } from '../common/config/config.module';
+
+@Module({
+  imports: [ConfigModule],
+  providers: [ScenarioService],
+  controllers: [ScenarioController],
+})
+export class ScenarioModule {}

src/scenario/scenario.module.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { ScenarioService } from './scenario.service';
+
+describe('ScenarioService', () => {
+  let service: ScenarioService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [ScenarioService],
+    }).compile();
+
+    service = module.get<ScenarioService>(ScenarioService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+});

src/scenario/scenario.service.spec.ts

@@ -0,0 +1,87 @@
+import { Injectable, OnModuleInit } from '@nestjs/common';
+import { normalize, Scenario, uuid } from '@letsflow/api';
+import { ConfigService } from '../common/config/config.service';
+import * as fs from 'fs/promises';
+import { ScenarioSummary } from './scenario.dto';
+
+type NormalizedScenario = Required<Scenario>;
+
+@Injectable()
+export class ScenarioService implements OnModuleInit {
+  private path: string;
+  private readonly scenarios: Map<string, NormalizedScenario> = new Map();
+  private readonly disabled = new Set<string>();
+
+  constructor(private config: ConfigService) {}
+
+  private async load(): Promise<void> {
+    const files = (await fs.readdir(this.path)).filter((file) => file.endsWith('.json'));
+
+    await Promise.all(
+      files.map(async (file) => {
+        const json = await fs.readFile(`${this.path}/${file}`, 'utf-8');
+        const scenario = JSON.parse(json.toString());
+
+        const id = file.replace(/\.json$/, '');
+        this.scenarios.set(id, scenario);
+      }),
+    );
+  }
+
+  private async loadDisabled(): Promise<void> {
+    try {
+      const disabled = await fs.readFile(`${this.path}/.disabled`, 'utf-8');
+      this.disabled.clear();
+      disabled.split('\n').forEach((id) => this.disabled.add(id));
+    } catch (e) {
+      if (e.code !== 'ENOENT') throw e;
+      this.disabled.clear();
+    }
+  }
+
+  async onModuleInit() {
+    this.path = this.config.get('paths.scenarios');
+
+    await fs.mkdir(this.path, { recursive: true });
+    await this.load();
+    await this.loadDisabled();
+  }
+
+  list(): ScenarioSummary[] {
+    return Array.from(this.scenarios.entries()).map(([filename, { title, description }]) => {
+      const id = filename.replace(/\.json$/, '');
+      return { id, title, description, disabled: this.isDisabled(id) };
+    });
+  }
+
+  has(id: string): boolean {
+    return this.scenarios.has(id);
+  }
+
+  get(id: string): NormalizedScenario {
+    return this.scenarios.get(id);
+  }
+
+  isDisabled(id: string): boolean {
+    return this.disabled.has(id);
+  }
+
+  async store(scenario: Scenario): Promise<string> {
+    const normalized = normalize(scenario) as Required<Scenario>;
+    const id = uuid(normalized);
+
+    if (!this.has(id)) {
+      await fs.writeFile(`${this.path}/${id}.json`, JSON.stringify(normalized, null, 2));
+      this.scenarios.set(id, normalized);
+    }
+
+    return id;
+  }
+
+  async disable(id: string): Promise<void> {
+    this.disabled.add(id);
+
+    const disabled = Array.from(this.disabled.values()).join('\n');
+    await fs.writeFile(`${this.path}/.disabled`, disabled);
+  }
+}