Host Set and Target SDK Generation using new Pathing (#320)

* Adding new style template starts.

* Host-set crud changes generated and tested.

* Add templates for every resource with the new pathing.  Only host-sets has testing or the backed pathing.

* Only generate new style API if requested in the input.  Have disabling old be opt in.

api/internal/genapi/input.go

@@ -13,6 +13,7 @@ import (
 	"github.com/hashicorp/boundary/internal/gen/controller/api/resources/hostsets"
 	"github.com/hashicorp/boundary/internal/gen/controller/api/resources/roles"
 	"github.com/hashicorp/boundary/internal/gen/controller/api/resources/scopes"
+	"github.com/hashicorp/boundary/internal/gen/controller/api/resources/targets"
 	"github.com/hashicorp/boundary/internal/gen/controller/api/resources/users"
 	"google.golang.org/protobuf/proto"
 )
@@ -75,6 +76,10 @@ type structInfo struct {
 	// given type, e.g. arguments only valid for one call or purpose and not
 	// conveyed within the item itself
 	extraOptions []fieldInfo
+
+	useNewStyle bool
+
+	disableOldStyle bool
 }
 
 var inputStructs = []*structInfo{
@@ -291,11 +296,41 @@ var inputStructs = []*structInfo{
 			updateTemplate,
 			deleteTemplate,
 			listTemplate,
+			createTemplate2,
+			readTemplate2,
+			updateTemplate2,
+			deleteTemplate2,
+			listTemplate2,
 		},
 		pathArgs: []string{"host-catalog", "host-set"},
 		sliceSubTypes: map[string]string{
 			"Hosts": "hostIds",
 		},
 		versionEnabled: true,
+		useNewStyle:    true,
+	},
+	{
+		inProto: &targets.HostSet{},
+		outFile: "targets/host_set.gen.go",
+	},
+	{
+		inProto: &targets.Target{},
+		outFile: "targets/target.gen.go",
+		templates: []*template.Template{
+			clientTemplate,
+			createTemplate2,
+			readTemplate2,
+			updateTemplate2,
+			deleteTemplate2,
+			listTemplate2,
+		},
+		pathArgs: []string{"target"},
+		sliceSubTypes: map[string]string{
+			"HostSets": "hostSetIds",
+		},
+		versionEnabled:  true,
+		typeOnCreate:    true,
+		useNewStyle:     true,
+		disableOldStyle: true,
 	},
 }

api/internal/genapi/templates.go

@@ -58,6 +58,22 @@ func getArgsAndPaths(in []string, action string) (colArgs, resArgs []string, col
 	return
 }
 
