feat: Crossplane generation process automation (#141)

* feat: Crossplane generation process automation

* fix reviews

Author: yfodil

.github/workflows/update-terraform-provider.yaml

@@ -0,0 +1,46 @@
+name: Update Terraform Provider
+
+on:
+  schedule:
+    - cron: '0 0 * * *'
+  workflow_dispatch: {}
+
+permissions:
+  contents: write
+
+jobs:
+  update:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up Go
+        uses: actions/setup-go@v2
+        with:
+          go-version: '1.22'
+
+      - name: Install golangci-lint
+        uses: golangci/golangci-lint-action@v7
+        with:
+          version: latest
+          args: --timeout 10m
+
+      - name: Run update script
+        run: |
+          chmod +x scripts/update-provider.sh
+          scripts/update-provider.sh
+
+      - name: Create Pull Request
+        uses: peter-evans/create-pull-request@v7
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          branch: update-tf-provider/${{ env.new_version }}
+          commit-message: "chore: bump Terraform provider to v${{ env.new_version }}"
+          title: "chore: bump Terraform provider to v${{ env.new_version }}"
+          body: |
+            - Bumped `TERRAFORM_PROVIDER_VERSION` to **v${{ env.new_version }}**
+            - Re-ran `make generate` and auto-generated new Crossplane resource configs
+
+          labels: automated, dependencies

config/tools/comparator/main.go

@@ -0,0 +1,123 @@
+package main
+
+import (
+	_ "embed"
+	"encoding/json"
+	"fmt"
+	"os"
+	"regexp"
+	"strings"
+
+	"golang.org/x/text/cases"
+	"golang.org/x/text/language"
+
+	"github.com/crossplane/upjet/pkg/registry"
+	"github.com/pkg/errors"
+	"github.com/scaleway/crossplane-provider-scaleway/config/tools"
+
+	"gopkg.in/yaml.v3"
+)
+
+var groupAliases = map[string]string{
+	"transactionalemail": "tem",
+	"domainsanddns":      "domain",
+}
+
+// ProviderMetadata represents the structure of provider-metadata.yaml
+type ProviderMetadata struct {
+	Resources map[string]*registry.Resource `yaml:"resources"`
+}
+
+func main() {
+	currentProviderMetadata := os.Getenv("CURRENT_METADATA")
+	newProviderMetadata := os.Getenv("NEW_METADATA")
+
+	currentResources, err := parseProviderMetadata(currentProviderMetadata)
+	if err != nil {
+		fmt.Printf("Error parsing current provider metadata: %v\n", err)
+		return
+	}
+
+	newResources, err := parseProviderMetadata(newProviderMetadata)
+	if err != nil {
+		fmt.Printf("Error parsing new provider metadata: %v\n", err)
+		return
+	}
+
+	addedResources := findNewResources(currentResources, newResources)
+	fmt.Println("New resources found:")
+	resourceConfigs := make([]tools.ResourceConfig, 0, len(addedResources))
+
+	for _, resource := range addedResources {
+		references := make(map[string]string)
+
+		for _, example := range resource.Examples {
+			for refKey, refValue := range example.References {
+				resourceType := strings.Split(refValue, ".")[0]
+				references[refKey] = resourceType
+			}
+		}
+
+		raw := generatePackageName(resource.SubCategory)
+
+		pkg, ok := groupAliases[raw]
+		if !ok {
+			pkg = raw
+		}
+
+		config := tools.ResourceConfig{
+			PackageName:           pkg,
+			ShortGroup:            pkg,
+			ResourceName:          resource.Title,
+			TerraformResourceName: resource.Name,
+			Kind:                  parseKindFromResourceName(resource.Name),
+			References:            references,
+		}
+		resourceConfigs = append(resourceConfigs, config)
+		fmt.Println(resource.Name)
+	}
+
+	jsonData, err := json.Marshal(resourceConfigs)
+	if err != nil {
+		fmt.Printf("Error marshaling resource configuration: %v\n", err)
+		return
+	}
+	fmt.Println(string(jsonData))
+}
+
+func parseProviderMetadata(metadata string) (map[string]*registry.Resource, error) {
+	var providerMetadata ProviderMetadata
+	err := yaml.Unmarshal([]byte(metadata), &providerMetadata)
+	if err != nil {
+		return nil, errors.Wrap(err, "Failed to unmarshal provider metadata")
+	}
+	return providerMetadata.Resources, nil
+}
+
+func findNewResources(current, new map[string]*registry.Resource) []*registry.Resource {
+	var addedResources []*registry.Resource
+	for resourceName, resource := range new {
+		if _, exists := current[resourceName]; !exists {
+			addedResources = append(addedResources, resource)
+		}
+	}
+	return addedResources
+}
+
+func parseKindFromResourceName(resourceName string) string {
+	titleCaser := cases.Title(language.English)
+
+	parts := strings.Split(resourceName, "_")
+	if len(parts) == 0 {
+		return ""
+	}
+	lastWord := parts[len(parts)-1]
+
+	return titleCaser.String(lastWord)
+}
+
+func generatePackageName(subCategory string) string {
+	re := regexp.MustCompile(`[^A-Za-z0-9]+`)
+	cleaned := re.ReplaceAllString(subCategory, "")
+	return strings.ToLower(cleaned)
+}

config/tools/comparator/main_test.go

@@ -0,0 +1,59 @@
+package main
+
+import (
+	"testing"
+)
+
+// TestParseKindFromResourceName tests the parseKindFromResourceName function.
+func TestParseKindFromResourceName(t *testing.T) {
+	tests := []struct {
+		resourceName string
+		expected     string
+	}{
+		{"scaleway_object_bucket", "Bucket"},
+		{"scaleway_flexible_ip", "Ip"},
+		{"simple_resource", "Resource"},
+		{"", ""},
+		{"singleword", "Singleword"},
+		{"trailing_underscore_", ""},
+		{"_leading_underscore", "Underscore"},
+		{"middle__double__underscore", "Underscore"},
+		{"_underscore", "Underscore"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.resourceName, func(t *testing.T) {
+			actual := parseKindFromResourceName(tt.resourceName)
+			if actual != tt.expected {
+				t.Errorf("parseKindFromResourceName(%s) = %s; expected %s", tt.resourceName, actual, tt.expected)
+			}
+		})
+	}
+}
+
+// TestGeneratePackageName tests the generatePackageName function.
+func TestGeneratePackageName(t *testing.T) {
+	tests := []struct {
+		subCategory string
+		expected    string
+	}{
+		{"Apple Silicon", "applesilicon"},
+		{"Virtual Machines", "virtualmachines"},
+		{" ", ""},
+		{"", ""},
+		{"Special Chars *&^%$#", "specialchars*&^%$#"},
+		{"MixedCASE Category", "mixedcasecategory"},
+		{"  Leading and Trailing  ", "leadingandtrailing"},
+		{"Dotted.Category", "dotted.category"},
+		{"Hyphenated-Category", "hyphenated-category"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.subCategory, func(t *testing.T) {
+			actual := generatePackageName(tt.subCategory)
+			if actual != tt.expected {
+				t.Errorf("generatePackageName(%s) = %s; expected %s", tt.subCategory, actual, tt.expected)
+			}
+		})
+	}
+}

config/tools/generator/config_templates.tmpl

@@ -0,0 +1,36 @@
+{{ define "initialConfigTemplate" }}
+package {{ .PackageName }}
+
+import "github.com/crossplane/upjet/pkg/config"
+
+const shortGroup = "{{ .ShortGroup }}"
+{{ end }}
+
+{{ define "resourceConfigTemplate" }}
+// Configure adds configurations for {{ .ResourceName }} resource.
+func Configure(p *config.Provider) {
+    p.AddResourceConfigurator("{{ .TerraformResourceName }}", func(r *config.Resource) {
+        r.ExternalName = config.IdentifierFromProvider
+        r.ShortGroup = shortGroup
+        r.Kind = "{{ .Kind }}"
+        {{ range $key, $value := .References }}
+        r.References["{{$key}}"] = config.Reference{
+            TerraformName: "{{$value}}",
+        }
+        {{ end }}
+    })
+}
+{{ end }}
+
+{{ define "updateExistingConfigTemplate" }}
+    p.AddResourceConfigurator("{{ .TerraformResourceName }}", func(r *config.Resource) {
+        r.ExternalName = config.IdentifierFromProvider
+        r.ShortGroup = "{{ .ShortGroup }}"
+        r.Kind = "{{ .Kind }}"
+        {{ range $key, $value := .References }}
+        r.References["{{$key}}"] = config.Reference{
+            TerraformName: "{{$value}}",
+        }
+    {{ end }}
+    })
+{{ end }}