refactor(gen_v2): split into 7 files by concern (types, loader, params, writers, helpers, templates, main)

universal_rebuild/tools/gen_v2/helpers.go

@@ -0,0 +1,176 @@
+// helpers — конвертация имён, форматирование, plan-модификаторы.
+package main
+
+import (
+	"fmt"
+	"go/format"
+	"os"
+	"strings"
+	"unicode"
+)
+
+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 {
+			continue
+		}
+		parts[i] = strings.ToUpper(p[:1]) + p[1:]
+	}
+	out := strings.Join(parts, "")
+	return ensureGoIdent(out)
+}
+
+func toSnake(s string) string {
+	var out []rune
+	for i, r := range s {
+		if i > 0 && r >= 'A' && r <= 'Z' {
+			out = append(out, '_')
+		}
+		out = append(out, rune(strings.ToLower(string(r))[0]))
+	}
+	return string(out)
+}
+
+func paramType(p Param) string {
+	switch strings.ToLower(p.Type) {
+	case "bool":
+		return "types.Bool"
+	case "int", "int64", "number":
+		return "types.Int64"
+	default:
+		return "types.String"
+	}
+}
+
+func paramDefaultExpr(p Param) string {
+	if p.Default == "" {
+		return ""
+	}
+	switch strings.ToLower(p.Type) {
+	case "bool":
+		val := strings.ToLower(p.Default)
+		return fmt.Sprintf("booldefault.StaticBool(%s)", val)
+	case "int", "int64", "number":
+		return fmt.Sprintf("int64default.StaticInt64(%s)", p.Default)
+	default:
+		return fmt.Sprintf("stringdefault.StaticString(%q)", p.Default)
+	}
+}
+
+func paramFormat(p Param, varName string) string {
+	switch strings.ToLower(p.Type) {
+	case "bool":
+		return fmt.Sprintf("resources_core.FormatBool(%s)", varName)
+	case "int", "int64", "number":
+		return fmt.Sprintf("resources_core.FormatInt64(%s)", varName)
+	default:
+		return fmt.Sprintf("resources_core.FormatString(%s)", varName)
+	}
+}
+
+func paramParse(p Param) string {
+	switch strings.ToLower(p.Type) {
+	case "bool":
+		return "resources_core.ParseBool"
+	case "int", "int64", "number":
+		return "resources_core.ParseInt64"
+	default:
+		return "resources_core.ParseString"
+	}
+}
+
+func paramDescription(p Param) string {
+	var desc string
+	if strings.TrimSpace(p.Descr) != "" {
+		desc = strings.TrimSpace(p.Descr)
+	} else if strings.TrimSpace(p.Man) != "" {
+		desc = strings.TrimSpace(p.Man)
+	} else if p.RefSvcId > 0 {
+		desc = fmt.Sprintf("UI display_name for service_id=%d (mapped to UUID in core)", p.RefSvcId)
+	}
+	if p.CreateOnly {
+		if desc == "" {
+			desc = "Не изменяется после создания."
+		} else {
+			desc = desc + " Не изменяется после создания."
+		}
+	}
+	if p.ForceNew {
+		if desc == "" {
+			desc = "Изменение требует пересоздания."
+		} else {
+			desc = desc + " Изменение требует пересоздания."
+		}
+	}
+	if desc == "" {
+		return ""
+	}
+	return fmt.Sprintf("%q", desc)
+}
+
+func outputParamType(p OutputParam) string {
+	switch strings.ToLower(p.Type) {
+	case "map":
+		return "types.Map"
+	case "list":
+		return "types.List"
+	default:
+		return "types.String"
+	}
+}
+
+func outputParamIsMap(p OutputParam) bool {
+	return strings.EqualFold(strings.TrimSpace(p.Type), "map")
+}
+
+func outputParamIsList(p OutputParam) bool {
+	return strings.EqualFold(strings.TrimSpace(p.Type), "list")
+}
+
+func outputParamSensitive(p OutputParam) bool {
+	return p.Sensitive
+}
+
+func ensureGoIdent(s string) string {
+	if s == "" {
+		return "R"
+	}
+	first := rune(s[0])
+	if unicode.IsLetter(first) || first == '_' {
+		return s
+	}
+	return "R" + s
+}
+
+
+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)
+		return src
+	}
+	return formatted
+}
+
+func planModifierType(p Param) string {
+	switch strings.ToLower(strings.TrimSpace(p.Type)) {
+	case "bool":
+		return "Bool"
+	case "int", "int64", "number":
+		return "Int64"
+	default:
+		return "String"
+	}
+}
+
+func planModifierExpr(p Param) string {
+	switch strings.ToLower(strings.TrimSpace(p.Type)) {
+	case "bool":
+		return "boolplanmodifier.RequiresReplace()"
+	case "int", "int64", "number":
+		return "int64planmodifier.RequiresReplace()"
+	default:
+		return "stringplanmodifier.RequiresReplace()"
+	}
+}

