Add api.GenerateOptions.Write and api.GenerateOptions.Diff

The two new boolean options let api.Generate cover the writefiles loop
and the diff comparison that previously lived in cmd. The compile
command becomes Generate with neither flag set, generate maps to
Write: true, and diff maps to Diff: true.

While simplifying GenerateOptions:
* Drop MutateConfig — tests now express config mutations by writing a
  temporary configuration file via writeMutatedConfig and pointing
  GenerateOptions.File at it. The mutated config is parsed (always to
  v2 shape), forced to version "2", and round-tripped via yaml.
* Drop DisableProcessPlugins from the API surface; we will revisit how
  to express that constraint.
* Add MarshalJSON/MarshalYAML to AnalyzerDatabase so the parsed Config
  round-trips through yaml.Marshal cleanly, which is what the new test
  helper relies on.

cmd/diff.go is gone and cmd/generate.go is left with only the helpers
(readConfig, parse, printFileErr) other cmd commands still use.

https://claude.ai/code/session_01RCzB2JR5Y5ScFDUmwcxGVZ

Author: claude

internal/api/diff.go

@@ -0,0 +1,100 @@
+package api
+
+import (
+	"bufio"
+	"bytes"
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"runtime/trace"
+	"sort"
+	"strings"
+
+	"github.com/cubicdaiya/gonp"
+)
+
+func writeFiles(ctx context.Context, files map[string]string, stderr io.Writer) error {
+	defer trace.StartRegion(ctx, "writefiles").End()
+	for filename, source := range files {
+		if err := os.MkdirAll(filepath.Dir(filename), 0755); err != nil {
+			fmt.Fprintf(stderr, "%s: %s\n", filename, err)
+			return err
+		}
+		if err := os.WriteFile(filename, []byte(source), 0644); err != nil {
+			fmt.Fprintf(stderr, "%s: %s\n", filename, err)
+			return err
+		}
+	}
+	return nil
+}
+
+func diffFiles(ctx context.Context, dir string, files map[string]string, stderr io.Writer) error {
+	defer trace.StartRegion(ctx, "checkfiles").End()
+	var errored bool
+
+	keys := make([]string, 0, len(files))
+	for k := range files {
+		keys = append(keys, k)
+	}
+	sort.Strings(keys)
+
+	for _, filename := range keys {
+		source := files[filename]
+		if _, err := os.Stat(filename); errors.Is(err, os.ErrNotExist) {
+			errored = true
+			continue
+		}
+		existing, err := os.ReadFile(filename)
+		if err != nil {
+			errored = true
+			fmt.Fprintf(stderr, "%s: %s\n", filename, err)
+			continue
+		}
+		d := gonp.New(getLines(existing), getLines([]byte(source)))
+		d.Compose()
+		uniHunks := filterHunks(d.UnifiedHunks())
+
+		if len(uniHunks) > 0 {
+			errored = true
+			fmt.Fprintf(stderr, "--- a%s\n", strings.TrimPrefix(filename, dir))
+			fmt.Fprintf(stderr, "+++ b%s\n", strings.TrimPrefix(filename, dir))
+			d.FprintUniHunks(stderr, uniHunks)
+		}
+	}
+	if errored {
+		return errors.New("diff found")
+	}
+	return nil
+}
+
+func getLines(f []byte) []string {
+	fp := bytes.NewReader(f)
+	scanner := bufio.NewScanner(fp)
+	lines := make([]string, 0)
+	for scanner.Scan() {
+		lines = append(lines, scanner.Text())
+	}
+	return lines
+}
+
+func filterHunks[T gonp.Elem](uniHunks []gonp.UniHunk[T]) []gonp.UniHunk[T] {
+	var out []gonp.UniHunk[T]
+	for i, uniHunk := range uniHunks {
+		var changed bool
+		for _, e := range uniHunk.GetChanges() {
+			switch e.GetType() {
+			case gonp.SesDelete:
+				changed = true
+			case gonp.SesAdd:
+				changed = true
+			}
+		}
+		if changed {
+			out = append(out, uniHunks[i])
+		}
+	}
+	return out
+}

