It works!

Author: kyleconroy

cmd/sqlc-gen-json/main.go

@@ -0,0 +1,45 @@
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"io"
+	"os"
+
+	"github.com/kyleconroy/sqlc/internal/codegen/json"
+	"github.com/kyleconroy/sqlc/internal/plugin"
+)
+
+func main() {
+	if err := run(); err != nil {
+		fmt.Fprintf(os.Stderr, "error generating JSON: %s", err)
+		os.Exit(2)
+	}
+}
+
+func run() error {
+	var req plugin.CodeGenRequest
+	reqBlob, err := io.ReadAll(os.Stdin)
+	if err != nil {
+		return err
+	}
+	if err := req.UnmarshalVT(reqBlob); err != nil {
+		return err
+	}
+	resp, err := json.Generate(&req)
+	if err != nil {
+		return err
+	}
+	respBlob, err := resp.MarshalVT()
+	if err != nil {
+		return err
+	}
+	w := bufio.NewWriter(os.Stdout)
+	if _, err := w.Write(respBlob); err != nil {
+		return err
+	}
+	if err := w.Flush(); err != nil {
+		return err
+	}
+	return nil
+}

internal/cmd/generate.go

@@ -14,6 +14,7 @@ import (
 	"github.com/kyleconroy/sqlc/internal/codegen/golang"
 	"github.com/kyleconroy/sqlc/internal/codegen/json"
 	"github.com/kyleconroy/sqlc/internal/codegen/kotlin"
+	"github.com/kyleconroy/sqlc/internal/codegen/process"
 	"github.com/kyleconroy/sqlc/internal/codegen/python"
 	"github.com/kyleconroy/sqlc/internal/compiler"
 	"github.com/kyleconroy/sqlc/internal/config"
@@ -44,7 +45,9 @@ func printFileErr(stderr io.Writer, dir string, fileErr *multierr.FileError) {
 }
 
 type outPair struct {
-	Gen config.SQLGen
+	Gen    config.SQLGen
+	Plugin *config.Codegen
+
 	config.SQL
 }
 
@@ -145,10 +148,19 @@ func Generate(ctx context.Context, e Env, dir, filename string, stderr io.Writer
 				Gen: config.SQLGen{JSON: sql.Gen.JSON},
 			})
 		}