universal_rebuild/tools/gen_v2/loader.go

@@ -0,0 +1,282 @@
+// 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/main.go

@@ -0,0 +1,96 @@
+// generate_resources_v2 — главный генератор Terraform-провайдера Nubes.
+//
+// ⛔ ПОДЧИНЯЕТСЯ devops/ARCHITECTURE.md — все правила генерации прописаны там.
+//
+// Пайплайн: YAML-спеки сервисов → Go-ресурсы + registry.go.
+//
+// На вход: resources_yaml/*.yaml (сгенерированы service_spec_gen из API).
+// На выход: internal/resources_gen/*.go (CRUD-ресурсы, subresource'ы, registry).
+//
+// Три вида ресурсов:
+//   - instance    → nubes_{service}              (основной CRUD инстанса)
+//   - subresource → nubes_{service}_{sub}         (пользователи, базы, ...)
+//   - action      → ТОЛЬКО redeploy встроен как git_revision.
+//                    restart/recovery/reconcile исключены (ARCHITECTURE.md).
+
+package main
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+func main() {
+	root, err := os.Getwd()
+	if err != nil {
+		panic(err)
+	}
+	resourcesDir := strings.TrimSpace(os.Getenv("NUBES_RESOURCES_DIR"))
+	if resourcesDir == "" {
+		resourcesDir = filepath.Join(root, "resources_yaml")
+	}
+	outDir := strings.TrimSpace(os.Getenv("NUBES_RESOURCES_GEN_DIR"))
+	if outDir == "" {
+		outDir = filepath.Join(root, "internal", "resources_gen")
+	}
+
+	instanceResources, subresources, actions, err := loadSpecs(resourcesDir)
+	if err != nil {
+		panic(err)
+	}
+
+	for _, svc := range instanceResources {
+		if err := writeInstanceResource(outDir, svc); err != nil {
+			panic(err)
+		}
+	}
+	for _, sr := range subresources {
+		if err := writeSubresource(outDir, sr); err != nil {
+			panic(err)
+		}
+	}
+	for _, act := range actions {
+		if err := writeActionResource(outDir, act); err != nil {
+			panic(err)
+		}
+	}
+	if err := 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

@@ -0,0 +1,254 @@
+// params — слияние, фильтрация, анализ параметров и ForceNew.
+package main
+
+import (
+	"sort"
+	"strings"
+)
+
+func mergeParams(sets ...[]Param) []Param {
+	seen := map[string]Param{}
+	for _, s := range sets {
+		for _, p := range s {
+			key := strings.ToLower(strings.TrimSpace(p.Code))
+			if key == "" {
+				continue
+			}
+			if _, ok := seen[key]; !ok {
+				seen[key] = p
+			}
+		}
+	}
+	out := make([]Param, 0, len(seen))
+	for _, p := range seen {
+		out = append(out, p)
+	}
+	sort.Slice(out, func(i, j int) bool { return out[i].Code < out[j].Code })
+	return out
+}
+
+func alignParamTypes(params []Param, schema []Param) []Param {
+	if len(params) == 0 || len(schema) == 0 {
+		return params
+	}
+	codeType := make(map[string]string, len(schema))
+	for _, p := range schema {
+		key := strings.ToLower(strings.TrimSpace(p.Code))
+		if key == "" {
+			continue
+		}
+		if strings.TrimSpace(p.Type) != "" {
+			codeType[key] = p.Type
+		}
+	}
+	if len(codeType) == 0 {
+		return params
+	}
+
+	for i, p := range params {
+		key := strings.ToLower(strings.TrimSpace(p.Code))
+		if key == "" {
+			continue
+		}
+		if t, ok := codeType[key]; ok && strings.TrimSpace(t) != "" {
+			params[i].Type = t
+		}
+	}
+
+	return params
+}
+
+func computeCreateOnly(createParams []Param, modifyParams []Param) map[string]struct{} {
+	modifyCodes := make(map[string]struct{}, len(modifyParams))
+	for _, p := range modifyParams {
+		key := strings.ToLower(strings.TrimSpace(p.Code))
+		if key == "" {
+			continue
+		}
+		modifyCodes[key] = struct{}{}
+	}
+
+	createOnly := make(map[string]struct{})
+	for _, p := range createParams {
+		key := strings.ToLower(strings.TrimSpace(p.Code))
+		if key == "" {
+			continue
+		}
+		if _, ok := modifyCodes[key]; !ok {
+			createOnly[key] = struct{}{}
+		}
+	}
+
+	return createOnly
+}
+
+func markCreateOnly(schema []Param, createOnly map[string]struct{}) []Param {
+	if len(schema) == 0 || len(createOnly) == 0 {
+		return schema
+	}
+
+	for i, p := range schema {
+		key := strings.ToLower(strings.TrimSpace(p.Code))
+		if key == "" {
+			continue
+		}
+		if _, ok := createOnly[key]; ok {
+			schema[i].CreateOnly = true
+		}
+	}
+
+	return schema
+}
+
+func filterCreateOnly(schema []Param) []Param {
+	if len(schema) == 0 {
+		return []Param{}
+	}
+
+	result := make([]Param, 0, len(schema))
+	for _, p := range schema {
+		if p.CreateOnly {
+			result = append(result, p)
+		}
+	}
+	return result
+}
+
+func filterCreateOnlyRequired(schema []Param) []Param {
+	if len(schema) == 0 {
+		return []Param{}
+	}
+
+	result := make([]Param, 0, len(schema))
+	for _, p := range schema {
+		if p.CreateOnly && p.Required {
+			result = append(result, p)
+		}
+	}
+	return result
+}
+
+func analyzeParams(usesBool *bool, usesInt64 *bool, usesString *bool, hasDefaults *bool, needsBoolDefault *bool, needsInt64Default *bool, needsStringDefault *bool, params []Param) {
+	for _, p := range params {
+		switch strings.ToLower(p.Type) {
+		case "bool":
+			*usesBool = true
+			if p.Default != "" {
+				*needsBoolDefault = true
+				*hasDefaults = true
+			}
+		case "int", "int64", "number":
+			*usesInt64 = true
+			if p.Default != "" {
+				*needsInt64Default = true
+				*hasDefaults = true
+			}
+		default:
+			*usesString = true
+			if p.Default != "" {
+				*needsStringDefault = true
+				*hasDefaults = true
+			}
+		}
+	}
+}
+
+
+func buildSubresourceForceNewCodes(sr *GenSubresource, createOnly map[string]struct{}) map[string]struct{} {
+	forceNew := map[string]struct{}{}
+	if sr.ModifyOpName == "" {
+		for _, p := range sr.SchemaParams {
+			key := strings.ToLower(strings.TrimSpace(p.Code))
+			if key != "" {
+				forceNew[key] = struct{}{}
+			}
+		}
+		return forceNew
+	}
+	for key := range createOnly {
+		forceNew[key] = struct{}{}
+	}
+	for _, p := range sr.DeleteParams {
+		key := strings.ToLower(strings.TrimSpace(p.Code))
+		if key != "" {
+			forceNew[key] = struct{}{}
+		}
+	}
+	return forceNew
+}
+
+func markForceNew(params []Param, forceNew map[string]struct{}) []Param {
+	if len(params) == 0 || len(forceNew) == 0 {
+		return params
+	}
+	for i, p := range params {
+		key := strings.ToLower(strings.TrimSpace(p.Code))
+		if key == "" {
+			continue
+		}
+		if _, ok := forceNew[key]; ok {
+			params[i].ForceNew = true
+		}
+	}
+	return params
+}
+
+func filterForceNew(params []Param) []Param {
+	result := []Param{}
+	for _, p := range params {
+		if p.ForceNew {
+			result = append(result, p)
+		}
+	}
+	return result
+}
+
+// analyzeJsonPlanMod возвращает true, если хотя бы один параметр является JSON-строкой.
+// Используется для условного добавления импорта planmodifier в сгенерированные файлы.
+func analyzeJsonPlanMod(params []Param) bool {
+	for _, p := range params {
+		if p.IsJson {
+			return true
+		}
+	}
+	return false
+}
+
+// hasRestoreCasingParams возвращает true, если есть ref_svc params с RefSvcId > 0 && != 12
+// (restore-casing блок в Create/Read/Update использует strings.EqualFold для них).
+func hasRestoreCasingParams(params []Param) bool {
+	for _, p := range params {
+		if p.RefSvcId > 0 && p.RefSvcId != 12 && strings.EqualFold(strings.TrimSpace(p.Type), "string") {
+			return true
+		}
+	}
+	return false
+}
+
+// analyzeNeedsStrings возвращает true, если среди params есть хотя бы один строковый параметр.
+// Используется для условного добавления импорта "strings" (EqualFold в Update).
+func analyzeNeedsStrings(params []Param) bool {
+	for _, p := range params {
+		t := strings.ToLower(strings.TrimSpace(p.Type))
+		if t != "bool" && t != "int" && t != "int64" && t != "number" {
+			return true
+		}
+	}
+	return false
+}
+
+func analyzePlanModifiers(needsBool *bool, needsInt64 *bool, needsString *bool, params []Param) {
+	for _, p := range params {
+		if !p.ForceNew {
+			continue
+		}
+		switch strings.ToLower(strings.TrimSpace(p.Type)) {
+		case "bool":
+			*needsBool = true
+		case "int", "int64", "number":
+			*needsInt64 = true
+		default:
+			*needsString = true
+		}
+	}
+}

universal_rebuild/tools/gen_v2/types.go

@@ -0,0 +1,153 @@
+// types — структуры данных для генератора Terraform-провайдера.
+package main
+
+
+// ─── Входные структуры (из YAML) ───────────────────────────────────────────
+
+// ParamSpec — один параметр операции как он описан в YAML.
+// Соответствует cfsParam из API Nubes.
+type ParamSpec struct {
+	ID        int         `yaml:"id"`                     // svcOperationCfsParamId
+	Code      string      `yaml:"code"`                   // имя параметра (camelCase)
+	DataType  string      `yaml:"data_type,omitempty"`    // string | integer > 0 | boolean | map-fixed | uuid | json | ...
+	Required  bool        `yaml:"required"`               // обязательный?
+	Default   interface{} `yaml:"default,omitempty"`      // значение по умолчанию (строка или число)
+	RefSvcId  *int        `yaml:"ref_svc_id,omitempty"`   // ссылка на другой сервис (UUID-параметр)
+	Descr     string      `yaml:"descr,omitempty"`        // описание
+	Man       string      `yaml:"man,omitempty"`          // MAN-руководство
+	Sensitive bool        `yaml:"is_sensitive,omitempty"` // секретный параметр?
+}
+
+// OutputParam — выходной параметр сервиса (state_params, vault_secrets, ...).
+type OutputParam struct {
+	Code      string `yaml:"code"`                // код: state_params, state_out, vault_url, ...
+	Type      string `yaml:"type"`                // map | string | list
+	Sensitive bool   `yaml:"sensitive,omitempty"` // vault_secrets = true
+}
+
+// OperationSpec — одна операция сервиса (create, modify, delete_user, ...).
+type OperationSpec struct {
+	Name        string      `yaml:"name"`                  // имя операции (create, modify, ...)
+	ID          int         `yaml:"id"`                    // svcOperationId
+	Kind        string      `yaml:"kind"`                  // instance | subresource | action
+	Action      string      `yaml:"action"`                // create | modify | delete | suspend | redeploy | ...
+	Subresource string      `yaml:"subresource,omitempty"` // для subresource: user, database, topic, ...
+	Man         string      `yaml:"man,omitempty"`         // MAN-руководство операции
+	Params      []ParamSpec `yaml:"params"`                // параметры операции
+}
+
+// ServiceSpec — полная YAML-спецификация одного сервиса.
+type ServiceSpec struct {
+	Name      string `yaml:"name"`       // snake_case имя (postgres, s3bucket, ...)
+	ServiceID int    `yaml:"service_id"` // числовой ID сервиса в Nubes
+	Outputs   struct {
+		Params []OutputParam `yaml:"params"`
+	} `yaml:"outputs"`
+	Lifecycle struct {
+		SuspendOnDestroyDefault      *bool `yaml:"suspend_on_destroy_default"`
+		AdoptExistingOnCreateDefault *bool `yaml:"adopt_existing_on_create_default"`
+	} `yaml:"lifecycle"`
+	Operations []OperationSpec `yaml:"operations"`
+}
+
+type Param struct {
+	ID         int
+	Code       string
+	Type       string
+	Required   bool
+	Default    string
+	RefSvcId   int
+	Descr      string
+	Man        string
+	Sensitive  bool
+	CreateOnly bool
+	ForceNew   bool
+	// IsJson — атрибут является JSON-строкой (data_type: json в YAML-спеке).
+	// При IsJson=true в схему добавляется JsonNormalize план-модификатор,
+	// чтобы план и API-ответ (компактный JSON) всегда совпадали.
+	IsJson bool
+}
+
+type GenResource struct {
+	Name                     string
+	ServiceID                int
+	CreateParams             []Param
+	ModifyParams             []Param
+	SchemaParams             []Param
+	CreateOnlyParams         []Param
+	CreateOnlyRequiredParams []Param
+	OutputParams             []OutputParam
+	HasRefSvcParams          bool
+	SupportsSuspendDestroy   bool
+	SuspendOnDestroy         bool
+	AdoptExistingOnCreate    bool
+	UsesBool                 bool
+	UsesInt64                bool
+	UsesString               bool
+	HasDefaults              bool
+	NeedsBoolDefault         bool
+	NeedsInt64Default        bool
+	NeedsStringDefault       bool
+	HasDomainParam           bool
+	DomainServiceIDs         []int
+	// HasRedeploy: сервис поддерживает redeploy (пересборка из git).
+	// Если true — в основной ресурс добавляется поле git_revision.
+	// При изменении git_revision вызывается redeploy вместо modify.
+	// Правило из ARCHITECTURE.md: только redeploy включается как inline action.
+	// restart, recovery, reconcile — исключены (ручные операции, только UI).
+	HasRedeploy bool
+	// NeedsJsonPlanMod: хотя бы один атрибут имеет data_type: json.
+	// Управляет добавлением импорта planmodifier в сгенерированный файл.
+	NeedsJsonPlanMod bool
+	// NeedsStringsImport: есть строковые ModifyParams (нужен EqualFold в Update).
+	NeedsStringsImport bool
+}
+
+type GenSubresource struct {
+	ServiceName        string
+	ServiceID          int
+	SubName            string
+	CreateOpName       string
+	ModifyOpName       string
+	DeleteOpName       string
+	CreateParams       []Param
+	ModifyParams       []Param
+	DeleteParams       []Param
+	SchemaParams       []Param
+	IdentityParams     []Param
+	HasRefSvcParams    bool
+	UsesBool           bool
+	UsesInt64          bool
+	UsesString         bool
+	HasDefaults        bool
+	NeedsBoolDefault   bool
+	NeedsInt64Default  bool
+	NeedsStringDefault bool
+	NeedsBoolPlanMod   bool
+	NeedsInt64PlanMod  bool
+	NeedsStringPlanMod bool
+	// NeedsJsonPlanMod: хотя бы один атрибут имеет IsJson=true.
+	NeedsJsonPlanMod bool
+	// NeedsStringsImport: есть строковые ModifyParams (нужен EqualFold в Update).
+	NeedsStringsImport bool
+}
+
+type GenAction struct {
+	ServiceName        string
+	ServiceID          int
+	ActionName         string
+	OperationName      string
+	Params             []Param
+	SchemaParams       []Param
+	UsesBool           bool
+	UsesInt64          bool
+	UsesString         bool
+	HasDefaults        bool
+	NeedsBoolDefault   bool
+	NeedsInt64Default  bool
+	NeedsStringDefault bool
+	// NeedsJsonPlanMod: хотя бы один атрибут имеет IsJson=true.
+	NeedsJsonPlanMod bool
+	// NeedsStringsImport: есть строковые SchemaParams (нужен EqualFold).
+	NeedsStringsImport bool
+}

universal_rebuild/tools/gen_v2/writers.go

@@ -0,0 +1,128 @@
+// 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)
+}
+