feat: pass options to processors (#328)

Author: jonaslagoni

src/generators/AbstractGenerator.ts

@@ -1,16 +1,15 @@
-import { CommonInputModel, CommonModel, OutputModel, Preset, Presets } from '../models';
+import { CommonInputModel, CommonModel, OutputModel, Preset, Presets, RenderOutput, ProcessorOptions } from '../models';
 import { InputProcessor } from '../processors';
 import { IndentationTypes } from '../helpers';
 import { isPresetWithOptions } from '../utils';
-import { RenderOutput } from '../models/RenderOutput';
-
 export interface CommonGeneratorOptions<P extends Preset = Preset> {
   indentation?: {
     type: IndentationTypes;
     size: number;
   };
   defaultPreset?: P;
   presets?: Presets<P>;
+  processorOptions?: ProcessorOptions
 }
 
 export const defaultGeneratorOptions: CommonGeneratorOptions = {
@@ -36,8 +35,8 @@ export abstract class AbstractGenerator<Options extends CommonGeneratorOptions =
 
   public abstract render(model: CommonModel, inputModel: CommonInputModel): Promise<RenderOutput>;
 
-  public async process(input: Record<string, unknown>): Promise<CommonInputModel> {
-    return await InputProcessor.processor.process(input);
+  public process(input: Record<string, unknown>): Promise<CommonInputModel> {
+    return InputProcessor.processor.process(input, this.options.processorOptions);
   }
 
   public async generate(input: Record<string, unknown> | CommonInputModel): Promise<OutputModel[]> {

src/models/ProcessorOptions.ts

@@ -0,0 +1,9 @@
+export interface AsyncapiProcessorOptions {
+  path?: string
+  parse?: any;
+  resolve?: any;
+  applyTraits?: any;
+}
+export interface ProcessorOptions {
+  asyncapi?: AsyncapiProcessorOptions
+}

src/models/index.ts

@@ -5,3 +5,4 @@ export * from './CommonSchema';
 export * from './OutputModel';
 export * from './Preset';
 export * from './Schema';
+export * from './ProcessorOptions';

src/processors/AbstractInputProcessor.ts

@@ -1,7 +1,6 @@
-import { CommonInputModel } from '../models/CommonInputModel';
-
+import { ProcessorOptions, CommonInputModel } from '../models';
 export abstract class AbstractInputProcessor {
   public static MODELGEN_INFFERED_NAME = 'x-modelgen-inferred-name';
-  abstract process(input: Record<string, any>): Promise<CommonInputModel>;
+  abstract process(input: Record<string, any>, options?: ProcessorOptions): Promise<CommonInputModel>;
   abstract shouldProcess(input: Record<string, any>): boolean;
 }

src/processors/AsyncAPIInputProcessor.ts

@@ -1,28 +1,28 @@
 import {parse, AsyncAPIDocument, Schema as AsyncAPISchema} from '@asyncapi/parser';
-
 import { AbstractInputProcessor } from './AbstractInputProcessor';
 import { JsonSchemaInputProcessor } from './JsonSchemaInputProcessor';
-import { CommonInputModel, Schema } from '../models';
+import { CommonInputModel, ProcessorOptions, Schema } from '../models';
 import { Logger } from '../utils';
 
 /**
  * Class for processing AsyncAPI inputs
  */
 export class AsyncAPIInputProcessor extends AbstractInputProcessor {
   static supportedVersions = ['2.0.0', '2.1.0'];
+
   /**
    * Process the input as an AsyncAPI document
    * 
    * @param input 
    */
-  async process(input: Record<string, any>): Promise<CommonInputModel> {
+  async process(input: Record<string, any>, options?: ProcessorOptions): Promise<CommonInputModel> {
     if (!this.shouldProcess(input)) {throw new Error('Input is not an AsyncAPI document so it cannot be processed.');}
 
     Logger.debug('Processing input as an AsyncAPI document');
     let doc: AsyncAPIDocument;
     const common = new CommonInputModel();
     if (!AsyncAPIInputProcessor.isFromParser(input)) {
-      doc = await parse(input as any);
+      doc = await parse(input as any, options?.asyncapi);
     } else {
       doc = input as AsyncAPIDocument;
     }

src/processors/InputProcessor.ts

@@ -1,7 +1,7 @@
 import { AbstractInputProcessor } from './AbstractInputProcessor';
 import { AsyncAPIInputProcessor } from './AsyncAPIInputProcessor';
 import { JsonSchemaInputProcessor } from './JsonSchemaInputProcessor';
-import { CommonInputModel } from '../models/CommonInputModel';
+import { ProcessorOptions, CommonInputModel } from '../models';
 
 /**
  * Main input processor which figures out the type of input it receives and delegates the processing into separate individual processors.
@@ -37,18 +37,18 @@ export class InputProcessor {
    * The processor code which delegates the processing to the correct implementation.
    * 
    * @param input to process
-   * @param type of processor to use
+   * @param options passed to the processors
    */
-  process(input: Record<string, any>): Promise<CommonInputModel> {
+  process(input: Record<string, any>, options?: ProcessorOptions): Promise<CommonInputModel> {
     for (const [type, processor] of this.processors) {
       if (type === 'default') {continue;}
       if (processor.shouldProcess(input)) {
-        return processor.process(input);
+        return processor.process(input, options);
       }
     }
     const defaultProcessor = this.processors.get('default');
     if (defaultProcessor !== undefined) {
-      return defaultProcessor.process(input);
+      return defaultProcessor.process(input, options);
     }
     return Promise.reject(new Error('No default processor found'));
   }

test/processors/InputProcessor.spec.ts

@@ -1,11 +1,11 @@
 import * as fs from 'fs';
 import * as path from 'path';
-import { CommonInputModel } from '../../src/models';
+import { CommonInputModel, ProcessorOptions } from '../../src/models';
 import { InputProcessor } from '../../src/processors/InputProcessor';
 import { JsonSchemaInputProcessor } from '../../src/processors/JsonSchemaInputProcessor';
 import { AsyncAPIInputProcessor } from '../../src/processors/AsyncAPIInputProcessor';
 import { AbstractInputProcessor } from '../../src/processors';
-
+import AsyncAPIParser from '@asyncapi/parser';
 describe('InputProcessor', () => {
   beforeEach(() => {
     jest.resetAllMocks();
@@ -64,7 +64,7 @@ describe('InputProcessor', () => {
       await processor.process(inputSchema);
       expect(asyncInputProcessor.process).not.toHaveBeenCalled();
       expect(asyncInputProcessor.shouldProcess).toHaveBeenNthCalledWith(1, inputSchema);
-      expect(defaultInputProcessor.process).toHaveBeenNthCalledWith(1, inputSchema);
+      expect(defaultInputProcessor.process).toHaveBeenNthCalledWith(1, inputSchema, undefined);
       expect(defaultInputProcessor.shouldProcess).toHaveBeenNthCalledWith(1, inputSchema);
     });
 
@@ -73,8 +73,25 @@ describe('InputProcessor', () => {
       const inputSchemaString = fs.readFileSync(path.resolve(__dirname, './AsyncAPIInputProcessor/basic.json'), 'utf8');
       const inputSchema = JSON.parse(inputSchemaString);
       await processor.process(inputSchema);
-      expect(asyncInputProcessor.process).toHaveBeenNthCalledWith(1, inputSchema);
+      expect(asyncInputProcessor.process).toHaveBeenNthCalledWith(1, inputSchema, undefined);
+      expect(asyncInputProcessor.shouldProcess).toHaveBeenNthCalledWith(1, inputSchema);
+      expect(defaultInputProcessor.process).not.toHaveBeenCalled();
+      expect(defaultInputProcessor.shouldProcess).not.toHaveBeenCalled();
+    });
+    test('should be able to process AsyncAPI schema input with options', async () => {
+      const {processor, asyncInputProcessor, defaultInputProcessor} = getProcessors(); 
+      const spy = jest.spyOn(AsyncAPIParser, 'parse');
+      const options: ProcessorOptions = {
+        asyncapi: {
+          path: 'test'
+        }
+      };
+      const inputSchemaString = fs.readFileSync(path.resolve(__dirname, './AsyncAPIInputProcessor/basic.json'), 'utf8');
+      const inputSchema = JSON.parse(inputSchemaString);
+      await processor.process(inputSchema, options);
+      expect(asyncInputProcessor.process).toHaveBeenNthCalledWith(1, inputSchema, options);
       expect(asyncInputProcessor.shouldProcess).toHaveBeenNthCalledWith(1, inputSchema);
+      expect(spy).toHaveBeenNthCalledWith(1, inputSchema, expect.objectContaining(options.asyncapi));
       expect(defaultInputProcessor.process).not.toHaveBeenCalled();
       expect(defaultInputProcessor.shouldProcess).not.toHaveBeenCalled();
     });