Duplicate code in the "_gen.go" file

[olivierbeauve]

tfplugingen-framework CLI version

tfplugingen-framework module: v0.4.0

Provider Code Spec File

It is very long. Could you generate it using this ?
tfplugingen-openapi generate   --config ./generator_config.yml   --output ./provider-code-spec.json   ./jira_cloud.json

Expected Behavior

Generate a "_gen.go" file without duplicates

Actual Behavior

Many of my generated func() and struct are duplicated in the "_gen.go". As a result, it's impossible to do “go install .” because there are too many errors in the "_gen.go" file.

Additional Information

API used (json file):
https://developer.atlassian.com/cloud/jira/platform/swagger-v3.v3.json

generator config:
provider:
name: jira
resources:
project:
create:
path: /rest/api/3/project
method: POST
read:
path: /rest/api/3/project
method: GET
update:
path: /rest/api/3/project/{projectIdOrKey}
method: PUT
delete:
path: /rest/api/3/project/{projectIdOrKey}
method: DELETE
workflow_scheme:
create:
path: /rest/api/3/workflowscheme
method: POST
read:
path: /rest/api/3/workflowscheme
method: GET
update:
path: /rest/api/3/workflowscheme/update
method: POST
delete:
path: /rest/api/3/workflowscheme/{id}
method: DELETE

For the project resource, it works perfectly, but does not work for the workflow_scheme resource.

Code of Conduct

• I agree to follow this project's Code of Conduct

[bradyburke]

I wrote a fix for this:

// Copyright (c) HashiCorp, Inc.
// SPDX-License-Identifier: MPL-2.0

package output

import (
	"errors"
	"fmt"
	"io/fs"
	"os"
	"path/filepath"
	"strings"
)

// WriteDataSources uses the packageName to determine whether to create a directory and package per data source.
// If packageName is an empty string, this indicates that the flag was not set, and the default behaviour is
// then to create a package and directory per data source. If packageName is set then all generated code is
// placed into the same directory and package.
func WriteDataSources(dataSourcesSchema, dataSourcesModels, customTypeValue, dataSourcesToFrom map[string][]byte, outputDir, packageName string) error {
	for k, v := range dataSourcesSchema {
		dirName := ""

		if packageName == "" {
			dirName = fmt.Sprintf("datasource_%s", k)

			err := os.MkdirAll(filepath.Join(outputDir, dirName), os.ModePerm)
			if err != nil {
				return err
			}
		}

		filename := fmt.Sprintf("%s_data_source_gen.go", k)

		f, err := os.Create(filepath.Join(outputDir, dirName, filename))
		if err != nil {
			return err
		}

		_, err = f.Write(v)
		if err != nil {
			return err
		}

		_, err = f.Write(dataSourcesModels[k])
		if err != nil {
			return err
		}

		_, err = f.Write(customTypeValue[k])
		if err != nil {
			return err
		}

		_, err = f.Write(dataSourcesToFrom[k])
		if err != nil {
			return err
		}
	}

	return nil
}

// WriteResources uses the packageName to determine whether to create a directory and package per resource.
// If packageName is an empty string, this indicates that the flag was not set, and the default behaviour is
// then to create a package and directory per resource. If packageName is set then all generated code is
// placed into the same directory and package.
func WriteResources(resourcesSchema, resourcesModels, customTypeValue, resourcesToFrom map[string][]byte, outputDir, packageName string) error {
		for k, v := range resourcesSchema {
			dirName := ""

			if packageName == "" {
				dirName = fmt.Sprintf("resource_%s", k)

				err := os.MkdirAll(filepath.Join(outputDir, dirName), os.ModePerm)
				if err != nil {
					return err
				}
			}

			filename := fmt.Sprintf("%s_resource_gen.go", k)

			f, err := os.Create(filepath.Join(outputDir, dirName, filename))
			if err != nil {
				return err
			}

			// Deduplication logic
			written := make(map[string]struct{})

			writeUnique := func(code []byte) error {
				lines := strings.Split(string(code), "\n")
				var buffer []string
				for _, line := range lines {
					trim := strings.TrimSpace(line)
					if strings.HasPrefix(trim, "type ") || strings.HasPrefix(trim, "func ") || strings.HasPrefix(trim, "struct ") {
						name := trim
						if _, exists := written[name]; exists {
							continue // skip duplicate
						}
						written[name] = struct{}{}
					}
					buffer = append(buffer, line)
				}
				if len(buffer) > 0 {
					_, err := f.Write([]byte(strings.Join(buffer, "\n") + "\n"))
					if err != nil {
						return err
					}
				}
				return nil
			}

			if err := writeUnique(v); err != nil {
				return err
			}
			if err := writeUnique(resourcesModels[k]); err != nil {
				return err
			}
			if err := writeUnique(customTypeValue[k]); err != nil {
				return err
			}
			if err := writeUnique(resourcesToFrom[k]); err != nil {
				return err
			}
		}

		return nil
}

