[TFgen] Added a identifier translator to match the go SDK (#3850)

* [TFgen] Added a identifier translator to match the goSDK

The translator will transform the OAS snake_case names into the
equivalent PascalCase that are used in the go SDK.

Removed internal ticket names.

* [TFgen] Added .gitignore

Author: Supam

.generator-v2/.gitignore

@@ -0,0 +1 @@
+tfgen

.generator-v2/internal/cli/generate.go

@@ -12,7 +12,7 @@ func newGenerateCmd(flags *globalFlags) *cobra.Command {
 		Use:   "generate",
 		Short: "Generate Terraform artifacts from the OpenAPI spec",
 		RunE: func(cmd *cobra.Command, args []string) error {
-			// TODO: implement in T033
+			// TODO: implement
 			return nil
 		},
 	}

.generator-v2/internal/cli/verify.go

@@ -11,7 +11,7 @@ func newVerifyCmd(flags *globalFlags) *cobra.Command {
 		Use:   "verify",
 		Short: "Run post-generation checks without writing files",
 		RunE: func(cmd *cobra.Command, args []string) error {
-			// TODO: implement in T065
+			// TODO: implement
 			return nil
 		},
 	}

.generator-v2/internal/model/identifier.go

@@ -0,0 +1,43 @@
+package model
+
+import (
+	"regexp"
+	"strings"
+	"unicode"
+)
+
+// Mirroring the generator's own rule is what makes the names we emit match
+// datadog-api-client-go, the SDK uses naive PascalCase with
+// no acronym uppercasing ("org_id" → "OrgId","url" → "Url", "uuid" → "Uuid").
+var (
+	patternLeadingAlpha     = regexp.MustCompile(`(.)([A-Z][a-z]+)`)
+	patternFollowingAlpha   = regexp.MustCompile(`([a-z0-9])([A-Z])`)
+	patternWhitespace       = regexp.MustCompile(`\W`)
+	patternDoubleUnderscore = regexp.MustCompile(`__+`)
+)
+
+func snakeCase(value string) string {
+	value = patternLeadingAlpha.ReplaceAllString(value, "${1}_${2}")
+	value = strings.ToLower(patternFollowingAlpha.ReplaceAllString(value, "${1}_${2}"))
+	value = patternWhitespace.ReplaceAllString(value, "_")
+	value = strings.TrimRight(value, "_")
+	return patternDoubleUnderscore.ReplaceAllString(value, "_")
+}
+
+// SdkName translates an OpenAPI identifier into the PascalCase form used by
+// datadog-api-client-go.
+//
+// OperationIds in the Datadog spec are already PascalCase and serve as SDK
+// method anchors directly; SdkName is for snake_case property and parameter names.
+func SdkName(openapiName string) string {
+	var b strings.Builder
+	for _, part := range strings.Split(snakeCase(openapiName), "_") {
+		if part == "" {
+			continue
+		}
+		runes := []rune(part)
+		b.WriteRune(unicode.ToUpper(runes[0]))
+		b.WriteString(string(runes[1:]))
+	}
+	return b.String()
+}

.generator-v2/internal/model/identifier_test.go

@@ -0,0 +1,73 @@
+package model
+
+import "testing"
+
+// TestSdkName locks in the naive PascalCase translation: split on underscores,
+// Title-case each segment (first rune upper, the rest lower), and never
+// special-case acronyms. The "no acronym uppercasing" cases (url, uuid, ID)
+// are the ones that keep generated code compiling against the SDK.
+func TestSdkName(t *testing.T) {
+	tests := []struct {
+		name string
+		in   string
+		want string
+	}{
+		// Basic cases
+		{"two snake segments", "org_id", "OrgId"},
+		{"api key", "api_key", "ApiKey"},
+		{"single word", "url", "Url"},
+		{"compound word", "http_endpoint", "HttpEndpoint"},
+		{"acronym stays naive", "uuid", "Uuid"},
+
+		// Mixed cases: input casing is normalized, not preserved.
+		{"upper acronym segment lowercased", "HTTP_endpoint", "HttpEndpoint"},
+		{"mixed segments normalized", "Org_ID", "OrgId"},
+		{"trailing digits preserved", "o_auth2", "OAuth2"},
+		{"camelCase split on case boundary", "isURL", "IsUrl"},
+
+		// Edge cases.
+		{"empty input", "", ""},
+		{"stray underscores skipped", "__org__id__", "OrgId"},
+		{"leading underscore", "_id", "Id"},
+
+		// Generator parity: snake_case folds \W (spaces, hyphens) to
+		// underscores, and acronyms stay naive
+		{"whitespace folded", "foo bar", "FooBar"},
+		{"hyphen folded", "foo-bar", "FooBar"},
+		{"all-caps stays naive", "DASHBOARD_ID", "DashboardId"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := SdkName(tt.in); got != tt.want {
+				t.Errorf("SdkName(%q) = %q, want %q", tt.in, got, tt.want)
+			}
+		})
+	}
+}
+
+// TestSdkNameIdempotent asserts SdkName is idempotent: applying it to an
+// already-converted name is a no-op, SdkName(SdkName(x)) == SdkName(x). This
+// guards the case where a name reaches the translator twice, and covers both
+// snake_case inputs and their PascalCase outputs (the latter must be fixed points).
+func TestSdkNameIdempotent(t *testing.T) {
+	inputs := []string{
+		// snake_case inputs
+		"org_id", "api_key", "url", "http_endpoint", "uuid", "team_id", "o_auth2",
+		// already-cased / mixed inputs
+		"HTTP_endpoint", "Org_ID", "isURL", "v2_api",
+		// already-PascalCase outputs — these must map to themselves
+		"OrgId", "ApiKey", "Url", "HttpEndpoint", "Uuid", "OAuth2", "IsUrl", "HttpServer",
+		"", "_id",
+	}
+
+	for _, in := range inputs {
+		t.Run(in, func(t *testing.T) {
+			once := SdkName(in)
+			twice := SdkName(once)
+			if once != twice {
+				t.Errorf("SdkName not idempotent: SdkName(%q) = %q, SdkName(%q) = %q", in, once, once, twice)
+			}
+		})
+	}
+}

.generator-v2/internal/model/types.go

@@ -51,7 +51,6 @@ const (
 	IdStrategyHeaderLocation    IdStrategy = "header.location"
 )
 
-
 // ----------------------------------------------------------------------------
 // Parser-facing types
 // ----------------------------------------------------------------------------

.generator-v2/internal/parser/parser.go

@@ -3,7 +3,6 @@ package parser
 import "github.com/pb33f/libopenapi"
 
 // LoadSpec loads and parses the OpenAPI specification at path.
-// Full implementation in T009.
 func LoadSpec(path string) (libopenapi.Document, error) {
 	panic("not implemented")
 }