define the properties as specific as possible

src/performance/models/performance.model.ts

@@ -1,24 +1,42 @@
 import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
 import { Document } from 'mongoose';
-import { PerformanceEntry } from './performanceentry.model';
+import {
+  PerformanceEntry,
+  PerformanceEntrySchema,
+} from './performanceentry.model';
 
 export type PerformanceDocument = Performance & Document;
 
 @Schema()
 export class Performance {
-  @Prop({ required: true })
+  @Prop({
+    type: String,
+    required: true,
+  })
   icaoCode: string;
 
-  @Prop({ required: true, type: PerformanceEntry })
+  @Prop({
+    required: true,
+    type: PerformanceEntrySchema,
+  })
   aboveFL240: PerformanceEntry;
 
-  @Prop({ required: true, type: PerformanceEntry })
+  @Prop({
+    required: true,
+    type: PerformanceEntrySchema,
+  })
   aboveFL100: PerformanceEntry;
 
-  @Prop({ required: true, type: PerformanceEntry })
+  @Prop({
+    required: true,
+    type: PerformanceEntrySchema,
+  })
   belowFL100: PerformanceEntry;
 
-  @Prop({ required: true })
+  @Prop({
+    required: true,
+    type: Number,
+  })
   minimalApproachSpeed: number;
 }
 

src/performance/models/performanceentry.model.ts

@@ -5,10 +5,16 @@ export type PerformanceEntryDocument = PerformanceEntry & Document;
 
 @Schema()
 export class PerformanceEntry {
-  @Prop({ required: true })
+  @Prop({
+    required: true,
+    type: Number,
+  })
   speed: number;
 
-  @Prop({ required: true })
+  @Prop({
+    required: true,
+    type: Number,
+  })
   rateOfDescend: number;
 }
 

src/performance/performance.service.ts

@@ -21,26 +21,41 @@ export class PerformanceService {
   private async updatePerformanceData(
     performanceData: Record<string, any>,
     version: SemanticVersionDto,
-  ): Promise<boolean> {
+  ): Promise<string[]> {
     return this.performanceModel.deleteMany({}).then(async () => {
+      const invalidEntries: string[] = [];
+
       for (const key in performanceData) {
         if (key !== 'FILEINFO') {
-          await this.performanceModel.create({
+          const validAircraft =
-            icaoCode: key,
+            performanceData[key]['speedabovefl240'] !== undefined &&
-            aboveFL240: {
+            performanceData[key]['rodabovefl240'] !== undefined &&
-              speed: performanceData[key]['speedabovefl240'],
+            performanceData[key]['speedabovefl100'] !== undefined &&
-              rateOfDescend: performanceData[key]['rodabovefl240'],
+            performanceData[key]['rodabovefl100'] !== undefined &&
-            },
+            performanceData[key]['speedbelowfl100'] !== undefined &&
-            aboveFL100: {
+            performanceData[key]['rodbelowfl100'] !== undefined &&
-              speed: performanceData[key]['speedabovefl100'],
+            performanceData[key]['speedapproach'] !== undefined;
-              rateOfDescend: performanceData[key]['rodabovefl100'],
+
-            },
+          if (!validAircraft) {
-            belowFL100: {
+            invalidEntries.push(key);
-              speed: performanceData[key]['speedbelowfl100'],
+          } else {
-              rateOfDescend: performanceData[key]['rodbelowfl100'],
+            await this.performanceModel.create({
-            },
+              icaoCode: key,
-            minimalApproachSpeed: performanceData[key]['speedapproach'],
+              aboveFL240: {
-          });
+                speed: performanceData[key]['speedabovefl240'],
+                rateOfDescend: performanceData[key]['rodabovefl240'],
+              },
+              aboveFL100: {
+                speed: performanceData[key]['speedabovefl100'],
+                rateOfDescend: performanceData[key]['rodabovefl100'],
+              },
+              belowFL100: {
+                speed: performanceData[key]['speedbelowfl100'],
+                rateOfDescend: performanceData[key]['rodbelowfl100'],
+              },
+              minimalApproachSpeed: performanceData[key]['speedapproach'],
+            });
+          }
         }
       }
 
@@ -50,15 +65,15 @@ export class PerformanceService {
         version,
       );
 
-      return true;
+      return invalidEntries;
     });
   }
 
-  private async validateAndUpdatePerformanceData(): Promise<boolean> {
+  private async validateAndUpdatePerformanceData(): Promise<string[]> {
     // read the performance file and validate the version length
     const data = PerformanceService.readPerformanceFile();
     const versionParts = (data['FILEINFO']['version'] as string).split('.');
-    if (versionParts.length !== 3) return false;
+    if (versionParts.length !== 3) return [];
 
     // create the fileversion
     const fileversion: SemanticVersionDto = {
@@ -84,7 +99,7 @@ export class PerformanceService {
           return this.updatePerformanceData(data, fileversion);
         }
 
-        return false;
+        return [];
       })
       .catch(() => this.updatePerformanceData(data, fileversion));
   }

src/versioning/models/versioning.model.ts

@@ -5,19 +5,34 @@ export type VersioningDocument = Versioning & Document;
 
 @Schema()
 export class Versioning {
-  @Prop({ required: true })
+  @Prop({
+    required: true,
+    type: String,
+  })
   componentName: string;
 
-  @Prop({ required: true })
+  @Prop({
+    required: true,
+    type: String,
+  })
   createdAt: string;
 
-  @Prop({ required: true })
+  @Prop({
+    required: true,
+    type: Number,
+  })
   versionMain: number;
 
-  @Prop({ required: true })
+  @Prop({
+    required: true,
+    type: Number,
+  })
   versionMajor: number;
 
-  @Prop({ required: true })
+  @Prop({
+    required: true,
+    type: Number,
+  })
   versionMinor: number;
 }
 

src/versioning/versioning.module.ts

@@ -1,6 +1,6 @@
 import { Module } from '@nestjs/common';
 import { MongooseModule } from '@nestjs/mongoose';
-import { VersioningSchema } from './versioning.model';
+import { VersioningSchema } from './models/versioning.model';
 import { VersioningService } from './versioning.service';
 
 @Module({

src/versioning/versioning.service.ts

@@ -2,7 +2,7 @@ import { Injectable } from '@nestjs/common';
 import { InjectModel } from '@nestjs/mongoose';
 import { Model } from 'mongoose';
 import { SemanticVersionDto } from './dto/semanticversion.dto';
-import { Versioning, VersioningDocument } from './versioning.model';
+import { Versioning, VersioningDocument } from './models/versioning.model';
 
 @Injectable()
 export class VersioningService {