Add api.GenerateOptions.BaseDir for path resolution and label stripping

Restore the dir context that vanished with the io.Reader switch, but as
a single optional field. BaseDir is the directory relative paths in the
config (schema, queries, output) are resolved against, and the prefix
stripped from file paths shown in parse errors and diff labels. When
empty, BaseDir defaults to the current working directory.

A small resolvePath helper sits in api/generate.go and is called from
processQuerySets and ProcessResult; absolute paths pass through
unchanged. Parse errors and diff labels reuse the same BaseDir for
relative formatting.

Side-effects:
* The endtoend tests no longer pre-rewrite paths to absolute — they
  just pass BaseDir = test directory. The absolutizePaths helper is
  gone.
* The CLI sets BaseDir to the config's directory (returned by
  loadConfig) but keeps the chdir for now since other cmd paths
  (vet, push) still use cwd-relative resolution.

Tradeoff vs. the strictly-cosmetic option: GenerateOptions still has
six fields, but BaseDir's semantics are coherent with how it's used
(resolution + label) and library callers don't need to chdir or
hand-rewrite paths.

https://claude.ai/code/session_01RCzB2JR5Y5ScFDUmwcxGVZ

Author: claude

internal/api/diff.go

@@ -30,11 +30,13 @@ func writeFiles(ctx context.Context, files map[string]string, stderr io.Writer)
 	return nil
 }
 
