feat: add basic struct generation for Go (#267)

Author: smoya

src/generators/go/GoGenerator.ts

@@ -0,0 +1,42 @@
+import {
+  AbstractGenerator,
+  CommonGeneratorOptions,
+  defaultGeneratorOptions,
+} from '../AbstractGenerator';
+import { CommonModel, CommonInputModel, RenderOutput } from '../../models';
+import { TypeHelpers, ModelKind } from '../../helpers';
+import { GoPreset, GO_DEFAULT_PRESET } from './GoPreset';
+import { StructRenderer } from './renderers/StructRenderer';
+
+export type GoOptions = CommonGeneratorOptions<GoPreset>
+
+/**
+ * Generator for Go
+ */
+export class GoGenerator extends AbstractGenerator<GoOptions> {
+  static defaultOptions: GoOptions = {
+    ...defaultGeneratorOptions,
+    defaultPreset: GO_DEFAULT_PRESET,
+  };
+
+  constructor(
+    options: GoOptions = GoGenerator.defaultOptions,
+  ) {
+    super('Go', GoGenerator.defaultOptions, options);
+  }
+
+  render(model: CommonModel, inputModel: CommonInputModel): Promise<RenderOutput> {
+    const kind = TypeHelpers.extractKind(model);
+    if (kind === ModelKind.OBJECT) {
+      return this.renderStruct(model, inputModel);
+    }
+    return Promise.resolve(RenderOutput.toRenderOutput({ result: '', dependencies: [] }));
+  }
+
+  async renderStruct(model: CommonModel, inputModel: CommonInputModel): Promise<RenderOutput> {
+    const presets = this.getPresets('struct');
+    const renderer = new StructRenderer(this.options, presets, model, inputModel);
+    const result = await renderer.runSelfPreset();
+    return RenderOutput.toRenderOutput({ result, dependencies: renderer.dependencies });
+  }
+}

src/generators/go/GoPreset.ts

@@ -0,0 +1,24 @@
+/* eslint-disable @typescript-eslint/ban-types */
+import { AbstractRenderer } from '../AbstractRenderer';
+import { Preset, CommonModel, CommonPreset, PresetArgs } from '../../models';
+import { StructRenderer, GO_DEFAULT_STRUCT_PRESET } from './renderers/StructRenderer';
+
+export interface FieldArgs {
+  fieldName: string;
+  field: CommonModel;
+}
+
+export interface StructPreset<R extends AbstractRenderer, O extends object = any> extends CommonPreset<R, O> {
+  ctor?: (args: PresetArgs<R, O>) => Promise<string> | string;
+  field?: (args: PresetArgs<R, O> & FieldArgs) => Promise<string> | string;
+  getter?: (args: PresetArgs<R, O> & FieldArgs) => Promise<string> | string;
+  setter?: (args: PresetArgs<R, O> & FieldArgs) => Promise<string> | string;
+}
+
+export type GoPreset = Preset<{
+  struct: StructPreset<StructRenderer>;
+}>;
+
+export const GO_DEFAULT_PRESET: GoPreset = {
+  struct: GO_DEFAULT_STRUCT_PRESET,
+};

src/generators/go/GoRenderer.ts

@@ -0,0 +1,77 @@
+import { AbstractRenderer } from '../AbstractRenderer';
+import { GoOptions } from './GoGenerator';
+import { CommonModel, CommonInputModel, Preset } from '../../models';
+import { FormatHelpers } from '../../helpers/FormatHelpers';
+import { pascalCaseTransformMerge } from 'pascal-case';
+
+/**
+ * Common renderer for Go types
+ * 
+ * @extends AbstractRenderer
+ */
+export abstract class GoRenderer extends AbstractRenderer<GoOptions> {
+  constructor(
+    options: GoOptions,
+    presets: Array<[Preset, unknown]>,
+    model: CommonModel,
+    inputModel: CommonInputModel,
+  ) {
+    super(options, presets, model, inputModel);
+  }
+
+  async renderFields(): Promise<string> {
+    const fields = this.model.properties || {};
+    const content: string[] = [];
+
+    for (const [fieldName, field] of Object.entries(fields)) {
+      const renderField = await this.runFieldPreset(fieldName, field);
+      content.push(renderField);
+    }
+
+    return this.renderBlock(content);
+  }
+
+  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 });
+    }
+
+    if (Array.isArray(model.type)) {
+      return model.type.length > 1 ? '[]interface{}' : `[]${this.toGoType(model.type[0], model)}`;
+    }
+
+    return this.toGoType(model.type, model);
+  }
+
+  /* eslint-disable sonarjs/no-duplicate-string */
+  toGoType(type: string | undefined, model: CommonModel): string {
+    if (type === undefined) {
+      return 'interface{}';
+    }
+
+    switch (type) {
+    case 'string':
+      return 'string';
+    case 'integer':
+      return 'int';
+    case 'number':
+      return 'float64';
+    case 'boolean':
+      return 'bool';
+    case 'object':
+      return 'interface{}';
+    case 'array': {
+      if (Array.isArray(model.items)) {
+        return model.items.length > 1? '[]interface{}' : `[]${this.renderType(model.items[0])}`;
+      }
+      const arrayType = model.items ? this.renderType(model.items) : 'interface{}';
+      return `[]${arrayType}`;
+    }
+    default: return type;
+    }
+  }
+}

