feat!: refactors generators to use the same arg types (#1505)

asyncapi · Sep 14, 2023 · 7db1bd7 · 7db1bd7
1 parent 35d1b6c
commit 7db1bd7
Show file tree

Hide file tree

Showing 15 changed files with 418 additions and 254 deletions.
diff --git a/src/generators/AbstractGenerator.ts b/src/generators/AbstractGenerator.ts
@@ -43,6 +43,25 @@ export const defaultGeneratorOptions: CommonGeneratorOptions = {
   }
 };
 
+export interface AbstractGeneratorRenderArgs<
+  Options extends CommonGeneratorOptions,
+  ConstrainedModel = ConstrainedMetaModel
+> {
+  constrainedModel: ConstrainedModel;
+  inputModel: InputMetaModel;
+  options?: DeepPartial<Options>;
+}
+
+export interface AbstractGeneratorRenderCompleteModelArgs<
+  Options extends CommonGeneratorOptions,
+  RenderCompleteModelOptions
+> {
+  constrainedModel: ConstrainedMetaModel;
+  inputModel: InputMetaModel;
+  completeOptions: Partial<RenderCompleteModelOptions>;
+  options?: DeepPartial<Options>;
+}
+
 /**
  * Abstract generator which must be implemented by each language
  */
@@ -56,15 +75,13 @@ export abstract class AbstractGenerator<
   ) {}
 
   public abstract render(
-    model: MetaModel,
-    inputModel: InputMetaModel,
-    options?: DeepPartial<Options>
+    args: AbstractGeneratorRenderArgs<Options>
   ): Promise<RenderOutput>;
   public abstract renderCompleteModel(
-    model: MetaModel,
-    inputModel: InputMetaModel,
-    completeOptions: Partial<RenderCompleteModelOptions>,
-    options?: DeepPartial<Options>
+    args: AbstractGeneratorRenderCompleteModelArgs<
+      Options,
+      RenderCompleteModelOptions
+    >
   ): Promise<RenderOutput>;
   public abstract constrainToMetaModel(
     model: MetaModel,
@@ -186,12 +203,12 @@ export abstract class AbstractGenerator<
     return Promise.all(
       this.getConstrainedModels(inputModel).map(
         async ({ constrainedModel, dependencyManager }) => {
-          const renderedOutput = await this.renderCompleteModel(
+          const renderedOutput = await this.renderCompleteModel({
             constrainedModel,
             inputModel,
             completeOptions,
-            { dependencyManager } as DeepPartial<Options>
-          );
+            options: { dependencyManager } as DeepPartial<Options>
+          });
           return OutputModel.toOutputModel({
             result: renderedOutput.result,
             modelName: renderedOutput.renderedName,
@@ -213,13 +230,13 @@ export abstract class AbstractGenerator<
     return Promise.all(
       this.getConstrainedModels(inputModel).map(
         async ({ constrainedModel, dependencyManager }) => {
-          const renderedOutput = await this.render(
+          const renderedOutput = await this.render({
             constrainedModel,
             inputModel,
-            {
+            options: {
               dependencyManager
             } as DeepPartial<Options>
-          );
+          });
           return OutputModel.toOutputModel({
             result: renderedOutput.result,
             modelName: renderedOutput.renderedName,

diff --git a/src/generators/cplusplus/CplusplusGenerator.ts b/src/generators/cplusplus/CplusplusGenerator.ts
@@ -1,5 +1,7 @@
 import {
   AbstractGenerator,
+  AbstractGeneratorRenderArgs,
+  AbstractGeneratorRenderCompleteModelArgs,
   CommonGeneratorOptions,
   defaultGeneratorOptions
 } from '../AbstractGenerator';
@@ -121,26 +123,32 @@ export class CplusplusGenerator extends AbstractGenerator<
    * @param inputModel
    */
   render(
-    model: ConstrainedMetaModel,
-    inputModel: InputMetaModel,
-    options?: DeepPartial<CplusplusOptions>
+    args: AbstractGeneratorRenderArgs<CplusplusOptions>
   ): Promise<RenderOutput> {
     const optionsToUse = CplusplusGenerator.getOptions({
       ...this.options,
-      ...options
+      ...args.options
     });
     if (isReservedCplusplusKeyword(optionsToUse.namespace)) {
       throw new Error(
         `You cannot use reserved C++ keyword (${optionsToUse.namespace}) as namespace, please use another.`
       );
     }
-    if (model instanceof ConstrainedObjectModel) {
-      return this.renderClass(model, inputModel, optionsToUse);
-    } else if (model instanceof ConstrainedEnumModel) {
-      return this.renderEnum(model, inputModel, optionsToUse);
+    if (args.constrainedModel instanceof ConstrainedObjectModel) {
+      return this.renderClass(
+        args.constrainedModel,
+        args.inputModel,
+        optionsToUse
+      );
+    } else if (args.constrainedModel instanceof ConstrainedEnumModel) {
+      return this.renderEnum(
+        args.constrainedModel,
+        args.inputModel,
+        optionsToUse
+      );
     }
     Logger.warn(
-      `C++ generator, cannot generate this type of model, ${model.name}`
+      `C++ generator, cannot generate this type of model, ${args.constrainedModel.name}`
     );
     return Promise.resolve(
       RenderOutput.toRenderOutput({
@@ -161,30 +169,35 @@ export class CplusplusGenerator extends AbstractGenerator<
    * @param options used to render the full output
    */
   async renderCompleteModel(
-    model: ConstrainedMetaModel,
-    inputModel: InputMetaModel,
-    completeModelOptions: Partial<CplusplusRenderCompleteModelOptions>,
-    options: DeepPartial<CplusplusOptions>
+    args: AbstractGeneratorRenderCompleteModelArgs<
+      CplusplusOptions,
+      CplusplusRenderCompleteModelOptions
+    >
   ): Promise<RenderOutput> {
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     const completeModelOptionsToUse = mergePartialAndDefault(
       CplusplusGenerator.defaultCompleteModelOptions,
-      completeModelOptions
+      args.completeOptions
     ) as CplusplusRenderCompleteModelOptions;
     const optionsToUse = CplusplusGenerator.getOptions({
       ...this.options,
-      ...options
+      ...args.options
     });
     const dependencyManagerToUse = this.getDependencyManager(optionsToUse);
 
-    const outputModel = await this.render(model, inputModel, {
-      ...optionsToUse,
-      dependencyManager: dependencyManagerToUse
+    const outputModel = await this.render({
+      ...args,
+      options: {
+        ...optionsToUse,
+        dependencyManager: dependencyManagerToUse
+      }
     });
 
-    const imports = model.getNearestDependencies().map((model) => {
-      return `#include "${model.name}.hpp"`;
-    });
+    const imports = args.constrainedModel
+      .getNearestDependencies()
+      .map((model) => {
+        return `#include "${model.name}.hpp"`;
+      });
     const formattedOutputResult = FormatHelpers.indent(
       outputModel.result,
       2,

diff --git a/src/generators/csharp/CSharpGenerator.ts b/src/generators/csharp/CSharpGenerator.ts
@@ -1,5 +1,7 @@
 import {
   AbstractGenerator,
+  AbstractGeneratorRenderArgs,
+  AbstractGeneratorRenderCompleteModelArgs,
   CommonGeneratorOptions,
   defaultGeneratorOptions
 } from '../AbstractGenerator';
@@ -146,26 +148,29 @@ export class CSharpGenerator extends AbstractGenerator<
    * @param options used to render the full output
    */
   async renderCompleteModel(
-    model: ConstrainedMetaModel,
-    inputModel: InputMetaModel,
-    completeModelOptions: DeepPartial<CSharpRenderCompleteModelOptions>,
-    options: DeepPartial<CSharpOptions>
+    args: AbstractGeneratorRenderCompleteModelArgs<
+      CSharpOptions,
+      CSharpRenderCompleteModelOptions
+    >
   ): Promise<RenderOutput> {
     const completeModelOptionsToUse = mergePartialAndDefault(
       CSharpGenerator.defaultCompleteModelOptions,
-      completeModelOptions
+      args.completeOptions
     ) as CSharpRenderCompleteModelOptions;
     const optionsToUse = CSharpGenerator.getCSharpOptions({
       ...this.options,
-      ...options
+      ...args.options
     });
     if (isReservedCSharpKeyword(completeModelOptionsToUse.namespace)) {
       throw new Error(
         `You cannot use reserved CSharp keyword (${completeModelOptionsToUse.namespace}) as namespace, please use another.`
       );
     }
 
-    const outputModel = await this.render(model, inputModel);
+    const outputModel = await this.render({
+      ...args,
+      options: optionsToUse
+    });
 
     const outputDependencies =
       outputModel.dependencies.length === 0
@@ -189,24 +194,34 @@ ${FormatHelpers.indent(
   }
 
   render(
-    model: ConstrainedMetaModel,
-    inputModel: InputMetaModel,
-    options?: DeepPartial<CSharpOptions>
+    args: AbstractGeneratorRenderArgs<CSharpOptions>
   ): Promise<RenderOutput> {
     const optionsToUse = CSharpGenerator.getCSharpOptions({
       ...this.options,
-      ...options
+      ...args.options
     });
-    if (model instanceof ConstrainedObjectModel) {
+    if (args.constrainedModel instanceof ConstrainedObjectModel) {
       if (this.options.modelType === 'record') {
-        return this.renderRecord(model, inputModel, optionsToUse);
+        return this.renderRecord(
+          args.constrainedModel,
+          args.inputModel,
+          optionsToUse
+        );
       }
-      return this.renderClass(model, inputModel, optionsToUse);
-    } else if (model instanceof ConstrainedEnumModel) {
-      return this.renderEnum(model, inputModel, optionsToUse);
+      return this.renderClass(
+        args.constrainedModel,
+        args.inputModel,
+        optionsToUse
+      );
+    } else if (args.constrainedModel instanceof ConstrainedEnumModel) {
+      return this.renderEnum(
+        args.constrainedModel,
+        args.inputModel,
+        optionsToUse
+      );
     }
     Logger.warn(
-      `C# generator, cannot generate this type of model, ${model.name}`
+      `C# generator, cannot generate this type of model, ${args.constrainedModel.name}`
     );
     return Promise.resolve(
       RenderOutput.toRenderOutput({

diff --git a/src/generators/dart/DartGenerator.ts b/src/generators/dart/DartGenerator.ts
@@ -1,5 +1,7 @@
 import {
   AbstractGenerator,
+  AbstractGeneratorRenderArgs,
+  AbstractGeneratorRenderCompleteModelArgs,
   CommonGeneratorOptions,
   defaultGeneratorOptions
 } from '../AbstractGenerator';
@@ -121,21 +123,27 @@ export class DartGenerator extends AbstractGenerator<
    * @param inputModel
    */
   render(
-    model: ConstrainedMetaModel,
-    inputModel: InputMetaModel,
-    options?: DeepPartial<DartOptions>
+    args: AbstractGeneratorRenderArgs<DartOptions>
   ): Promise<RenderOutput> {
     const optionsToUse = DartGenerator.getDartOptions({
       ...this.options,
-      ...options
+      ...args.options
     });
-    if (model instanceof ConstrainedObjectModel) {
-      return this.renderClass(model, inputModel, optionsToUse);
-    } else if (model instanceof ConstrainedEnumModel) {
-      return this.renderEnum(model, inputModel, optionsToUse);
+    if (args.constrainedModel instanceof ConstrainedObjectModel) {
+      return this.renderClass(
+        args.constrainedModel,
+        args.inputModel,
+        optionsToUse
+      );
+    } else if (args.constrainedModel instanceof ConstrainedEnumModel) {
+      return this.renderEnum(
+        args.constrainedModel,
+        args.inputModel,
+        optionsToUse
+      );
     }
     Logger.warn(
-      `Dart generator, cannot generate this type of model, ${model.name}`
+      `Dart generator, cannot generate this type of model, ${args.constrainedModel.name}`
     );
     return Promise.resolve(
       RenderOutput.toRenderOutput({
@@ -156,18 +164,18 @@ export class DartGenerator extends AbstractGenerator<
    * @param options used to render the full output
    */
   async renderCompleteModel(
-    model: ConstrainedMetaModel,
-    inputModel: InputMetaModel,
-    completeModelOptions: Partial<DartRenderCompleteModelOptions>,
-    options: DeepPartial<DartOptions>
+    args: AbstractGeneratorRenderCompleteModelArgs<
+      DartOptions,
+      DartRenderCompleteModelOptions
+    >
   ): Promise<RenderOutput> {
     const completeModelOptionsToUse = mergePartialAndDefault(
       DartGenerator.defaultCompleteModelOptions,
-      completeModelOptions
+      args.completeOptions
     ) as DartRenderCompleteModelOptions;
     const optionsToUse = DartGenerator.getDartOptions({
       ...this.options,
-      ...options
+      ...args.options
     });
     const dependencyManagerToUse = this.getDependencyManager(optionsToUse);
     if (isReservedDartKeyword(completeModelOptionsToUse.packageName)) {
@@ -176,9 +184,9 @@ export class DartGenerator extends AbstractGenerator<
       );
     }
 
-    const outputModel = await this.render(model, inputModel, optionsToUse);
+    const outputModel = await this.render({ ...args, options: optionsToUse });
     const modelDependencies = dependencyManagerToUse.renderAllModelDependencies(
-      model,
+      args.constrainedModel,
       completeModelOptionsToUse.packageName
     );
     const outputContent = `${modelDependencies}