+		for i, _ := range sql.Codegen {
+			pairs = append(pairs, outPair{
+				SQL:    sql,
+				Plugin: &sql.Codegen[i],
+			})
+		}
 	}
 
 	for _, sql := range pairs {
 		combo := config.Combine(*conf, sql.SQL)
+		if sql.Plugin != nil {
+			combo.Codegen = *sql.Plugin
+		}
 
 		// TODO: This feels like a hack that will bite us later
 		joined := make([]string, 0, len(sql.Schema))
@@ -167,24 +179,32 @@ func Generate(ctx context.Context, e Env, dir, filename string, stderr io.Writer
 		parseOpts := opts.Parser{
 			Debug: debug.Debug,
 		}
-		if sql.Gen.Go != nil {
+
+		switch {
+		case sql.Gen.Go != nil:
 			name = combo.Go.Package
 			lang = "golang"
-		} else if sql.Gen.Kotlin != nil {
+
+		case sql.Gen.Kotlin != nil:
 			if sql.Engine == config.EnginePostgreSQL {
 				parseOpts.UsePositionalParameters = true
 			}
 			lang = "kotlin"
 			name = combo.Kotlin.Package
-		} else if sql.Gen.Python != nil {
+
+		case sql.Gen.Python != nil:
 			lang = "python"
 			name = combo.Python.Package
+
+		case sql.Plugin != nil:
+			lang = fmt.Sprintf("process:%s", sql.Plugin.Plugin)
+			name = sql.Plugin.Plugin
 		}
 
 		var packageRegion *trace.Region
 		if debug.Traced {
 			packageRegion = trace.StartRegion(ctx, "package")
-			trace.Logf(ctx, "", "name=%s dir=%s language=%s", name, dir, lang)
+			trace.Logf(ctx, "", "name=%s dir=%s plugin=%s", name, dir, lang)
 		}
 
 		result, failed := parse(ctx, e, name, dir, sql.SQL, combo, parseOpts, stderr)
@@ -206,15 +226,27 @@ func Generate(ctx context.Context, e Env, dir, filename string, stderr io.Writer
 		case sql.Gen.Go != nil:
 			out = combo.Go.Out
 			genfunc = golang.Generate
+
 		case sql.Gen.Kotlin != nil:
 			out = combo.Kotlin.Out
 			genfunc = kotlin.Generate
+
 		case sql.Gen.Python != nil:
 			out = combo.Python.Out
 			genfunc = python.Generate
+
 		case sql.Gen.JSON != nil:
 			out = combo.JSON.Out
 			genfunc = json.Generate
+
+		case sql.Plugin != nil:
+			out = sql.Plugin.Out
+			runner := process.Runner{
+				Config: combo.Global,
+				Plugin: sql.Plugin.Plugin,
+			}
+			genfunc = runner.Generate
+
 		default:
 			panic("missing language backend")
 		}

internal/cmd/shim.go

@@ -5,6 +5,7 @@ import (
 
 	"github.com/kyleconroy/sqlc/internal/compiler"
 	"github.com/kyleconroy/sqlc/internal/config"
+	"github.com/kyleconroy/sqlc/internal/config/convert"
 	"github.com/kyleconroy/sqlc/internal/info"
 	"github.com/kyleconroy/sqlc/internal/plugin"
 	"github.com/kyleconroy/sqlc/internal/sql/catalog"
@@ -56,13 +57,26 @@ func pluginSettings(cs config.CombinedSettings) *plugin.Settings {
 		Queries:   []string(cs.Package.Queries),
 		Overrides: over,
 		Rename:    cs.Rename,
+		Codegen:   pluginCodegen(cs.Codegen),
 		Python:    pluginPythonCode(cs.Python),
 		Kotlin:    pluginKotlinCode(cs.Kotlin),
 		Go:        pluginGoCode(cs.Go),
 		Json:      pluginJSONCode(cs.JSON),
 	}
 }
 
+func pluginCodegen(s config.Codegen) *plugin.Codegen {
+	opts, err := convert.YAMLtoJSON(s.Options)
+	if err != nil {
+		panic(err)
+	}
+	return &plugin.Codegen{
+		Out:     s.Out,
+		Plugin:  s.Plugin,
+		Options: opts,
+	}
+}
+
 func pluginPythonCode(s config.SQLPython) *plugin.PythonCode {
 	return &plugin.PythonCode{
 		Out:                 s.Out,
@@ -127,8 +141,9 @@ func pluginKotlinCode(s config.SQLKotlin) *plugin.KotlinCode {
 
 func pluginJSONCode(s config.SQLJSON) *plugin.JSONCode {
 	return &plugin.JSONCode{
-		Out:    s.Out,
-		Indent: s.Indent,
+		Out:      s.Out,
+		Indent:   s.Indent,
+		Filename: s.Filename,
 	}
 }
 

internal/codegen/json/gen.go

@@ -1,18 +1,52 @@
 package json
 
 import (
+	"bytes"
 	ejson "encoding/json"
+	"fmt"
 
 	"google.golang.org/protobuf/encoding/protojson"
 
 	"github.com/kyleconroy/sqlc/internal/plugin"
 )
 
+func parseOptions(req *plugin.CodeGenRequest) (plugin.JSONCode, error) {
+	if req.Settings == nil {
+		return plugin.JSONCode{}, nil
+	}
+	if req.Settings.Codegen != nil {
+		if len(req.Settings.Codegen.Options) != 0 {
+			var options plugin.JSONCode
+			dec := ejson.NewDecoder(bytes.NewReader(req.Settings.Codegen.Options))
+			dec.DisallowUnknownFields()
+			if err := dec.Decode(&options); err != nil {
+				return options, fmt.Errorf("unmarshalling options: %s", err)
+			}
+			return options, nil
+		}
+	}
+	if req.Settings.Json != nil {
+		return *req.Settings.Json, nil
+	}
+	return plugin.JSONCode{}, nil
+}
+
 func Generate(req *plugin.CodeGenRequest) (*plugin.CodeGenResponse, error) {
-	indent := ""
-	if req.Settings != nil && req.Settings.Json != nil {
-		indent = req.Settings.Json.Indent
+	options, err := parseOptions(req)
+	if err != nil {
+		return nil, err
+	}
+
+	indent := "  "
+	if options.Indent != "" {
+		indent = options.Indent
 	}
+
+	filename := "codegen_request.json"
+	if options.Filename != "" {
+		filename = options.Filename
+	}
+
 	// The output of protojson has randomized whitespace
 	// https://github.com/golang/protobuf/issues/1082
 	m := &protojson.MarshalOptions{
@@ -32,7 +66,7 @@ func Generate(req *plugin.CodeGenRequest) (*plugin.CodeGenResponse, error) {
 	return &plugin.CodeGenResponse{
 		Files: []*plugin.File{
 			{
-				Name:     "codegen_request.json",
+				Name:     filename,
 				Contents: append(blob, '\n'),
 			},
 		},

internal/codegen/process/gen.go

@@ -0,0 +1,75 @@
+package process
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"fmt"
+	"os/exec"
+
+	"google.golang.org/protobuf/proto"
+
+	"github.com/kyleconroy/sqlc/internal/config"
+	"github.com/kyleconroy/sqlc/internal/plugin"
+)
+
+type Runner struct {
+	Config config.Config
+	Plugin string
+}
+
+func (r Runner) pluginCmd() (string, error) {
+	for _, plug := range r.Config.Plugins {
+		if plug.Name != r.Plugin {
+			continue
+		}
+		if plug.Process == nil {
+			continue
+		}
+		return plug.Process.Cmd, nil
+	}
+	return "", fmt.Errorf("plugin not found")
+}
+
+// TODO: Update the gen func signature to take a ctx
+func (r Runner) Generate(req *plugin.CodeGenRequest) (*plugin.CodeGenResponse, error) {
+	stdin, err := proto.Marshal(req)
+	if err != nil {
+		return nil, fmt.Errorf("failed to encode codegen request: %s", err)
+	}
+
+	name, err := r.pluginCmd()
+	if err != nil {
+		return nil, fmt.Errorf("process: unknown plugin %s", r.Plugin)
+	}
+
+	// Check if the output plugin exists
+	path, err := exec.LookPath(name)
+	if err != nil {
+		return nil, fmt.Errorf("process: %s not found", name)
+	}
+
+	ctx := context.Background()
+	cmd := exec.CommandContext(ctx, path)
+	cmd.Stdin = bytes.NewReader(stdin)
+	cmd.Env = []string{
+		"SQLC_VERSION=foo",
+	}
+
+	out, err := cmd.Output()
+	if err != nil {
+		stderr := err.Error()
+		var exit *exec.ExitError
+		if errors.As(err, &exit) {
+			stderr = string(exit.Stderr)
+		}
+		return nil, fmt.Errorf("process: error running command %s", stderr)
+	}
+
+	var resp plugin.CodeGenResponse
+	if err := proto.Unmarshal(out, &resp); err != nil {
+		return nil, fmt.Errorf("process: failed to read codegen resp: %s", err)
+	}
+
+	return &resp, nil
+}

internal/config/config.go

@@ -8,8 +8,6 @@ import (
 	"io"
 
 	yaml "gopkg.in/yaml.v3"
-
-	"github.com/kyleconroy/sqlc/internal/config/convert"
 )
 
 const errMessageNoVersion = `The configuration file must have a version number.
@@ -119,6 +117,7 @@ type SQL struct {
 	Codegen              []Codegen `json:"codegen" yaml:"codegen"`
 }
 
+// TODO: Figure out a better name for this
 type Codegen struct {
 	Out     string    `json:"out" yaml:"out"`
 	Plugin  string    `json:"plugin" yaml:"plugin"`
@@ -172,8 +171,9 @@ type SQLPython struct {
 }
 
 type SQLJSON struct {
-	Out    string `json:"out" yaml:"out"`
-	Indent string `json:"indent,omitempty" yaml:"indent"`
+	Out      string `json:"out" yaml:"out"`
+	Indent   string `json:"indent,omitempty" yaml:"indent"`
+	Filename string `json:"filename,omitempty" yaml:"filename"`
 }
 
 var ErrMissingEngine = errors.New("unknown engine")
@@ -189,6 +189,7 @@ var ErrUnknownVersion = errors.New("invalid version number")
 var ErrPluginBuiltin = errors.New("a built-in plugin with that name already exists")
 var ErrPluginNoName = errors.New("missing plugin name")
 var ErrPluginExists = errors.New("a plugin with that name already exists")
+var ErrPluginNotFound = errors.New("no plugin found")
 var ErrPluginNoType = errors.New("plugin: field `process` or `wasm` required")
 var ErrPluginBothTypes = errors.New("plugin: both `process` and `wasm` cannot both be defined")
 var ErrPluginProcessNoCmd = errors.New("plugin: missing process command")
@@ -238,18 +239,16 @@ type CombinedSettings struct {
 	JSON      SQLJSON
 	Rename    map[string]string
 	Overrides []Override
+
+	// TODO: Combine these into a more usable type
+	Codegen Codegen
 }
 
 func Combine(conf Config, pkg SQL) CombinedSettings {
 	cs := CombinedSettings{
 		Global:  conf,
 		Package: pkg,
 	}
-
-	for i, cg := range pkg.Codegen {
-		fmt.Printf("%d: %s\n", i, convert.YAMLtoJSON(cg.Options))
-	}
-
 	if conf.Gen.Go != nil {
 		cs.Rename = conf.Gen.Go.Rename
 		cs.Overrides = append(cs.Overrides, conf.Gen.Go.Overrides...)