angryjet: generate xpv2 interface methods

Signed-off-by: Erhan Cagirici <erhan@upbound.io>

cmd/angryjet/main.go

@@ -91,11 +91,16 @@ func main() {
 			kingpin.FatalIfError(err, "error loading packages using pattern %s", *pattern)
 		}
 		kingpin.FatalIfError(GenerateManaged(*filenameManaged, header, p), "cannot write managed resource method set for package %s", p.PkgPath)
+		kingpin.FatalIfError(GenerateManagedV2(*filenameManaged, header, p), "cannot write managed resource method set for package %s", p.PkgPath)
 		kingpin.FatalIfError(GenerateManagedList(*filenameManagedList, header, p), "cannot write managed resource list method set for package %s", p.PkgPath)
+		kingpin.FatalIfError(GenerateManagedListV2(*filenameManagedList, header, p), "cannot write managed resource list method set for package %s", p.PkgPath)
 		kingpin.FatalIfError(GenerateProviderConfig(*filenamePC, header, p), "cannot write provider config method set for package %s", p.PkgPath)
 		kingpin.FatalIfError(GenerateProviderConfigUsage(*filenamePCU, header, p), "cannot write provider config usage method set for package %s", p.PkgPath)
+		kingpin.FatalIfError(GenerateProviderConfigUsageV2(*filenamePCU, header, p), "cannot write provider config usage method set for package %s", p.PkgPath)
 		kingpin.FatalIfError(GenerateProviderConfigUsageList(*filenamePCUList, header, p), "cannot write provider config usage list method set for package %s", p.PkgPath)
+		kingpin.FatalIfError(GenerateProviderConfigUsageListV2(*filenamePCUList, header, p), "cannot write provider config usage list method set for package %s", p.PkgPath)
 		kingpin.FatalIfError(GenerateReferences(*filenameResolvers, header, p), "cannot write reference resolvers for package %s", p.PkgPath)
+		kingpin.FatalIfError(GenerateReferencesV2(*filenameResolvers, header, p), "cannot write reference resolvers for package %s", p.PkgPath)
 	}
 }
 