src/generators/go/index.ts

@@ -0,0 +1,3 @@
+export * from './GoGenerator';
+export { GO_DEFAULT_PRESET } from './GoPreset';
+export type { GoPreset } from './GoPreset';

src/generators/go/renderers/StructRenderer.ts

@@ -0,0 +1,49 @@
+import { GoRenderer } from '../GoRenderer';
+import { StructPreset } from '../GoPreset';
+import { FormatHelpers } from '../../../helpers/FormatHelpers';
+import { pascalCaseTransformMerge } from 'pascal-case';
+
+/**
+ * Renderer for Go's `struct` type
+ * 
+ * @extends GoRenderer
+ */
+export class StructRenderer extends GoRenderer {
+  public async defaultSelf(): Promise<string> {
+    const content = [
+      await this.renderFields(),
+      await this.runAdditionalContentPreset()
+    ];
+
+    const formattedName = this.model.$id && FormatHelpers.toPascalCase(this.model.$id, { transform: pascalCaseTransformMerge });
+    const doc = this.renderComments(`${formattedName} represents a ${formattedName} model.`);
+    
+    return `${doc}
+type ${formattedName} struct {
+${this.indent(this.renderBlock(content, 2))}
+}`;
+  }
+  
+  renderComments(lines: string | string[]): string {
+    lines = FormatHelpers.breakLines(lines);
+    return lines.map(line => `// ${line}`).join('\n');
+  }
+}
+
+export const GO_DEFAULT_STRUCT_PRESET: StructPreset<StructRenderer> = {
+  self({ renderer }) {
+    return renderer.defaultSelf();
+  },
+  ctor() {
+    return 'thisShoulBeAConstructor';
+  },
+  field({ fieldName, field, renderer }) {
+    return `${FormatHelpers.toPascalCase(fieldName, { transform: pascalCaseTransformMerge }) } ${ renderer.renderType(field)}`;
+  },
+  getter() {
+    return 'getterFunc';
+  },
+  setter() {
+    return 'setterFunc';
+  },
+};

test/generators/go/GoGenerator.spec.ts

