Hinzufügen von Filterabfrageparametern in Go Huma

Nach allem, was ich herausfinden konnte, unterstützt Huma leider keine Array-Abfragefilter wie diesen: filter[]=filter1&filters[]=filter2 (ohne die Klammern wegzulassen, z. B. filter=filter1&filter=filter2). Ich bin auf dieses Github-Problem gestoßen, das ein Beispiel für die Trennung der Filter durch Kommas gibt: https://github.com/danielgtaylor/huma/issues/325, also haben wir am Ende Folgendes gemacht: filter=postcode:eq:RM7(EX, erstellt:gt:2024-01-01

Filter dokumentieren

Im Gegensatz zu den Body-Parametern, die man einfach als Strukturen angeben kann und die dann sowohl validiert als auch in der Dokumentation generiert werden, muss die Dokumentation und Validierung für Filter separat erfolgen.

Die Dokumentation kann einfach unter dem Beschreibungsattribut des Huma.Param-Objekts (unter Operation) hinzugefügt werden:

Parameters: []*huma.Param{{
            Name: "filters",
            In:   "query",
            Description: "Filter properties by various fields. Separate filters by comma.\n\n" +
                "Format: field:operator:value\n\n" +
                "Supported fields:\n" +
                "- postcode (operator: eq)\n" +
                "- created (operators: gt, lt, gte, lte)\n",
            Schema: &huma.Schema{
                Type: "string",
                Items: &huma.Schema{
                    Type:    "string",
                    Pattern: "^[a-zA-Z_]+:(eq|neq|gt|lt|gte|lte):[a-zA-Z0-9-:.]+$",
                },
                Examples: []any{
                    "postcode:eq:RM7 8EX",
                    "created:gt:2024-01-01",
                },
            },
            Required: false,
        }},

Wir können jetzt unsere PropertyFilterParams-Struktur zur Validierung definieren:

type FilterParam struct {
    Field    string
    Operator string
    Value    interface{}
}

type PropertyFilterParams struct {
    Items []FilterParam
}

func (s *PropertyFilterParams) UnmarshalText(text []byte) error {
    equalityFields := []string{"postcode"}
    greaterSmallerFields := []string{}
    dateFields := []string{"created"}

    for _, item := range strings.Split(string(text), ",") {
        filterParam, err := parseAndValidateFilterItem(item, equalityFields, greaterSmallerFields, dateFields)
        if err != nil {
            return err
        }
        s.Items = append(s.Items, filterParam)
    }

    return nil
}

func (s *PropertyFilterParams) Schema(registry huma.Registry) *huma.Schema {
    return &huma.Schema{
        Type: huma.TypeString,
    }
}

func parseAndValidateFilterItem(item string, equalityFields []string, greaterSmallerFields []string, dateFields []string) (FilterParam, error) {
    parts := strings.SplitN(item, ":", 3)

    field := parts[0]
    operator := parts[1]
    value := parts[2]

    if contains(equalityFields, field) {
        if operator != "eq" && operator != "neq" {
            return FilterParam{}, fmt.Errorf("Unsupported operator %s for field %s. Only 'eq' and 'neq' are supported.", operator, field)
        }
    } else if contains(greaterSmallerFields, field) {
        if !validation.IsValidCompareGreaterSmallerOperator(operator) {
            return FilterParam{}, fmt.Errorf("Unsupported operator %s for field %s. Supported operators: eq, neq, gt, lt, gte, lte.", operator, field)
        }
    } else if contains(dateFields, field) {
        if !validation.IsValidCompareGreaterSmallerOperator(operator) {
            return FilterParam{}, fmt.Errorf("Unsupported operator %s for field %s. Supported operators: eq, neq, gt, lt, gte, lte.", operator, field)
        }
        if !validation.IsValidDate(value) {
            return FilterParam{}, fmt.Errorf("Invalid date format: %s. Expected: YYYY-MM-DD", value)
        }
    } else {
        return FilterParam{}, fmt.Errorf("Unsupported filter field: %s", field)
    }

    return FilterParam{Field: field, Operator: operator, Value: value}, nil
}

Ich habe PropertyFilterParams zur PropertyQueryParams-Struktur hinzugefügt:

type PropertyQueryParams struct {
    PaginationParams
    Filter PropertyFilterParams `query:"filters" doc:"Filter properties by various fields"`
    Sort   PropertySortParams   `query:"sorts" doc:"Sort properties by various fields"`
}

So sieht das Hinzufügen von PropertyQueryParams zur Route aus (beachten Sie, dass sich der Operationscode selbst, einschließlich der Filterbeschreibung, unter getAllPropertyOperation befindet – ich habe dafür nicht den vollständigen Code eingefügt, aber hoffentlich verstehen Sie das Wesentliche) . Wenn die Validierung fehlschlägt, wird eine 422-Antwort ausgegeben. Ich habe auch hinzugefügt, wie wir die übergebenen Filterwerte durchlaufen können:

huma.Register(api, getAllPropertyOperation(schema, "get-properties", "/properties", []string{"Properties"}),
        func(ctx context.Context, input *struct {
            models.Headers
            models.PropertyQueryParams
        }) (*models.MultiplePropertyOutput, error) {

            for _, filter := range input.Filter.Items {
                fmt.Println(filter)
            }

            return mockMultiplePropertyResponse(), err
        })
}

Ich hoffe, das hilft jemandem. Lassen Sie mich in den Kommentaren wissen, wenn Sie eine bessere Lösung gefunden haben.

Das obige ist der detaillierte Inhalt vonHinzufügen von Filterabfrageparametern in Go Huma. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!