From c62c0d527ca1a90683a80aeabc527fa2c624f3ac Mon Sep 17 00:00:00 2001 From: Erhan Cagirici Date: Tue, 17 Jun 2025 15:15:33 +0300 Subject: [PATCH] angryjet: generate xpv2 interface methods Signed-off-by: Erhan Cagirici --- cmd/angryjet/main.go | 128 +++++++++++++++++++++++++++++++++++- internal/fields/fields.go | 16 +++++ internal/match/match.go | 64 ++++++++++++++++++ internal/method/method.go | 50 ++++++++++++++ internal/method/resolver.go | 66 ++++++++++++++++--- 5 files changed, 313 insertions(+), 11 deletions(-) diff --git a/cmd/angryjet/main.go b/cmd/angryjet/main.go index 77cec3c..1825ee2 100644 --- a/cmd/angryjet/main.go +++ b/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") +} diff --git a/internal/fields/fields.go b/internal/fields/fields.go index 1a576c4..0a227d2 100644 --- a/internal/fields/fields.go +++ b/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 { diff --git a/internal/match/match.go b/internal/match/match.go index d5f0061..34fce8d 100644 --- a/internal/match/match.go +++ b/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. diff --git a/internal/method/method.go b/internal/method/method.go index 7164e8c..34aaad1 100644 --- a/internal/method/method.go +++ b/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")), + ) + } +} diff --git a/internal/method/resolver.go b/internal/method/resolver.go index 7d47d89..397733d 100644 --- a/internal/method/resolver.go +++ b/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,