terraform/tf_provider
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor(gen_v2): split into 7 Go packages (types, templates, helpers, params, loader, writers, main)

Browse Source
This commit is contained in:
“Naeel”
2026-07-05 09:13:07 +04:00
parent e8935f1ebf
commit f3616d0fe1
10 changed files with 542 additions and 2789 deletions
Download Patch File Download Diff File Expand all files Collapse all files
universal_rebuild/tools/gen_v2/generate_resources_v2.go.bak
-2277
View File
File diff suppressed because it is too large Load Diff
universal_rebuild/tools/gen_v2/helpers.go → universal_rebuild/tools/gen_v2/helpers/helpers.go
+35 -19
View File
@@ -1,5 +1,5 @@
// helpers — конвертация имён, форматирование, plan-модификаторы.
package main
// Package helpers — конвертация имён, форматирование, plan-модификаторы.
package helpers
import (
"fmt"
@@ -7,9 +7,12 @@ import (
"os"
"strings"
"unicode"
"terraform-provider-nubes/tools/gen_v2/types"
)
func toCamel(s string) string {
// ToCamel конвертирует snake_case → CamelCase.
func ToCamel(s string) string {
parts := strings.FieldsFunc(s, func(r rune) bool { return r == '_' || r == '-' })
for i, p := range parts {
if len(p) == 0 {
@@ -18,10 +21,11 @@ func toCamel(s string) string {
parts[i] = strings.ToUpper(p[:1]) + p[1:]
}
out := strings.Join(parts, "")
return ensureGoIdent(out)
return EnsureGoIdent(out)
}
func toSnake(s string) string {
// ToSnake конвертирует CamelCase → snake_case.
func ToSnake(s string) string {
var out []rune
for i, r := range s {
if i > 0 && r >= 'A' && r <= 'Z' {
@@ -32,7 +36,8 @@ func toSnake(s string) string {
return string(out)
}
func paramType(p Param) string {
// ParamType возвращает Go-тип для параметра (types.Bool/Int64/String).
func ParamType(p types.Param) string {
switch strings.ToLower(p.Type) {
case "bool":
return "types.Bool"
@@ -43,7 +48,8 @@ func paramType(p Param) string {
}
}
func paramDefaultExpr(p Param) string {
// ParamDefaultExpr возвращает выражение значения по умолчанию.
func ParamDefaultExpr(p types.Param) string {
if p.Default == "" {
return ""
}
@@ -58,7 +64,8 @@ func paramDefaultExpr(p Param) string {
}
}
func paramFormat(p Param, varName string) string {
// ParamFormat возвращает вызов Format* для форматирования значения параметра.
func ParamFormat(p types.Param, varName string) string {
switch strings.ToLower(p.Type) {
case "bool":
return fmt.Sprintf("resources_core.FormatBool(%s)", varName)
@@ -69,7 +76,8 @@ func paramFormat(p Param, varName string) string {
}
}
func paramParse(p Param) string {
// ParamParse возвращает имя Parse*-функции для параметра.
func ParamParse(p types.Param) string {
switch strings.ToLower(p.Type) {
case "bool":
return "resources_core.ParseBool"
@@ -80,7 +88,8 @@ func paramParse(p Param) string {
}
}
func paramDescription(p Param) string {
// ParamDescription формирует MarkdownDescription для параметра.
func ParamDescription(p types.Param) string {
var desc string
if strings.TrimSpace(p.Descr) != "" {
desc = strings.TrimSpace(p.Descr)
@@ -109,7 +118,8 @@ func paramDescription(p Param) string {
return fmt.Sprintf("%q", desc)
}
func outputParamType(p OutputParam) string {
// OutputParamType возвращает Go-тип для выходного параметра (types.Map/List/String).
func OutputParamType(p types.OutputParam) string {
switch strings.ToLower(p.Type) {
case "map":
return "types.Map"
@@ -120,19 +130,23 @@ func outputParamType(p OutputParam) string {
}
}
func outputParamIsMap(p OutputParam) bool {
// OutputParamIsMap возвращает true, если выходной параметр — map.
func OutputParamIsMap(p types.OutputParam) bool {
return strings.EqualFold(strings.TrimSpace(p.Type), "map")
}
func outputParamIsList(p OutputParam) bool {
// OutputParamIsList возвращает true, если выходной параметр — list.
func OutputParamIsList(p types.OutputParam) bool {
return strings.EqualFold(strings.TrimSpace(p.Type), "list")
}
func outputParamSensitive(p OutputParam) bool {
// OutputParamSensitive возвращает true, если параметр секретный.
func OutputParamSensitive(p types.OutputParam) bool {
return p.Sensitive
}
func ensureGoIdent(s string) string {
// EnsureGoIdent проверяет, что строка начинается с буквы или _.
func EnsureGoIdent(s string) string {
if s == "" {
return "R"
}
@@ -143,8 +157,8 @@ func ensureGoIdent(s string) string {
return "R" + s
}
func formatSourceOrWarn(filePath string, src []byte) []byte {
// FormatSourceOrWarn форматирует Go-код. При ошибке пишет warning в stderr.
func FormatSourceOrWarn(filePath string, src []byte) []byte {
formatted, err := format.Source(src)
if err != nil {
fmt.Fprintf(os.Stderr, "WARNING: gofmt failed for %s: %v — writing unformatted code\n", filePath, err)
@@ -153,7 +167,8 @@ func formatSourceOrWarn(filePath string, src []byte) []byte {
return formatted
}
func planModifierType(p Param) string {
// PlanModifierType возвращает суффикс типа план-модификатора (Bool/Int64/String).
func PlanModifierType(p types.Param) string {
switch strings.ToLower(strings.TrimSpace(p.Type)) {
case "bool":
return "Bool"
@@ -164,7 +179,8 @@ func planModifierType(p Param) string {
}
}
func planModifierExpr(p Param) string {
// PlanModifierExpr возвращает выражение план-модификатора RequiresReplace.
func PlanModifierExpr(p types.Param) string {
switch strings.ToLower(strings.TrimSpace(p.Type)) {
case "bool":
return "boolplanmodifier.RequiresReplace()"
universal_rebuild/tools/gen_v2/loader.go
-282
View File
@@ -1,282 +0,0 @@
// loader — загрузка YAML-спеков и построение ресурсов.
package main
import (
"fmt"
"io/fs"
"os"
"path/filepath"
"sort"
"strings"
"gopkg.in/yaml.v3"
)
func loadSpecs(dir string) ([]GenResource, []GenSubresource, []GenAction, error) {
var services []GenResource
var subs []GenSubresource
var actions []GenAction
domainServiceIDsSet := map[int]struct{}{}
walkErr := filepath.WalkDir(dir, func(path string, d fs.DirEntry, err error) error {
if err != nil {
return err
}
if d.IsDir() || !strings.HasSuffix(d.Name(), ".yaml") {
return nil
}
b, err := os.ReadFile(path)
if err != nil {
return err
}
var spec ServiceSpec
if err := yaml.Unmarshal(b, &spec); err != nil {
return err
}
// P1.4: fail-fast на неизвестных kind'ах и отсутствующих обязательных полях.
if err := validateSpec(path, &spec); err != nil {
return fmt.Errorf("%s: %w", path, err)
}
createParams := []Param{}
modifyParams := []Param{}
supportsSuspendDestroy := false
for _, op := range spec.Operations {
if op.Kind != "instance" {
continue
}
switch op.Action {
case "create":
createParams = convertParams(op.Params)
case "modify":
modifyParams = convertParams(op.Params)
case "suspend":
supportsSuspendDestroy = true
}
}
schemaParams := mergeParams(createParams, modifyParams)
createParams = alignParamTypes(createParams, schemaParams)
modifyParams = alignParamTypes(modifyParams, schemaParams)
createOnly := computeCreateOnly(createParams, modifyParams)
schemaParams = markCreateOnly(schemaParams, createOnly)
hasDomainParam := false
for _, param := range schemaParams {
if strings.EqualFold(strings.TrimSpace(param.Code), "domain") {
hasDomainParam = true
domainServiceIDsSet[spec.ServiceID] = struct{}{}
break
}
}
adoptExistingOnCreate := false
suspendOnDestroy := true
if spec.Lifecycle.SuspendOnDestroyDefault != nil {
suspendOnDestroy = *spec.Lifecycle.SuspendOnDestroyDefault
}
gr := GenResource{
Name: spec.Name,
ServiceID: spec.ServiceID,
CreateParams: createParams,
ModifyParams: modifyParams,
SchemaParams: schemaParams,
CreateOnlyParams: filterCreateOnly(schemaParams),
CreateOnlyRequiredParams: filterCreateOnlyRequired(schemaParams),
OutputParams: normalizeOutputParams(spec.Outputs.Params),
HasRefSvcParams: hasRefSvcParams(schemaParams),
SupportsSuspendDestroy: supportsSuspendDestroy,
SuspendOnDestroy: suspendOnDestroy,
AdoptExistingOnCreate: adoptExistingOnCreate,
HasDomainParam: hasDomainParam,
}
analyzeParams(&gr.UsesBool, &gr.UsesInt64, &gr.UsesString, &gr.HasDefaults, &gr.NeedsBoolDefault, &gr.NeedsInt64Default, &gr.NeedsStringDefault, gr.SchemaParams)
gr.NeedsJsonPlanMod = analyzeJsonPlanMod(gr.SchemaParams)
// NeedsStringsImport = true если:
// 1) есть ref_svc params (RefSvcId > 0, != 12) — шаблон генерирует restore-casing блоки с strings.EqualFold
// 2) есть строковые ModifyParams — шаблон генерирует EqualFold в hasServiceParamChanges (Update)
// 3) есть строковые CreateOnlyParams — шаблон генерирует EqualFold в create-only validation (ModifyPlan)
// RefSvcId=12 (S3 Object Storage) НЕ генерирует restore-блок — для S3 UUID обязателен точный формат
gr.NeedsStringsImport = hasRestoreCasingParams(gr.SchemaParams) || analyzeNeedsStrings(gr.ModifyParams) || analyzeNeedsStrings(gr.CreateOnlyRequiredParams) || analyzeNeedsStrings(gr.CreateOnlyParams)
// --- Action processing (ДО append, чтобы HasRedeploy попал в слайс) ---
// Правила из ARCHITECTURE.md:
// - redeploy → встроить как git_revision в основной ресурс
// - restart, recovery, reconcile → исключить (ручные операции, только UI)
// - всё остальное → стандартный action-ресурс (на будущее, если появятся новые)
for _, op := range spec.Operations {
if op.Kind != "action" {
continue
}
switch op.Action {
case "redeploy":
gr.HasRedeploy = true
case "restart", "recovery", "reconcile":
// Исключены
default:
act := GenAction{
ServiceName: spec.Name,
ServiceID: spec.ServiceID,
ActionName: op.Action,
OperationName: op.Name,
Params: convertParams(op.Params),
}
act.SchemaParams = act.Params
analyzeParams(&act.UsesBool, &act.UsesInt64, &act.UsesString, &act.HasDefaults, &act.NeedsBoolDefault, &act.NeedsInt64Default, &act.NeedsStringDefault, act.SchemaParams)
act.NeedsJsonPlanMod = analyzeJsonPlanMod(act.SchemaParams)
act.NeedsStringsImport = analyzeNeedsStrings(act.SchemaParams)
actions = append(actions, act)
}
}
services = append(services, gr)
srByName := map[string]*GenSubresource{}
for _, op := range spec.Operations {
if op.Kind != "subresource" {
continue
}
name := strings.TrimSpace(op.Subresource)
if name == "" {
continue
}
sr := srByName[name]
if sr == nil {
sr = &GenSubresource{ServiceName: spec.Name, ServiceID: spec.ServiceID, SubName: name}
srByName[name] = sr
}
switch op.Action {
case "create":
sr.CreateOpName = op.Name
sr.CreateParams = convertParams(op.Params)
case "modify":
sr.ModifyOpName = op.Name
sr.ModifyParams = convertParams(op.Params)
case "delete":
sr.DeleteOpName = op.Name
sr.DeleteParams = convertParams(op.Params)
}
}
for _, sr := range srByName {
sr.SchemaParams = mergeParams(sr.CreateParams, sr.ModifyParams, sr.DeleteParams)
sr.CreateParams = alignParamTypes(sr.CreateParams, sr.SchemaParams)
sr.ModifyParams = alignParamTypes(sr.ModifyParams, sr.SchemaParams)
sr.DeleteParams = alignParamTypes(sr.DeleteParams, sr.SchemaParams)
createOnly := computeCreateOnly(sr.CreateParams, sr.ModifyParams)
sr.SchemaParams = markCreateOnly(sr.SchemaParams, createOnly)
forceNewCodes := buildSubresourceForceNewCodes(sr, createOnly)
sr.SchemaParams = markForceNew(sr.SchemaParams, forceNewCodes)
sr.IdentityParams = filterForceNew(sr.SchemaParams)
if len(sr.IdentityParams) == 0 {
sr.IdentityParams = sr.SchemaParams
}
sr.HasRefSvcParams = hasRefSvcParams(sr.SchemaParams)
analyzeParams(&sr.UsesBool, &sr.UsesInt64, &sr.UsesString, &sr.HasDefaults, &sr.NeedsBoolDefault, &sr.NeedsInt64Default, &sr.NeedsStringDefault, sr.SchemaParams)
analyzePlanModifiers(&sr.NeedsBoolPlanMod, &sr.NeedsInt64PlanMod, &sr.NeedsStringPlanMod, sr.SchemaParams)
sr.NeedsJsonPlanMod = analyzeJsonPlanMod(sr.SchemaParams)
sr.NeedsStringsImport = analyzeNeedsStrings(sr.ModifyParams)
subs = append(subs, *sr)
}
return nil
})
if walkErr != nil {
return nil, nil, nil, walkErr
}
domainServiceIDs := make([]int, 0, len(domainServiceIDsSet))
for serviceID := range domainServiceIDsSet {
domainServiceIDs = append(domainServiceIDs, serviceID)
}
sort.Ints(domainServiceIDs)
for idx := range services {
if len(domainServiceIDs) == 0 {
services[idx].DomainServiceIDs = nil
continue
}
services[idx].DomainServiceIDs = append([]int(nil), domainServiceIDs...)
}
sort.Slice(services, func(i, j int) bool { return services[i].Name < services[j].Name })
sort.Slice(subs, func(i, j int) bool {
if subs[i].ServiceName == subs[j].ServiceName {
return subs[i].SubName < subs[j].SubName
}
return subs[i].ServiceName < subs[j].ServiceName
})
sort.Slice(actions, func(i, j int) bool {
if actions[i].ServiceName == actions[j].ServiceName {
return actions[i].ActionName < actions[j].ActionName
}
return actions[i].ServiceName < actions[j].ServiceName
})
return services, subs, actions, nil
}
func convertParams(params []ParamSpec) []Param {
out := make([]Param, 0, len(params))
for _, p := range params {
typeName := normalizeParamType(p.DataType)
defVal := normalizeDefault(p.Default)
ref := 0
if p.RefSvcId != nil {
ref = *p.RefSvcId
}
out = append(out, Param{
ID: p.ID,
Code: p.Code,
Type: typeName,
Required: p.Required,
Default: defVal,
RefSvcId: ref,
Descr: strings.TrimSpace(p.Descr),
Man: strings.TrimSpace(p.Man),
Sensitive: p.Sensitive,
// IsJson: флаг для добавления JsonNormalize план-модификатора в схему.
IsJson: strings.EqualFold(strings.TrimSpace(p.DataType), "json"),
})
}
return out
}
func normalizeParamType(value string) string {
v := strings.ToLower(strings.TrimSpace(value))
if strings.Contains(v, "bool") {
return "bool"
}
if strings.Contains(v, "int") || strings.Contains(v, "number") {
return "int64"
}
return "string"
}
func normalizeDefault(value interface{}) string {
if value == nil {
return ""
}
switch t := value.(type) {
case string:
return strings.TrimSpace(t)
default:
return fmt.Sprintf("%v", t)
}
}
func normalizeOutputParams(params []OutputParam) []OutputParam {
if len(params) == 0 {
return []OutputParam{}
}
return params
}
func hasRefSvcParams(params []Param) bool {
for _, p := range params {
if p.RefSvcId > 0 && strings.EqualFold(strings.TrimSpace(p.Type), "string") {
return true
}
}
return false
}
universal_rebuild/tools/gen_v2/loader/loader.go
+313
View File
@@ -0,0 +1,313 @@
// Package loader — загрузка YAML-спеков и построение ресурсов.
package loader
import (
"fmt"
"io/fs"
"os"
"path/filepath"
"sort"
"strings"
"gopkg.in/yaml.v3"
"terraform-provider-nubes/tools/gen_v2/params"
"terraform-provider-nubes/tools/gen_v2/types"
)
// LoadSpecs загружает все YAML-спеки из директории и строит GenResource/GenSubresource/GenAction.
func LoadSpecs(dir string) ([]types.GenResource, []types.GenSubresource, []types.GenAction, error) {
var services []types.GenResource
var subs []types.GenSubresource
var actions []types.GenAction
domainServiceIDsSet := map[int]struct{}{}
walkErr := filepath.WalkDir(dir, func(path string, d fs.DirEntry, err error) error {
if err != nil {
return err
}
if d.IsDir() || !strings.HasSuffix(d.Name(), ".yaml") {
return nil
}
b, err := os.ReadFile(path)
if err != nil {
return err
}
var spec types.ServiceSpec
if err := yaml.Unmarshal(b, &spec); err != nil {
return err
}
// P1.4: fail-fast на неизвестных kind'ах и отсутствующих обязательных полях.
if err := ValidateSpec(path, &spec); err != nil {
return fmt.Errorf("%s: %w", path, err)
}
createParams := []types.Param{}
modifyParams := []types.Param{}
supportsSuspendDestroy := false
for _, op := range spec.Operations {
if op.Kind != "instance" {
continue
}
switch op.Action {
case "create":
createParams = ConvertParams(op.Params)
case "modify":
modifyParams = ConvertParams(op.Params)
case "suspend":
supportsSuspendDestroy = true
}
}
schemaParams := params.Merge(createParams, modifyParams)
createParams = params.AlignParamTypes(createParams, schemaParams)
modifyParams = params.AlignParamTypes(modifyParams, schemaParams)
createOnly := params.ComputeCreateOnly(createParams, modifyParams)
schemaParams = params.MarkCreateOnly(schemaParams, createOnly)
hasDomainParam := false
for _, param := range schemaParams {
if strings.EqualFold(strings.TrimSpace(param.Code), "domain") {
hasDomainParam = true
domainServiceIDsSet[spec.ServiceID] = struct{}{}
break
}
}
adoptExistingOnCreate := false
suspendOnDestroy := true
if spec.Lifecycle.SuspendOnDestroyDefault != nil {
suspendOnDestroy = *spec.Lifecycle.SuspendOnDestroyDefault
}
gr := types.GenResource{
Name: spec.Name,
ServiceID: spec.ServiceID,
CreateParams: createParams,
ModifyParams: modifyParams,
SchemaParams: schemaParams,
CreateOnlyParams: params.FilterCreateOnly(schemaParams),
CreateOnlyRequiredParams: params.FilterCreateOnlyRequired(schemaParams),
OutputParams: NormalizeOutputParams(spec.Outputs.Params),
HasRefSvcParams: HasRefSvcParams(schemaParams),
SupportsSuspendDestroy: supportsSuspendDestroy,
SuspendOnDestroy: suspendOnDestroy,
AdoptExistingOnCreate: adoptExistingOnCreate,
HasDomainParam: hasDomainParam,
}
params.Analyze(&gr.UsesBool, &gr.UsesInt64, &gr.UsesString, &gr.HasDefaults, &gr.NeedsBoolDefault, &gr.NeedsInt64Default, &gr.NeedsStringDefault, gr.SchemaParams)
gr.NeedsJsonPlanMod = params.AnalyzeJsonPlanMod(gr.SchemaParams)
gr.NeedsStringsImport = params.HasRestoreCasingParams(gr.SchemaParams) || params.AnalyzeNeedsStrings(gr.ModifyParams) || params.AnalyzeNeedsStrings(gr.CreateOnlyRequiredParams) || params.AnalyzeNeedsStrings(gr.CreateOnlyParams)
// --- Action processing (ДО append, чтобы HasRedeploy попал в слайс) ---
for _, op := range spec.Operations {
if op.Kind != "action" {
continue
}
switch op.Action {
case "redeploy":
gr.HasRedeploy = true
case "restart", "recovery", "reconcile":
// Исключены
default:
act := types.GenAction{
ServiceName: spec.Name,
ServiceID: spec.ServiceID,
ActionName: op.Action,
OperationName: op.Name,
Params: ConvertParams(op.Params),
}
act.SchemaParams = act.Params
params.Analyze(&act.UsesBool, &act.UsesInt64, &act.UsesString, &act.HasDefaults, &act.NeedsBoolDefault, &act.NeedsInt64Default, &act.NeedsStringDefault, act.SchemaParams)
act.NeedsJsonPlanMod = params.AnalyzeJsonPlanMod(act.SchemaParams)
act.NeedsStringsImport = params.AnalyzeNeedsStrings(act.SchemaParams)
actions = append(actions, act)
}
}
services = append(services, gr)
srByName := map[string]*types.GenSubresource{}
for _, op := range spec.Operations {
if op.Kind != "subresource" {
continue
}
name := strings.TrimSpace(op.Subresource)
if name == "" {
continue
}
sr := srByName[name]
if sr == nil {
sr = &types.GenSubresource{ServiceName: spec.Name, ServiceID: spec.ServiceID, SubName: name}
srByName[name] = sr
}
switch op.Action {
case "create":
sr.CreateOpName = op.Name
sr.CreateParams = ConvertParams(op.Params)
case "modify":
sr.ModifyOpName = op.Name
sr.ModifyParams = ConvertParams(op.Params)
case "delete":
sr.DeleteOpName = op.Name
sr.DeleteParams = ConvertParams(op.Params)
}
}
for _, sr := range srByName {
sr.SchemaParams = params.Merge(sr.CreateParams, sr.ModifyParams, sr.DeleteParams)
sr.CreateParams = params.AlignParamTypes(sr.CreateParams, sr.SchemaParams)
sr.ModifyParams = params.AlignParamTypes(sr.ModifyParams, sr.SchemaParams)
sr.DeleteParams = params.AlignParamTypes(sr.DeleteParams, sr.SchemaParams)
createOnly := params.ComputeCreateOnly(sr.CreateParams, sr.ModifyParams)
sr.SchemaParams = params.MarkCreateOnly(sr.SchemaParams, createOnly)
forceNewCodes := params.BuildSubresourceForceNewCodes(sr, createOnly)
sr.SchemaParams = params.MarkForceNew(sr.SchemaParams, forceNewCodes)
sr.IdentityParams = params.FilterForceNew(sr.SchemaParams)
if len(sr.IdentityParams) == 0 {
sr.IdentityParams = sr.SchemaParams
}
sr.HasRefSvcParams = HasRefSvcParams(sr.SchemaParams)
params.Analyze(&sr.UsesBool, &sr.UsesInt64, &sr.UsesString, &sr.HasDefaults, &sr.NeedsBoolDefault, &sr.NeedsInt64Default, &sr.NeedsStringDefault, sr.SchemaParams)
params.AnalyzePlanModifiers(&sr.NeedsBoolPlanMod, &sr.NeedsInt64PlanMod, &sr.NeedsStringPlanMod, sr.SchemaParams)
sr.NeedsJsonPlanMod = params.AnalyzeJsonPlanMod(sr.SchemaParams)
sr.NeedsStringsImport = params.AnalyzeNeedsStrings(sr.ModifyParams)
subs = append(subs, *sr)
}
return nil
})
if walkErr != nil {
return nil, nil, nil, walkErr
}
domainServiceIDs := make([]int, 0, len(domainServiceIDsSet))
for serviceID := range domainServiceIDsSet {
domainServiceIDs = append(domainServiceIDs, serviceID)
}
sort.Ints(domainServiceIDs)
for idx := range services {
if len(domainServiceIDs) == 0 {
services[idx].DomainServiceIDs = nil
continue
}
services[idx].DomainServiceIDs = append([]int(nil), domainServiceIDs...)
}
sort.Slice(services, func(i, j int) bool { return services[i].Name < services[j].Name })
sort.Slice(subs, func(i, j int) bool {
if subs[i].ServiceName == subs[j].ServiceName {
return subs[i].SubName < subs[j].SubName
}
return subs[i].ServiceName < subs[j].ServiceName
})
sort.Slice(actions, func(i, j int) bool {
if actions[i].ServiceName == actions[j].ServiceName {
return actions[i].ActionName < actions[j].ActionName
}
return actions[i].ServiceName < actions[j].ServiceName
})
return services, subs, actions, nil
}
// ConvertParams конвертирует []ParamSpec → []Param с нормализацией типов.
func ConvertParams(params []types.ParamSpec) []types.Param {
out := make([]types.Param, 0, len(params))
for _, p := range params {
typeName := NormalizeParamType(p.DataType)
defVal := NormalizeDefault(p.Default)
ref := 0
if p.RefSvcId != nil {
ref = *p.RefSvcId
}
out = append(out, types.Param{
ID: p.ID,
Code: p.Code,
Type: typeName,
Required: p.Required,
Default: defVal,
RefSvcId: ref,
Descr: strings.TrimSpace(p.Descr),
Man: strings.TrimSpace(p.Man),
Sensitive: p.Sensitive,
IsJson: strings.EqualFold(strings.TrimSpace(p.DataType), "json"),
})
}
return out
}
// NormalizeParamType нормализует строку data_type → bool | int64 | string.
func NormalizeParamType(value string) string {
v := strings.ToLower(strings.TrimSpace(value))
if strings.Contains(v, "bool") {
return "bool"
}
if strings.Contains(v, "int") || strings.Contains(v, "number") {
return "int64"
}
return "string"
}
// NormalizeDefault нормализует значение по умолчанию в строку.
func NormalizeDefault(value interface{}) string {
if value == nil {
return ""
}
switch t := value.(type) {
case string:
return strings.TrimSpace(t)
default:
return fmt.Sprintf("%v", t)
}
}
// NormalizeOutputParams нормализует выходные параметры.
func NormalizeOutputParams(params []types.OutputParam) []types.OutputParam {
if len(params) == 0 {
return []types.OutputParam{}
}
return params
}
// HasRefSvcParams проверяет наличие ref_svc-параметров.
func HasRefSvcParams(params []types.Param) bool {
for _, p := range params {
if p.RefSvcId > 0 && strings.EqualFold(strings.TrimSpace(p.Type), "string") {
return true
}
}
return false
}
// KnownKinds — допустимые значения Kind операций.
var KnownKinds = map[string]bool{
"instance": true,
"subresource": true,
"action": true,
}
// ValidateSpec проверяет YAML-спек на обязательные поля и неизвестные kinds.
// P1.4: fail-fast — паника при неизвестном kind вместо тихого игнорирования.
func ValidateSpec(path string, spec *types.ServiceSpec) error {
if spec.Name == "" {
return fmt.Errorf("missing required field: name")
}
if spec.ServiceID <= 0 {
return fmt.Errorf("missing required field: service_id")
}
for i, op := range spec.Operations {
if op.Kind == "" {
return fmt.Errorf("operation[%d] %q: missing required field: kind", i, op.Name)
}
if !KnownKinds[op.Kind] {
return fmt.Errorf("operation[%d] %q: unknown kind %q (valid: instance, subresource, action)", i, op.Name, op.Kind)
}
if op.Action == "" {
return fmt.Errorf("operation[%d] %q (kind=%s): missing required field: action", i, op.Name, op.Kind)
}
if op.Kind == "subresource" && op.Subresource == "" {
return fmt.Errorf("operation[%d] %q (kind=subresource): missing required field: subresource", i, op.Name)
}
}
return nil
}
universal_rebuild/tools/gen_v2/main.go
+8 -40
View File
@@ -16,10 +16,12 @@
package main
import (
"fmt"
"os"
"path/filepath"
"strings"
"terraform-provider-nubes/tools/gen_v2/loader"
"terraform-provider-nubes/tools/gen_v2/writers"
)
func main() {
@@ -36,61 +38,27 @@ func main() {
outDir = filepath.Join(root, "internal", "resources_gen")
}
instanceResources, subresources, actions, err := loadSpecs(resourcesDir)
instanceResources, subresources, actions, err := loader.LoadSpecs(resourcesDir)
if err != nil {
panic(err)
}
for _, svc := range instanceResources {
if err := writeInstanceResource(outDir, svc); err != nil {
if err := writers.WriteInstanceResource(outDir, svc); err != nil {
panic(err)
}
}
for _, sr := range subresources {
if err := writeSubresource(outDir, sr); err != nil {
if err := writers.WriteSubresource(outDir, sr); err != nil {
panic(err)
}
}
for _, act := range actions {
if err := writeActionResource(outDir, act); err != nil {
if err := writers.WriteActionResource(outDir, act); err != nil {
panic(err)
}
}
if err := writeRegistry(outDir, instanceResources, subresources, actions); err != nil {
if err := writers.WriteRegistry(outDir, instanceResources, subresources, actions); err != nil {
panic(err)
}
}
// knownKinds — допустимые значения Kind операций.
var knownKinds = map[string]bool{
"instance": true,
"subresource": true,
"action": true,
}
// validateSpec проверяет YAML-спек на обязательные поля и неизвестные kinds.
// P1.4: fail-fast — паника при неизвестном kind вместо тихого игнорирования.
func validateSpec(path string, spec *ServiceSpec) error {
if spec.Name == "" {
return fmt.Errorf("missing required field: name")
}
if spec.ServiceID <= 0 {
return fmt.Errorf("missing required field: service_id")
}
for i, op := range spec.Operations {
if op.Kind == "" {
return fmt.Errorf("operation[%d] %q: missing required field: kind", i, op.Name)
}
if !knownKinds[op.Kind] {
return fmt.Errorf("operation[%d] %q: unknown kind %q (valid: instance, subresource, action)", i, op.Name, op.Kind)
}
if op.Action == "" {
return fmt.Errorf("operation[%d] %q (kind=%s): missing required field: action", i, op.Name, op.Kind)
}
if op.Kind == "subresource" && op.Subresource == "" {
return fmt.Errorf("operation[%d] %q (kind=subresource): missing required field: subresource", i, op.Name)
}
}
return nil
}
universal_rebuild/tools/gen_v2/params.go → universal_rebuild/tools/gen_v2/params/params.go
+39 -30
View File
@@ -1,13 +1,16 @@
// params — слияние, фильтрация, анализ параметров и ForceNew.
package main
// Package params — слияние, фильтрация, анализ параметров и ForceNew.
package params
import (
"sort"
"strings"
"terraform-provider-nubes/tools/gen_v2/types"
)
func mergeParams(sets ...[]Param) []Param {
seen := map[string]Param{}
// Merge объединяет несколько наборов параметров, убирая дубликаты по Code.
func Merge(sets ...[]types.Param) []types.Param {
seen := map[string]types.Param{}
for _, s := range sets {
for _, p := range s {
key := strings.ToLower(strings.TrimSpace(p.Code))
@@ -19,7 +22,7 @@ func mergeParams(sets ...[]Param) []Param {
}
}
}
out := make([]Param, 0, len(seen))
out := make([]types.Param, 0, len(seen))
for _, p := range seen {
out = append(out, p)
}
@@ -27,7 +30,8 @@ func mergeParams(sets ...[]Param) []Param {
return out
}
func alignParamTypes(params []Param, schema []Param) []Param {
// AlignParamTypes выравнивает типы параметров по схеме.
func AlignParamTypes(params []types.Param, schema []types.Param) []types.Param {
if len(params) == 0 || len(schema) == 0 {
return params
}
@@ -58,7 +62,8 @@ func alignParamTypes(params []Param, schema []Param) []Param {
return params
}
func computeCreateOnly(createParams []Param, modifyParams []Param) map[string]struct{} {
// ComputeCreateOnly вычисляет набор полей, которые есть только в create (не в modify).
func ComputeCreateOnly(createParams []types.Param, modifyParams []types.Param) map[string]struct{} {
modifyCodes := make(map[string]struct{}, len(modifyParams))
for _, p := range modifyParams {
key := strings.ToLower(strings.TrimSpace(p.Code))
@@ -82,7 +87,8 @@ func computeCreateOnly(createParams []Param, modifyParams []Param) map[string]st
return createOnly
}
func markCreateOnly(schema []Param, createOnly map[string]struct{}) []Param {
// MarkCreateOnly проставляет CreateOnly=true для полей, которых нет в modify.
func MarkCreateOnly(schema []types.Param, createOnly map[string]struct{}) []types.Param {
if len(schema) == 0 || len(createOnly) == 0 {
return schema
}
@@ -100,12 +106,13 @@ func markCreateOnly(schema []Param, createOnly map[string]struct{}) []Param {
return schema
}
func filterCreateOnly(schema []Param) []Param {
// FilterCreateOnly возвращает только CreateOnly-параметры.
func FilterCreateOnly(schema []types.Param) []types.Param {
if len(schema) == 0 {
return []Param{}
return []types.Param{}
}
result := make([]Param, 0, len(schema))
result := make([]types.Param, 0, len(schema))
for _, p := range schema {
if p.CreateOnly {
result = append(result, p)
@@ -114,12 +121,13 @@ func filterCreateOnly(schema []Param) []Param {
return result
}
func filterCreateOnlyRequired(schema []Param) []Param {
// FilterCreateOnlyRequired возвращает обязательные CreateOnly-параметры.
func FilterCreateOnlyRequired(schema []types.Param) []types.Param {
if len(schema) == 0 {
return []Param{}
return []types.Param{}
}
result := make([]Param, 0, len(schema))
result := make([]types.Param, 0, len(schema))
for _, p := range schema {
if p.CreateOnly && p.Required {
result = append(result, p)
@@ -128,7 +136,8 @@ func filterCreateOnlyRequired(schema []Param) []Param {
return result
}
func analyzeParams(usesBool *bool, usesInt64 *bool, usesString *bool, hasDefaults *bool, needsBoolDefault *bool, needsInt64Default *bool, needsStringDefault *bool, params []Param) {
// Analyze анализирует типы параметров и проставляет флаги uses/needs.
func Analyze(usesBool *bool, usesInt64 *bool, usesString *bool, hasDefaults *bool, needsBoolDefault *bool, needsInt64Default *bool, needsStringDefault *bool, params []types.Param) {
for _, p := range params {
switch strings.ToLower(p.Type) {
case "bool":
@@ -153,8 +162,8 @@ func analyzeParams(usesBool *bool, usesInt64 *bool, usesString *bool, hasDefault
}
}
func buildSubresourceForceNewCodes(sr *GenSubresource, createOnly map[string]struct{}) map[string]struct{} {
// BuildSubresourceForceNewCodes строит карту параметров, требующих ForceNew.
func BuildSubresourceForceNewCodes(sr *types.GenSubresource, createOnly map[string]struct{}) map[string]struct{} {
forceNew := map[string]struct{}{}
if sr.ModifyOpName == "" {
for _, p := range sr.SchemaParams {
@@ -177,7 +186,8 @@ func buildSubresourceForceNewCodes(sr *GenSubresource, createOnly map[string]str
return forceNew
}
func markForceNew(params []Param, forceNew map[string]struct{}) []Param {
// MarkForceNew проставляет ForceNew=true для указанных параметров.
func MarkForceNew(params []types.Param, forceNew map[string]struct{}) []types.Param {
if len(params) == 0 || len(forceNew) == 0 {
return params
}
@@ -193,8 +203,9 @@ func markForceNew(params []Param, forceNew map[string]struct{}) []Param {
return params
}
func filterForceNew(params []Param) []Param {
result := []Param{}
// FilterForceNew возвращает только ForceNew-параметры.
func FilterForceNew(params []types.Param) []types.Param {
result := []types.Param{}
for _, p := range params {
if p.ForceNew {
result = append(result, p)
@@ -203,9 +214,8 @@ func filterForceNew(params []Param) []Param {
return result
}
// analyzeJsonPlanMod возвращает true, если хотя бы один параметр является JSON-строкой.
// Используется для условного добавления импорта planmodifier в сгенерированные файлы.
func analyzeJsonPlanMod(params []Param) bool {
// AnalyzeJsonPlanMod возвращает true, если хотя бы один параметр — JSON.
func AnalyzeJsonPlanMod(params []types.Param) bool {
for _, p := range params {
if p.IsJson {
return true
@@ -214,9 +224,8 @@ func analyzeJsonPlanMod(params []Param) bool {
return false
}
// hasRestoreCasingParams возвращает true, если есть ref_svc params с RefSvcId > 0 && != 12
// (restore-casing блок в Create/Read/Update использует strings.EqualFold для них).
func hasRestoreCasingParams(params []Param) bool {
// HasRestoreCasingParams возвращает true, если есть ref_svc-параметры (кроме S3).
func HasRestoreCasingParams(params []types.Param) bool {
for _, p := range params {
if p.RefSvcId > 0 && p.RefSvcId != 12 && strings.EqualFold(strings.TrimSpace(p.Type), "string") {
return true
@@ -225,9 +234,8 @@ func hasRestoreCasingParams(params []Param) bool {
return false
}
// analyzeNeedsStrings возвращает true, если среди params есть хотя бы один строковый параметр.
// Используется для условного добавления импорта "strings" (EqualFold в Update).
func analyzeNeedsStrings(params []Param) bool {
// AnalyzeNeedsStrings возвращает true, если есть строковые параметры.
func AnalyzeNeedsStrings(params []types.Param) bool {
for _, p := range params {
t := strings.ToLower(strings.TrimSpace(p.Type))
if t != "bool" && t != "int" && t != "int64" && t != "number" {
@@ -237,7 +245,8 @@ func analyzeNeedsStrings(params []Param) bool {
return false
}
func analyzePlanModifiers(needsBool *bool, needsInt64 *bool, needsString *bool, params []Param) {
// AnalyzePlanModifiers анализирует ForceNew-параметры для добавления planmodifier-импортов.
func AnalyzePlanModifiers(needsBool *bool, needsInt64 *bool, needsString *bool, params []types.Param) {
for _, p := range params {
if !p.ForceNew {
continue
universal_rebuild/tools/gen_v2/templates.go → universal_rebuild/tools/gen_v2/templates/templates.go
+4 -4
View File
@@ -1,6 +1,6 @@
package main
package templates
const instanceTemplate = `package resources_gen
const Instance = `package resources_gen
import (
"context"
@@ -608,7 +608,7 @@ func (r *{{ToCamel .Name}}Resource) Configure(_ context.Context, req resource.Co
}
`
const subresourceTemplate = `package resources_gen
const Subresource = `package resources_gen
import (
"context"
@@ -1052,7 +1052,7 @@ func (r *{{ToCamel (printf "%s_%s" .ServiceName .SubName)}}Resource) Configure(_
}
`
const actionTemplate = `package resources_gen
const Action = `package resources_gen
import (
"context"
universal_rebuild/tools/gen_v2/types.go → universal_rebuild/tools/gen_v2/types/types.go
+8 -9
View File
@@ -1,6 +1,5 @@
// types — структуры данных для генератора Terraform-провайдера.
package main
// Package types — структуры данных для генератора Terraform-провайдера.
package types
// ─── Входные структуры (из YAML) ───────────────────────────────────────────
@@ -50,6 +49,7 @@ type ServiceSpec struct {
Operations []OperationSpec `yaml:"operations"`
}
// Param — нормализованный параметр (после конвертации из ParamSpec).
type Param struct {
ID int
Code string
@@ -68,6 +68,7 @@ type Param struct {
IsJson bool
}
// GenResource — ресурс инстанса (nubes_{service}).
type GenResource struct {
Name string
ServiceID int
@@ -103,6 +104,7 @@ type GenResource struct {
NeedsStringsImport bool
}
// GenSubresource — подресурс (nubes_{service}_{sub}).
type GenSubresource struct {
ServiceName string
ServiceID int
@@ -126,12 +128,11 @@ type GenSubresource struct {
NeedsBoolPlanMod bool
NeedsInt64PlanMod bool
NeedsStringPlanMod bool
// NeedsJsonPlanMod: хотя бы один атрибут имеет IsJson=true.
NeedsJsonPlanMod bool
// NeedsStringsImport: есть строковые ModifyParams (нужен EqualFold в Update).
NeedsJsonPlanMod bool
NeedsStringsImport bool
}
// GenAction — action-ресурс (почти не используется, redeploy встроен в GenResource).
type GenAction struct {
ServiceName string
ServiceID int
@@ -146,8 +147,6 @@ type GenAction struct {
NeedsBoolDefault bool
NeedsInt64Default bool
NeedsStringDefault bool
// NeedsJsonPlanMod: хотя бы один атрибут имеет IsJson=true.
NeedsJsonPlanMod bool
// NeedsStringsImport: есть строковые SchemaParams (нужен EqualFold).
NeedsJsonPlanMod bool
NeedsStringsImport bool
}
universal_rebuild/tools/gen_v2/writers.go
-128
View File
@@ -1,128 +0,0 @@
// writers — генерация Go-файлов ресурсов и registry.go.
package main
import (
"bytes"
"fmt"
"os"
"path/filepath"
"text/template"
)
func writeInstanceResource(outDir string, svc GenResource) error {
fileName := fmt.Sprintf("%d_%s_resource.go", svc.ServiceID, svc.Name)
filePath := filepath.Join(outDir, fileName)
tpl, err := template.New("resource").Funcs(template.FuncMap{
"ToCamel": toCamel,
"ToSnake": toSnake,
"ParamType": paramType,
"ParamDefaultExpr": paramDefaultExpr,
"ParamFormat": paramFormat,
"ParamParse": paramParse,
"ParamDescription": paramDescription,
"OutputType": outputParamType,
"OutputIsMap": outputParamIsMap,
"OutputIsList": outputParamIsList,
"OutputSensitive": outputParamSensitive,
"bt": func() string { return "`" },
}).Parse(instanceTemplate)
if err != nil {
return err
}
var buf bytes.Buffer
if err := tpl.Execute(&buf, svc); err != nil {
return err
}
formatted := formatSourceOrWarn(filePath, buf.Bytes())
return os.WriteFile(filePath, formatted, 0644)
}
func writeSubresource(outDir string, sr GenSubresource) error {
name := fmt.Sprintf("%s_%s", sr.ServiceName, sr.SubName)
fileName := fmt.Sprintf("%d_%s_resource.go", sr.ServiceID, name)
filePath := filepath.Join(outDir, fileName)
tpl, err := template.New("subresource").Funcs(template.FuncMap{
"ToCamel": toCamel,
"ToSnake": toSnake,
"ParamType": paramType,
"ParamDefaultExpr": paramDefaultExpr,
"ParamFormat": paramFormat,
"ParamParse": paramParse,
"ParamDescription": paramDescription,
"PlanModifierType": planModifierType,
"PlanModifierExpr": planModifierExpr,
"bt": func() string { return "`" },
}).Parse(subresourceTemplate)
if err != nil {
return err
}
var buf bytes.Buffer
if err := tpl.Execute(&buf, sr); err != nil {
return err
}
formatted := formatSourceOrWarn(filePath, buf.Bytes())
return os.WriteFile(filePath, formatted, 0644)
}
func writeActionResource(outDir string, act GenAction) error {
name := fmt.Sprintf("%s_%s", act.ServiceName, act.ActionName)
fileName := fmt.Sprintf("%d_%s_action.go", act.ServiceID, name)
filePath := filepath.Join(outDir, fileName)
tpl, err := template.New("action").Funcs(template.FuncMap{
"ToCamel": toCamel,
"ToSnake": toSnake,
"ParamType": paramType,
"ParamDefaultExpr": paramDefaultExpr,
"ParamFormat": paramFormat,
"ParamParse": paramParse,
"ParamDescription": paramDescription,
"bt": func() string { return "`" },
}).Parse(actionTemplate)
if err != nil {
return err
}
var buf bytes.Buffer
if err := tpl.Execute(&buf, act); err != nil {
return err
}
formatted := formatSourceOrWarn(filePath, buf.Bytes())
return os.WriteFile(filePath, formatted, 0644)
}
func writeRegistry(outDir string, services []GenResource, subs []GenSubresource, actions []GenAction) error {
var buf bytes.Buffer
buf.WriteString("package resources_gen\n\n")
buf.WriteString("import \"github.com/hashicorp/terraform-plugin-framework/resource\"\n\n")
buf.WriteString("// Code generated by tools/gen_v2. DO NOT EDIT.\n")
buf.WriteString("func AllResources() []func() resource.Resource {\n")
buf.WriteString("\treturn []func() resource.Resource{\n")
for _, svc := range services {
buf.WriteString(fmt.Sprintf("\t\tNew%[1]sResource,\n", toCamel(svc.Name)))
}
for _, sr := range subs {
buf.WriteString(fmt.Sprintf("\t\tNew%[1]sResource,\n", toCamel(sr.ServiceName+"_"+sr.SubName)))
}
for _, act := range actions {
buf.WriteString(fmt.Sprintf("\t\tNew%[1]sResource,\n", toCamel(act.ServiceName+"_"+act.ActionName)))
}
buf.WriteString("\t}\n")
buf.WriteString("}\n")
regPath := filepath.Join(outDir, "registry.go")
formatted := formatSourceOrWarn(regPath, buf.Bytes())
return os.WriteFile(regPath, formatted, 0644)
}
universal_rebuild/tools/gen_v2/writers/writers.go
+135
View File
@@ -0,0 +1,135 @@
// Package writers — генерация Go-файлов ресурсов и registry.go.
package writers
import (
"bytes"
"fmt"
"os"
"path/filepath"
"text/template"
"terraform-provider-nubes/tools/gen_v2/helpers"
"terraform-provider-nubes/tools/gen_v2/templates"
"terraform-provider-nubes/tools/gen_v2/types"
)
// WriteInstanceResource генерирует nubes_{service} (CRUD инстанса).
func WriteInstanceResource(outDir string, svc types.GenResource) error {
fileName := fmt.Sprintf("%d_%s_resource.go", svc.ServiceID, svc.Name)
filePath := filepath.Join(outDir, fileName)
tpl, err := template.New("resource").Funcs(template.FuncMap{
"ToCamel": helpers.ToCamel,
"ToSnake": helpers.ToSnake,
"ParamType": helpers.ParamType,
"ParamDefaultExpr": helpers.ParamDefaultExpr,
"ParamFormat": helpers.ParamFormat,
"ParamParse": helpers.ParamParse,
"ParamDescription": helpers.ParamDescription,
"OutputType": helpers.OutputParamType,
"OutputIsMap": helpers.OutputParamIsMap,
"OutputIsList": helpers.OutputParamIsList,
"OutputSensitive": helpers.OutputParamSensitive,
"bt": func() string { return "`" },
}).Parse(templates.Instance)
if err != nil {
return err
}
var buf bytes.Buffer
if err := tpl.Execute(&buf, svc); err != nil {
return err
}
formatted := helpers.FormatSourceOrWarn(filePath, buf.Bytes())
return os.WriteFile(filePath, formatted, 0644)
}
// WriteSubresource генерирует nubes_{service}_{sub} (пользователи, базы, ...).
func WriteSubresource(outDir string, sr types.GenSubresource) error {
name := fmt.Sprintf("%s_%s", sr.ServiceName, sr.SubName)
fileName := fmt.Sprintf("%d_%s_resource.go", sr.ServiceID, name)
filePath := filepath.Join(outDir, fileName)
tpl, err := template.New("subresource").Funcs(template.FuncMap{
"ToCamel": helpers.ToCamel,
"ToSnake": helpers.ToSnake,
"ParamType": helpers.ParamType,
"ParamDefaultExpr": helpers.ParamDefaultExpr,
"ParamFormat": helpers.ParamFormat,
"ParamParse": helpers.ParamParse,
"ParamDescription": helpers.ParamDescription,
"PlanModifierType": helpers.PlanModifierType,
"PlanModifierExpr": helpers.PlanModifierExpr,
"bt": func() string { return "`" },
}).Parse(templates.Subresource)
if err != nil {
return err
}
var buf bytes.Buffer
if err := tpl.Execute(&buf, sr); err != nil {
return err
}
formatted := helpers.FormatSourceOrWarn(filePath, buf.Bytes())
return os.WriteFile(filePath, formatted, 0644)
}
// WriteActionResource генерирует action-ресурс (почти не используется).
func WriteActionResource(outDir string, act types.GenAction) error {
name := fmt.Sprintf("%s_%s", act.ServiceName, act.ActionName)
fileName := fmt.Sprintf("%d_%s_action.go", act.ServiceID, name)
filePath := filepath.Join(outDir, fileName)
tpl, err := template.New("action").Funcs(template.FuncMap{
"ToCamel": helpers.ToCamel,
"ToSnake": helpers.ToSnake,
"ParamType": helpers.ParamType,
"ParamDefaultExpr": helpers.ParamDefaultExpr,
"ParamFormat": helpers.ParamFormat,
"ParamParse": helpers.ParamParse,
"ParamDescription": helpers.ParamDescription,
"bt": func() string { return "`" },
}).Parse(templates.Action)
if err != nil {
return err
}
var buf bytes.Buffer
if err := tpl.Execute(&buf, act); err != nil {
return err
}
formatted := helpers.FormatSourceOrWarn(filePath, buf.Bytes())
return os.WriteFile(filePath, formatted, 0644)
}
// WriteRegistry генерирует registry.go со списком всех ресурсов.
func WriteRegistry(outDir string, services []types.GenResource, subs []types.GenSubresource, actions []types.GenAction) error {
var buf bytes.Buffer
buf.WriteString("package resources_gen\n\n")
buf.WriteString("import \"github.com/hashicorp/terraform-plugin-framework/resource\"\n\n")
buf.WriteString("// Code generated by tools/gen_v2. DO NOT EDIT.\n")
buf.WriteString("func AllResources() []func() resource.Resource {\n")
buf.WriteString("\treturn []func() resource.Resource{\n")
for _, svc := range services {
buf.WriteString(fmt.Sprintf("\t\tNew%[1]sResource,\n", helpers.ToCamel(svc.Name)))
}
for _, sr := range subs {
buf.WriteString(fmt.Sprintf("\t\tNew%[1]sResource,\n", helpers.ToCamel(sr.ServiceName+"_"+sr.SubName)))
}
for _, act := range actions {
buf.WriteString(fmt.Sprintf("\t\tNew%[1]sResource,\n", helpers.ToCamel(act.ServiceName+"_"+act.ActionName)))
}
buf.WriteString("\t}\n")
buf.WriteString("}\n")
regPath := filepath.Join(outDir, "registry.go")
formatted := helpers.FormatSourceOrWarn(regPath, buf.Bytes())
return os.WriteFile(regPath, formatted, 0644)
}