BunQL

package main

import (
    "context"
    "fmt"
    "github.com/fxnoob/bunql"
    "github.com/uptrace/bun"
    "github.com/uptrace/bun/dialect/sqlitedialect"
    "github.com/uptrace/bun/driver/sqliteshim"
    "database/sql"
)

type User struct {
    bun.BaseModel `bun:"table:users,alias:u"`

    ID        int64  `bun:"id,pk,autoincrement"`
    FirstName string `bun:"first_name"`
    LastName  string `bun:"last_name"`
    Email     string `bun:"email"`
    Age       int    `bun:"age"`
    Active    bool   `bun:"active"`
}

func main() {
    // Connect to database
    sqldb, err := sql.Open(sqliteshim.ShimName, "file::memory:?cache=shared")
    if err != nil {
        panic(err)
    }
    defer sqldb.Close()

    db := bun.NewDB(sqldb, sqlitedialect.New())
    ctx := context.Background()

    // Create table and insert sample data
    db.NewCreateTable().Model((*User)(nil)).Exec(ctx)
    // Insert sample data...

    // Create a filter for users with age > 20
    filterJSON := `{
        "logic": "and",
        "filters": [
            {"field": "age", "operator": "gt", "value": 20}
        ]
    }`

    // Create a sort by last_name
    sortJSON := `[{"field": "last_name", "dir": "asc"}]`

    // Parse the filter and sort JSON
    ql, err := bunql.ParseFromParams(filterJSON, sortJSON, 1, 10)
    if err != nil {
        panic(err)
    }

    // Create a base query
    query := db.NewSelect().Model((*User)(nil))

    // Apply the BunQL filters, sort, and pagination
    query = ql.Apply(ctx, query)

    // Execute the query
    var users []User
    err = query.Scan(ctx, &users)
    if err != nil {
        panic(err)
    }

    // Print results
    for _, user := range users {
        fmt.Printf("%s %s (Age: %d)\n", user.FirstName, user.LastName, user.Age)
    }
}

// Define allowed fields for filtering and sorting
allowedFilterFields := []string{"age", "first_name", "last_name"}
allowedSortFields := []string{"age", "last_name"}

// Parse the filter and sort JSON with allowed fields
ql, err := bunql.ParseFromParamsWithAllowedFields(filterJSON, sortJSON, 1, 10, allowedFilterFields, allowedSortFields)
if err != nil {
    // Handle validation error
    panic(err)
}

// Parse the filter and sort JSON with pagination
ql, err := bunql.ParseFromParams(filterJSON, sortJSON, 1, 10)
if err != nil {
    panic(err)
}

// Create a base query
query := db.NewSelect().Model((*User)(nil))

// Apply the BunQL filters, sort, and pagination, and get a count query
mainQuery, countQuery := ql.ApplyWithCount(ctx, query)

// Execute both queries and get the results along with the total count
users, totalCount, err := bunql.ExecuteWithCount[User](ctx, mainQuery, countQuery)
if err != nil {
    panic(err)
}

// Calculate pagination metadata with base URI for prev/next links
metadata := bunql.GetPaginationMetadata(ql.Pagination, totalCount, "https://api.example.com/users")
fmt.Printf("Pagination metadata: %+v\n", metadata)