// WriteProviders uses the packageName to determine whether to create a directory and package for the provider.
// If packageName is an empty string, this indicates that the flag was not set, and the default behaviour is
// then to create a package and directory for the provider. If packageName is set then all generated code is
// placed into the same directory and package.
func WriteProviders(providersSchema, providerModels, customTypeValue, providerToFrom map[string][]byte, outputDir, packageName string) error {
	for k, v := range providersSchema {
		dirName := ""

		if packageName == "" {
			dirName = fmt.Sprintf("provider_%s", k)

			err := os.MkdirAll(filepath.Join(outputDir, dirName), os.ModePerm)
			if err != nil {
				return err
			}
		}

		filename := fmt.Sprintf("%s_provider_gen.go", k)

		f, err := os.Create(filepath.Join(outputDir, dirName, filename))
		if err != nil {
			return err
		}

		_, err = f.Write(v)
		if err != nil {
			return err
		}

		_, err = f.Write(providerModels[k])
		if err != nil {
			return err
		}

		_, err = f.Write(customTypeValue[k])
		if err != nil {
			return err
		}

		_, err = f.Write(providerToFrom[k])
		if err != nil {
			return err
		}
	}

	return nil
}

func WriteBytes(outputFilePath string, outputBytes []byte, forceOverwrite bool) error {
	if _, err := os.Stat(outputFilePath); !errors.Is(err, fs.ErrNotExist) && !forceOverwrite {
		return fmt.Errorf("file (%s) already exists and --force is false", outputFilePath)
	}

	f, err := os.Create(outputFilePath)
	if err != nil {
		return err
	}
	defer f.Close()

	_, err = f.Write(outputBytes)
	if err != nil {
		return err
	}

	return nil
}

and a unit test:

package output_test

import (
	"io/ioutil"
	"os"
	"path/filepath"
	"testing"

	"github.com/hashicorp/terraform-plugin-codegen-framework/internal/output"
)

func TestWriteResources_Deduplication(t *testing.T) {
	// Setup: create temp dir
	dir, err := ioutil.TempDir("", "dedup_test")
	if err != nil {
		t.Fatalf("failed to create temp dir: %v", err)
	}
	defer os.RemoveAll(dir)

	// Simulate duplicate code in input
	resourceName := "myresource"
	code := []byte(`type Duplicated struct {}
type Duplicated struct {}
func Duplicated() {}
func Duplicated() {}
`)
	resourcesSchema := map[string][]byte{resourceName: code}
	resourcesModels := map[string][]byte{resourceName: code}
	customTypeValue := map[string][]byte{resourceName: code}
	resourcesToFrom := map[string][]byte{resourceName: code}

	// Run WriteResources
	err = output.WriteResources(resourcesSchema, resourcesModels, customTypeValue, resourcesToFrom, dir, "")
	if err != nil {
		t.Fatalf("WriteResources failed: %v", err)
	}

	// Read output file
	outFile := filepath.Join(dir, "resource_"+resourceName, resourceName+"_resource_gen.go")
	outBytes, err := os.ReadFile(outFile)
	if err != nil {
		t.Fatalf("failed to read output file: %v", err)
	}

	outStr := string(outBytes)

	// Check only one struct and one func definition
	structCount := 0
	funcCount := 0
	for _, line := range splitLines(outStr) {
		if line == "type Duplicated struct {}" {
			structCount++
		}
		if line == "func Duplicated() {}" {
			funcCount++
		}
	}
	if structCount != 1 {
		t.Errorf("expected 1 struct, got %d", structCount)
	}
	if funcCount != 1 {
		t.Errorf("expected 1 func, got %d", funcCount)
	}
}

func splitLines(s string) []string {
	var lines []string
	start := 0
	for i := range s {
		if s[i] == '\n' {
			lines = append(lines, s[start:i])
			start = i + 1
		}
	}
	if start < len(s) {
		lines = append(lines, s[start:])
	}
	return lines
}

However, since there are no contributing documents, I'm unsure how to add it to the project. @hashicorp-cloud
cc @hashicorp-cloud
cc recent contributors @SBGoods @bbasata @ansgarm

[bradyburke]

Added #216