refactor(schema)!: collect all types in ModuleSchema (#21036)

schema/decoding/decoding_test.go

@@ -366,8 +366,9 @@ func (e exampleBankModule) subBalance(acct, denom string, amount uint64) error {
 	return nil
 }
 
-var exampleBankSchema = schema.ModuleSchema{
-	ObjectTypes: []schema.ObjectType{
+func init() {
+	var err error
+	exampleBankSchema, err = schema.NewModuleSchema([]schema.ObjectType{
 		{
 			Name: "balances",
 			KeyFields: []schema.Field{
@@ -387,9 +388,14 @@ var exampleBankSchema = schema.ModuleSchema{
 				},
 			},
 		},
-	},
+	})
+	if err != nil {
+		panic(err)
+	}
 }
 
+var exampleBankSchema schema.ModuleSchema
+
 func (e exampleBankModule) ModuleCodec() (schema.ModuleCodec, error) {
 	return schema.ModuleCodec{
 		Schema: exampleBankSchema,
@@ -426,17 +432,25 @@ type oneValueModule struct {
 	store *testStore
 }
 
-var oneValueModSchema = schema.ModuleSchema{
-	ObjectTypes: []schema.ObjectType{
-		{
-			Name: "item",
-			ValueFields: []schema.Field{
-				{Name: "value", Kind: schema.StringKind},
+func init() {
+	var err error
+	oneValueModSchema, err = schema.NewModuleSchema(
+		[]schema.ObjectType{
+			{
+				Name: "item",
+				ValueFields: []schema.Field{
+					{Name: "value", Kind: schema.StringKind},
+				},
 			},
 		},
-	},
+	)
+	if err != nil {
+		panic(err)
+	}
 }
 
+var oneValueModSchema schema.ModuleSchema
+
 func (i oneValueModule) ModuleCodec() (schema.ModuleCodec, error) {
 	return schema.ModuleCodec{
 		Schema: oneValueModSchema,

schema/decoding/resolver_test.go

@@ -10,16 +10,24 @@ import (
 type modA struct{}
 
 func (m modA) ModuleCodec() (schema.ModuleCodec, error) {
+	modSchema, err := schema.NewModuleSchema([]schema.ObjectType{{Name: "A", KeyFields: []schema.Field{{Name: "field1", Kind: schema.StringKind}}}})
+	if err != nil {
+		return schema.ModuleCodec{}, err
+	}
 	return schema.ModuleCodec{
-		Schema: schema.ModuleSchema{ObjectTypes: []schema.ObjectType{{Name: "A"}}},
+		Schema: modSchema,
 	}, nil
 }
 
 type modB struct{}
 
 func (m modB) ModuleCodec() (schema.ModuleCodec, error) {
+	modSchema, err := schema.NewModuleSchema([]schema.ObjectType{{Name: "B", KeyFields: []schema.Field{{Name: "field2", Kind: schema.StringKind}}}})
+	if err != nil {
+		return schema.ModuleCodec{}, err
+	}
 	return schema.ModuleCodec{
-		Schema: schema.ModuleSchema{ObjectTypes: []schema.ObjectType{{Name: "B"}}},
+		Schema: modSchema,
 	}, nil
 }
 
@@ -36,7 +44,13 @@ var testResolver = ModuleSetDecoderResolver(moduleSet)
 func TestModuleSetDecoderResolver_IterateAll(t *testing.T) {
 	objectTypes := map[string]bool{}
 	err := testResolver.IterateAll(func(moduleName string, cdc schema.ModuleCodec) error {
-		objectTypes[cdc.Schema.ObjectTypes[0].Name] = true
+		cdc.Schema.Types(func(t schema.Type) bool {
+			objTyp, ok := t.(schema.ObjectType)
+			if ok {
+				objectTypes[objTyp.Name] = true
+			}
+			return true
+		})
 		return nil
 	})
 	if err != nil {
@@ -66,8 +80,9 @@ func TestModuleSetDecoderResolver_LookupDecoder(t *testing.T) {
 		t.Fatalf("expected to find decoder for modA")
 	}
 
-	if decoder.Schema.ObjectTypes[0].Name != "A" {
-		t.Fatalf("expected object type A, got %s", decoder.Schema.ObjectTypes[0].Name)
+	_, ok := decoder.Schema.LookupType("A")
+	if !ok {
+		t.Fatalf("expected object type A")
 	}
 
 	decoder, found, err = testResolver.LookupDecoder("modB")
@@ -79,8 +94,9 @@ func TestModuleSetDecoderResolver_LookupDecoder(t *testing.T) {
 		t.Fatalf("expected to find decoder for modB")
 	}
 
-	if decoder.Schema.ObjectTypes[0].Name != "B" {
-		t.Fatalf("expected object type B, got %s", decoder.Schema.ObjectTypes[0].Name)
+	_, ok = decoder.Schema.LookupType("B")
+	if !ok {
+		t.Fatalf("expected object type B")
 	}
 
 	decoder, found, err = testResolver.LookupDecoder("modC")