chore: remove old post interpreter and fix tests

src/interpreter/Interpreter.ts

@@ -1,5 +1,5 @@
 import { CommonModel, Draft6Schema, Draft4Schema, SwaggerV2Schema, AsyncapiV2Schema, Draft7Schema } from '../models';
-import { interpretName, isEnum, isModelObject } from './Utils';
+import { interpretName } from './Utils';
 import interpretProperties from './InterpretProperties';
 import interpretAllOf from './InterpretAllOf';
 import interpretConst from './InterpretConst';
@@ -91,12 +91,8 @@ export class Interpreter {
 
     interpretNot(schema, model, this, interpreterOptions);
 
-    //All schemas of type model object or enum MUST have ids
-    if (isModelObject(model) === true || isEnum(model) === true) {
-      model.$id = interpretName(schema) || `anonymSchema${this.anonymCounter++}`;
-    } else if ((!(schema instanceof Draft4Schema) && schema.$id !== undefined) || (schema instanceof Draft4Schema && schema.id !== undefined)) {
-      model.$id = interpretName(schema);
-    }
+    //All schemas MUST have ids as we do not know how it will be generated and when it will be needed
+    model.$id = interpretName(schema) || `anonymSchema${this.anonymCounter++}`;
   }
 
   /**

src/processors/AsyncAPIInputProcessor.ts

@@ -1,7 +1,7 @@
 import {parse, AsyncAPIDocument, Schema as AsyncAPISchema, ParserOptions} from '@asyncapi/parser';
 import { AbstractInputProcessor } from './AbstractInputProcessor';
 import { JsonSchemaInputProcessor } from './JsonSchemaInputProcessor';
-import { CommonModel, InputMetaModel, ProcessorOptions } from '../models';
+import { InputMetaModel, ProcessorOptions } from '../models';
 import { Logger } from '../utils';
 import { AsyncapiV2Schema } from '../models/AsyncapiV2Schema';
 import { convertToMetaModel } from '../helpers';
@@ -29,16 +29,19 @@ export class AsyncAPIInputProcessor extends AbstractInputProcessor {
       doc = input as AsyncAPIDocument;
     }
     inputModel.originalInput = doc;
-
-    //Intermediate model before meta model
-    let commonModels: {[key: string]: CommonModel} = {};
+    // Go over all the message payloads and convert them to models
     for (const [, message] of doc.allMessages()) {
       const schema = AsyncAPIInputProcessor.convertToInternalSchema(message.payload());
-      const newCommonModels = JsonSchemaInputProcessor.convertSchemaToCommonModel(schema);
-      commonModels = {...commonModels, ...newCommonModels};
-    }
-    for (const [key, commonModel] of Object.entries(commonModels)) {
-      inputModel.models[String(key)] = convertToMetaModel(commonModel);
+      const newCommonModel = JsonSchemaInputProcessor.convertSchemaToCommonModel(schema);
+      if (newCommonModel.$id !== undefined) {
+        if (inputModel.models[newCommonModel.$id] !== undefined) {
+          Logger.warn(`Overwriting existing model with $id ${newCommonModel.$id}, are there two models with the same id present?`, newCommonModel);
+        }
+        const metaModel = convertToMetaModel(newCommonModel);
+        inputModel.models[metaModel.name] = metaModel;
+      } else {
+        Logger.warn('Model did not have $id which is required, ignoring.', newCommonModel);
+      }
     }
     return inputModel;
   }

src/processors/JsonSchemaInputProcessor.ts

@@ -3,7 +3,6 @@ import $RefParser from '@apidevtools/json-schema-ref-parser';
 import path from 'path';
 import { CommonModel, InputMetaModel, Draft4Schema, Draft7Schema, Draft6Schema, SwaggerV2Schema, OpenapiV3Schema, AsyncapiV2Schema } from '../models';
 import { Logger } from '../utils';
-import { postInterpretModel } from '../interpreter/PostInterpreter';
 import { Interpreter } from '../interpreter/Interpreter';
 import { convertToMetaModel } from '../helpers';
 
@@ -66,10 +65,9 @@ export class JsonSchemaInputProcessor extends AbstractInputProcessor {
     input = JsonSchemaInputProcessor.reflectSchemaNames(input, {}, 'root', true) as Record<string, any>;
     await this.dereferenceInputs(input);
     const parsedSchema = Draft7Schema.toSchema(input);
-    const commonModels = JsonSchemaInputProcessor.convertSchemaToCommonModel(parsedSchema);
-    for (const [key, commonModel] of Object.entries(commonModels)) {
-      inputModel.models[String(key)] = convertToMetaModel(commonModel);
-    }
+    const newCommonModel = JsonSchemaInputProcessor.convertSchemaToCommonModel(parsedSchema);
+    const metaModel = convertToMetaModel(newCommonModel);
+    inputModel.models[metaModel.name] = metaModel;
     Logger.debug('Completed processing input as JSON Schema draft 7 document');
     return inputModel;
   }
@@ -86,10 +84,9 @@ export class JsonSchemaInputProcessor extends AbstractInputProcessor {
     input = JsonSchemaInputProcessor.reflectSchemaNames(input, {}, 'root', true) as Record<string, any>;
     await this.dereferenceInputs(input);
     const parsedSchema = Draft4Schema.toSchema(input);
-    const commonModels = JsonSchemaInputProcessor.convertSchemaToCommonModel(parsedSchema);
-    for (const [key, commonModel] of Object.entries(commonModels)) {
-      inputModel.models[String(key)] = convertToMetaModel(commonModel);
-    }
+    const newCommonModel = JsonSchemaInputProcessor.convertSchemaToCommonModel(parsedSchema);
+    const metaModel = convertToMetaModel(newCommonModel);
+    inputModel.models[metaModel.name] = metaModel;
     Logger.debug('Completed processing input as JSON Schema draft 4 document');
     return inputModel;
   }
@@ -106,10 +103,9 @@ export class JsonSchemaInputProcessor extends AbstractInputProcessor {
     input = JsonSchemaInputProcessor.reflectSchemaNames(input, {}, 'root', true) as Record<string, any>;
     await this.dereferenceInputs(input);
     const parsedSchema = Draft6Schema.toSchema(input);
-    const commonModels = JsonSchemaInputProcessor.convertSchemaToCommonModel(parsedSchema);
-    for (const [key, commonModel] of Object.entries(commonModels)) {
-      inputModel.models[String(key)] = convertToMetaModel(commonModel);
-    }
+    const newCommonModel = JsonSchemaInputProcessor.convertSchemaToCommonModel(parsedSchema);
+    const metaModel = convertToMetaModel(newCommonModel);
+    inputModel.models[metaModel.name] = metaModel;
     Logger.debug('Completed processing input as JSON Schema draft 6 document');
     return inputModel;
   }
@@ -279,23 +275,12 @@ export class JsonSchemaInputProcessor extends AbstractInputProcessor {
    * 
    * @param schema to simplify to common model
    */
