feat: add append optiom

Author: walterwanderley

README.md

@@ -21,11 +21,12 @@ sql:
     options:
       package: db
       sql_package: pgx/v5
+      server_type: grpc
 ```
 
 ## Post-process
 
-After execute `sqlc generate` you need to organize imorts, compile protocol buffer and fix go.mod.
+After execute `sqlc generate` you need to organize imports, compile protocol buffer and fix go.mod.
 
 1. Install the required tools:
 
@@ -58,6 +59,8 @@ buf generate
 go mod tidy
 ```
 
+5. If you define more than one package, you’ll need to add them to the generated **registry.go** file. 
+
 ## Plugin options
 
 You can use all of the [Golang plugin's options](https://docs.sqlc.dev/en/latest/reference/config.html#go) as well as the options described below.
@@ -77,15 +80,14 @@ sql:
   - plugin: go-server
     out: "db"
     options:
-      package: "db"
-      emit_json_tags: true
-      server_type: "grpc" # The server type: grpc or connect.
+      server_type: "grpc" # The server type: grpc or connect.      
       module: "my-module" # The module name for the generated go.mod.
       tracing: false # If true, enable distributed tracing with open telemetry.
       litefs: false # If true, enable support for distributed SQLite powered by embedded LiteFS.
-      litestream: false # If true, enable support for continuous backup sqlite to S3 powered by embeded Litestream
-      migration_path: "" # If you want to execute database migrations on startup
-      skip_go_mod: false # If true, skip the generation of the go.mod
+      litestream: false # If true, enable support for continuous backup sqlite to S3 powered by embeded Litestream.
+      migration_path: "" # If you want to execute database migrations on startup.
+      skip_go_mod: false # If true, skip the generation of the go.mod.
+      append: false # If true, enable the append mode and do not generate the editable files.
 ```
 
 ## Building from source

internal/gen.go

@@ -324,26 +324,9 @@ func generate(req *plugin.GenerateRequest, options *opts.Options, enums []Enum,
 		})
 	}
 
-	if options.ServerType == "" {
-		options.ServerType = "grpc"
-	}
-	var (
-		err         error
-		serverFiles []*plugin.File
-	)
-	switch options.ServerType {
-	case "connect":
-		serverFiles, err = connectFiles(req, options, enums, structs, queries)
-		if err != nil {
-			return nil, err
-		}
-	case "grpc":
-		serverFiles, err = grpcFiles(req, options, enums, structs, queries)
-		if err != nil {
-			return nil, err
-		}
-	default:
-		return nil, fmt.Errorf("invalid server_type %q. Choose 'connect' or 'grpc'", options.ServerType)
+	serverFiles, err := serverFiles(req, options, enums, structs, queries)
+	if err != nil {
+		return nil, err
 	}
 	resp.Files = append(resp.Files, serverFiles...)
 

internal/opts/options.go

@@ -50,6 +50,7 @@ type Options struct {
 	MigrationPath               string            `json:"migration_path,omitempty" yaml:"migration_path"`
 	SkipGoMod                   bool              `json:"skip_go_mod,omitempty" yaml:"skip_go_mod"`
 	ServerType                  string            `json:"server_type,omitempty" yaml:"server_type"`
+	Append                      bool              `json:"append,omitempty" yaml:"append"`
 }
 
 type GlobalOptions struct {

internal/server.go

@@ -7,16 +7,134 @@ import (
 	"io"
 	"io/fs"
 	"log"
+	"path/filepath"
 	"sort"
 	"strings"
 	"text/template"
 
 	"github.com/sqlc-dev/plugin-sdk-go/plugin"
 	"github.com/sqlc-dev/sqlc-gen-go/internal/opts"
+	connecttemplates "github.com/walterwanderley/sqlc-connect/templates"
 	"github.com/walterwanderley/sqlc-grpc/converter"
 	"github.com/walterwanderley/sqlc-grpc/metadata"
+	grpctemplates "github.com/walterwanderley/sqlc-grpc/templates"
 )
 
+func serverFiles(req *plugin.GenerateRequest, options *opts.Options, enums []Enum, structs []Struct, queries []Query) ([]*plugin.File, error) {
+	var (
+		tmplFS    fs.FS
+		tmplFuncs template.FuncMap
+	)
+
+	switch options.ServerType {
+	case "", "grpc": // the default server type
+		tmplFS = grpctemplates.Files
+		tmplFuncs = grpctemplates.Funcs
+	case "connect":
+		tmplFS = connecttemplates.Files
+		tmplFuncs = connecttemplates.Funcs
+	default:
+		return nil, fmt.Errorf("invalid server_type %q. Choose 'connect' or 'grpc'", options.ServerType)
+	}
+	def := toServerDefinition(req, options, enums, structs, queries)
+	if err := def.Validate(); err != nil {
+		return nil, err
+	}
+	pkg := def.Packages[0]
+	depth := make([]string, 0)
+	for i := 0; i < len(strings.Split(options.Out, string(filepath.Separator)))+1; i++ {
+		depth = append(depth, "..")
+	}
+	toRootPath := filepath.Join(depth...)
+	files := make([]*plugin.File, 0)
+	err := fs.WalkDir(tmplFS, ".", func(path string, d fs.DirEntry, err error) error {
+		if err != nil {
+			log.Println("ERROR ", err.Error())
+			return err
+		}
+
+		if d.IsDir() {
+			return nil
+		}
+
+		newPath := strings.TrimSuffix(path, ".tmpl")
+
+		if strings.HasSuffix(newPath, "templates.go") {
+			return nil
+		}
+		log.Println(path, "...")
+		if strings.HasSuffix(newPath, "service.proto") {
+			protoContent, err := execServerTemplate(tmplFS, tmplFuncs, path, pkg, false)
+			if err != nil {
+				return err
+			}
+			protoFile := filepath.Join(toRootPath, "proto", converter.ToSnakeCase(pkg.Package), "v1", (converter.ToSnakeCase(pkg.Package) + ".proto"))
+			files = append(files, &plugin.File{
+				Name:     protoFile,
+				Contents: protoContent,
+			})
+			return nil
+		}
+
+		if strings.HasSuffix(newPath, "adapters.go") || strings.HasSuffix(newPath, "service.go") || strings.HasSuffix(newPath, "service.factory.go") {
+			if options.Append && strings.HasSuffix(newPath, "service.factory.go") {
+				return nil
+			}
+			content, err := execServerTemplate(tmplFS, tmplFuncs, path, pkg, true)
+			if err != nil {
+				return err
+			}
+			files = append(files, &plugin.File{
+				Name:     newPath,
+				Contents: content,
+			})
+			return nil
+		}
+
+		if options.Append {
+			return nil
+		}
+
+		if strings.HasSuffix(newPath, "tracing.go") && !def.DistributedTracing {
+			return nil
+		}
+
+		if strings.HasSuffix(newPath, "migration.go") && def.MigrationPath == "" {
+			return nil
+		}
+
+		if strings.HasSuffix(newPath, "litestream.go") && !(def.Database() == "sqlite" && def.Litestream) {
+			return nil
+		}
+
+		if (strings.HasSuffix(newPath, "litefs.go") || strings.HasSuffix(newPath, "forward.go")) && !(def.Database() == "sqlite" && def.LiteFS) {
+			return nil
+		}
+
+		content, err := execServerTemplate(tmplFS, tmplFuncs, path, def, strings.HasSuffix(newPath, ".go"))
+		if err != nil {
+			return err
+		}
+		files = append(files, &plugin.File{
+			Name:     filepath.Join(toRootPath, newPath),
+			Contents: content,
+		})
+
+		return nil
+	})
+	if err != nil {
+		return nil, err
+	}
+	if !options.SkipGoMod {
+		files = append(files, &plugin.File{
+			Name:     filepath.Join(toRootPath, "go.mod"),
+			Contents: []byte(fmt.Sprintf("module %s\n", def.GoModule)),
+		})
+	}
+
+	return files, nil
+}
+
 func toServerDefinition(req *plugin.GenerateRequest, options *opts.Options, enums []Enum, structs []Struct, queries []Query) *metadata.Definition {
 	module := options.Module
 	if module == "" {