Аргумент graphql запроса не преобразуетс­я в слайс структур

type Product struct {
    ProductId   int64   `json:"product_id"`
    Name        string  `json:"name"`
    CategoryId  int64   `json:"category_id"`
    BrandId     int64   `json:"brand_id"`
}
type Filter  struct {
    Id      int64   `json:"id"`
    Code    string  `json:"code"`
}
 
// products
var products = []Product{
    {
        ProductId:  18810,
        Name:       "Book",
        CategoryId: 19,
        BrandId:    39,
    },
}

                Resolve: func(p graphql.ResolveParams) (interface{}, error) {
                    p_id, pOk := p.Args["product_id"].(int)
                    filters, filtersOk := p.Args["filters"].([]Filter)
 
                    fmt.Println("->filters: ", filters, "filtersOk: ", filtersOk)
 
                    fmt.Println("->print p.Args[filters]: ", p.Args["filters"])
                    
                    if pOk {
                        product_id := int64(p_id)
                        for _, product := range products {
                            if product.ProductId == product_id {
                                fmt.Println("->Name: ", product.Name, " queryType")
 
                                if len(filters) > 0 {
                                    for _, f := range filters {
                                        if (f.Code == "category" && product.CategoryId == f.Id) && (f.Code == "brand" && product.BrandId == f.Id) {
                                            return product, nil
                                        }
                                    }
                                }
 
 
                            }
                        }
                    }
                    return nil, nil
                },

if (f.Code == "category" && product.CategoryId == f.Id) && (f.Code == "brand" && product.BrandId == f.Id)

import (
    "encoding/json"
    "fmt"
    "log"
    "net/http"
 
    "github.com/graphql-go/graphql"
)
 
type (
    Product struct {
        ProductId  int64  `json:"product_id"`
        Name       string `json:"name"`
        CategoryId int64  `json:"category_id"`
        BrandId    int64  `json:"brand_id"`
    }
 
    Filter struct {
        Id   int64
        Code string
    }
)
 
var products = []Product{
    {
        ProductId:  18810,
        Name:       "Book",
        CategoryId: 19,
        BrandId:    39,
    },
}
 
var productType = graphql.NewObject(graphql.ObjectConfig{
    Name: "Product",
    Fields: graphql.Fields{
        "product_id": &graphql.Field{
            Type: graphql.Int,
        },
        "name": &graphql.Field{
            Type: graphql.String,
        },
    },
})
 
var filtersInputType = graphql.NewInputObject(graphql.InputObjectConfig{
    Name: "FiltersInput",
    Fields: graphql.InputObjectConfigFieldMap{
        "id": &graphql.InputObjectFieldConfig{
            Type: graphql.Int,
        },
        "code": &graphql.InputObjectFieldConfig{
            Type: graphql.String,
        },
    },
})
 
var queryType = graphql.NewObject(graphql.ObjectConfig{
    Name: "Query",
    Fields: graphql.Fields{
        //http://localhost:8000/graphql?query={product(product_id:18810,filters:[{code:"category",id:19},{code:"brand",id:39}]){product_id,name}}
        "product": &graphql.Field{
            Type:        productType,
            Description: "Get product by product_id",
            Args: graphql.FieldConfigArgument{
                "product_id": &graphql.ArgumentConfig{
                    Type: graphql.Int,
                },
                "filters": &graphql.ArgumentConfig{
                    Type: graphql.NewList(filtersInputType),
                },
            },
            Resolve: func(p graphql.ResolveParams) (_ interface{}, err error) {
                var productId int64
                if productId, err = ProductId(p.Args); err != nil {
                    return nil, err
                }
 
                var filters []Filter
                if filters, err = Filters(p.Args); err != nil {
                    return nil, err
                }
 
                log.Println("-> productId:", productId, ", filters:", filters)
 
                for _, product := range products {
                    if product.ProductId != productId {
                        continue
                    }
 
                    if MatchFilters(&product, filters) {
                        return product, nil
                    }
                }
 
                return nil, nil
            },
        },
    },
})
 
func MatchFilters(p *Product, filters []Filter) bool {
    for _, f := range filters {
        if f.Code == "category" && p.CategoryId != f.Id {
            return false
        }
 
        if f.Code == "brand" && p.BrandId != f.Id {
            return false
        }
    }
 
    return true
}
 
func ProductId(args map[string]interface{}) (int64, error) {
    var pID, pOk = args["product_id"].(int)
    if !pOk {
        return 0, fmt.Errorf("product_id is not an int: %+v", args["product_id"])
    }
    return int64(pID), nil
}
 
func Filters(args map[string]interface{}) ([]Filter, error) {
    slice, ok := args["filters"].([]interface{})
    if !ok {
        return nil, fmt.Errorf("filters are not a slice: %+v", args["filters"])
    }
 
    var filters = make([]Filter, len(slice))
 
    for i, item := range slice {
        dict, ok := item.(map[string]interface{})
        if !ok {
            return nil, fmt.Errorf("filter is not a map: %+v", dict)
        }
 
        id, ok := dict["id"].(int)
        if !ok {
            return nil, fmt.Errorf("filter.id is not an int: %+v", dict["id"])
        }
 
        code, ok := dict["code"].(string)
        if !ok {
            return nil, fmt.Errorf("filter.code is not a string: %+v", dict["code"])
        }
 
        filters[i] = Filter{
            Id:   int64(id),
            Code: code,
        }
    }
 
    return filters, nil
}
 
var schema, _ = graphql.NewSchema(
    graphql.SchemaConfig{
        Query: queryType,
    },
)
 
func executeQuery(query string, schema graphql.Schema) *graphql.Result {
    result := graphql.Do(graphql.Params{
        Schema:        schema,
        RequestString: query,
    })
 
    return result
}
 
func Start() {
    http.HandleFunc("/graphql", func(w http.ResponseWriter, r *http.Request) {
        var requestData = r.URL.Query().Get("query")
 
        var result = executeQuery(requestData, schema)
 
        if err := json.NewEncoder(w).Encode(result); err != nil {
            log.Println(err)
        }
    })
 
    log.Println("Server is running on port 8000")
    log.Fatalln(http.ListenAndServe(":8000", nil))
}