-func diffFiles(ctx context.Context, files map[string]string, stderr io.Writer) error {
+func diffFiles(ctx context.Context, baseDir string, files map[string]string, stderr io.Writer) error {
 	defer trace.StartRegion(ctx, "checkfiles").End()
 	var errored bool
 
-	wd, _ := os.Getwd()
+	if baseDir == "" {
+		baseDir, _ = os.Getwd()
+	}
 
 	keys := make([]string, 0, len(files))
 	for k := range files {
@@ -61,8 +63,8 @@ func diffFiles(ctx context.Context, files map[string]string, stderr io.Writer) e
 		if len(uniHunks) > 0 {
 			errored = true
 			label := filename
-			if wd != "" {
-				if rel, err := filepath.Rel(wd, filename); err == nil {
+			if baseDir != "" {
+				if rel, err := filepath.Rel(baseDir, filename); err == nil {
 					label = "/" + rel
 				}
 			}

internal/api/generate.go

@@ -34,6 +34,11 @@ type GenerateOptions struct {
 	// found, an error is appended to GenerateResult.Errors.
 	Diff bool
 
+	// BaseDir is the directory relative paths in Config are resolved against,
+	// and the prefix stripped from file paths shown in parse errors and diff
+	// labels. When empty, BaseDir defaults to the current working directory.
+	BaseDir string
+
 	// InsecureProcessPluginNames is the allowlist of process-based plugin
 	// names that Generate is permitted to invoke. Any process plugin declared
 	// in the configuration whose name is not in this list causes Generate to
@@ -104,9 +109,9 @@ func Generate(ctx context.Context, opts GenerateOptions) GenerateResult {
 		}
 	}
 
-	g := &generator{output: map[string]string{}}
+	g := &generator{output: map[string]string{}, baseDir: opts.BaseDir}
 
-	if err := processQuerySets(ctx, g, &conf, stderr); err != nil {
+	if err := processQuerySets(ctx, g, &conf, opts.BaseDir, stderr); err != nil {
 		res.Errors = append(res.Errors, err)
 		return res
 	}
@@ -120,7 +125,7 @@ func Generate(ctx context.Context, opts GenerateOptions) GenerateResult {
 	}
 
 	if opts.Diff {
-		if err := diffFiles(ctx, res.Files, stderr); err != nil {
+		if err := diffFiles(ctx, opts.BaseDir, res.Files, stderr); err != nil {
 			res.Errors = append(res.Errors, err)
 		}
 	}
@@ -144,8 +149,9 @@ The supported version can only be "1" or "2".
 const errMessageNoPackages = `No packages are configured`
 
 type generator struct {
-	m      sync.Mutex
-	output map[string]string
+	m       sync.Mutex
+	baseDir string
+	output  map[string]string
 }
 
 func (g *generator) Pairs(ctx context.Context, conf *config.Config) []outputPair {
@@ -185,16 +191,10 @@ func (g *generator) ProcessResult(ctx context.Context, combo config.CombinedSett
 	g.m.Lock()
 	defer g.m.Unlock()
 
-	absout, err := filepath.Abs(out)
-	if err != nil {
-		return err
-	}
+	absout := resolvePath(g.baseDir, out)
 
 	for n, source := range files {
-		filename, err := filepath.Abs(filepath.Join(out, n))
-		if err != nil {
-			return err
-		}
+		filename := resolvePath(g.baseDir, filepath.Join(out, n))
 		if strings.Contains(filename, "..") {
 			return fmt.Errorf("invalid file output path: %s", filename)
 		}
@@ -205,3 +205,19 @@ func (g *generator) ProcessResult(ctx context.Context, combo config.CombinedSett
 	}
 	return nil
 }
+
+// resolvePath joins p with baseDir when p is relative. baseDir is treated as
+// the current working directory when empty.
+func resolvePath(baseDir, p string) string {
+	if filepath.IsAbs(p) {
+		return p
+	}
+	if baseDir == "" {
+		abs, err := filepath.Abs(p)
+		if err == nil {
+			return abs
+		}
+		return p
+	}
+	return filepath.Join(baseDir, p)
+}

internal/api/parse.go

@@ -15,21 +15,22 @@ import (
 	"github.com/sqlc-dev/sqlc/internal/opts"
 )
 
-func printFileErr(stderr io.Writer, fileErr *multierr.FileError) {
-	wd, err := os.Getwd()
-	if err != nil {
-		wd = ""
+func printFileErr(stderr io.Writer, baseDir string, fileErr *multierr.FileError) {
+	if baseDir == "" {
+		if wd, err := os.Getwd(); err == nil {
+			baseDir = wd
+		}
 	}
 	filename := fileErr.Filename
-	if wd != "" {
-		if rel, err := filepath.Rel(wd, fileErr.Filename); err == nil {
+	if baseDir != "" {
+		if rel, err := filepath.Rel(baseDir, fileErr.Filename); err == nil {
 			filename = rel
 		}
 	}
 	fmt.Fprintf(stderr, "%s:%d:%d: %s\n", filename, fileErr.Line, fileErr.Column, fileErr.Err)
 }
 
-func parse(ctx context.Context, name string, sql config.SQL, combo config.CombinedSettings, parserOpts opts.Parser, stderr io.Writer) (*compiler.Result, bool) {
+func parse(ctx context.Context, name, baseDir string, sql config.SQL, combo config.CombinedSettings, parserOpts opts.Parser, stderr io.Writer) (*compiler.Result, bool) {
 	defer trace.StartRegion(ctx, "parse").End()
 	c, err := compiler.NewCompiler(sql, combo, parserOpts)
 	defer func() {
@@ -45,7 +46,7 @@ func parse(ctx context.Context, name string, sql config.SQL, combo config.Combin
 		fmt.Fprintf(stderr, "# package %s\n", name)
 		if parserErr, ok := err.(*multierr.Error); ok {
 			for _, fileErr := range parserErr.Errs() {
-				printFileErr(stderr, fileErr)
+				printFileErr(stderr, baseDir, fileErr)
 			}
 		} else {
 			fmt.Fprintf(stderr, "error parsing schema: %s\n", err)
@@ -59,7 +60,7 @@ func parse(ctx context.Context, name string, sql config.SQL, combo config.Combin
 		fmt.Fprintf(stderr, "# package %s\n", name)
 		if parserErr, ok := err.(*multierr.Error); ok {
 			for _, fileErr := range parserErr.Errs() {
-				printFileErr(stderr, fileErr)
+				printFileErr(stderr, baseDir, fileErr)
 			}
 		} else {
 			fmt.Fprintf(stderr, "error parsing queries: %s\n", err)

internal/api/process.go

@@ -5,7 +5,6 @@ import (
 	"context"
 	"fmt"
 	"io"
-	"path/filepath"
 	"runtime"
 	"runtime/trace"
 
@@ -29,7 +28,7 @@ type resultProcessor interface {
 	ProcessResult(context.Context, config.CombinedSettings, outputPair, *compiler.Result) error
 }
 
-func processQuerySets(ctx context.Context, rp resultProcessor, conf *config.Config, stderr io.Writer) error {
+func processQuerySets(ctx context.Context, rp resultProcessor, conf *config.Config, baseDir string, stderr io.Writer) error {
 	errored := false
 
 	pairs := rp.Pairs(ctx, conf)
@@ -50,25 +49,13 @@ func processQuerySets(ctx context.Context, rp resultProcessor, conf *config.Conf
 
 			absSchema := make([]string, 0, len(sql.Schema))
 			for _, s := range sql.Schema {
-				abs, err := filepath.Abs(s)
-				if err != nil {
-					fmt.Fprintf(errout, "resolve schema path %s: %s\n", s, err)
-					errored = true
-					return nil
-				}
-				absSchema = append(absSchema, abs)
+				absSchema = append(absSchema, resolvePath(baseDir, s))
 			}
 			sql.Schema = absSchema
 
 			absQueries := make([]string, 0, len(sql.Queries))
 			for _, q := range sql.Queries {
-				abs, err := filepath.Abs(q)
-				if err != nil {
-					fmt.Fprintf(errout, "resolve query path %s: %s\n", q, err)
-					errored = true
-					return nil
-				}
-				absQueries = append(absQueries, abs)
+				absQueries = append(absQueries, resolvePath(baseDir, q))
 			}
 			sql.Queries = absQueries
 
@@ -90,7 +77,7 @@ func processQuerySets(ctx context.Context, rp resultProcessor, conf *config.Conf
 			packageRegion := trace.StartRegion(gctx, "package")
 			trace.Logf(gctx, "", "name=%s plugin=%s", name, lang)
 
-			result, failed := parse(gctx, name, sql.SQL, combo, parseOpts, errout)
+			result, failed := parse(gctx, name, baseDir, sql.SQL, combo, parseOpts, errout)
 			if failed {
 				packageRegion.End()
 				errored = true

internal/cmd/cmd.go

@@ -186,9 +186,10 @@ func getConfigPath(stderr io.Writer, f *pflag.Flag) (string, string) {
 // loadConfig opens the sqlc config and reads it into memory. It also chdirs
 // the process to the config's directory so that relative paths declared in the
 // config resolve correctly when api.Generate is called. Returns the config
-// bytes and the list of process plugin names declared in the config (used to
-// populate api.GenerateOptions.InsecureProcessPluginNames).
-func loadConfig(stderr io.Writer, dir, name string) ([]byte, []string) {
+// bytes, the absolute config directory (for api.GenerateOptions.BaseDir), and
+// the list of process plugin names declared in the config (used to populate
+// api.GenerateOptions.InsecureProcessPluginNames).
+func loadConfig(stderr io.Writer, dir, name string) ([]byte, string, []string) {
 	configPath, _, err := readConfig(stderr, dir, name)
 	if err != nil {
 		os.Exit(1)
@@ -208,7 +209,8 @@ func loadConfig(stderr io.Writer, dir, name string) ([]byte, []string) {
 		fmt.Fprintf(stderr, "error parsing %s: %s\n", configPath, err)
 		os.Exit(1)
 	}
-	if err := os.Chdir(filepath.Dir(configPath)); err != nil {
+	configDir := filepath.Dir(configPath)
+	if err := os.Chdir(configDir); err != nil {
 		fmt.Fprintf(stderr, "error changing directory: %s\n", err)
 		os.Exit(1)
 	}
@@ -218,7 +220,7 @@ func loadConfig(stderr io.Writer, dir, name string) ([]byte, []string) {
 			names = append(names, p.Name)
 		}
 	}
-	return data, names
+	return data, configDir, names
 }
 
 // allowedProcessPluginNames returns the names that should populate
@@ -239,11 +241,12 @@ var genCmd = &cobra.Command{
 		stderr := cmd.ErrOrStderr()
 		dir, name := getConfigPath(stderr, cmd.Flag("file"))
 		env := ParseEnv(cmd)
-		data, declared := loadConfig(stderr, dir, name)
+		data, baseDir, declared := loadConfig(stderr, dir, name)
 		res := api.Generate(cmd.Context(), api.GenerateOptions{
 			Config:                     bytes.NewReader(data),
 			Stderr:                     stderr,
 			Write:                      true,
+			BaseDir:                    baseDir,
 			InsecureProcessPluginNames: allowedProcessPluginNames(env, declared),
 		})
 		if len(res.Errors) > 0 {
@@ -261,10 +264,11 @@ var checkCmd = &cobra.Command{
 		stderr := cmd.ErrOrStderr()
 		dir, name := getConfigPath(stderr, cmd.Flag("file"))
 		env := ParseEnv(cmd)
-		data, declared := loadConfig(stderr, dir, name)
+		data, baseDir, declared := loadConfig(stderr, dir, name)
 		res := api.Generate(cmd.Context(), api.GenerateOptions{
 			Config:                     bytes.NewReader(data),
 			Stderr:                     stderr,
+			BaseDir:                    baseDir,
 			InsecureProcessPluginNames: allowedProcessPluginNames(env, declared),
 		})
 		if len(res.Errors) > 0 {
@@ -282,11 +286,12 @@ var diffCmd = &cobra.Command{
 		stderr := cmd.ErrOrStderr()
 		dir, name := getConfigPath(stderr, cmd.Flag("file"))
 		env := ParseEnv(cmd)
-		data, declared := loadConfig(stderr, dir, name)
+		data, baseDir, declared := loadConfig(stderr, dir, name)
 		res := api.Generate(cmd.Context(), api.GenerateOptions{
 			Config:                     bytes.NewReader(data),
 			Stderr:                     stderr,
 			Diff:                       true,
+			BaseDir:                    baseDir,
 			InsecureProcessPluginNames: allowedProcessPluginNames(env, declared),
 		})
 		if len(res.Errors) > 0 {