feat: Generate enable feature pairs (#998)

Signed-off-by: Xuanwo <[email protected]>

definitions/gen_pair.go

@@ -23,8 +23,19 @@ func GeneratePair(path string) {
 
 %s %s`, pname, v.Name, pname, v.Description)
 		xfn := f.NewFunction("With" + pname)
-		xfn.AddParameter("v", v.Type.FullName("pairs"))
 		xfn.AddResult("p", "types.Pair")
+
+		// If value type is bool, we don't need to accept parameters.
+		if v.Type.Name == "bool" {
+			xfn.AddBody(
+				gg.Return(
+					gg.Value("types.Pair").
+						AddField("Key", gg.Lit(v.Name)).
+						AddField("Value", "true")))
+			continue
+		}
+
+		xfn.AddParameter("v", v.Type.FullName("pairs"))
 		xfn.AddBody(
 			gg.Return(
 				gg.Value("types.Pair").

definitions/gen_service.go

@@ -419,8 +419,7 @@ func (gs *genService) generateFactory() {
 	newStorager := f.NewFunction("NewStorager").
 		WithReceiver("f", "*Factory").
 		AddResult("sto", "types.Storager").
-		AddResult("err", "error").
-		AddBody()
+		AddResult("err", "error")
 	if gs.data.Storage == nil {
 		newStorager.AddBody(`return nil, errors.New("storager not implemented")`)
 	} else if !gs.implemented[NamespaceFactory]["new_storage"] {
@@ -433,6 +432,36 @@ func (gs *genService) generateFactory() {
 	} else {
 		newStorager.AddBody("return f.newStorage()")
 	}
+
+	serviceFeatures := f.NewFunction("serviceFeatures").
+		WithReceiver("f", "*Factory").
+		AddResult("s", "types.ServiceFeatures")
+	for _, op := range gs.data.Service.Operations() {
+		if gs.data.Service.HasFeature(op.Name) {
+			serviceFeatures.AddBody(gg.S("s.%s = true", templateutils.ToPascal(op.Name)))
+		}
+	}
+	for _, fe := range gs.data.Service.VirtualFeatures() {
+		serviceFeatures.AddBody(
+			gg.If("f." + templateutils.ToPascal("enable_"+fe.Name)).AddBody(
+				gg.S("s.%s = true", templateutils.ToPascal(fe.Name))))
+	}
+	serviceFeatures.AddBody(gg.Return())
+
+	storageFeatures := f.NewFunction("storageFeatures").
+		WithReceiver("f", "*Factory").
+		AddResult("s", "types.StorageFeatures")
+	for _, op := range gs.data.Storage.Operations() {
+		if gs.data.Storage.HasFeature(op.Name) {
+			storageFeatures.AddBody(gg.S("s.%s = true", templateutils.ToPascal(op.Name)))
+		}
+	}
+	for _, fe := range gs.data.Storage.VirtualFeatures() {
+		storageFeatures.AddBody(
+			gg.If("f." + templateutils.ToPascal("enable_"+fe.Name)).AddBody(
+				gg.S("s.%s = true", templateutils.ToPascal(fe.Name))))
+	}
+	storageFeatures.AddBody(gg.Return())
 }
 
 func (gs *genService) generateFunctionPairs(ns Namespace, op Operation) {

definitions/metadata.go

@@ -13,6 +13,7 @@ type Metadata struct {
 
 func (m Metadata) Normalize() Metadata {
 	m.buildDefaultPairs()
+	m.buildFeaturePairs()
 	return m
 }
 
@@ -31,3 +32,16 @@ func (m *Metadata) buildDefaultPairs() {
 	m.Pairs = append(m.Pairs, dp...)
 	m.Factory = append(m.Factory, dp...)
 }
+
+func (m *Metadata) buildFeaturePairs() {
+	dp := make(map[string]bool)
+	for _, v := range []Namespace{m.Service, m.Storage} {
+		for _, f := range v.VirtualFeatures() {
+			dp["enable_"+f.Name] = true
+		}
+	}
+
+	for name := range dp {
+		m.Factory = append(m.Factory, PairMap[name])
+	}
+}

definitions/namespace.go

@@ -4,6 +4,7 @@ type Namespace interface {
 	Name() string
 	Operations() []Operation
 	HasFeature(name string) bool
+	VirtualFeatures() []Feature
 	ListPairs(name string) []Pair
 }
 
@@ -19,6 +20,17 @@ func (s Service) HasFeature(name string) bool {
 	return s.Features.Has(name)
 }
 
+func (s Service) VirtualFeatures() []Feature {
+	fs := make([]Feature, 0)
+
+	for _, f := range FeaturesArray {
+		if f.HasNamespace(NamespaceService) && s.Features.Has(f.Name) {
+			fs = append(fs, f)
+		}
+	}
+	return SortFeatures(fs)
+}
+
 func (s Storage) Name() string {
 	return NamespaceStorage
 }
@@ -30,3 +42,14 @@ func (s Storage) Operations() []Operation {
 func (s Storage) HasFeature(name string) bool {
 	return s.Features.Has(name)
 }
+
+func (s Storage) VirtualFeatures() []Feature {
+	fs := make([]Feature, 0)
+
+	for _, f := range FeaturesArray {
+		if f.HasNamespace(NamespaceStorage) && s.Features.Has(f.Name) {
+			fs = append(fs, f)
+		}
+	}
+	return SortFeatures(fs)
+}

definitions/pairs.go

@@ -52,6 +52,19 @@ func init() {
 	}
 	PairArray = append(PairArray, dps...)
 
+	// Build feature pairs.
+	fps := make([]Pair, 0)
+	for _, f := range FeaturesArray {
+		fps = append(fps, Pair{
+			Name:        "enable_" + f.Name,
+			Type:        Type{Name: "bool"},
+			Description: "Enable feature " + f.Name,
+			global:      true,
+		})
+	}
+	PairArray = append(PairArray, fps...)
+
+	// Setup maps.
 	for _, v := range PairArray {
 		PairMap[v.Name] = v
 	}