proxygen

Proxygen allows you to generate proxies for Go interfaces. These are useful if you want to add middleware/handlers before a call is made to add observability for example. Even in big codebases this tool should be fairly fast (0-1sec per file) as it only parses the files top-down and doesn't look at nested dependencies unless it has to. The parsing is done using the golang.org/x/tools/go/packages package. You will also notice that this tool does not use the reflect package so it fast at runtime as well.

Installation

Install the proxygen tool

go install github.com/panagiotisptr/proxygen/cmd/proxygen@latest

Quickstart

Say that you have an interface that looks like this:

package example

import "context"

type ExampleContext interface {
	context.Context
	ValuesChannel() <-chan interface{}
}

You can run this command (in the root of your project) to generate a proxy for that interface:

proxygen \
    --interface github.com/panagiotisptr/demo/example.ExampleContext \
    --package example \
    --name ExampleProxy \
    --output demo/example/example_proxy.go

Which will generate this code in demo/example/example_proxy.go:

View generated code

// Code generated by proxygen. DO NOT EDIT.
package example

import (
	proxygenInterceptors "github.com/panagiotisptr/proxygen/interceptor"

	importcontextContext5 "time"
)

type ExampleContextProxy struct {
	Implementation ExampleContext
	Interceptors   proxygenInterceptors.InterceptorChain
}

var _ ExampleContext = (*ExampleContextProxy)(nil)

func (this *ExampleContextProxy) ValuesChannel() <-chan interface{} {
	rets := this.Interceptors.Apply(
		[]interface{}{},
		"ValuesChannel",
		func(args []interface{}) []interface{} {
			res0 := this.Implementation.ValuesChannel()

			return []interface{}{
				res0,
			}
		},
	)

	return rets[0].(<-chan interface{})
}

func (this *ExampleContextProxy) Deadline() (
	importcontextContext5.Time,
	bool,
) {
	rets := this.Interceptors.Apply(
		[]interface{}{},
		"Deadline",
		func(args []interface{}) []interface{} {
			res0,
				res1 := this.Implementation.Deadline()

			return []interface{}{
				res0,
				res1,
			}
		},
	)

	return rets[0].(importcontextContext5.Time),
		rets[1].(bool)
}

func (this *ExampleContextProxy) Done() <-chan struct{} {
	rets := this.Interceptors.Apply(
		[]interface{}{},
		"Done",
		func(args []interface{}) []interface{} {
			res0 := this.Implementation.Done()

			return []interface{}{
				res0,
			}
		},
	)

	return rets[0].(<-chan struct{})
}

func (this *ExampleContextProxy) Err() error {
	rets := this.Interceptors.Apply(
		[]interface{}{},
		"Err",
		func(args []interface{}) []interface{} {
			res0 := this.Implementation.Err()

			return []interface{}{
				res0,
			}
		},
	)

	return rets[0].(error)
}

func (this *ExampleContextProxy) Value(
	arg0 any,
) any {
	rets := this.Interceptors.Apply(
		[]interface{}{
			arg0,
		},
		"Value",
		func(args []interface{}) []interface{} {
			res0 := this.Implementation.Value(
				args[0].(any),
			)

			return []interface{}{
				res0,
			}
		},
	)

	return rets[0].(any)
}

If you then have an implementation of that interface you can create the proxy like so:

func NewExampleContext() ExampleContext {
    return &ExampleContext{
        Implementation: ExampleContextImplementation{},
        Interceptors: proxygen.InterceptorChain{
            func(method string, next Handler) Handler {
                return func(args []interface{}) []interface{} {
                    fmt.Println("called:", method)
                    return next(args)
                }
            },
        },
    }
}

Even if you don't have an interface for your struct you can easily generate it with ifacemaker.