-  static convertSchemaToCommonModel(schema: Draft4Schema | Draft6Schema | Draft7Schema | SwaggerV2Schema| AsyncapiV2Schema | boolean): Record<string, CommonModel> {
-    const commonModelsMap: Record<string, CommonModel> = {};
+  static convertSchemaToCommonModel(schema: Draft4Schema | Draft6Schema | Draft7Schema | SwaggerV2Schema| AsyncapiV2Schema | boolean): CommonModel {
     const interpreter = new Interpreter();
     const model = interpreter.interpret(schema);
-    if (model !== undefined) { 
-      const commonModels = postInterpretModel(model);
-      for (const commonModel of commonModels) {
-        if (commonModel.$id) {
-          if (commonModelsMap[commonModel.$id] !== undefined) {
-            Logger.warn(`Overwriting existing model with $id ${commonModel.$id}, are there two models with the same id present?`, commonModel);
-          }
-          commonModelsMap[commonModel.$id] = commonModel;
-        } else {
-          Logger.warn('Model did not have $id, ignoring.', commonModel);
-        }
-      }
+    if (model === undefined) {
+      throw new Error('Could not interpret schema to internal model');
     }
-    return commonModelsMap;
+    return model;
   }
 }

src/processors/OpenAPIInputProcessor.ts

@@ -90,9 +90,15 @@ export class OpenAPIInputProcessor extends AbstractInputProcessor {
 
   private includeSchema(schema: OpenAPIV3.SchemaObject, name: string, inputModel: InputMetaModel) {
     const internalSchema = OpenAPIInputProcessor.convertToInternalSchema(schema, name);
-    const commonModels = JsonSchemaInputProcessor.convertSchemaToCommonModel(internalSchema);
-    for (const [key, commonModel] of Object.entries(commonModels)) {
-      inputModel.models[String(key)] = convertToMetaModel(commonModel);
+    const newCommonModel = JsonSchemaInputProcessor.convertSchemaToCommonModel(internalSchema);
+    if (newCommonModel.$id !== undefined) {
+      if (inputModel.models[newCommonModel.$id] !== undefined) {
+        Logger.warn(`Overwriting existing model with $id ${newCommonModel.$id}, are there two models with the same id present?`, newCommonModel);
+      }
+      const metaModel = convertToMetaModel(newCommonModel);
+      inputModel.models[metaModel.name] = metaModel;
+    } else {
+      Logger.warn('Model did not have $id, ignoring.', newCommonModel);
     }
   }
 

src/processors/SwaggerInputProcessor.ts

@@ -73,9 +73,15 @@ export class SwaggerInputProcessor extends AbstractInputProcessor {
 
   private includeSchema(schema: OpenAPIV2.SchemaObject, name: string, inputModel: InputMetaModel) {
     const internalSchema = SwaggerInputProcessor.convertToInternalSchema(schema, name);
-    const commonModels = JsonSchemaInputProcessor.convertSchemaToCommonModel(internalSchema);
-    for (const [key, commonModel] of Object.entries(commonModels)) {
-      inputModel.models[String(key)] = convertToMetaModel(commonModel);
+    const newCommonModel = JsonSchemaInputProcessor.convertSchemaToCommonModel(internalSchema);
+    if (newCommonModel.$id !== undefined) {
+      if (inputModel.models[newCommonModel.$id] !== undefined) {
+        Logger.warn(`Overwriting existing model with $id ${newCommonModel.$id}, are there two models with the same id present?`, newCommonModel);
+      }
+      const metaModel = convertToMetaModel(newCommonModel);
+      inputModel.models[metaModel.name] = metaModel;
+    } else {
+      Logger.warn('Model did not have $id, ignoring.', newCommonModel);
     }
   }
 

src/processors/TypeScriptInputProcessor.ts

@@ -1,13 +1,13 @@
-import { CommonModel, InputMetaModel, ProcessorOptions } from '../models';
+import { InputMetaModel, ProcessorOptions } from '../models';
 import { resolve } from 'path';
 import ts from 'typescript';
 import * as TJS from 'typescript-json-schema';
 import { JsonSchemaInputProcessor } from './JsonSchemaInputProcessor';
 import { AbstractInputProcessor } from './AbstractInputProcessor';
 import { convertToMetaModel } from '../helpers';
+import { Logger } from '../utils';
 
 /** Class for processing Typescript code inputs to Common module*/
-
 export interface TypeScriptInputProcessorOptions extends TJS.PartialArgs{
   uniqueNames? : boolean;
   required? : boolean;
@@ -81,13 +81,17 @@ export class TypeScriptInputProcessor extends AbstractInputProcessor {
     // obtain generated schema
     const generatedSchemas = this.generateJSONSchema(baseFile, '*', options?.typescript);
     if (generatedSchemas) {
-      let commonModels: {[key: string]: CommonModel} = {};
       for (const schema of generatedSchemas) {
-        const newCommonModels = JsonSchemaInputProcessor.convertSchemaToCommonModel(schema as Record<string, any>);
-        commonModels = {...commonModels, ...newCommonModels };
-      }
-      for (const [key, commonModel] of Object.entries(commonModels)) {
-        inputModel.models[String(key)] = convertToMetaModel(commonModel);
+        const newCommonModel = JsonSchemaInputProcessor.convertSchemaToCommonModel(schema as Record<string, any>);
+        if (newCommonModel.$id !== undefined) {
+          if (inputModel.models[newCommonModel.$id] !== undefined) {
+            Logger.warn(`Overwriting existing model with $id ${newCommonModel.$id}, are there two models with the same id present?`, newCommonModel);
+          }
+          const metaModel = convertToMetaModel(newCommonModel);
+          inputModel.models[metaModel.name] = metaModel;
+        } else {
+          Logger.warn('Model did not have $id, ignoring.', newCommonModel);
+        }
       }
     }
     return Promise.resolve(inputModel);