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

2026-07-05 09:03:16 +04:00
parent 703bac4bc4
commit e8935f1ebf
8 changed files with 3366 additions and 1050 deletions
@@ -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
+}
+