Feat: XML schema validation (#61)

* removing properties from schema

* merge master

* added error message if message payload is not in JSON format

* refactored the schema validation in post and patch

* fixed dupWindow condition checking

* added node-libxml

* fixed relative path issue

.gitignore

@@ -71,4 +71,6 @@ dist/
 
 .idea/
 
-index.html
+index.html
+
+apps/dsb-message-broker/xsd_files/

apps/dsb-message-broker/package.json

@@ -54,7 +54,9 @@
         "@nestjs/platform-socket.io": "8.0.6",
         "socket.io": "4.1.3",
         "@energyweb/dsb-address-book-nats-js": "~0.0.1",
-        "ajv-formats": "2.1.1"
+        "ajv-formats": "2.1.1",
+        "node-libxml": "4.1.2",
+        "uuid": "~8.3.2"
     },
     "devDependencies": {
         "@nestjs/cli": "7.6.0",
@@ -78,6 +80,7 @@
         "ts-node": "9.1.1",
         "typescript": "4.4.3",
         "json-to-pretty-yaml": "1.2.2",
-        "base64url": "3.0.1"
+        "base64url": "3.0.1",
+        "@types/uuid": "~8.3.1"
     }
 }

apps/dsb-message-broker/src/channel/channel.controller.ts

@@ -89,7 +89,7 @@ export class ChannelController {
     })
     public async updateChannel(
         @UserDecorator() user: any,
-        @Body(ChannelDataPipe) updateDto: UpdateChannelDto
+        @Body(FqcnValidationPipe, ChannelDataPipe) updateDto: UpdateChannelDto
     ): Promise<string> {
         try {
             const result = await this.channelService.updateChannel({

apps/dsb-message-broker/src/channel/channel.data.pipe.ts

@@ -1,5 +1,4 @@
-import { PipeTransform, Injectable, BadRequestException } from '@nestjs/common';
-import { ConfigService } from '@nestjs/config';
+import { PipeTransform, Injectable, BadRequestException, Logger } from '@nestjs/common';
 
 import { Channel } from '@energyweb/dsb-transport-core';
 
@@ -8,45 +7,69 @@ import { TopicSchemaService } from '../utils/topic.schema.service';
 
 @Injectable()
 export class ChannelDataPipe implements PipeTransform<any> {
-    constructor(
-        private readonly configService: ConfigService,
-        private readonly topicSchemaService: TopicSchemaService
-    ) {}
+    private readonly logger = new Logger(ChannelDataPipe.name);
+
+    constructor(private readonly topicSchemaService: TopicSchemaService) {}
 
     async transform(channelData: Channel) {
+        /* validation of first part of fqcn */
         const { channel } = extractFqcn(channelData.fqcn);
 
         const fqcnIsValid = new RegExp('^[a-zA-Z0-9]{1,16}$').test(channel);
 
         if (!fqcnIsValid) {
             throw new BadRequestException({
                 statusCode: 400,
-                message: 'fqcn does not match the defined pattern.',
+                message:
+                    'First part of the fqcn does not match the defined pattern(^[a-zA-Z0-9]{1,16}$).',
                 error: 'Bad Request'
             });
         }
 
-        channelData.topics?.forEach((topic: any, index: number) => {
-            let _schema: any = topic.schema;
+        /* validation of each topic schema */
+        if (channelData.topics) {
+            this.topicSchemaService.removeValidators(channelData.fqcn);
 
-            if (typeof _schema === 'string') _schema = JSON.parse(_schema);
+            for await (const [index, topic] of channelData.topics.entries()) {
+                try {
+                    let _schema = topic.schema as any;
+                    if (topic.schemaType !== 'XSD') {
+                        if (typeof _schema === 'string') {
+                            _schema = JSON.parse(_schema);
+                        }
+                        if (_schema && _schema.hasOwnProperty('$schema')) {
+                            delete _schema['$schema'];
+                        }
+                        if (_schema && _schema.hasOwnProperty('$id')) {
+                            delete _schema['$id'];
+                        }
+                        if (_schema && _schema.hasOwnProperty('version')) {
+                            delete _schema['version'];
+                        }
+                    }
+                    topic.schema = _schema;
 
-            if (_schema && _schema.hasOwnProperty('$schema')) delete _schema['$schema'];
-            if (_schema && _schema.hasOwnProperty('$id')) delete _schema['$id'];
-            if (_schema && _schema.hasOwnProperty('version')) delete _schema['version'];
+                    await this.topicSchemaService.validateSchema(
+                        channelData.fqcn,
+                        topic.namespace,
+                        topic.schemaType,
+                        topic.schema
+                    );
+                } catch (error) {
+                    this.logger.error(error.message);
 
-            const isValid = this.topicSchemaService.validateSchema(_schema);
+                    let errMsg = error.message;
+                    if (error instanceof SyntaxError) errMsg = [errMsg];
+                    else errMsg = JSON.parse(errMsg);
 
-            if (!isValid) {
-                throw new BadRequestException({
-                    statusCode: 400,
-                    message: `topics.${index}.schema is not valid`,
-                    error: 'Bad Request'
-                });
+                    throw new BadRequestException({
+                        statusCode: 400,
+                        message: [`topics.${index}.schema is not valid`, ...errMsg],
+                        error: 'Bad Request'
+                    });
+                }
             }
-
-            topic.schema = JSON.stringify(_schema);
-        });
+        }
 
         return channelData;
     }

apps/dsb-message-broker/src/channel/channel.service.ts

@@ -53,8 +53,6 @@ export class ChannelService implements OnModuleInit {
 
         const result = await this.transport.updateChannel(updatedChannel);
 
-        this.topicSchemaService.removeValidators(updateDto.fqcn);
-
         this.addressbook.registerChannel(updatedChannel);
 
         return result;

apps/dsb-message-broker/src/channel/dto/create-channel.dto.ts

@@ -6,17 +6,27 @@ import {
     IsOptional,
     ArrayNotEmpty,
     ValidateNested,
-    Max
+    Max,
+    IsEnum
 } from 'class-validator';
 import { Type } from 'class-transformer';
 import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
 import { JSONSchemaType } from 'ajv';
 
+enum SchemaType {
+    'JSD-7',
+    'XSD'
+}
+
 class Topic {
     @IsDefined()
     @IsString()
     namespace: string;
 
+    @IsOptional()
+    @IsEnum(SchemaType)
+    schemaType: SchemaType;
+
     @IsDefined()
     schema: string | Record<string, unknown>;
 }
@@ -37,15 +47,20 @@ export class CreateChannelDto {
             namespace: {
                 type: 'string'
             },
+            shcemaType: {
+                description: 'Values are JSD-7(JSON Schema Draft-7) and XSD(XML Schema Definition)',
+                default: 'JSD-7',
+                type: 'enum'
+            },
             schema: {
                 type: 'string | JSONSchemaType'
             }
         },
-        required: false,
         description: 'Array of topic objects that determines topics for messages.',
         example: [
             {
                 namespace: 'testTopic',
+                schemaType: 'JSD-7',
                 schema: '{"type": "object","properties": {"data": {"type": "string"}},"required": ["data"],"additionalProperties": false}'
             }
         ]
@@ -57,6 +72,7 @@ export class CreateChannelDto {
     @Type(() => Topic)
     topics?: {
         namespace: string;
+
         schema: JSONSchemaType<any> | string;
     }[];
 

apps/dsb-message-broker/src/message/error.handler.ts

@@ -31,6 +31,10 @@ export const HttpMessageErrorHandler = (error: any) => {
         });
     }
 
+    if (error instanceof BadRequestException) {
+        throw error;
+    }
+
     if (
         error instanceof UnauthorizedToPublishError ||
         error instanceof UnauthorizedToSubscribeError

apps/dsb-message-broker/src/message/message.service.ts

@@ -51,8 +51,8 @@ export class MessageService implements OnModuleInit {
     ): Promise<string> {
         this.ensureCanPublish(fqcn, pubDID, pubVRs);
 
-        const { isValid, error } = this.topicSchemaService.validate(fqcn, topic, payload);
-        if (!isValid) throw new PayloadNotValidError(topic, error);
+        const { isValid, error } = await this.topicSchemaService.validate(fqcn, topic, payload);
+        if (!isValid) throw new PayloadNotValidError(topic, error ?? '[]');
 
         return this.transport.publish(
             fqcn,