internal/api/generate.go

@@ -2,7 +2,6 @@ package api
 
 import (
 	"context"
-	"errors"
 	"fmt"
 	"io"
 	"path/filepath"
@@ -13,10 +12,6 @@ import (
 	"github.com/sqlc-dev/sqlc/internal/config"
 )
 
-// errPluginProcessDisabled is returned when the configuration uses a process
-// plugin but the caller has disabled them via GenerateOptions.DisableProcessPlugins.
-var errPluginProcessDisabled = errors.New("plugin: process-based plugins disabled via SQLCDEBUG=processplugins=0")
-
 // GenerateOptions controls a single Generate invocation.
 type GenerateOptions struct {
 	// Dir is the working directory used to resolve the config file and any
@@ -30,14 +25,14 @@ type GenerateOptions struct {
 	// Stderr receives diagnostic output. If nil, output is discarded.
 	Stderr io.Writer
 
-	// DisableProcessPlugins, when true, causes Generate to fail if the
-	// configuration uses a process-based plugin. The sqlc CLI sets this from
-	// SQLCDEBUG=processplugins=0.
-	DisableProcessPlugins bool
+	// Write, when true, writes the generated files to disk after a successful
+	// generate. Failures are reported via GenerateResult.Errors.
+	Write bool
 
-	// MutateConfig is called after the configuration is parsed but before it is
-	// validated. It is intended for tests.
-	MutateConfig func(*config.Config)
+	// Diff, when true, compares each generated file against any existing file
+	// on disk and writes a unified diff for differences to Stderr. If any
+	// differences are found, an error is appended to GenerateResult.Errors.
+	Diff bool
 }
 
 // GenerateResult is the outcome of a Generate call. Files maps absolute output
@@ -69,9 +64,6 @@ func Generate(ctx context.Context, opts GenerateOptions) GenerateResult {
 		res.Errors = append(res.Errors, err)
 		return res
 	}
-	if opts.MutateConfig != nil {
-		opts.MutateConfig(conf)
-	}
 
 	base := filepath.Base(configPath)
 	if err := config.Validate(conf); err != nil {
@@ -80,14 +72,6 @@ func Generate(ctx context.Context, opts GenerateOptions) GenerateResult {
 		return res
 	}
 
-	if opts.DisableProcessPlugins {
-		if err := validateProcessPluginsDisabled(conf); err != nil {
-			fmt.Fprintf(stderr, "error validating %s: %s\n", base, err)
-			res.Errors = append(res.Errors, err)
-			return res
-		}
-	}
-
 	g := &generator{
 		dir:    opts.Dir,
 		output: map[string]string{},
@@ -99,16 +83,20 @@ func Generate(ctx context.Context, opts GenerateOptions) GenerateResult {
 	}
 
 	res.Files = g.output
-	return res
-}
 
-func validateProcessPluginsDisabled(cfg *config.Config) error {
-	for _, plugin := range cfg.Plugins {
-		if plugin.Process != nil {
-			return errPluginProcessDisabled
+	if opts.Write {
+		if err := writeFiles(ctx, res.Files, stderr); err != nil {
+			res.Errors = append(res.Errors, err)
 		}
 	}
-	return nil
+
+	if opts.Diff {
+		if err := diffFiles(ctx, opts.Dir, res.Files, stderr); err != nil {
+			res.Errors = append(res.Errors, err)
+		}
+	}
+
+	return res
 }
 
 type generator struct {

internal/cmd/cmd.go

@@ -1,8 +1,6 @@
 package cmd
 
 import (
-	"bufio"
-	"bytes"
 	"context"
 	"errors"
 	"fmt"
@@ -12,11 +10,11 @@ import (
 	"path/filepath"
 	"runtime/trace"
 
-	"github.com/cubicdaiya/gonp"
 	"github.com/spf13/cobra"
 	"github.com/spf13/pflag"
 	"gopkg.in/yaml.v3"
 
+	"github.com/sqlc-dev/sqlc/internal/api"
 	"github.com/sqlc-dev/sqlc/internal/config"
 	"github.com/sqlc-dev/sqlc/internal/debug"
 	"github.com/sqlc-dev/sqlc/internal/info"
@@ -191,21 +189,15 @@ var genCmd = &cobra.Command{
 		defer trace.StartRegion(cmd.Context(), "generate").End()
 		stderr := cmd.ErrOrStderr()
 		dir, name := getConfigPath(stderr, cmd.Flag("file"))
-		output, err := Generate(cmd.Context(), dir, name, &Options{
-			Env:    ParseEnv(cmd),
+		res := api.Generate(cmd.Context(), api.GenerateOptions{
+			Dir:    dir,
+			File:   name,
 			Stderr: stderr,
+			Write:  true,
 		})
-		if err != nil {
+		if len(res.Errors) > 0 {
 			os.Exit(1)
 		}
-		defer trace.StartRegion(cmd.Context(), "writefiles").End()
-		for filename, source := range output {
-			os.MkdirAll(filepath.Dir(filename), 0755)
-			if err := os.WriteFile(filename, []byte(source), 0644); err != nil {
-				fmt.Fprintf(stderr, "%s: %s\n", filename, err)
-				return err
-			}
-		}
 		return nil
 	},
 }
@@ -217,58 +209,32 @@ var checkCmd = &cobra.Command{
 		defer trace.StartRegion(cmd.Context(), "compile").End()
 		stderr := cmd.ErrOrStderr()
 		dir, name := getConfigPath(stderr, cmd.Flag("file"))
-		_, err := Generate(cmd.Context(), dir, name, &Options{
-			Env:    ParseEnv(cmd),
+		res := api.Generate(cmd.Context(), api.GenerateOptions{
+			Dir:    dir,
+			File:   name,
 			Stderr: stderr,
 		})
-		if err != nil {
+		if len(res.Errors) > 0 {
 			os.Exit(1)
 		}
 		return nil
 	},
 }
 
-func getLines(f []byte) []string {
-	fp := bytes.NewReader(f)
-	scanner := bufio.NewScanner(fp)
-	lines := make([]string, 0)
-	for scanner.Scan() {
-		lines = append(lines, scanner.Text())
-	}
-	return lines
-}
-
-func filterHunks[T gonp.Elem](uniHunks []gonp.UniHunk[T]) []gonp.UniHunk[T] {
-	var out []gonp.UniHunk[T]
-	for i, uniHunk := range uniHunks {
-		var changed bool
-		for _, e := range uniHunk.GetChanges() {
-			switch e.GetType() {
-			case gonp.SesDelete:
-				changed = true
-			case gonp.SesAdd:
-				changed = true
-			}
-		}
-		if changed {
-			out = append(out, uniHunks[i])
-		}
-	}
-	return out
-}
-
 var diffCmd = &cobra.Command{
 	Use:   "diff",
 	Short: "Compare the generated files to the existing files",
 	RunE: func(cmd *cobra.Command, args []string) error {
 		defer trace.StartRegion(cmd.Context(), "diff").End()
 		stderr := cmd.ErrOrStderr()
 		dir, name := getConfigPath(stderr, cmd.Flag("file"))
-		opts := &Options{
-			Env:    ParseEnv(cmd),
+		res := api.Generate(cmd.Context(), api.GenerateOptions{
+			Dir:    dir,
+			File:   name,
 			Stderr: stderr,
-		}
-		if err := Diff(cmd.Context(), dir, name, opts); err != nil {
+			Diff:   true,
+		})
+		if len(res.Errors) > 0 {
 			os.Exit(1)
 		}
 		return nil