@@ -110,8 +115,6 @@ func GenerateManaged(filename, header string, p *packages.Package) error {
 		"SetProviderConfigReference":          method.NewSetProviderConfigReference(receiver, RuntimeImport),
 		"SetWriteConnectionSecretToReference": method.NewSetWriteConnectionSecretToReference(receiver, RuntimeImport),
 		"GetWriteConnectionSecretToReference": method.NewGetWriteConnectionSecretToReference(receiver, RuntimeImport),
-		"SetPublishConnectionDetailsTo":       method.NewSetPublishConnectionDetailsTo(receiver, RuntimeImport),
-		"GetPublishConnectionDetailsTo":       method.NewGetPublishConnectionDetailsTo(receiver, RuntimeImport),
 		"SetManagementPolicies":               method.NewSetManagementPolicies(receiver, RuntimeImport),
 		"GetManagementPolicies":               method.NewGetManagementPolicies(receiver, RuntimeImport),
 		"SetDeletionPolicy":                   method.NewSetDeletionPolicy(receiver, RuntimeImport),
@@ -133,6 +136,36 @@ func GenerateManaged(filename, header string, p *packages.Package) error {
 	return errors.Wrap(err, "cannot write managed resource methods")
 }
 
+// GenerateManagedV2 generates the resource.Managed method set for v2-style namespaced MRs.
+func GenerateManagedV2(filename, header string, p *packages.Package) error {
+	receiver := "mg"
+
+	methods := method.Set{
+		"SetConditions":                       method.NewSetConditions(receiver, RuntimeImport),
+		"GetCondition":                        method.NewGetCondition(receiver, RuntimeImport),
+		"GetProviderConfigReference":          method.NewGetTypedProviderConfigReference(receiver, RuntimeImport),
+		"SetProviderConfigReference":          method.NewSetTypedProviderConfigReference(receiver, RuntimeImport),
+		"SetWriteConnectionSecretToReference": method.NewLocalSetWriteConnectionSecretToReference(receiver, RuntimeImport),
+		"GetWriteConnectionSecretToReference": method.NewLocalGetWriteConnectionSecretToReference(receiver, RuntimeImport),
+		"SetManagementPolicies":               method.NewSetManagementPolicies(receiver, RuntimeImport),
+		"GetManagementPolicies":               method.NewGetManagementPolicies(receiver, RuntimeImport),
+	}
+
+	err := generate.WriteMethods(p, methods, filepath.Join(filepath.Dir(p.GoFiles[0]), filename),
+		generate.WithHeaders(header),
+		generate.WithImportAliases(map[string]string{
+			CoreImport:    CoreAlias,
+			RuntimeImport: RuntimeAlias,
+		}),
+		generate.WithMatcher(match.AllOf(
+			match.ManagedV2(),
+			match.DoesNotHaveMarker(comments.In(p), DisableMarker, "false")),
+		),
+	)
+
+	return errors.Wrap(err, "cannot write V2 managed resource methods")
+}
+
 // GenerateManagedList generates the resource.ManagedList method set.
 func GenerateManagedList(filename, header string, p *packages.Package) error {
 	receiver := "l"
@@ -155,6 +188,28 @@ func GenerateManagedList(filename, header string, p *packages.Package) error {
 	return errors.Wrap(err, "cannot write managed resource list methods")
 }
 
+// GenerateManagedListV2 generates the resource.ManagedList method set for v2-style namespaced MRs.
+func GenerateManagedListV2(filename, header string, p *packages.Package) error {
+	receiver := "l"
+
+	methods := method.Set{
+		"GetItems": method.NewManagedGetItems(receiver, ResourceImport),
+	}
+
+	err := generate.WriteMethods(p, methods, filepath.Join(filepath.Dir(p.GoFiles[0]), filename),
+		generate.WithHeaders(header),
+		generate.WithImportAliases(map[string]string{
+			ResourceImport: ResourceAlias,
+		}),
+		generate.WithMatcher(match.AllOf(
+			match.ManagedListV2(),
+			match.DoesNotHaveMarker(comments.In(p), DisableMarker, "false")),
+		),
+	)
+
+	return errors.Wrap(err, "cannot write V2 managed resource list methods")
+}
+
 // GenerateProviderConfig generates the resource.ProviderConfig method set.
 func GenerateProviderConfig(filename, header string, p *packages.Package) error {
 	receiver := "p"
@@ -201,6 +256,29 @@ func GenerateProviderConfigUsage(filename, header string, p *packages.Package) e
 	return errors.Wrap(err, "cannot write provider config usage methods")
 }
 
+// GenerateProviderConfigUsageV2 generates the v2.ProviderConfigUsage method set.
+func GenerateProviderConfigUsageV2(filename, header string, p *packages.Package) error {
+	receiver := "p"
+
+	methods := method.Set{
+		"SetProviderConfigReference": method.NewSetRootProviderConfigTypedReference(receiver, RuntimeImport),
+		"GetProviderConfigReference": method.NewGetRootProviderConfigTypedReference(receiver, RuntimeImport),
+		"SetResourceReference":       method.NewSetRootResourceReference(receiver, RuntimeImport),
+		"GetResourceReference":       method.NewGetRootResourceReference(receiver, RuntimeImport),
+	}
+
+	err := generate.WriteMethods(p, methods, filepath.Join(filepath.Dir(p.GoFiles[0]), filename),
+		generate.WithHeaders(header),
+		generate.WithImportAliases(map[string]string{RuntimeImport: RuntimeAlias}),
+		generate.WithMatcher(match.AllOf(
+			match.TypedProviderConfigUsage(),
+			match.DoesNotHaveMarker(comments.In(p), DisableMarker, "false")),
+		),
+	)
+
+	return errors.Wrap(err, "cannot write provider config usage methods")
+}
+
 // GenerateProviderConfigUsageList generates the
 // resource.ProviderConfigUsageList method set.
 func GenerateProviderConfigUsageList(filename, header string, p *packages.Package) error {
@@ -222,6 +300,28 @@ func GenerateProviderConfigUsageList(filename, header string, p *packages.Packag
 	return errors.Wrap(err, "cannot write provider config usage list methods")
 }
 
+// GenerateProviderConfigUsageListV2 generates the
+// resource.ProviderConfigUsageList method set
+// for XPv2 namespaced MRs.
+func GenerateProviderConfigUsageListV2(filename, header string, p *packages.Package) error {
+	receiver := "p"
+
+	methods := method.Set{
+		"GetItems": method.NewProviderConfigUsageGetItems(receiver, ResourceImport),
+	}
+
+	err := generate.WriteMethods(p, methods, filepath.Join(filepath.Dir(p.GoFiles[0]), filename),
+		generate.WithHeaders(header),
+		generate.WithImportAliases(map[string]string{RuntimeImport: RuntimeAlias, ResourceImport: ResourceAlias}),
+		generate.WithMatcher(match.AllOf(
+			match.TypedProviderConfigUsageList(),
+			match.DoesNotHaveMarker(comments.In(p), DisableMarker, "false")),
+		),
+	)
+
+	return errors.Wrap(err, "cannot write V2 provider config usage list methods")
+}
+
 // GenerateReferences generates reference resolver calls.
 func GenerateReferences(filename, header string, p *packages.Package) error {
 	receiver := "mg"
@@ -245,3 +345,27 @@ func GenerateReferences(filename, header string, p *packages.Package) error {
 
 	return errors.Wrap(err, "cannot write reference resolver methods")
 }
+
+// GenerateReferencesV2 generates reference resolver calls for XPv2 namespaced MRs.
+func GenerateReferencesV2(filename, header string, p *packages.Package) error {
+	receiver := "mg"
+	comm := comments.In(p)
+
+	methods := method.Set{
+		"ResolveReferences": method.NewResolveReferencesV2(types.NewTraverser(comm), receiver, ClientImport, ReferenceImport),
+	}
+
+	err := generate.WriteMethods(p, methods, filepath.Join(filepath.Dir(p.GoFiles[0]), filename),
+		generate.WithHeaders(header),
+		generate.WithImportAliases(map[string]string{
+			ClientImport:    ClientAlias,
+			ReferenceImport: ReferenceAlias,
+		}),
+		generate.WithMatcher(match.AllOf(
+			match.ManagedV2(),
+			match.DoesNotHaveMarker(comm, DisableMarker, "false")),
+		),
+	)
+
+	return errors.Wrap(err, "cannot write V2 reference resolver methods")
+}

internal/fields/fields.go

@@ -36,6 +36,9 @@ const (
 	NameProviderConfigStatus = "ProviderConfigStatus"
 	NameProviderConfigUsage  = "ProviderConfigUsage"
 	NameItems                = "Items"
+
+	NameTypedProviderConfigUsage = "TypedProviderConfigUsage"
+	NameResourceV2Spec           = "ManagedResourceSpec"
 )
 
 // Field type suffixes.
@@ -51,6 +54,9 @@ const (
 	TypeSuffixProviderConfigSpec   = "github.com/crossplane/crossplane-runtime/apis/common/v1.ProviderConfigSpec"
 	TypeSuffixProviderConfigStatus = "github.com/crossplane/crossplane-runtime/apis/common/v1.ProviderConfigStatus"
 	TypeSuffixProviderConfigUsage  = "github.com/crossplane/crossplane-runtime/apis/common/v1.ProviderConfigUsage"
+
+	TypeSuffixProviderConfigUsageV2 = "github.com/crossplane/crossplane-runtime/apis/common/v2.TypedProviderConfigUsage"
+	TypeSuffixResourceV2Spec        = "github.com/crossplane/crossplane-runtime/apis/common/v2.ManagedResourceSpec"
 )
 
 func matches(s *types.Struct, m Matcher) bool {
@@ -182,6 +188,10 @@ func IsStatus() Matcher { return IsTypeNamed(NameStatus, TypeSuffixStatus) }
 // appears to be a Crossplane managed resource spec.
 func IsResourceSpec() Matcher { return IsTypeNamed(TypeSuffixResourceSpec, NameResourceSpec) }
 
+// IsResourceV2Spec returns a Matcher that returns true if the supplied field
+// appears to be a Crossplane managed resource spec.
+func IsResourceV2Spec() Matcher { return IsTypeNamed(TypeSuffixResourceV2Spec, NameResourceV2Spec) }
+
 // IsResourceStatus returns a Matcher that returns true if the supplied field
 // appears to be a Crossplane managed resource status.
 func IsResourceStatus() Matcher { return IsTypeNamed(TypeSuffixResourceStatus, NameResourceStatus) }
@@ -204,6 +214,12 @@ func IsProviderConfigUsage() Matcher {
 	return IsTypeNamed(TypeSuffixProviderConfigUsage, NameProviderConfigUsage)
 }
 
+// IsTypedProviderConfigUsage returns a Matcher that returns true if the supplied
+// field appears to be a Crossplane provider config usage with typed ref.
+func IsTypedProviderConfigUsage() Matcher {
+	return IsTypeNamed(TypeSuffixProviderConfigUsageV2, NameTypedProviderConfigUsage)
+}
+
 // IsItems returns a Matcher that returns true if the supplied field appears to
 // be the Items of a Kubernetes list.
 func IsItems() Matcher {

internal/match/match.go

@@ -45,6 +45,23 @@ func Managed() Object {
 	}
 }
 
+// ManagedV2 returns an Object matcher that returns true if the supplied Object is
+// a v2-style Crossplane managed resource.
+func ManagedV2() Object {
+	return func(o types.Object) bool {
+		return fields.Has(o,
+			fields.IsTypeMeta().And(fields.IsEmbedded()),
+			fields.IsObjectMeta().And(fields.IsEmbedded()),
+			fields.IsSpec().And(fields.HasFieldThat(
+				fields.IsResourceV2Spec().And(fields.IsEmbedded()),
+			)),
+			fields.IsStatus().And(fields.HasFieldThat(
+				fields.IsResourceStatus().And(fields.IsEmbedded()),
+			)),
+		)
+	}
+}
+
 // ManagedList returns an Object matcher that returns true if the supplied
 // Object is a list of Crossplane managed resource.
 func ManagedList() Object {
@@ -65,6 +82,26 @@ func ManagedList() Object {
 	}
 }
 
+// ManagedListV2 returns an Object matcher that returns true if the supplied
+// Object is a list of Crossplane managed resource.
+func ManagedListV2() Object {
+	return func(o types.Object) bool {
+		return fields.Has(o,
+			fields.IsTypeMeta().And(fields.IsEmbedded()),
+			fields.IsItems().And(fields.IsSlice()).And(fields.HasFieldThat(
+				fields.IsTypeMeta().And(fields.IsEmbedded()),
+				fields.IsObjectMeta().And(fields.IsEmbedded()),
+				fields.IsSpec().And(fields.HasFieldThat(
+					fields.IsResourceV2Spec().And(fields.IsEmbedded()),
+				)),
+				fields.IsStatus().And(fields.HasFieldThat(
+					fields.IsResourceStatus().And(fields.IsEmbedded()),
+				)),
+			)),
+		)
+	}
+}
+
 // ProviderConfig returns an Object matcher that returns true if the supplied
 // Object is a Crossplane ProviderConfig.
 func ProviderConfig() Object {
@@ -92,6 +129,18 @@ func ProviderConfigUsage() Object {
 	}
 }
 
+// TypedProviderConfigUsage returns an Object matcher that returns true if the supplied
+// Object is a Crossplane v2 style ProviderConfigUsage.
+func TypedProviderConfigUsage() Object {
+	return func(o types.Object) bool {
+		return fields.Has(o,
+			fields.IsTypeMeta().And(fields.IsEmbedded()),
+			fields.IsObjectMeta().And(fields.IsEmbedded()),
+			fields.IsTypedProviderConfigUsage().And(fields.IsEmbedded()),
+		)
+	}
+}
+
 // ProviderConfigUsageList returns an Object matcher that returns true if the
 // supplied Object is a list of Crossplane provider config usages.
 func ProviderConfigUsageList() Object {
@@ -107,6 +156,21 @@ func ProviderConfigUsageList() Object {
 	}
 }
 
+// TypedProviderConfigUsageList returns an Object matcher that returns true if the
+// supplied Object is a list of Crossplane provider config usages.
+func TypedProviderConfigUsageList() Object {
+	return func(o types.Object) bool {
+		return fields.Has(o,
+			fields.IsTypeMeta().And(fields.IsEmbedded()),
+			fields.IsItems().And(fields.IsSlice()).And(fields.HasFieldThat(
+				fields.IsTypeMeta().And(fields.IsEmbedded()),
+				fields.IsObjectMeta().And(fields.IsEmbedded()),
+				fields.IsTypedProviderConfigUsage().And(fields.IsEmbedded()),
+			)),
+		)
+	}
+}
+
 // HasMarker returns an Object matcher that returns true if the supplied Object
 // has a comment marker k with the value v. Comment markers are read from the
 // supplied Comments.

internal/method/method.go

@@ -142,6 +142,28 @@ func NewGetProviderConfigReference(receiver, runtime string) New {
 	}
 }
 
+// NewSetTypedProviderConfigReference returns a NewMethod that writes a SetProviderConfigReference
+// method for the supplied Object to the supplied file.
+func NewSetTypedProviderConfigReference(receiver, runtime string) New {
+	return func(f *jen.File, o types.Object) {
+		f.Commentf("SetProviderConfigReference of this %s.", o.Name())
+		f.Func().Params(jen.Id(receiver).Op("*").Id(o.Name())).Id("SetProviderConfigReference").Params(jen.Id("r").Op("*").Qual(runtime, "ProviderConfigReference")).Block(
+			jen.Id(receiver).Dot(fields.NameSpec).Dot("ProviderConfigReference").Op("=").Id("r"),
+		)
+	}
+}
+
+// NewGetTypedProviderConfigReference returns a NewMethod that writes a GetProviderConfigReference
+// method for the supplied Object to the supplied file.
+func NewGetTypedProviderConfigReference(receiver, runtime string) New {
+	return func(f *jen.File, o types.Object) {
+		f.Commentf("GetProviderConfigReference of this %s.", o.Name())
+		f.Func().Params(jen.Id(receiver).Op("*").Id(o.Name())).Id("GetProviderConfigReference").Params().Op("*").Qual(runtime, "ProviderConfigReference").Block(
+			jen.Return(jen.Id(receiver).Dot(fields.NameSpec).Dot("ProviderConfigReference")),
+		)
+	}
+}
+
 // NewSetWriteConnectionSecretToReference returns a NewMethod that writes a
 // SetWriteConnectionSecretToReference method for the supplied Object to the
 // supplied file.
@@ -359,3 +381,31 @@ func NewProviderConfigUsageGetItems(receiver, resource string) New {
 		)
 	}
 }
+
+// NewSetRootProviderConfigTypedReference returns a NewMethod that writes a
+// SetProviderConfigTypedReference method for the supplied Object to the supplied
+// file. Note that unlike NewSetProviderConfigTypedReference the generated method
+// expects the ProviderConfigReference to be at the root of the struct, not
+// under its Spec field.
+func NewSetRootProviderConfigTypedReference(receiver, runtime string) New {
+	return func(f *jen.File, o types.Object) {
+		f.Commentf("SetProviderConfigReference of this %s.", o.Name())
+		f.Func().Params(jen.Id(receiver).Op("*").Id(o.Name())).Id("SetProviderConfigReference").Params(jen.Id("r").Qual(runtime, "ProviderConfigReference")).Block(
+			jen.Id(receiver).Dot("ProviderConfigReference").Op("=").Id("r"),
+		)
+	}
+}
+
+// NewGetRootProviderConfigTypedReference returns a NewMethod that writes a
+// GetProviderConfigTypedReference method for the supplied Object to the supplied
+// file. Note that unlike NewGetProviderConfigTypedReference the generated
+// method expects the ProviderConfigReference to be at the root of the struct,
+// not under its Spec field.
+func NewGetRootProviderConfigTypedReference(receiver, runtime string) New {
+	return func(f *jen.File, o types.Object) {
+		f.Commentf("GetProviderConfigReference of this %s.", o.Name())
+		f.Func().Params(jen.Id(receiver).Op("*").Id(o.Name())).Id("GetProviderConfigReference").Params().Qual(runtime, "ProviderConfigReference").Block(
+			jen.Return(jen.Id(receiver).Dot("ProviderConfigReference")),
+		)
+	}
+}

internal/method/resolver.go

@@ -27,9 +27,57 @@ import (
 	xptypes "github.com/crossplane/crossplane-tools/internal/types"
 )
 
+const (
+	funcnameNewAPINamespacedResolver          = "NewAPINamespacedResolver"
+	typenameNamespacedResolutionRequest       = "NamespacedResolutionRequest"
+	typenameNamespacedResolutionResponse      = "NamespacedResolutionResponse"
+	typenameMultiNamespacedResolutionRequest  = "MultiNamespacedResolutionRequest"
+	typenameMultiNamespacedResolutionResponse = "MultiNamespacedResolutionResponse"
+)
+
+const (
+	funcnameNewAPIResolver          = "NewAPIResolver"
+	typenameResolutionRequest       = "ResolutionRequest"
+	typenameResolutionResponse      = "ResolutionResponse"
+	typenameMultiResolutionRequest  = "MultiResolutionRequest"
+	typenameMultiResolutionResponse = "MultiResolutionResponse"
+)
+
+type names struct {
+	APIResolverFunctionName         string
+	ResolutionRequestTypeName       string
+	ResolutionResponseTypeName      string
+	MultiResolutionRequestTypeName  string
+	MultiResolutionResponseTypeName string
+}
+
 // NewResolveReferences returns a NewMethod that writes a ResolveReferences for
 // given managed resource, if needed.
 func NewResolveReferences(traverser *xptypes.Traverser, receiver, clientPath, referencePkgPath string) New {
+	return NewResolveReferencesCommon(traverser, receiver, clientPath, referencePkgPath, names{
+		APIResolverFunctionName:         funcnameNewAPIResolver,
+		ResolutionRequestTypeName:       typenameResolutionRequest,
+		ResolutionResponseTypeName:      typenameResolutionResponse,
+		MultiResolutionRequestTypeName:  typenameMultiResolutionRequest,
+		MultiResolutionResponseTypeName: typenameMultiResolutionResponse,
+	})
+}
+
+// NewResolveReferencesV2 returns a NewMethod that writes a ResolveReferences for
+// given managed resource, if needed.
+func NewResolveReferencesV2(traverser *xptypes.Traverser, receiver, clientPath, referencePkgPath string) New {
+	return NewResolveReferencesCommon(traverser, receiver, clientPath, referencePkgPath, names{
+		APIResolverFunctionName:         funcnameNewAPINamespacedResolver,
+		ResolutionRequestTypeName:       typenameNamespacedResolutionRequest,
+		ResolutionResponseTypeName:      typenameNamespacedResolutionResponse,
+		MultiResolutionRequestTypeName:  typenameMultiNamespacedResolutionRequest,
+		MultiResolutionResponseTypeName: typenameMultiNamespacedResolutionResponse,
+	})
+}
+
+// NewResolveReferencesCommon returns a NewMethod that writes a ResolveReferences for
+// given managed resource, if needed.
+func NewResolveReferencesCommon(traverser *xptypes.Traverser, receiver, clientPath, referencePkgPath string, names names) New {
 	return func(f *jen.File, o types.Object) {
 		n, ok := o.Type().(*types.Named)
 		if !ok {
@@ -55,23 +103,23 @@ func NewResolveReferences(traverser *xptypes.Traverser, receiver, clientPath, re
 		for i, ref := range refs {
 			if ref.IsSlice {
 				hasMultiResolution = true
-				resolverCalls[i] = encapsulate(0, multiResolutionCall(ref, referencePkgPath), ref.GoValueFieldPath...).Line()
+				resolverCalls[i] = encapsulate(0, multiResolutionCall(ref, referencePkgPath, names.MultiResolutionRequestTypeName), ref.GoValueFieldPath...).Line()
 			} else {
 				hasSingleResolution = true
-				resolverCalls[i] = encapsulate(0, singleResolutionCall(ref, referencePkgPath), ref.GoValueFieldPath...).Line()
+				resolverCalls[i] = encapsulate(0, singleResolutionCall(ref, referencePkgPath, names.ResolutionRequestTypeName), ref.GoValueFieldPath...).Line()
 			}
 		}
 		var initStatements jen.Statement
 		if hasSingleResolution {
-			initStatements = append(initStatements, jen.Var().Id("rsp").Qual(referencePkgPath, "ResolutionResponse"))
+			initStatements = append(initStatements, jen.Var().Id("rsp").Qual(referencePkgPath, names.ResolutionResponseTypeName))
 		}
 		if hasMultiResolution {
-			initStatements = append(initStatements, jen.Line().Var().Id("mrsp").Qual(referencePkgPath, "MultiResolutionResponse"))
+			initStatements = append(initStatements, jen.Line().Var().Id("mrsp").Qual(referencePkgPath, names.MultiResolutionResponseTypeName))
 		}
 
 		f.Commentf("ResolveReferences of this %s.", o.Name())
 		f.Func().Params(jen.Id(receiver).Op("*").Id(o.Name())).Id("ResolveReferences").Params(jen.Id("ctx").Qual("context", "Context"), jen.Id("c").Qual(clientPath, "Reader")).Error().Block(
-			jen.Id("r").Op(":=").Qual(referencePkgPath, "NewAPIResolver").Call(jen.Id("c"), jen.Id(receiver)),
+			jen.Id("r").Op(":=").Qual(referencePkgPath, names.APIResolverFunctionName).Call(jen.Id("c"), jen.Id(receiver)),
 			jen.Line(),
 			&initStatements,
 			jen.Var().Err().Error(),
@@ -113,7 +161,7 @@ func encapsulate(index int, callFn resolutionCallFn, fields ...string) *jen.Stat
 	}
 }
 
-func singleResolutionCall(ref Reference, referencePkgPath string) resolutionCallFn {
+func singleResolutionCall(ref Reference, referencePkgPath, resolutionRequestTypeName string) resolutionCallFn {
 	return func(fields ...string) *jen.Statement {
 		prefixPath := jen.Id(fields[0])
 		for i := 1; i < len(fields)-1; i++ {
@@ -137,7 +185,7 @@ func singleResolutionCall(ref Reference, referencePkgPath string) resolutionCall
 		return &jen.Statement{
 			jen.List(jen.Id("rsp"), jen.Err()).Op("=").Id("r").Dot("Resolve").Call(
 				jen.Id("ctx"),
-				jen.Qual(referencePkgPath, "ResolutionRequest").Values(jen.Dict{
+				jen.Qual(referencePkgPath, resolutionRequestTypeName).Values(jen.Dict{
 					jen.Id("CurrentValue"): currentValuePath,
 					jen.Id("Reference"):    referenceFieldPath,
 					jen.Id("Selector"):     selectorFieldPath,
@@ -163,7 +211,7 @@ func singleResolutionCall(ref Reference, referencePkgPath string) resolutionCall
 	}
 }
 
-func multiResolutionCall(ref Reference, referencePkgPath string) resolutionCallFn {
+func multiResolutionCall(ref Reference, referencePkgPath, multiResolutionRequestTypeName string) resolutionCallFn {
 	return func(fields ...string) *jen.Statement {
 		prefixPath := jen.Id(fields[0])
 		for i := 1; i < len(fields)-1; i++ {
@@ -189,7 +237,7 @@ func multiResolutionCall(ref Reference, referencePkgPath string) resolutionCallF
 		return &jen.Statement{
 			jen.List(jen.Id("mrsp"), jen.Err()).Op("=").Id("r").Dot("ResolveMultiple").Call(
 				jen.Id("ctx"),
-				jen.Qual(referencePkgPath, "MultiResolutionRequest").Values(jen.Dict{
+				jen.Qual(referencePkgPath, multiResolutionRequestTypeName).Values(jen.Dict{
 					jen.Id("CurrentValues"): currentValuePath,
 					jen.Id("References"):    referenceFieldPath,
 					jen.Id("Selector"):      selectorFieldPath,