feat: add namingConvention option and pass generator to renderers (#266)

Co-authored-by: Maciej Urbańczyk <urbanczyk.maciej.95@gmail.com>

Author: jonaslagoni

docs/generators.md

@@ -37,6 +37,34 @@ Below is a list of additional options available for a given generator.
 |---|---|---|---|
 | `renderTypes` | Boolean | Render signature for types. | `true` |
 | `modelType` | String | It indicates which model type should be rendered for the `object` type. Its value can be either `interface` or `class`. | `class` |
+| `namingConvention` | Object | Options for naming conventions. | - |
+| `namingConvention.type` | Function | A function that returns the format of the type. | _Returns pascal cased name_ |
+| `namingConvention.property` | Function | A function that returns the format of the property. | _Returns camel cased name_ |
+
+### [Java](../src/generators/java/JavaGenerator.ts)
+
+| Option | Type | Description | Default value |
+|---|---|---|---|
+| `collectionType` | String | It indicates with which signature should be rendered the `array` type. Its value can be either `List` (`List<{type}>`) or `Array` (`{type}[]`). | `List` |
+| `namingConvention` | Object | Options for naming conventions. | - |
+| `namingConvention.type` | Function | A function that returns the format of the type. | _Returns pascal cased name_ |
+| `namingConvention.property` | Function | A function that returns the format of the property. | _Returns camel cased name_ |
+
+### [JavaScript](../src/generators/javascript/JavaScriptGenerator.ts)
+
+| Option | Type | Description | Default value |
+|---|---|---|---|
+| `namingConvention` | Object | Options for naming conventions. | - |
+| `namingConvention.type` | Function | A function that returns the format of the type. | _Returns pascal cased name_ |
+| `namingConvention.property` | Function | A function that returns the format of the property. | _Returns camel cased name_ |
+
+### [Go](../src/generators/javascript/GoGenerator.ts)
+
+| Option | Type | Description | Default value |
+|---|---|---|---|
+| `namingConvention` | Object | Options for naming conventions. | - |
+| `namingConvention.type` | Function | A function that returns the format of the type. | _Returns pascal cased name_ |
+| `namingConvention.field` | Function | A function that returns the format of the field. | _Returns pascal cased name_ |
 
 ## Custom generator
 

src/generators/AbstractGenerator.ts

@@ -13,11 +13,11 @@ export interface CommonGeneratorOptions<P extends Preset = Preset> {
   presets?: Presets<P>;
 }
 
-export const defaultGeneratorOptions = {
+export const defaultGeneratorOptions: CommonGeneratorOptions = {
   indentation: {
     type: IndentationTypes.SPACES,
     size: 2,
-  },
+  }
 };
 
 /**
@@ -87,7 +87,7 @@ export abstract class AbstractGenerator<Options extends CommonGeneratorOptions =
     return {
       ...defaultGeneratorOptions,
       ...defaultOptions,
-      ...passedOptions,
+      ...passedOptions
     };
   }
 }

src/generators/AbstractRenderer.ts

@@ -1,13 +1,17 @@
-import { CommonGeneratorOptions } from './AbstractGenerator';
+import { AbstractGenerator, CommonGeneratorOptions } from './AbstractGenerator';
 import { CommonModel, CommonInputModel, Preset } from '../models';
 import { FormatHelpers, IndentationTypes } from '../helpers';
 
 /**
  * Abstract renderer with common helper methods
  */
-export abstract class AbstractRenderer<O extends CommonGeneratorOptions = CommonGeneratorOptions> {
+export abstract class AbstractRenderer<
+  O extends CommonGeneratorOptions = CommonGeneratorOptions,
+  G extends AbstractGenerator = AbstractGenerator
+> {
   constructor(
     protected readonly options: O,
+    readonly generator: G,
     protected readonly presets: Array<[Preset, unknown]>,
     protected readonly model: CommonModel, 
     protected readonly inputModel: CommonInputModel,
@@ -51,6 +55,7 @@ export abstract class AbstractRenderer<O extends CommonGeneratorOptions = Common
   runAdditionalContentPreset(): Promise<string> {
     return this.runPreset('additionalContent');
   }
+  
   async runPreset<RT = string>(
     functionName: string,
     params: Record<string, unknown> = {},

src/generators/go/GoGenerator.ts

@@ -4,12 +4,37 @@ import {
   defaultGeneratorOptions,
 } from '../AbstractGenerator';
 import { CommonModel, CommonInputModel, RenderOutput } from '../../models';
-import { TypeHelpers, ModelKind } from '../../helpers';
+import { TypeHelpers, ModelKind, FormatHelpers } from '../../helpers';
 import { GoPreset, GO_DEFAULT_PRESET } from './GoPreset';
 import { StructRenderer } from './renderers/StructRenderer';
 import { EnumRenderer } from './renderers/EnumRenderer';
+import { pascalCaseTransformMerge } from 'pascal-case';
 
-export type GoOptions = CommonGeneratorOptions<GoPreset>
+/**
+ * The Go naming convention type
+ */
+export type GoNamingConvention = {
+  type?: (name: string | undefined, ctx: { model: CommonModel, inputModel: CommonInputModel }) => string;
+  field?: (name: string | undefined, ctx: { model: CommonModel, inputModel: CommonInputModel, field?: CommonModel }) => string;
+};
+
+/**
+ * A GoNamingConvention implementation for Go
+ */
+export const GoNamingConventionImplementation: GoNamingConvention = {
+  type: (name: string | undefined) => {
+    if (!name) {return '';}
+    return FormatHelpers.toPascalCase(name, { transform: pascalCaseTransformMerge });
+  },
+  field: (fieldName: string | undefined) => {
+    if (!fieldName) {return '';}
+    return FormatHelpers.toPascalCase(fieldName, { transform: pascalCaseTransformMerge });
+  }
+};
+
+export interface GoOptions extends CommonGeneratorOptions<GoPreset> {
+  namingConvention?: GoNamingConvention;
+}
 
 /**
  * Generator for Go
@@ -18,6 +43,7 @@ export class GoGenerator extends AbstractGenerator<GoOptions> {
   static defaultOptions: GoOptions = {
     ...defaultGeneratorOptions,
     defaultPreset: GO_DEFAULT_PRESET,
+    namingConvention: GoNamingConventionImplementation
   };
 
   constructor(
@@ -29,27 +55,25 @@ export class GoGenerator extends AbstractGenerator<GoOptions> {
   render(model: CommonModel, inputModel: CommonInputModel): Promise<RenderOutput> {
     const kind = TypeHelpers.extractKind(model);
     switch (kind) {
-    case ModelKind.OBJECT: {
+    case ModelKind.OBJECT: 
       return this.renderStruct(model, inputModel);
-    }
-    case ModelKind.ENUM: {
+    case ModelKind.ENUM: 
       return this.renderEnum(model, inputModel);
     }
-    }
 
     return Promise.resolve(RenderOutput.toRenderOutput({ result: '', dependencies: [] }));
   }
 
   async renderEnum(model: CommonModel, inputModel: CommonInputModel): Promise<RenderOutput> {
     const presets = this.getPresets('enum');
-    const renderer = new EnumRenderer(this.options, presets, model, inputModel);
+    const renderer = new EnumRenderer(this.options, this, presets, model, inputModel);
     const result = await renderer.runSelfPreset();
     return RenderOutput.toRenderOutput({ result, dependencies: renderer.dependencies });
   }
 
   async renderStruct(model: CommonModel, inputModel: CommonInputModel): Promise<RenderOutput> {
     const presets = this.getPresets('struct');
-    const renderer = new StructRenderer(this.options, presets, model, inputModel);
+    const renderer = new StructRenderer(this.options, this, presets, model, inputModel);
     const result = await renderer.runSelfPreset();
     return RenderOutput.toRenderOutput({ result, dependencies: renderer.dependencies });
   }

src/generators/go/GoRenderer.ts

@@ -1,8 +1,7 @@
 import { AbstractRenderer } from '../AbstractRenderer';
-import { GoOptions } from './GoGenerator';
+import { GoGenerator, GoOptions } from './GoGenerator';
 import { CommonModel, CommonInputModel, Preset } from '../../models';
 import { FormatHelpers } from '../../helpers/FormatHelpers';
-import { pascalCaseTransformMerge } from 'pascal-case';
 
 /**
  * Common renderer for Go types
@@ -12,11 +11,12 @@ import { pascalCaseTransformMerge } from 'pascal-case';
 export abstract class GoRenderer extends AbstractRenderer<GoOptions> {
   constructor(
     options: GoOptions,
+    generator: GoGenerator,
     presets: Array<[Preset, unknown]>,
     model: CommonModel,
     inputModel: CommonInputModel,
   ) {
-    super(options, presets, model, inputModel);
+    super(options, generator, presets, model, inputModel);
   }
 
   async renderFields(): Promise<string> {
@@ -31,13 +31,40 @@ export abstract class GoRenderer extends AbstractRenderer<GoOptions> {
     return this.renderBlock(content);
   }
 
+  /**
+   * Renders the name of a type based on provided generator option naming convention type function.
+   * 
+   * This is used to render names of models and then later used if that class is referenced from other models.
+   * 
+   * @param name 
+   * @param model 
+   */
+  nameType(name: string | undefined, model?: CommonModel): string {
+    return this.options?.namingConvention?.type 
+      ? this.options.namingConvention.type(name, { model: model || this.model, inputModel: this.inputModel })
+      : name || '';
+  }
+
+  /**
+   * Renders the name of a field based on provided generator option naming convention field function.
+   * 
+   * @param fieldName 
+   * @param property
+   */
+  nameField(fieldName: string | undefined, field?: CommonModel): string {
+    return this.options?.namingConvention?.field 
+      ? this.options.namingConvention.field(fieldName, { model: this.model, inputModel: this.inputModel, field })
+      : fieldName || '';
+  }
+
   runFieldPreset(fieldName: string, field: CommonModel): Promise<string> {
     return this.runPreset('field', { fieldName, field });
   }
 
   renderType(model: CommonModel): string {
     if (model.$ref !== undefined) {
-      return `*${FormatHelpers.toPascalCase(model.$ref, { transform: pascalCaseTransformMerge })}`;
+      const formattedRef = this.nameType(model.$ref);
+      return `*${formattedRef}`;
     }
 
     if (Array.isArray(model.type)) {

src/generators/go/renderers/EnumRenderer.ts

@@ -1,6 +1,5 @@
 import { GoRenderer } from '../GoRenderer';
 import { EnumPreset, CommonModel } from '../../../models';
-import { FormatHelpers } from '../../../helpers';
 
 /**
  * Renderer for Go's `enum` type
@@ -9,7 +8,7 @@ import { FormatHelpers } from '../../../helpers';
  */
 export class EnumRenderer extends GoRenderer {
   public defaultSelf(): string {
-    const formattedName = this.model.$id && FormatHelpers.toPascalCase(this.model.$id);
+    const formattedName = this.nameType(this.model.$id);
     const type = this.enumType(this.model);
     const doc = formattedName && this.renderCommentForEnumType(formattedName, type);
 

src/generators/go/renderers/StructRenderer.ts

@@ -1,7 +1,5 @@
 import { GoRenderer } from '../GoRenderer';
 import { StructPreset } from '../GoPreset';
-import { FormatHelpers } from '../../../helpers/FormatHelpers';
-import { pascalCaseTransformMerge } from 'pascal-case';
 
 /**
  * Renderer for Go's `struct` type
@@ -14,8 +12,8 @@ export class StructRenderer extends GoRenderer {
       await this.renderFields(),
       await this.runAdditionalContentPreset()
     ];
-
-    const formattedName = this.model.$id && FormatHelpers.toPascalCase(this.model.$id, { transform: pascalCaseTransformMerge });
+    
+    const formattedName = this.nameType(this.model.$id);
     const doc = this.renderComments(`${formattedName} represents a ${formattedName} model.`);
 
     return `${doc}
@@ -30,6 +28,7 @@ export const GO_DEFAULT_STRUCT_PRESET: StructPreset<StructRenderer> = {
     return renderer.defaultSelf();
   },
   field({ fieldName, field, renderer }) {
-    return `${FormatHelpers.toPascalCase(fieldName, { transform: pascalCaseTransformMerge }) } ${ renderer.renderType(field)}`;
+    fieldName = renderer.nameField(fieldName, field);
+    return `${ fieldName } ${ renderer.renderType(field)}`;
   },
 };

src/generators/java/JavaGenerator.ts

@@ -4,17 +4,20 @@ import {
   defaultGeneratorOptions,
 } from '../AbstractGenerator';
 import { CommonModel, CommonInputModel, RenderOutput } from '../../models';
-import { ModelKind, TypeHelpers } from '../../helpers';
+import { CommonNamingConvention, CommonNamingConventionImplementation, ModelKind, TypeHelpers } from '../../helpers';
 import { JavaPreset, JAVA_DEFAULT_PRESET } from './JavaPreset';
 import { ClassRenderer } from './renderers/ClassRenderer';
 import { EnumRenderer } from './renderers/EnumRenderer';
-
-export type JavaOptions = CommonGeneratorOptions<JavaPreset>
-
+export interface JavaOptions extends CommonGeneratorOptions<JavaPreset> {
+  collectionType?: 'List' | 'Array';
+  namingConvention?: CommonNamingConvention;
+}
 export class JavaGenerator extends AbstractGenerator<JavaOptions> {
   static defaultOptions: JavaOptions = {
     ...defaultGeneratorOptions,
-    defaultPreset: JAVA_DEFAULT_PRESET,
+    defaultPreset: JAVA_DEFAULT_PRESET,     
+    collectionType: 'Array',
+    namingConvention: CommonNamingConventionImplementation
   };
 
   constructor(
@@ -33,14 +36,14 @@ export class JavaGenerator extends AbstractGenerator<JavaOptions> {
 
   async renderClass(model: CommonModel, inputModel: CommonInputModel): Promise<RenderOutput> {
     const presets = this.getPresets('class');
-    const renderer = new ClassRenderer(this.options, presets, model, inputModel);
+    const renderer = new ClassRenderer(this.options, this, presets, model, inputModel);
     const result = await renderer.runSelfPreset();
     return RenderOutput.toRenderOutput({result, dependencies: renderer.dependencies});
   }
 
   async renderEnum(model: CommonModel, inputModel: CommonInputModel): Promise<RenderOutput> {
     const presets = this.getPresets('enum'); 
-    const renderer = new EnumRenderer(this.options, presets, model, inputModel);
+    const renderer = new EnumRenderer(this.options, this, presets, model, inputModel);
     const result = await renderer.runSelfPreset();
     return RenderOutput.toRenderOutput({result, dependencies: renderer.dependencies});
   }