@@ -0,0 +1,78 @@
+import { GoGenerator } from '../../../src/generators/go/GoGenerator';
+
+describe('GoGenerator', () => {
+  let generator: GoGenerator;
+  beforeEach(() => {
+    generator = new GoGenerator();
+  });
+  test('should render `struct` type', async () => {
+    const doc = {
+      $id: '_address',
+      type: 'object',
+      properties: {
+        street_name: { type: 'string' },
+        city: { type: 'string', description: 'City description' },
+        state: { type: 'string' },
+        house_number: { type: 'number' },
+        marriage: { type: 'boolean', description: 'Status if marriage live in given house' },
+        members: { oneOf: [{ type: 'string' }, { type: 'number' }, { type: 'boolean' }], },
+        tuple_type: { type: 'array', items: [{ type: 'string' }, { type: 'number' }] },
+        array_type: { type: 'array', items: { type: 'string' } },
+      },
+      required: ['street_name', 'city', 'state', 'house_number', 'array_type'],
+    };
+    const expected = `// Address represents a Address model.
+type Address struct {
+  StreetName string
+  City string
+  State string
+  HouseNumber float64
+  Marriage bool
+  Members []interface{}
+  TupleType []interface{}
+  ArrayType []string
+}`;
+
+    const inputModel = await generator.process(doc);
+    const model = inputModel.models['_address'];
+
+    let structModel = await generator.renderStruct(model, inputModel);
+    expect(structModel.result).toEqual(expected);
+    expect(structModel.dependencies).toEqual([]);
+
+    structModel = await generator.render(model, inputModel);
+    expect(structModel.result).toEqual(expected);
+    expect(structModel.dependencies).toEqual([]);
+  });
+
+  test('should work custom preset for `struct` type', async () => {
+    const doc = {
+      $id: 'CustomStruct',
+      type: 'object',
+      properties: {
+        property: { type: 'string' },
+      }
+    };
+    const expected = `// CustomStruct represents a CustomStruct model.
+type CustomStruct struct {
+  property string
+}`;
+
+    generator = new GoGenerator({ presets: [
+      {
+        struct: {
+          field({ fieldName, field, renderer }) {
+            return `${fieldName} ${renderer.renderType(field)}`; // private fields
+          },
+        }
+      }
+    ] });
+
+    const inputModel = await generator.process(doc);
+    const model = inputModel.models['CustomStruct'];
+    
+    const structModel = await generator.render(model, inputModel);
+    expect(structModel.result).toEqual(expected);
+    expect(structModel.dependencies).toEqual([]);
+  });
+});

test/generators/go/GoRenderer.spec.ts

@@ -0,0 +1,56 @@
+import { GoRenderer } from '../../../src/generators/go/GoRenderer';
+import { CommonInputModel, CommonModel } from '../../../src/models';
+class MockGoRenderer extends GoRenderer {
+
+}
+describe('GoRenderer', () => {
+  let renderer: MockGoRenderer;
+  beforeEach(() => {
+    renderer = new MockGoRenderer({}, [], new CommonModel(), new CommonInputModel());
+  });
+
+  describe('toGoType()', () => {
+    test('Should render undefined as interface type', () => {
+      expect(renderer.toGoType(undefined, new CommonModel())).toEqual('interface{}');
+    });
+    test('Should render integer as int type', () => {
+      expect(renderer.toGoType('integer', new CommonModel())).toEqual('int');
+    });
+    test('Should render number as float64 type', () => {
+      expect(renderer.toGoType('number', new CommonModel())).toEqual('float64');
+    });
+    test('Should render array as slice of the type', () => {
+      const model = new CommonModel();
+      model.items = CommonModel.toCommonModel({ type: 'number' });
+      expect(renderer.toGoType('array', model)).toEqual('[]float64');
+    });
+    test('Should render tuple with one type as slice of that type', () => {
+      const model = new CommonModel();
+      model.items = [CommonModel.toCommonModel({ type: 'number' })];
+      expect(renderer.toGoType('array', model)).toEqual('[]float64');
+    });
+    test('Should render tuple with multiple types as slice of interface{}', () => {
+      const model = new CommonModel();
+      model.items = [CommonModel.toCommonModel({ type: 'number' }), CommonModel.toCommonModel({ type: 'string' })];
+      expect(renderer.toGoType('array', model)).toEqual('[]interface{}');
+    });
+    test('Should render object as interface type', () => {
+      expect(renderer.toGoType('object', new CommonModel())).toEqual('interface{}');
+    });
+  });
+  describe('renderType()', () => {
+    test('Should render refs with pascal case (no _ prefix before numbers)', () => {
+      const model = new CommonModel();
+      model.$ref = '<anonymous-schema-1>';
+      expect(renderer.renderType(model)).toEqual('AnonymousSchema1');
+    });
+    test('Should render union types with one type as slice of that type', () => {
+      const model = CommonModel.toCommonModel({ type: ['number'] });
+      expect(renderer.renderType(model)).toEqual('[]float64');
+    });
+    test('Should render union types with multiple types as slice of interface', () => {
+      const model = CommonModel.toCommonModel({ type: ['number', 'string'] });
+      expect(renderer.renderType(model)).toEqual('[]interface{}');
+    });
+  });
+});