+func getArgsAndPathsNewStyle(in []string, action string) (colArg, resArg string, colPath, resPath string) {
+	resArg = fmt.Sprintf("%sId", strcase.ToLowerCamel(strings.ReplaceAll(in[len(in)-1], "-", "_")))
+	if len(in) == 1 {
+		colArg = "scopeId"
+	} else {
+		colArg = fmt.Sprintf("%sId", strcase.ToLowerCamel(strings.ReplaceAll(in[len(in)-2], "-", "_")))
+	}
+	colPath = fmt.Sprintf("%ss", in[len(in)-1])
+
+	if action != "" {
+		action = fmt.Sprintf(":%s", action)
+	}
+	resPath = fmt.Sprintf("fmt.Sprintf(\"%s/%%s%s\", %s)", colPath, action, resArg)
+	return
+}
+
 type templateInput struct {
 	Name                   string
 	Package                string
@@ -67,6 +83,10 @@ type templateInput struct {
 	ResourceFunctionArgs   []string
 	CollectionPath         string
 	ResourcePath           string
+	CollectionFunctionArg2 string
+	ResourceFunctionArg2   string
+	CollectionPath2        string
+	ResourcePath2          string
 	SliceSubTypes          map[string]string
 	ExtraOptions           []fieldInfo
 	VersionEnabled         bool
@@ -89,6 +109,7 @@ func fillTemplates() {
 
 		if len(in.pathArgs) > 0 {
 			input.CollectionFunctionArgs, input.ResourceFunctionArgs, input.CollectionPath, input.ResourcePath = getArgsAndPaths(in.pathArgs, "")
+			input.CollectionFunctionArg2, input.ResourceFunctionArg2, input.CollectionPath2, input.ResourcePath2 = getArgsAndPathsNewStyle(in.pathArgs, "")
 		}
 
 		if err := structTemplate.Execute(outBuf, input); err != nil {
@@ -98,7 +119,12 @@ func fillTemplates() {
 
 		if len(in.sliceSubTypes) > 0 {
 			input.SliceSubTypes = in.sliceSubTypes
-			in.templates = append(in.templates, sliceSubTypeTemplate)
+			if !in.disableOldStyle {
+				in.templates = append(in.templates, sliceSubTypeTemplate)
+			}
+			if in.useNewStyle {
+				in.templates = append(in.templates, sliceSubTypeTemplate2)
+			}
 		}
 
 		for _, t := range in.templates {
@@ -197,6 +223,58 @@ func fillTemplates() {
 	}
 }
 
+var listTemplate2 = template.Must(template.New("").Funcs(
+	template.FuncMap{
+		"snakeCase": snakeCase,
+	},
+).Parse(`
+func (c *Client) List2(ctx context.Context, {{ .CollectionFunctionArg2 }} string, opt... Option) ([]*{{ .Name }}, *api.Error, error) {
+	if {{ .CollectionFunctionArg2 }} == "" {
+		return nil, nil, fmt.Errorf("empty {{ .CollectionFunctionArg2 }} value passed into List request")
+	}
+	if c.client == nil {
+		return nil, nil, fmt.Errorf("nil client")
+	}
+
+	opts, apiOpts := getOpts(opt...)
+	apiOpts = append(apiOpts, api.WithNewStyle())
+	opts.queryMap["{{ snakeCase .CollectionFunctionArg2 }}"] = {{ .CollectionFunctionArg2 }}
+
+	req, err := c.client.NewRequest(ctx, "GET", "{{ .CollectionPath2 }}", nil, apiOpts...)
+	if err != nil {
+		return nil, nil, fmt.Errorf("error creating List request: %w", err)
+	}
+	{{ if ( eq .CollectionPath "\"scopes\"" ) }}
+	opts.queryMap["scope_id"] = scopeId
+	{{ end }}
+	if len(opts.queryMap) > 0 {
+		q := url.Values{}
+		for k, v := range opts.queryMap {
+			q.Add(k, v)
+		}
+		req.URL.RawQuery = q.Encode()
+	}
+
+	resp, err := c.client.Do(req)
+	if err != nil {
+		return nil, nil, fmt.Errorf("error performing client request during List call: %w", err)
+	}
+
+	type listResponse struct {
+		Items []*{{ .Name }}
+	}
+	target := &listResponse{}
+	apiErr, err := resp.Decode(target)
+	if err != nil {
+		return nil, nil, fmt.Errorf("error decoding List response: %w", err)
+	}
+	if apiErr != nil {
+		return nil, apiErr, nil
+	}
+	return target.Items, apiErr, nil
+}
+`))
+
 var listTemplate = template.Must(template.New("").Parse(`
 func (c *Client) List(ctx context.Context, {{ range .CollectionFunctionArgs }} {{ . }} string, {{ end }}opt... Option) ([]*{{ .Name }}, *api.Error, error) { {{ range .CollectionFunctionArgs }}
 	if {{ . }} == "" {
@@ -244,6 +322,48 @@ func (c *Client) List(ctx context.Context, {{ range .CollectionFunctionArgs }} {
 }
 `))
 
+var readTemplate2 = template.Must(template.New("").Parse(`
+func (c *Client) Read2(ctx context.Context, {{ .ResourceFunctionArg2 }} string, opt... Option) (*{{ .Name }}, *api.Error, error) {
+	if {{ .ResourceFunctionArg2 }} == "" {
+		return nil, nil, fmt.Errorf("empty  {{ .ResourceFunctionArg2 }} value passed into Read request")
+	}
+	if c.client == nil {
+		return nil, nil, fmt.Errorf("nil client")
+	}
+
+	opts, apiOpts := getOpts(opt...)
+	apiOpts = append(apiOpts, api.WithNewStyle())
+
+	req, err := c.client.NewRequest(ctx, "GET", {{ .ResourcePath2 }}, nil, apiOpts...)
+	if err != nil {
+		return nil, nil, fmt.Errorf("error creating Read request: %w", err)
+	}
+
+	if len(opts.queryMap) > 0 {
+		q := url.Values{}
+		for k, v := range opts.queryMap {
+			q.Add(k, v)
+		}
+		req.URL.RawQuery = q.Encode()
+	}
+
+	resp, err := c.client.Do(req)
+	if err != nil {
+		return nil, nil, fmt.Errorf("error performing client request during Read call: %w", err)
+	}
+
+	target := new({{ .Name }})
+	apiErr, err := resp.Decode(target)
+	if err != nil {
+		return nil, nil, fmt.Errorf("error decoding Read response: %w", err)
+	}
+	if apiErr != nil {
+		return nil, apiErr, nil
+	}
+	return target, apiErr, nil
+}
+`))
+
 var readTemplate = template.Must(template.New("").Parse(`
 func (c *Client) Read(ctx context.Context, {{ range .ResourceFunctionArgs }} {{ . }} string, {{ end }} opt... Option) (*{{ .Name }}, *api.Error, error) { {{ range .ResourceFunctionArgs }}
 	if {{ . }} == "" {
@@ -286,6 +406,51 @@ func (c *Client) Read(ctx context.Context, {{ range .ResourceFunctionArgs }} {{
 }
 `))
 
+var deleteTemplate2 = template.Must(template.New("").Parse(`
+func (c *Client) Delete2(ctx context.Context, {{ .ResourceFunctionArg2 }} string, opt... Option) (bool, *api.Error, error) { 
+	if {{ .ResourceFunctionArg2 }} == "" {
+		return false, nil, fmt.Errorf("empty {{ .ResourceFunctionArg2 }} value passed into Delete request")
+	}
+	if c.client == nil {
+		return false, nil, fmt.Errorf("nil client")
+	}
+	
+	opts, apiOpts := getOpts(opt...)
+	apiOpts = append(apiOpts, api.WithNewStyle())
+
+	req, err := c.client.NewRequest(ctx, "DELETE", {{ .ResourcePath2 }}, nil, apiOpts...)
+	if err != nil {
+		return false, nil, fmt.Errorf("error creating Delete request: %w", err)
+	}
+
+	if len(opts.queryMap) > 0 {
+		q := url.Values{}
+		for k, v := range opts.queryMap {
+			q.Add(k, v)
+		}
+		req.URL.RawQuery = q.Encode()
+	}
+
+	resp, err := c.client.Do(req)
+	if err != nil {
+		return false, nil, fmt.Errorf("error performing client request during Delete call: %w", err)
+	}
+
+	type deleteResponse struct {
+		Existed bool
+	}
+	target := &deleteResponse{}
+	apiErr, err := resp.Decode(target)
+	if err != nil {
+		return false, nil, fmt.Errorf("error decoding Delete response: %w", err)
+	}
+	if apiErr != nil {
+		return false, apiErr, nil
+	}
+	return target.Existed, apiErr, nil
+}
+`))
+
 var deleteTemplate = template.Must(template.New("").Parse(`
 func (c *Client) Delete(ctx context.Context, {{ range .ResourceFunctionArgs }} {{ . }} string, {{ end }} opt... Option) (bool, *api.Error, error) { {{ range .ResourceFunctionArgs }}
 	if {{ . }} == "" {
@@ -331,6 +496,60 @@ func (c *Client) Delete(ctx context.Context, {{ range .ResourceFunctionArgs }} {
 }
 `))
 
+var createTemplate2 = template.Must(template.New("").Funcs(
+	template.FuncMap{
+		"snakeCase": snakeCase,
+	},
+).Parse(`
+func (c *Client) Create2(ctx context.Context, {{ if .TypeOnCreate }} resourceType string, {{ end }} {{ .CollectionFunctionArg2 }} string, opt... Option) (*{{ .Name }}, *api.Error, error) {
+	if {{ .CollectionFunctionArg2 }} == "" {
+		return nil, nil, fmt.Errorf("empty {{ .CollectionFunctionArg2 }} value passed into Create request")
+	}
+	opts, apiOpts := getOpts(opt...)
+	apiOpts = append(apiOpts, api.WithNewStyle())
+	if c.client == nil {
+		return nil, nil, fmt.Errorf("nil client")
+	}
+	{{ if .TypeOnCreate }} if resourceType == "" {
+		return nil, nil, fmt.Errorf("empty resourceType value passed into Create request")
+	} else {
+		opts.postMap["type"] = resourceType
+	}{{ end }}
+
+	opts.postMap["{{ snakeCase .CollectionFunctionArg2 }}"] = {{ .CollectionFunctionArg2 }}
+
+	req, err := c.client.NewRequest(ctx, "POST", "{{ .CollectionPath2 }}", opts.postMap, apiOpts...)
+	if err != nil {
+		return nil, nil, fmt.Errorf("error creating Create request: %w", err)
+	}
+	{{ if ( eq .CollectionPath "\"scopes\"" ) }}
+	opts.queryMap["scope_id"] = scopeId
+	{{ end }}
+	if len(opts.queryMap) > 0 {
+		q := url.Values{}
+		for k, v := range opts.queryMap {
+			q.Add(k, v)
+		}
+		req.URL.RawQuery = q.Encode()
+	}
+
+	resp, err := c.client.Do(req)
+	if err != nil {
+		return nil, nil, fmt.Errorf("error performing client request during Create call: %w", err)
+	}
+
+	target := new({{ .Name }})
+	apiErr, err := resp.Decode(target)
+	if err != nil {
+		return nil, nil, fmt.Errorf("error decoding Create response: %w", err)
+	}
+	if apiErr != nil {
+		return nil, apiErr, nil
+	}
+	return target, apiErr, nil
+}
+`))
+
 var createTemplate = template.Must(template.New("").Parse(`
 func (c *Client) Create(ctx context.Context, {{ if .TypeOnCreate }} resourceType string, {{ end }} {{ range .CollectionFunctionArgs }} {{ . }} string, {{ end }} opt... Option) (*{{ .Name }}, *api.Error, error) { {{ range .CollectionFunctionArgs }}
 	if {{ . }} == "" {
@@ -378,6 +597,69 @@ func (c *Client) Create(ctx context.Context, {{ if .TypeOnCreate }} resourceType
 }
 `))
 
+var updateTemplate2 = template.Must(template.New("").Parse(`
+func (c *Client) Update2(ctx context.Context, {{ .ResourceFunctionArg2 }} string, version uint32, opt... Option) (*{{ .Name }}, *api.Error, error) {
+	if {{ .ResourceFunctionArg2 }} == "" {
+		return nil, nil, fmt.Errorf("empty {{ .ResourceFunctionArg2 }} value passed into Update request")
+	}
+	if c.client == nil {
+		return nil, nil, fmt.Errorf("nil client")
+	}
+
+	opts, apiOpts := getOpts(opt...)
+	apiOpts = append(apiOpts, api.WithNewStyle())
+
+	{{ if .VersionEnabled }}
+	if version == 0 {
+		if !opts.withAutomaticVersioning {
+			return nil, nil, errors.New("zero version number passed into Update request and automatic versioning not specified")
+		}
+		existingTarget, existingApiErr, existingErr := c.Read2(ctx, {{ .ResourceFunctionArg2 }}, opt...)
+		if existingErr != nil {
+			return nil, nil, fmt.Errorf("error performing initial check-and-set read: %w", existingErr)
+		}
+		if existingApiErr != nil {
+			return nil, nil, fmt.Errorf("error from controller when performing initial check-and-set read: %s", pretty.Sprint(existingApiErr))
+		}
+		if existingTarget == nil {
+			return nil, nil, errors.New("nil resource found when performing initial check-and-set read")
+		}
+		version = existingTarget.Version
+	}
+	{{ end }}
+
+	opts.postMap["version"] = version
+
+	req, err := c.client.NewRequest(ctx, "PATCH", {{ .ResourcePath2 }}, opts.postMap, apiOpts...)
+	if err != nil {
+		return nil, nil, fmt.Errorf("error creating Update request: %w", err)
+	}
+
+	if len(opts.queryMap) > 0 {
+		q := url.Values{}
+		for k, v := range opts.queryMap {
+			q.Add(k, v)
+		}
+		req.URL.RawQuery = q.Encode()
+	}
+
+	resp, err := c.client.Do(req)
+	if err != nil {
+		return nil, nil, fmt.Errorf("error performing client request during Update call: %w", err)
+	}
+
+	target := new({{ .Name }})
+	apiErr, err := resp.Decode(target)
+	if err != nil {
+		return nil, nil, fmt.Errorf("error decoding Update response: %w", err)
+	}
+	if apiErr != nil {
+		return nil, apiErr, nil
+	}
+	return target, apiErr, nil
+}
+`))
+
 var updateTemplate = template.Must(template.New("").Parse(`
 func (c *Client) Update(ctx context.Context, {{ range .ResourceFunctionArgs }} {{ . }} string, {{ end }}version uint32, opt... Option) (*{{ .Name }}, *api.Error, error) { {{ range .ResourceFunctionArgs }}
 	if {{ . }} == "" {
@@ -524,6 +806,91 @@ func (c *Client) {{ $fullName }}(ctx context.Context, {{ range $input.ResourceFu
 {{ end }}
 `))
 
+var sliceSubTypeTemplate2 = template.Must(template.New("").Funcs(
+	template.FuncMap{
+		"makeSlice":                 makeSlice,
+		"snakeCase":                 snakeCase,
+		"kebabCase":                 kebabCase,
+		"getPathWithActionNewStyle": getPathWithActionNewStyle,
+	},
+).Parse(`
+{{ $input := . }}
+{{ range $index, $op := makeSlice "Add" "Set" "Remove" }}
+{{ range $key, $value := $input.SliceSubTypes }}
+{{ $fullName := print $op $key }}
+{{ $actionName := kebabCase $fullName }}
+{{ $resPath := getPathWithActionNewStyle $input.PathArgs $actionName }}
+func (c *Client) {{ $fullName }}2(ctx context.Context, {{ $input.ResourceFunctionArg2 }} string, version uint32, {{ $value }} []string, opt... Option) (*{{ $input.Name }}, *api.Error, error) { 
+	if {{ $input.ResourceFunctionArg2 }} == "" {
+		return nil, nil, fmt.Errorf("empty {{ $input.ResourceFunctionArg2 }} value passed into {{ $fullName }} request")
+	}
+	if c.client == nil {
+		return nil, nil, fmt.Errorf("nil client")
+	}
+
+	opts, apiOpts := getOpts(opt...)
+	apiOpts = append(apiOpts, api.WithNewStyle())
+
+	{{ if $input.VersionEnabled }}
+	if version == 0 {
+		if !opts.withAutomaticVersioning {
+			return nil, nil, errors.New("zero version number passed into {{ $fullName }} request")
+		}
+		existingTarget, existingApiErr, existingErr := c.Read2(ctx, {{ $input.ResourceFunctionArg2 }}, opt...)
+		if existingErr != nil {
+			return nil, nil, fmt.Errorf("error performing initial check-and-set read: %w", existingErr)
+		}
+		if existingApiErr != nil {
+			return nil, nil, fmt.Errorf("error from controller when performing initial check-and-set read: %s", pretty.Sprint(existingApiErr))
+		}
+		if existingTarget == nil {
+			return nil, nil, errors.New("nil resource found when performing initial check-and-set read")
+		}
+		version = existingTarget.Version
+	}
+	{{ end }}
+	opts.postMap["version"] = version
+
+	if len({{ $value }}) > 0 {
+		opts.postMap["{{ snakeCase $value }}"] = {{ $value }}
+	}{{ if ( eq $op "Set" ) }} else if {{ $value }} != nil {
+			// In this function, a non-nil but empty list means clear out
+			opts.postMap["{{ snakeCase $value }}"] = nil
+		}
+	{{ end }}
+
+	req, err := c.client.NewRequest(ctx, "POST", {{ $resPath }}, opts.postMap, apiOpts...)
+	if err != nil {
+		return nil, nil, fmt.Errorf("error creating {{ $fullName }} request: %w", err)
+	}
+
+	if len(opts.queryMap) > 0 {
+		q := url.Values{}
+		for k, v := range opts.queryMap {
+			q.Add(k, v)
+		}
+		req.URL.RawQuery = q.Encode()
+	}
+
+	resp, err := c.client.Do(req)
+	if err != nil {
+		return nil, nil, fmt.Errorf("error performing client request during {{ $fullName }} call: %w", err)
+	}
+
+	target := new({{ $input.Name }})
+	apiErr, err := resp.Decode(target)
+	if err != nil {
+		return nil, nil, fmt.Errorf("error decoding {{ $fullName }} response: %w", err)
+	}
+	if apiErr != nil {
+		return nil, apiErr, nil
+	}
+	return target, apiErr, nil
+}
+{{ end }}
+{{ end }}
+`))
+
 var structTemplate = template.Must(template.New("").Parse(
 	fmt.Sprint(`// Code generated by "make api"; DO NOT EDIT.
 package {{ .Package }}
@@ -664,3 +1031,8 @@ func getPathWithAction(resArgs []string, action string) string {
 	_, _, _, resPath := getArgsAndPaths(resArgs, action)
 	return resPath
 }
+
+func getPathWithActionNewStyle(resArgs []string, action string) string {
+	_, _, _, resPath := getArgsAndPathsNewStyle(resArgs, action)
+	return resPath
+}