Goのライブラリのjenniferを使ってアーキテクチャに沿ったコードを自動生成する

generator
 ┣ di
 ┃ ┗ gen_di.go // di生成
 ┣ handler
 ┃ ┗ gen_handler.go // handler生成
 ┣ models
 ┃ ┣ admin.go // 生成したいモデル
 ┣ repository
 ┃ ┣ gen_repo_impl.go // レポジトリ実体生成
 ┃ ┗ gen_repo_interface.go // レポジトリインターフェース生成
 ┣ usecase
 ┃ ┗ gen_usease.go // ユースケース生成
 ┗ generator.go　// main関数

func main() {
    // コマンドライン引数を定義
    entity := flag.String("e", "", "Entity name")
    model := flag.String("m", "", "Model name")

    // コマンドライン引数を解析
    flag.Parse()

    // エンティティ名を取得
    e := *entity
    m := *model
    fileName := toSnakeCase(e)

    // handler作成
    genhandler.GenHandler(e, fileName)

    // di作成
    gendi.GenDi(e, fileName)

    // usecase作成
    genusecase.GenUsecase(e, fileName)

    // repositoryinterface　作成
    genrepository.GenRepoInterface(e, fileName)

    // repositoryimpl作成
    genrepository.GenRepoImpl(e, m, fileName)
}

package genusecase

import (
    "strings"

    "github.com/dave/jennifer/jen"
)

func GenUsecase(e string, fileName string) {
    // Usecase interface
    E := strings.Title(e) // エンティティ名の先頭を大文字に
    abbrUsecase := strings.ToLower(string(e[0])) + "u"
    abbrRepository := strings.ToLower(string(e[0])) + "r"
    f := jen.NewFile("usecase")
    f.ImportName("main/domain/entity", "entity")
    f.ImportName("main/domain/repository", "repository")

    f.Type().Id(E+"UseCase").Interface(
        jen.Id("Add"+E).Params(jen.Id(e).Op("*").Qual("main/domain/entity", E)).Error(),
        jen.Id("Update"+E).Params(jen.Id(e).Op("*").Qual("main/domain/entity", E)).Error(),
    )

    f.Type().Id(E + "UseCaseImpl").Struct(
        jen.Id(E+"Repository").Qual("main/domain/repository", E+"Repository"),
    )

    f.Func().Id("New"+E+"UseCaseImpl").Params(jen.Id(abbrRepository).Qual("main/domain/repository", E+"Repository")).Id(E + "UseCase").Block(
        jen.Return(jen.Op("&").Id(E+"UseCaseImpl").Values(jen.Dict{
            jen.Id(E + "Repository"): jen.Id(abbrRepository),
        })),
    )

    f.Line()

    f.Func().Params(jen.Id(abbrUsecase).Id(E + "UseCaseImpl")).Id("Add"+E).Params(jen.Id(e).Op("*").Qual("main/domain/entity", E)).Error().Block(
        jen.List(jen.Id("err")).Op(":=").Id(abbrUsecase + "." + E + "Repository").Dot("Add" + E).Call(jen.Id(e)),
        jen.If(jen.Id("err").Op("!=").Nil()).Block(
            jen.Return(jen.Id("err")),
        ),
        jen.Return(jen.Nil()),
    )

    f.Line()

    f.Func().Params(jen.Id(abbrUsecase).Id(E + "UseCaseImpl")).Id("Update"+E).Params(jen.Id(e).Op("*").Qual("main/domain/entity", E)).Error().Block(
        jen.List(jen.Id("err")).Op(":=").Id(abbrUsecase + "." + E + "Repository").Dot("Update" + E).Call(jen.Id(e)),
        jen.If(jen.Id("err").Op("!=").Nil()).Block(
            jen.Return(jen.Id("err")),
        ),
        jen.Return(jen.Nil()),
    )

    // Save to file
    f.Save("../application/usecase/" + fileName + ".go")
}

package usecase

import (
    "main/domain/entity"
    "main/domain/repository"
)

type MemberUseCase interface {
    AddMember(Member *entity.Member) error
    UpdateMember(Member *entity.Member) error
}
type MemberUseCaseImpl struct {
    MemberRepository repository.MemberRepository
}

func NewMemberUseCaseImpl(mr repository.MemberRepository) MemberUseCase {
    return &MemberUseCaseImpl{MemberRepository: mr}
}

func (mu MemberUseCaseImpl) AddMember(Member *entity.Member) error {
    err := mu.MemberRepository.AddMember(Member)
    if err != nil {
        return err
    }
    return nil
}

func (mu MemberUseCaseImpl) UpdateMember(Member *entity.Member) error {
    err := mu.MemberRepository.UpdateMember(Member)
    if err != nil {
        return err
    }
    return nil
}

func ToDbModelMember(mri *entity.Member) *models.Member {
    return &models.Member{
        Email:      mri.Email,
        EntryTime:  mri.EntryTime,
        Kana:       mri.Kana,
        MemberID:   mri.MemberID,
        Name:       mri.Name,
        Post:       mri.Post,
        UpdateTime: mri.UpdateTime,
    }
}

models, _ := FindModelStruct(fileName, modelName) // ここでmodelを取得
dict := make(map[string]jen.Code)                 // ここでフィールド名をkey 変換するentityをvalueとして作成
pk := "none"
for _, field := range models.Fields.List {        // modelの構造体をループさせます
    name := field.Names[0]
    if strings.Contains(name.Name, "ID") && strings.Contains(name.Name, E) {
        pk = name.Name // 主キー取得
    }

    // ここでtypeごとに変換関数を記述させるようにしています
    // sqlboilerで使われているnull.stringなどを変換できるようにしています
    switch typeName := fmt.Sprintf("%s", field.Type); typeName {
    case "&{null String}":
        dict[name.Name] = jen.Qual("github.com/volatiletech/null", "StringFrom").Call(jen.Id(abbrRepository + "." + name.Name))
    case "&{null Int}":
        dict[name.Name] = jen.Qual("github.com/volatiletech/null", "IntFrom").Call(jen.Id(abbrRepository + "." + name.Name))
    case "&{null Time}":
        dict[name.Name] = jen.Qual("github.com/volatiletech/null", "TimeFrom").Call(jen.Id(abbrRepository + "." + name.Name))
    default:
        // その他の型の場合の処理
        dict[name.Name] = jen.Id(abbrRepository + "." + name.Name)
    }
}

stmt := jen.Dict{}
for k, v := range dict {
    stmt[jen.Id(k)] = v
}

// model関数生成
f.Func().Id("ToDbModel" + E).Params(jen.Id(abbrRepository).Op("*").Id("entity." + E)).Op("*").Qual("main/infrastructure/postgres/sqlboiler", modelName).Block(
    jen.Return(
        jen.Op("&").Qual("main/infrastructure/postgres/sqlboiler", modelName).Values(stmt),
    ),
)

func FindModelStruct(fileName, modelName string) (*ast.StructType, error) {
    fset := token.NewFileSet()
    node, err := parser.ParseFile(fset, "./models/"+fileName+".go", nil, parser.ParseComments)
    if err != nil {
        log.Println(err)
        return nil, err
    }

    var model *ast.StructType
    ast.Inspect(node, func(n ast.Node) bool {
        switch t := n.(type) {
        case *ast.TypeSpec:
            if t.Name.Name == modelName {
                if x, ok := t.Type.(*ast.StructType); ok { // modelの構造体を取得
                    model = x
                    return false // 構造体が見つかったら探索を終了します
                }
            }
        }
        return true
    })

    if model == nil {
        return nil, fmt.Errorf("%s struct not found", modelName)
    }

    return model, nil
}