DEV Community: Gbubemi Attah

Introducing jsonvx: The Most Customisable JSON Parser, Querier & Formatter for Go

Gbubemi Attah — Thu, 28 Aug 2025 03:28:32 +0000

jsonvx is an elegant Go package that empowers developers with a fully configurable JSON parser, querier, and formatter—especially suitable for parsing non-standard JSON formats such as JSON5. Authored by Attah Gbubemi David (GitHub user bube054), this library is tailored for scenarios where strict compliance isn't guaranteed and flexibility is key.

Why jsonvx Stands Out

Supports Relaxed JSON Syntax

Beyond strict JSON per ECMA-404, jsonvx allows relaxed syntax like hexadecimal numbers, single-quoted strings, unquoted keys, trailing commas, comments, and more—making it highly suitable for parsing user-generated or legacy configuration data.
Fully Configurable via ParserConfig

Control exactly which extensions are allowed—be it AllowHexNumbers, AllowTrailingCommaArray, AllowLineComments, AllowSingleQuotes, AllowJSON5, and more. This lets you fine-tune strictness per input or use case.
Structured AST & Querying Tools

After parsing, jsonvx provides an abstract syntax tree (AST) composed of node types like Object, Array, Number, String, Boolean, and Null. Each node type offers helper methods (e.g., AsObject, AsNumber) and value accessors like .Value() to extract Go-native values.
Convenient Path-Based Querying

The QueryPath method allows you to dive into deeply nested data easily. For example, you can fetch fields like "name" → "first" or even array elements like "friends" → "0" → "last". Keys or array indices with special characters (e.g., "fav.movie") are fully supported.
Bitmap of Parsing Use Cases

Since jsonvx focuses on flexibility and correctness rather than maximum performance, it shines in use cases like building linters, CLI tools, formatters, or config loaders where input irregularities are expected.

Quick Start Example

package main

import (
  "fmt"
  "github.com/bube054/jsonvx"
)

func main() {
  data := []byte(`{
    name: { first: 'Tom', last: 'Anderson' },
    age: +37,
    children: ['Sara', 'Alex', 'Jack', ],
    // comment
    "fav.movie": 'Deer Hunter'
  }`)

  parser := jsonvx.NewParser(data, jsonvx.NewParserConfig(
    jsonvx.WithAllowUnquoted(true),
    jsonvx.WithAllowSingleQuotes(true),
    jsonvx.WithAllowLeadingPlus(true),
    jsonvx.WithAllowTrailingCommaArray(true),
    jsonvx.WithAllowLineComments(true),
  ))

  root, err := parser.Parse()
  if err != nil {
    panic(err)
  }

  obj, ok := jsonvx.AsObject(root)
  if !ok {
    panic("expected object")
  }

  ageNode, _ := obj.QueryPath("age")
  ageNum, _ := jsonvx.AsNumber(ageNode)
  ageValue, _ := ageNum.Value()
  fmt.Println("Age:", ageValue) // Output: Age: 37
}

In just a few lines, this example handles comments, unquoted keys, single-quoted strings, trailing commas, and +37 as input—all thanks to jsonvx's configurability.

Feature Highlights at a Glance

Feature	Description
Strict JSON + Relaxed Modes	Supports both strict JSON and optional relaxed syntax.
Flexible ParserConfig	Toggle syntax features individually via configuration.
AST-Based Access	Query, traverse, and manipulate JSON via structured nodes.
Path-Based Querying	Fetch nested data via `QueryPath`, even in awkward keys.
Ideal Use Cases	Tools, formatters, config parsers, linters, CLI utilities.

Getting Started

Installation Ensure Go is set up, then install with:

  go get -u github.com/bube054/jsonvx

Import & Parse

Use NewParser(data, config) to create a parser, then call .Parse().
Traverse Nodes

Use AsObject, AsArray, AsString, AsNumber, etc., and extract values through .Value() or ForEach.
Query Paths

Use QueryPath("friends", "0", "last") to navigate deeply nested structures.
Custom Config

Customize allowed syntactic variants using WithAllow... options or jsonvx.JSON5Config() for a full JSON5 setup.

Customization Options

Each option controls whether a relaxed JSON feature is allowed. Mix and match depending on your input source.

Number Handling

WithAllowHexNumbers(true) — Accept hexadecimal numbers like 0x1A.
WithAllowLeadingPlus(true) — Allow a leading + in numbers (e.g., +37).
WithAllowLeadingDecimalPoint(true) — Permit .5 instead of 0.5.
WithAllowTrailingDecimalPoint(true) — Accept 5. instead of 5.0.
WithAllowInfinity(true) — Parse Infinity and -Infinity.
WithAllowNaN(true) — Accept NaN as a valid number.

Strings & Keys

WithAllowSingleQuotes(true) — Strings can use 'single quotes'.
WithAllowUnquoted(true) — Object keys can be unquoted ({ name: "Tom" }).
WithAllowTrailingCommaArray(true) — Arrays can end with a trailing comma.
WithAllowTrailingCommaObject(true) — Objects can end with a trailing comma.

Comments

WithAllowLineComments(true) — Allow // single-line comments.
WithAllowBlockComments(true) — Allow /* block comments */.

JSON5 Preset

WithAllowJSON5(true) Enable all JSON5-like features at once (unquoted keys, trailing commas, single quotes, comments, Infinity, NaN, etc.).

Closing Thoughts

jsonvx is a powerful, thoughtfully designed Go library for working with both standard and non-standard JSON. Its flexible configuration and AST-driven design make it especially ideal for scenarios where inputs are unpredictable or loose in format. Whether you're building tools, formatters, or config loaders, jsonvx provides the right balance between strictness and flexibility.

If you find this project useful, don’t forget to ⭐ star it on GitHub to show your support!

I Built a Beam Analysis Tool Using Slope-Deflection! 🚀

Gbubemi Attah — Sun, 19 Jan 2025 19:10:00 +0000

Hi everyone! I recently created a tool to help engineers and students analyze multi-span beams using the Slope-Deflection Method. It generates bending moment diagrams, shear force diagrams, and more in a simple, intuitive interface.

🔗 Check it out here: Web App

🔗 Tutorial Youtube video, check it out here: Video

Big thanks to my UI designer Ajayi Tomiwa for making the interface so user-friendly! 🎨

👨‍💻 Also check out my GitHub: gh link

I’d love for you to try it out and share your feedback. Let me know what you think or how it could be improved!

Developing a Simple RESTful API with Gin, ginvalidator, and validatorgo

Gbubemi Attah — Mon, 13 Jan 2025 19:54:55 +0000

This tutorial introduces the basics of writing a RESTful web service API with Go and the Gin Web Framework (Gin). Which uses my two open source libraries: ginvalidator and validatorgo.

ginvalidator is a lightweight and expressive validation library for Go, designed specifically for the Gin web framework. It is based on the popular open source js library express-validator.
validatorgo is a versatile validation library for Go, offering a wide range of validators and sanitizers. It is based on the popular open source js library validator.js.

Please check out the above libraries and don’t forget to ⭐ star, 🔁 share, and 🍴 fork!

API endpoint design

You’ll build an API that provides access to a product inventory management system. So you’ll need to provide endpoints through which a HTTP client can create, read update and delete products.

When developing an API, you typically begin by designing the endpoints. Your API’s users will have more success if the endpoints are easy to understand.

Here are the endpoints you’ll create in this tutorial.

/products
- GET - Get a list of all products, returned as JSON.
- POST - Add a new product from request data and returned as JSON.
/products/:id
- GET - Get a product by its id, returning the product data as JSON.
- UPDATE - Get a product by its id, returning the newly updated data as JSON.
- Delete - Deletes a product by its id.

To keep things simple for the tutorial, you’ll store data in memory. A more typical API would interact with a database. Note that storing data in memory means that the list of products will be lost each time you stop the server, then recreated when you start it.

Also all HTTP requests will be represented as .http code snippets. You can use any HTTP client, such as Postman, Insomnia, or the HTTP client in your IDE, to send your requests.

Writing the Code

Start by following the quick installation guide to set up the necessary dependencies.
Next, create a main.go file.
In the main.go file, define the following structs to model your product data: Dimensions, Supplier, and Product. The Dimensions and Supplier structs will be embedded within the Product struct.

  package main

  import (
    "time"
  )

  // Dimensions represents the physical dimensions of a product.
  type Dimensions struct {
    Length float64 `json:"length"` // Length of the product in centimeters
    Width  float64 `json:"width"`  // Width of the product in centimeters
    Height float64 `json:"height"` // Height of the product in centimeters
    Weight float64 `json:"weight"` // Weight of the product in kilograms
  }

  // Supplier represents information about the supplier of a product.
  type Supplier struct {
    Name    string `json:"name"`    // Name of the supplier
    Contact string `json:"contact"` // Contact details (e.g., email or phone number)
    Address string `json:"address"` // Address of the supplier
  }

  // Product represents data about an inventory product.
  type Product struct {
    ID             string     `json:"id"`             // Unique identifier for the product
    Name           string     `json:"name"`           // Name of the product
    Category       string     `json:"category"`       // Category the product belongs to
    Description    string     `json:"description"`    // Detailed description of the product
    Price          float64    `json:"price"`          // Price of the product in decimal format
    Stock          int        `json:"stock"`          // Quantity of the product available in stock
    Dimensions     Dimensions `json:"dimensions"`     // Physical dimensions of the product
    Supplier       Supplier   `json:"supplier"`       // Supplier details
    Tags           []string   `json:"tags"`           // Tags for searching and filtering
    Image          string     `json:"image"`          // URLs of product images
    ManufacturedAt time.Time  `json:"manufacturedAt"` // Timestamp when the product was manufactured
    CreatedAt      time.Time  `json:"createdAt"`      // Timestamp when the product was created
    UpdatedAt      time.Time  `json:"updatedAt"`      // Timestamp when the product was last updated
  }

Then below add a slice products, with 2 items. This slice will be where our in memory database.

  var products = []Product{
    {
        ID:          "p1",
        Name:        "Wireless Mouse",
        Category:    "Electronics",
        Description: "A high-precision wireless mouse with ergonomic design.",
        Price:       29.99,
        Stock:       150,
        Dimensions: Dimensions{
            Length: 11.5,
            Width:  6.0,
            Height: 3.5,
            Weight: 0.2,
        },
        Supplier: Supplier{
            Name:    "Tech Supplies Inc.",
            Contact: "support@techsupplies.com",
            Address: "123 Tech Street, Silicon Valley, CA",
        },
        Tags:           []string{"wireless", "mouse", "electronics", "accessories"},
        Image:          "https://example.com/images/mouse1.jpg",
        ManufacturedAt: time.Now().AddDate(0, -30, 0),
        CreatedAt:      time.Now().AddDate(0, -1, 0),
        UpdatedAt:      time.Now().AddDate(0, -1, 0),
    },
    {
        ID:          "p2",
        Name:        "Gaming Keyboard",
        Category:    "Electronics",
        Description: "Mechanical keyboard with customizable RGB lighting.",
        Price:       79.99,
        Stock:       75,
        Dimensions: Dimensions{
            Length: 45.0,
            Width:  15.0,
            Height: 3.8,
            Weight: 1.1,
        },
        Supplier: Supplier{
            Name:    "Gaming Gear Ltd.",
            Contact: "info@gaminggear.com",
            Address: "456 Gaming Road, Austin, TX",
        },
        Tags:           []string{"keyboard", "gaming", "RGB", "electronics"},
        Image:          "https://example.com/images/keyboard2.jpg",
        ManufacturedAt: time.Now().AddDate(0, -20, 0),
        CreatedAt:      time.Now().AddDate(0, -2, 0),
        UpdatedAt:      time.Now().AddDate(0, -2, 0),
    },
  }

Lets register a GET endpoint for /products in the main function. Here is the updated main function:

    func main() {
      router := gin.Default()
      router.GET("/products",
        append(productQueriesValidators(), getProducts)...,
      )
      router.Run(":8080")
    }

Below the main function, define the productQueriesValidators and getProducts functions:

productQueriesValidators: This function returns a gin.HandlersChain (equivalent to []gin.HandlerFunc). It includes two query validators for the GET /products route:
- q: An optional query parameter. It will be validated only if present in the request, ensuring it's trimmed of leading and trailing whitespace and is not empty.
- order: An optional query parameter. It will be trimmed of whitespace and must be one of asc or desc.

  func productQueriesValidators() gin.HandlersChain {
    return gin.HandlersChain{
      gv.NewQuery("q", nil).Chain().Optional().Trim(" ").Not().Empty(nil).Validate(),
      gv.NewQuery("order", nil).Chain().Optional().Trim(" ").In([]string{"asc", "desc"}).Validate(),
    }
  }

getProducts: This is the final request handler middleware for the GET /products route. It performs the following steps:
- Checks for validation errors using gv.ValidationResult.
- If validation errors exist, it returns an HTTP 422 Unprocessable Entity status with the errors.
- If no validation errors occur, it returns the product data with an HTTP 200 OK status.

  func getProducts(c *gin.Context) {
    result, err := gv.ValidationResult(c)
    if err != nil {
      c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{
        "message": fmt.Sprintf("The server encountered an unexpected error: %v", err),
        "data":    nil,
        "errors":  nil,
      })
      return
    }

    if len(result) != 0 {
      c.AbortWithStatusJSON(http.StatusUnprocessableEntity, gin.H{
        "message": "The server encountered validation error",
        "data":    nil,
        "errors":  result,
      })
      return
    }

    c.AbortWithStatusJSON(http.StatusOK, gin.H{
      "message": "The products found successfully",
      "data":    products,
      "errors":  nil,
    })
  }

Note we don't actually use the the search params (q, order) in the getProducts handler for the sake of simplicity.

Update the dependencies at the top of your Go file to include both net/http, gin and ginvalidator (aliased as gv):

  package main

  import (
    "fmt"
    "net/http"
    "time"

      gv "github.com/bube054/ginvalidator"
    "github.com/gin-gonic/gin"
  )

Run and test the code for the GET /products endpoint.

  go run main.go

Here are examples of valid and invalid requests for testing:

A valid request.

GET http://localhost:8080/products?q=electronics&order=asc HTTP/1.1
content-type: application/json

An Invalid Request: order is neither asc nor desc.

GET http://localhost:8080/products?q=&order=xyz HTTP/1.1
content-type: application/json

An Invalid Request: q is empty

GET http://localhost:8080/products?q=   &order=asc HTTP/1.1
content-type: application/json

An Invalid Request: q is empty and order is neither asc nor desc
```
GET http://localhost:8080/products?q=   &order=xyz HTTP/1.1
content-type: application/json
```
- Lets register a GET endpoint for /products/:id in the main function. Here is the updated main function:

    func main() {
      router := gin.Default()
      router.GET("/products",
        append(productQueriesValidators(), getProducts)...,
      )
      router.GET("/products/:id",
        append(productParamIdValidators(), getProduct)...,
      )
      router.Run(":8080")
    }

Below the main function, define the productParamIdValidators and getProduct functions:

productParamIdValidators: It includes a param validator for id in /products/:id route:
- id is simply the id for each product.

  func productParamIdValidators() gin.HandlersChain {
    return gin.HandlersChain{gv.NewParam("id", nil).Chain().Trim(" ").Alphanumeric(nil).Validate()}
  }

getProducts: This is the final request handler middleware for the /products route. It performs the following steps
- Checks for validation errors using gv.ValidationResult.
- If validation errors exist, it returns an HTTP 422 Unprocessable Entity status with the errors.
- Retrieves matched data using gv.GetMatchedData.
- Searches for the product by its id in the products list.
- Return HTTP 404 if the product is not found and return HTTP 200 if the product is successfully found.

  func getProduct(c *gin.Context) {
    result, err := gv.ValidationResult(c)
    if err != nil {
      c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{
        "message": fmt.Sprintf("The server encountered an unexpected error: %v", err),
        "data":    nil,
        "errors":  nil,
      })
      return
    }

    if len(result) != 0 {
      c.AbortWithStatusJSON(http.StatusUnprocessableEntity, gin.H{
        "message": "The server encountered validation error",
        "data":    nil,
        "errors":  result,
      })
      return
    }

    data, err := gv.GetMatchedData(c)
    if err != nil {
      c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{
        "message": fmt.Sprintf("The server encountered an unexpected error: %v", err),
        "data":    nil,
        "errors":  nil,
      })
      return
    }

    id, _ := data.Get(gv.ParamLocation, "id")

    var product *Product

    for _, p := range products {
      if p.ID == id {
        product = &p
        break
      }
    }

    if product == nil {
      c.AbortWithStatusJSON(http.StatusNotFound, gin.H{
        "message": fmt.Sprintf("Product with id %s, not found", id),
        "data":    nil,
        "errors":  nil,
      })
      return
    } else {
      c.AbortWithStatusJSON(http.StatusOK, gin.H{
        "message": "The product found successfully",
        "data":    product,
        "errors":  nil,
      })
      return
    }
  }

Run and test the code for GET on /products/:id

Quit the previous process and rerun:

  go run main.go

A valid request.

  GET http://localhost:8080/products/p2 HTTP/1.1
  content-type: application/json

Invalid request: id which is p2 is not alphanumeric

  GET http://localhost:8080/products/@#! HTTP/1.1
  content-type: application/json

Lets register a DELETE endpoint for /products/:id in the main function. Here is the updated main function:

    func main() {
      router := gin.Default()
      router.GET("/products",
        append(productQueriesValidators(), getProducts)...,
      )
      router.GET("/products/:id",
        append(productParamIdValidators(), getProduct)...,
      )
      router.DELETE("/products/:id",
        append(productParamIdValidators(), deleteProduct)...,
      )
      router.Run(":8080")
    }

productParamIdValidators function will be reused.

deleteProduct: This is the final request handler middleware for the DELETE /products/:id route. It performs the following steps:
- Validates the request parameters using gv.ValidationResult.
- Returns an HTTP 422 status if validation errors are present.
- Retrieves matched data using gv.GetMatchedData.
- Searches for the product by its id in the products list.
- If the product exists, its removed from the list and returns HTTP 200 with the deleted product details.
- If the product does not exist, returns HTTP 404.

  func deleteProduct(c *gin.Context) {
    result, err := gv.ValidationResult(c)
    if err != nil {
      c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{
        "message": fmt.Sprintf("The server encountered an unexpected error: %v", err),
        "data":    nil,
        "errors":  nil,
      })
      return
    }

    if len(result) != 0 {
      c.AbortWithStatusJSON(http.StatusUnprocessableEntity, gin.H{
        "message": "The server encountered validation error",
        "data":    nil,
        "errors":  result,
      })
      return
    }

    data, err := gv.GetMatchedData(c)
    if err != nil {
      c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{
        "message": "The server encountered an unexpected error.",
        "data":    nil,
        "errors":  nil,
      })
      return
    }

    id, _ := data.Get(gv.ParamLocation, "id")

    var deletedProduct *Product
    var filteredProducts = []Product{}

    for _, prod := range products {
      if prod.ID == id {
        deletedProduct = &prod
        break
      } else {
        filteredProducts = append(filteredProducts, prod)
      }
    }

    if deletedProduct == nil {
      c.AbortWithStatusJSON(http.StatusNotFound, gin.H{
        "message": fmt.Sprintf("Product with id %s, not found", id),
        "data":    nil,
        "errors":  nil,
      })
      return
    }

    products = filteredProducts
    c.AbortWithStatusJSON(http.StatusOK, gin.H{
      "message": fmt.Sprintf("Product with id %s, deleted", id),
      "data":    deletedProduct,
      "errors":  nil,
    })
  }

Run and test the code for DELETE /products/:id

Quit the previous process and rerun:

  go run main.go

A valid request.

  DELETE http://localhost:8080/products/p2 HTTP/1.1
  content-type: application/json

Invalid request: id which is p2 is not alphanumeric

  DELETE http://localhost:8080/products/@#! HTTP/1.1
  content-type: application/json

Lets register a POST endpoint for /products in the main function. Here is the updated main function:

    func main() {
      router := gin.Default()
      router.GET("/products",
        append(productQueriesValidators(), getProducts)...,
      )
      router.GET("/products/:id",
        append(productParamIdValidators(), getProduct)...,
      )
      router.DELETE("/products/:id",
        append(productParamIdValidators(), deleteProduct)...,
      )
      router.POST("/products",
        append(productBodyValidators(), postProduct)...,
      )
      router.Run(":8080")
    }

productBodyValidators: This function validates the request body for POST and PUT requests to the /products route. It validates:
- name: Must not be empty.
- category: Must belong to predefined categories (Electronics, Apparels, Groceries, Home-Appliances).
- description: Length should be between 5 and 100 characters.
- price: Must have at least 2 decimal places and use the en-US locale.
- stock: Should be an integer, with a minimum value of 0.
- dimensions:
  - length, width, height, weight: Must be numeric.
- supplier:
  - name: Trimmed and not empty.
  - contact: Must be a valid email address.
  - address: Must match the regex format (number street, city, state abbreviation).
- tags: Should be an array of strings.
- image: Must be a valid URL.
- manufacturedAt: Should follow the ISO8601 format and be after 2020-05-10T00:00:00Z.

  func productBodyValidators() gin.HandlersChain {
    var (
      minDesc         uint     = 5
      maxDesc         uint     = 100
      minStock        int      = 0
      validCategories []string = []string{"Electronics", "Apparels", "Groceries", "Home-Appliances"}
    )

    return gin.HandlersChain{
      gv.NewBody("name", nil).Chain().Not().Empty(nil).Validate(),
      gv.NewBody("category", nil).Chain().In(validCategories).Validate(),
      gv.NewBody("description", nil).Chain().Length(&vgo.IsLengthOpts{Min: uint(minDesc), Max: &maxDesc}).Validate(),
      gv.NewBody("price", nil).Chain().Decimal(&vgo.IsDecimalOpts{DecimalDigits: vgo.DecimalDigits{Min: 2}, ForceDecimal: false, Locale: "en-US"}).Validate(),
      gv.NewBody("stock", nil).Chain().Int(&vgo.IsIntOpts{Min: &minStock}).Validate(),
      gv.NewBody(`dimensions.length`, nil).Chain().Numeric(nil).Validate(),
      gv.NewBody("dimensions.width", nil).Chain().Numeric(nil).Validate(),
      gv.NewBody("dimensions.height", nil).Chain().Numeric(nil).Validate(),
      gv.NewBody("dimensions.weight", nil).Chain().Numeric(nil).Validate(),
      gv.NewBody("supplier.name", nil).Chain().Trim(" ").Not().Empty(nil).Validate(),
      gv.NewBody("supplier.contact", nil).Chain().Email(nil).Validate(),
      gv.NewBody("supplier.address", nil).Chain().Matches(regexp.MustCompile(`^\d+\s[\w\s]+,\s[\w\s]+,\s[A-Z]{2}$`)).Validate(),
      gv.NewBody("tags", nil).Chain().Array(nil).Validate(),
      gv.NewBody("image", nil).Chain().URL(nil).Validate(),
      gv.NewBody("manufacturedAt", nil).Chain().Date(&vgo.IsDateOpts{Format: vgo.ISO8601ZuluLayout, StrictMode: true}).After(&vgo.IsAfterOpts{ComparisonDate: "2020-05-10T00:00:00Z"}).Validate(),
    }
  }

postProduct: This is the final request handler middleware for the POST /products route. It performs the following steps:
- Validates the request body using gv.ValidationResult.
- Returns an HTTP 422 status if validation errors are present.
- Binds the JSON request body to a Product struct.
- Adds a unique ID, CreatedAt, and UpdatedAt fields to the new product.
- Appends the new product to the products slice.
- Returns HTTP 200 with the created product details.

  func postProduct(c *gin.Context) {
    result, err := gv.ValidationResult(c)
    if err != nil {
      c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{
        "message": fmt.Sprintf("The server encountered an unexpected error: %v", err),
        "data":    nil,
        "errors":  nil,
      })
      return
    }

    if len(result) != 0 {
      c.AbortWithStatusJSON(http.StatusUnprocessableEntity, gin.H{
        "message": "The server encountered validation error",
        "data":    nil,
        "errors":  result,
      })
      return
    }

    var newProduct Product

    if err := c.BindJSON(&newProduct); err != nil {
      c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{
        "message": fmt.Sprintf("The server encountered an unexpected error: %v", err),
        "data":    nil,
        "errors":  nil,
      })
      return
    }

    newProduct.ID = fmt.Sprintf("p%d", len(products)+1)
    newProduct.CreatedAt = time.Now()
    newProduct.UpdatedAt = newProduct.CreatedAt

    products = append(products, newProduct)
    c.AbortWithStatusJSON(http.StatusOK, gin.H{
      "message": fmt.Sprintf("Product with id %s, has been created", newProduct.ID),
      "data":    newProduct,
      "errors":  nil,
    })
  }

Update the dependencies at the top of your Go file to include validatorgo (aliased as vgo):

  package main

  import (
    "fmt"
    "net/http"
      "regexp"
    "time"

      gv "github.com/bube054/ginvalidator"
      vgo "github.com/bube054/validatorgo"
    "github.com/gin-gonic/gin"
  )

Run and test the code for POST /products

Quit the previous process and rerun:

  go run main.go

A valid request.

  POST http://localhost:8080/products HTTP/1.1
  content-type: application/json

  {
    "name": "Ultra HD Monitor",
    "category": "Electronics",
    "description": "27-inch 4K Ultra HD monitor with HDR support and ultra-slim bezels.",
    "price": 345.99,
    "stock": 30,
    "dimensions": {
      "length": 61.0,
      "width": 36.0,
      "height": 5.0,
      "weight": 4.5
    },
    "supplier": {
      "name": "VisionTech Co.",
      "contact": "sales@visiontech.com",
      "address": "123 Display Lane, San Francisco, CA"
    },
    "tags": ["monitor", "4K", "HDR", "electronics", "display"],
    "image": "https://example.com/images/monitor1.jpg",
    "manufacturedAt": "2023-09-11T11:34:56Z"
  }

An invalid request.

  POST http://localhost:8080/products HTTP/1.1
  content-type: application/json

  {
    "name": "",
    "category": "Equipment",
    "description": "four",
    "price": 345.99,
    "stock": 30,
    "dimensions": {},
    "supplier": {
      "name": "",
      "contact": "123 Display Lane, San Francisco, CA",
      "address": "sales@visiontech.com",
    },
    "tags": null,
    "image": "image-here",
    "manufacturedAt": "2019-09-11T11:34:56Z"
  }

Lets register a PUT endpoint for /products/:id in the main function. Here is the updated main function:

    func main() {
      router := gin.Default()
      router.GET("/products",
        append(productQueriesValidators(), getProducts)...,
      )
      router.GET("/products/:id",
        append(productParamIdValidators(), getProduct)...,
      )
      router.DELETE("/products/:id",
        append(productParamIdValidators(), deleteProduct)...,
      )
      router.POST("/products",
        append(productBodyValidators(), postProduct)...,
      )
      router.PUT("/products/:id",
        append(append(productParamIdValidators(), productBodyValidators()...), putProducts)...,
      )
      router.Run(":8080")
    }

We will re-use productParamIdValidators and productBodyValidators functions.

putProduct: This is the final request handler middleware for the POST /products route. It performs the following steps:
- Validates the request parameters and body: Uses gv.ValidationResult to check for validation errors in both the route parameters and the request body.
- Retrieves matched data using gv.GetMatchedData.
- Finds the product: Matches the provided id with the existing products.
- Updates the product: If the product is found, it updates its details and sets a new UpdatedAt timestamp.
- It returns HTTP 200 with the updated product details if successful.
- It returns HTTP 404 if the product is not found.
- It returns HTTP 422 for validation errors.

  func putProducts(c *gin.Context) {
    result, err := gv.ValidationResult(c)
    if err != nil {
      c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{
        "message": fmt.Sprintf("The server encountered an unexpected error: %v", err),
        "data":    nil,
        "errors":  nil,
      })
      return
    }

    if len(result) != 0 {
      c.AbortWithStatusJSON(http.StatusUnprocessableEntity, gin.H{
        "message": "The server encountered validation error",
        "data":    nil,
        "errors":  result,
      })
      return
    }

    var newProduct Product

    if err := c.BindJSON(&newProduct); err != nil {
      c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{
        "message": fmt.Sprintf("The server encountered an unexpected error: %v", err),
        "data":    nil,
        "errors":  nil,
      })
      return
    }

    data, err := gv.GetMatchedData(c)
    if err != nil {
      c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{
        "message": "The server encountered an unexpected error.",
        "data":    nil,
        "errors":  nil,
      })
      return
    }

    id, _ := data.Get(gv.ParamLocation, "id")

    var EditedProduct *Product
    var newProducts = make([]Product, len(products))

    for ind, prod := range products {
      if prod.ID == id {
        newProduct.ID = id
        newProduct.CreatedAt = prod.CreatedAt
        newProduct.UpdatedAt = time.Now()
        newProducts[ind] = newProduct
        EditedProduct = &newProduct
      } else {
        newProducts[ind] = prod
      }
    }

    if EditedProduct == nil {
      c.AbortWithStatusJSON(http.StatusNotFound, gin.H{
        "message": fmt.Sprintf("Product with id %s, not found", id),
        "data":    nil,
        "errors":  nil,
      })
      return
    }

    products = newProducts
    c.AbortWithStatusJSON(http.StatusOK, gin.H{
      "message": fmt.Sprintf("Product with id %s, has been edited", id),
      "data":    EditedProduct,
      "errors":  nil,
    })
  }

Run and test the code for PUT /products

Quit the previous process and rerun:

  go run main.go

A valid request.

  PUT http://localhost:8080/products HTTP/1.1
  content-type: application/json

  {
    "name": "Ultra 8k Monitor",
    "category": "Electronics",
    "description": "27-inch 8K Ultra HD monitor with HDR support and ultra-slim bezels.",
    "price": 390.99,
    "stock": 15,
    "dimensions": {
      "length": 16.0,
      "width": 63.0,
      "height": 0.5,
      "weight": 4.5
    },
    "supplier": {
      "name": "VisionTech Co.",
      "contact": "sales@visiontech.com",
      "address": "123 Display Lane, San Francisco, CA"
    },
    "tags": ["8K", "HDR", "electronics", "display"],
    "image": "https://example.com/images/monitor1-edited.jpg",
    "manufacturedAt": "2023-09-11T11:34:56Z"
  }

An invalid request.

  PUT http://localhost:8080/products HTTP/1.1
  content-type: application/json

  {
    "name": "",
    "category": "Equipment",
    "description": "four",
    "price": 345.99,
    "stock": 30,
    "dimensions": null,
    "supplier": {
      "name": "",
      "contact": "123 Display Lane, San Francisco, CA",
      "address": "sales@visiontech.com",
    },
    "tags": null,
    "image": "image-here",
    "manufacturedAt": "2019-09-11T11:34:56Z"
  }

Final thoughts

Now you can see how straightforward it is to validate your HTTP requests in Gin using both ginvalidator and validatorgo.

For more details on customizing error messages, check out this guide. To learn more about field syntax extraction, refer to this section.

If you prefer not to use the append method in the route registration handlers, you can break down the middleware validator handlers into smaller chunks and add them individually to the registration handler.

Thanks for reading, and see you next time!

Full Code

package main

import (
    "fmt"
    "net/http"
    "regexp"
    "time"

    gv "github.com/bube054/ginvalidator"
    vgo "github.com/bube054/validatorgo"
    "github.com/gin-gonic/gin"
)

// Dimensions represents the physical dimensions of a product.
type Dimensions struct {
    Length float64 `json:"length"` // Length of the product in centimeters
    Width  float64 `json:"width"`  // Width of the product in centimeters
    Height float64 `json:"height"` // Height of the product in centimeters
    Weight float64 `json:"weight"` // Weight of the product in kilograms
}

// Supplier represents information about the supplier of a product.
type Supplier struct {
    Name    string `json:"name"`    // Name of the supplier
    Contact string `json:"contact"` // Contact details (e.g., email or phone number)
    Address string `json:"address"` // Address of the supplier
}

// Product represents data about an inventory product.
type Product struct {
    ID             string     `json:"id"`             // Unique identifier for the product
    Name           string     `json:"name"`           // Name of the product
    Category       string     `json:"category"`       // Category the product belongs to
    Description    string     `json:"description"`    // Detailed description of the product
    Price          float64    `json:"price"`          // Price of the product in decimal format
    Stock          int        `json:"stock"`          // Quantity of the product available in stock
    Dimensions     Dimensions `json:"dimensions"`     // Physical dimensions of the product
    Supplier       Supplier   `json:"supplier"`       // Supplier details
    Tags           []string   `json:"tags"`           // Tags for searching and filtering
    Image          string     `json:"image"`          // URLs of product images
    ManufacturedAt time.Time  `json:"manufacturedAt"` // Timestamp when the product was manufactured
    CreatedAt      time.Time  `json:"createdAt"`      // Timestamp when the product was created
    UpdatedAt      time.Time  `json:"updatedAt"`      // Timestamp when the product was last updated
}

var products = []Product{
    {
        ID:          "p1",
        Name:        "Wireless Mouse",
        Category:    "Electronics",
        Description: "A high-precision wireless mouse with ergonomic design.",
        Price:       29.99,
        Stock:       150,
        Dimensions: Dimensions{
            Length: 11.5,
            Width:  6.0,
            Height: 3.5,
            Weight: 0.2,
        },
        Supplier: Supplier{
            Name:    "Tech Supplies Inc.",
            Contact: "support@techsupplies.com",
            Address: "123 Tech Street, Silicon Valley, CA",
        },
        Tags:           []string{"wireless", "mouse", "electronics", "accessories"},
        Image:          "https://example.com/images/mouse1.jpg",
        ManufacturedAt: time.Now().AddDate(0, -30, 0),
        CreatedAt:      time.Now().AddDate(0, -1, 0),
        UpdatedAt:      time.Now().AddDate(0, -1, 0),
    },
    {
        ID:          "p2",
        Name:        "Gaming Keyboard",
        Category:    "Electronics",
        Description: "Mechanical keyboard with customizable RGB lighting.",
        Price:       79.99,
        Stock:       75,
        Dimensions: Dimensions{
            Length: 45.0,
            Width:  15.0,
            Height: 3.8,
            Weight: 1.1,
        },
        Supplier: Supplier{
            Name:    "Gaming Gear Ltd.",
            Contact: "info@gaminggear.com",
            Address: "456 Gaming Road, Austin, TX",
        },
        Tags:           []string{"keyboard", "gaming", "RGB", "electronics"},
        Image:          "https://example.com/images/keyboard2.jpg",
        ManufacturedAt: time.Now().AddDate(0, -20, 0),
        CreatedAt:      time.Now().AddDate(0, -2, 0),
        UpdatedAt:      time.Now().AddDate(0, -2, 0),
    },
}

func main() {
    router := gin.Default()
    router.GET("/products",
        append(productQueriesValidators(), getProducts)...,
    )
    router.GET("/products/:id",
        append(productParamIdValidators(), getProduct)...,
    )
    router.DELETE("/products/:id",
        append(productParamIdValidators(), deleteProduct)...,
    )
    router.POST("/products",
        append(productBodyValidators(), postProduct)...,
    )
    router.PUT("/products/:id",
        append(append(productParamIdValidators(), productBodyValidators()...), putProducts)...,
    )
    router.Run(":8080")
}

func productQueriesValidators() gin.HandlersChain {
    return gin.HandlersChain{
        gv.NewQuery("q", nil).Chain().Optional().Trim(" ").Not().Empty(nil).Validate(),
        gv.NewQuery("order", nil).Chain().Optional().Trim(" ").In([]string{"asc", "desc"}).Validate(),
    }
}

func productParamIdValidators() gin.HandlersChain {
    return gin.HandlersChain{gv.NewParam("id", nil).Chain().Trim(" ").Alphanumeric(nil).Validate()}
}

func productBodyValidators() gin.HandlersChain {
    var (
        minDesc         uint     = 5
        maxDesc         uint     = 100
        minStock        int      = 0
        validCategories []string = []string{"Electronics", "Apparels", "Groceries", "Home-Appliances"}
    )

    return gin.HandlersChain{
        gv.NewBody("name", nil).Chain().Not().Empty(nil).Validate(),
        gv.NewBody("category", nil).Chain().In(validCategories).Validate(),
        gv.NewBody("description", nil).Chain().Length(&vgo.IsLengthOpts{Min: uint(minDesc), Max: &maxDesc}).Validate(),
        gv.NewBody("price", nil).Chain().Decimal(&vgo.IsDecimalOpts{DecimalDigits: vgo.DecimalDigits{Min: 2}, ForceDecimal: false, Locale: "en-US"}).Validate(),
        gv.NewBody("stock", nil).Chain().Int(&vgo.IsIntOpts{Min: &minStock}).Validate(),
        gv.NewBody(`dimensions.length`, nil).Chain().Numeric(nil).Validate(),
        gv.NewBody("dimensions.width", nil).Chain().Numeric(nil).Validate(),
        gv.NewBody("dimensions.height", nil).Chain().Numeric(nil).Validate(),
        gv.NewBody("dimensions.weight", nil).Chain().Numeric(nil).Validate(),
        gv.NewBody("supplier.name", nil).Chain().Trim(" ").Not().Empty(nil).Validate(),
        gv.NewBody("supplier.contact", nil).Chain().Email(nil).Validate(),
        gv.NewBody("supplier.address", nil).Chain().Matches(regexp.MustCompile(`^\d+\s[\w\s]+,\s[\w\s]+,\s[A-Z]{2}$`)).Validate(),
        gv.NewBody("tags", nil).Chain().Array(nil).Validate(),
        gv.NewBody("image", nil).Chain().URL(nil).Validate(),
        gv.NewBody("manufacturedAt", nil).Chain().Date(&vgo.IsDateOpts{Format: vgo.ISO8601ZuluLayout, StrictMode: true}).After(&vgo.IsAfterOpts{ComparisonDate: "2020-05-10T00:00:00Z"}).Validate(),
    }
}

func getProducts(c *gin.Context) {
    result, err := gv.ValidationResult(c)
    if err != nil {
        c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{
            "message": fmt.Sprintf("The server encountered an unexpected error: %v", err),
            "data":    nil,
            "errors":  nil,
        })
        return
    }

    if len(result) != 0 {
        c.AbortWithStatusJSON(http.StatusUnprocessableEntity, gin.H{
            "message": "The server encountered validation error",
            "data":    nil,
            "errors":  result,
        })
        return
    }

    c.AbortWithStatusJSON(http.StatusOK, gin.H{
        "message": "The products found successfully",
        "data":    products,
        "errors":  nil,
    })
}

func getProduct(c *gin.Context) {
    result, err := gv.ValidationResult(c)
    if err != nil {
        c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{
            "message": fmt.Sprintf("The server encountered an unexpected error: %v", err),
            "data":    nil,
            "errors":  nil,
        })
        return
    }

    if len(result) != 0 {
        c.AbortWithStatusJSON(http.StatusUnprocessableEntity, gin.H{
            "message": "The server encountered validation error",
            "data":    nil,
            "errors":  result,
        })
        return
    }

    data, err := gv.GetMatchedData(c)
    if err != nil {
        c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{
            "message": fmt.Sprintf("The server encountered an unexpected error: %v", err),
            "data":    nil,
            "errors":  nil,
        })
        return
    }

    id, _ := data.Get(gv.ParamLocation, "id")

    var product *Product

    for _, p := range products {
        if p.ID == id {
            product = &p
            break
        }
    }

    if product == nil {
        c.AbortWithStatusJSON(http.StatusNotFound, gin.H{
            "message": fmt.Sprintf("Product with id %s, not found", id),
            "data":    nil,
            "errors":  nil,
        })
        return
    } else {
        c.AbortWithStatusJSON(http.StatusOK, gin.H{
            "message": "The product found successfully",
            "data":    product,
            "errors":  nil,
        })
        return
    }
}

func deleteProduct(c *gin.Context) {
    result, err := gv.ValidationResult(c)
    if err != nil {
        c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{
            "message": fmt.Sprintf("The server encountered an unexpected error: %v", err),
            "data":    nil,
            "errors":  nil,
        })
        return
    }

    if len(result) != 0 {
        c.AbortWithStatusJSON(http.StatusUnprocessableEntity, gin.H{
            "message": "The server encountered validation error",
            "data":    nil,
            "errors":  result,
        })
        return
    }

    data, err := gv.GetMatchedData(c)
    if err != nil {
        c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{
            "message": "The server encountered an unexpected error.",
            "data":    nil,
            "errors":  nil,
        })
        return
    }

    id, _ := data.Get(gv.ParamLocation, "id")

    var deletedProduct *Product
    var filteredProducts = []Product{}

    for _, prod := range products {
        if prod.ID == id {
            deletedProduct = &prod
            break
        } else {
            filteredProducts = append(filteredProducts, prod)
        }
    }

    if deletedProduct == nil {
        c.AbortWithStatusJSON(http.StatusNotFound, gin.H{
            "message": fmt.Sprintf("Product with id %s, not found", id),
            "data":    nil,
            "errors":  nil,
        })
        return
    }

    products = filteredProducts
    c.AbortWithStatusJSON(http.StatusOK, gin.H{
        "message": fmt.Sprintf("Product with id %s, deleted", id),
        "data":    deletedProduct,
        "errors":  nil,
    })
}

func postProduct(c *gin.Context) {
    result, err := gv.ValidationResult(c)
    if err != nil {
        c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{
            "message": fmt.Sprintf("The server encountered an unexpected error: %v", err),
            "data":    nil,
            "errors":  nil,
        })
        return
    }

    if len(result) != 0 {
        c.AbortWithStatusJSON(http.StatusUnprocessableEntity, gin.H{
            "message": "The server encountered validation error",
            "data":    nil,
            "errors":  result,
        })
        return
    }

    var newProduct Product

    if err := c.BindJSON(&newProduct); err != nil {
        c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{
            "message": fmt.Sprintf("The server encountered an unexpected error: %v", err),
            "data":    nil,
            "errors":  nil,
        })
        return
    }

    newProduct.ID = fmt.Sprintf("p%d", len(products)+1)
    newProduct.CreatedAt = time.Now()
    newProduct.UpdatedAt = newProduct.CreatedAt

    products = append(products, newProduct)
    c.AbortWithStatusJSON(http.StatusOK, gin.H{
        "message": fmt.Sprintf("Product with id %s, has been created", newProduct.ID),
        "data":    newProduct,
        "errors":  nil,
    })
}

func putProducts(c *gin.Context) {
    result, err := gv.ValidationResult(c)
    if err != nil {
        c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{
            "message": fmt.Sprintf("The server encountered an unexpected error: %v", err),
            "data":    nil,
            "errors":  nil,
        })
        return
    }

    if len(result) != 0 {
        c.AbortWithStatusJSON(http.StatusUnprocessableEntity, gin.H{
            "message": "The server encountered validation error",
            "data":    nil,
            "errors":  result,
        })
        return
    }

    var newProduct Product

    if err := c.BindJSON(&newProduct); err != nil {
        c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{
            "message": fmt.Sprintf("The server encountered an unexpected error: %v", err),
            "data":    nil,
            "errors":  nil,
        })
        return
    }

    data, err := gv.GetMatchedData(c)
    if err != nil {
        c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{
            "message": "The server encountered an unexpected error.",
            "data":    nil,
            "errors":  nil,
        })
        return
    }

    id, _ := data.Get(gv.ParamLocation, "id")

    var EditedProduct *Product
    var newProducts = make([]Product, len(products))

    for ind, prod := range products {
        if prod.ID == id {
            newProduct.ID = id
            newProduct.CreatedAt = prod.CreatedAt
            newProduct.UpdatedAt = time.Now()
            newProducts[ind] = newProduct
            EditedProduct = &newProduct
        } else {
            newProducts[ind] = prod
        }
    }

    if EditedProduct == nil {
        c.AbortWithStatusJSON(http.StatusNotFound, gin.H{
            "message": fmt.Sprintf("Product with id %s, not found", id),
            "data":    nil,
            "errors":  nil,
        })
        return
    }

    products = newProducts
    c.AbortWithStatusJSON(http.StatusOK, gin.H{
        "message": fmt.Sprintf("Product with id %s, has been edited", id),
        "data":    EditedProduct,
        "errors":  nil,
    })
}

Simplifying String Validation in Go: Introducing validatorgo

Gbubemi Attah — Thu, 14 Nov 2024 10:26:59 +0000

A library of string validators and sanitizers, based on the js library validator.js

Why Choose validatorgo?

Why not use popular Go libraries like Package validator or govalidator? While both libraries are well-known, validatorgo focuses on standalone string validation and provides an extensive collection of customizable validators inspired by validator.js, which neither of these Go libraries fully implement.

Here’s how validatorgo stands out compared to go-playground/validator and govalidator:

1. Compared to `go-playground/validator`

Direct String Validation: go-playground/validator is primarily built for validating struct fields using tags, which is ideal for handling JSON or struct-based data. However, it’s not designed for validating individual strings, which ValidatorGo does seamlessly, without the need for struct tags or additional setup.
Performance: go-playground/validator relies on reflection to dynamically inspect struct tags. While powerful, reflection can introduce performance overhead—especially when large or complex data structures are validated. validatorgo avoids reflection, which boosts performance, making it faster and more efficient for scenarios where single-field validations are needed.

2. Compared to `asaskevich/govalidator`

Customization and Flexibility: govalidator provides a range of validators for strings, but validatorgo enhances flexibility by allowing specific options and configurations for individual validators. For example, date formats or locale specifications can be customized, giving developers more control over validation rules tailored to project needs.

Project Motivation

I created validatorgo to serve as a dependency for another Go library called ginvalidator, which validates HTTP requests in Go web applications. Inspired by express-validator, the popular validation library for Node.js and Express, ValidatorGo fills a gap in the Go ecosystem for efficient, customizable, and straightforward string validation. Since other libraries were either overkill, lacked functionality, or didn’t meet my use case, I built validatorgo to offer a practical solution.

Installation

Using go get.

 go get github.com/bube054/validatorgo

Then import the package into your own code.

 import (
   "fmt"
   "github.com/bube054/validatorgo"
 )

If you are unhappy using the long validatorgo package name, you can do this.

 import (
   "fmt"
   vgo "github.com/bube054/validatorgo"
 )

Simple validator example

 func main(){
   id := "5f2a6c69e1d7a4e0077b4e6b"
   validId := vgo.IsMongoID(id)
   fmt.Println(validId) // true
 }

Some Validators

Below is a list of validators provided by the validatorgo package, which covers various string formats and types, making it versatile for multiple validation needs.

Validator	Description
`Contains`	Checks if a string contains a specified substring.
`Equals`	Validates if a string is exactly equal to a comparison string.
`IsAbaRouting`	Checks if the string is a valid ABA routing number (US bank accounts).
`IsAfter`	Validates if a date string is after a specified date.
`IsAlpha`	Ensures the string contains only letters (a-zA-Z).
`IsAlphanumeric`	Validates if a string contains only letters and numbers.
`IsAscii`	Checks if the string contains only ASCII characters.
`IsBase32`	Checks if the string is a valid Base32 encoded value.
`IsBase64`	Validates if a string is in Base64 encoding.
`IsBefore`	Ensures the date is before a specified date.
`IsBoolean`	Checks if the string is either "true" or "false".
`IsCreditCard`	Validates if the string is a valid credit card number.
`IsCurrency`	Checks if the string is a valid currency format.
`IsDate`	Validates if a string is a valid date.
`IsDecimal`	Ensures the string represents a valid decimal number.
`IsEmail`	Checks if the string is a valid email address format.
`IsEmpty`	Validates if a string is empty.
`IsFQDN`	Checks if the string is a fully qualified domain name.
`IsFloat`	Ensures the string represents a floating-point number.
`IsHexColor`	Validates if a string is a valid hex color (e.g., #FFFFFF).
`IsIP`	Checks if the string is a valid IP address (IPv4 or IPv6).
`IsISO8601`	Validates if the string is in ISO8601 date format.
`IsLength`	Checks if the string’s length is within a specified range.
`IsMimeType`	Validates if the string is a valid MIME type.
`IsMobilePhone`	Checks if the string is a valid mobile phone number for specified locales.
`IsMongoID`	Validates if the string is a valid MongoDB ObjectID.
`IsNumeric`	Ensures the string contains only numeric characters.
`IsPostalCode`	Checks if the string is a valid postal code for specified locale.
`IsRFC3339`	Validates if the string is in RFC3339 date format.
`IsSlug`	Checks if the string is URL-friendly (only letters, numbers, and dashes).
`IsStrongPassword`	Ensures the string meets common password strength requirements.
`IsURL`	Validates if the string is a URL.
`IsUUID`	Checks if the string is a valid UUID (versions 1-5).
`IsUpperCase`	Ensures the string is all uppercase.
`IsVAT`	Checks if the string is a valid VAT number for specified countries.
`Matches`	Validates if the string matches a specified regular expression.

This table should cover most validators currently available in validatorgo. Make sure to refer to the package's documentation for more detailed usage of each validator.

⚠ Caution

When using a validator that requires an options struct (either a pointer or non-pointer), always provide values for all the struct fields explicitly.
Unlike in validator.js, where missing fields are automatically set to defaults, Go uses strict types.
This means missing values will default to false for booleans, 0 for number types, etc.
Not specifying all fields could lead to unexpected behavior if you're used to the JavaScript version.

Examples

  // do this (using the default options specified in the docs)
  ok := validatorgo.IsFQDN("example", nil)

  // or this (explicitly setting all possible fields for the structs)
  ok := validatorgo.IsFQDN("example", &validatorgo.IsFQDNOpts{
    RequireTld: false,
    AllowUnderscores: false,
    AllowTrailingDot: true,
    AllowNumericTld: false,
    IgnoreMaxLength: true
  })

  // but rarely this(not explicitly setting all possible fields)
  ok := validatorgo.IsFQDN("example", &validatorgo.IsFQDNOpts{ RequireTld: false, })

Simple sanitizer example

  import (
   "fmt"
   "github.com/bube054/validatorgo/sanitizer"
 )

 func main(){
   str := sanitizer.Whitelist("Hello123 World!", "a-zA-Z")
   fmt.Println(str) // "HelloWorld"
 }

Sanitizers

Sanitizer	Description
`Trim`	Removes whitespace from both ends of the string.
`LTrim`	Removes whitespace from the left side of the string.
`RTrim`	Removes whitespace from the right side of the string.
`ToLower`	Converts the entire string to lowercase.
`ToUpper`	Converts the entire string to uppercase.
`Escape`	Escapes HTML characters in the string to prevent injection attacks.
`Unescape`	Reverts escaped HTML characters back to normal characters.
`NormalizeEmail`	Standardizes an email address, e.g., removing dots in Gmail addresses.
`Blacklist`	Removes characters from the string that match specified characters or patterns.
`Whitelist`	Retains only characters in the string that match specified characters or patterns.
`Replace`	Replaces occurrences of a substring with a specified replacement.
`StripLow`	Removes control characters, optionally allowing some specified ones.
`TrimSpace`	Trims all types of whitespace from both ends of the string.
`ToBoolean`	Converts common truthy and falsy values in strings into boolean `true` or `false`.
`ToInt`	Converts a numeric string into an integer, if possible.
`ToFloat`	Converts a numeric string into a floating-point number, if possible.

These sanitizers are often used to ensure data consistency and security by stripping out or modifying potentially unwanted or dangerous characters.

Make sure to refer to the official validatorgo documentation for specific implementations and examples of each sanitizer.

Summary

validatorgo is the ideal choice if you need:

Efficient, reflection-free validations for individual fields without the performance costs associated with struct-based reflection.
Highly customizable validation options that align with modern data formats, providing the same robustness as validator.js.

With validatorgo, you get a tool specifically designed for string validation, supporting both standalone and web application requirements in Go.

Maintainers

bube054 - Attah Gbubemi David (author)

Simplify Gin Input Validation in Go with ginvalidator

Gbubemi Attah — Wed, 13 Nov 2024 18:38:22 +0000

Overview

ginvalidator is a set of Gin middlewares that wraps the extensive collection of validators and sanitizers offered by my other open source package validatorgo. It also uses the popular open-source package gjson for JSON field syntax, providing efficient querying and extraction of data from JSON objects.

It allows you to combine them in many ways so that you can validate and sanitize your Gin requests, and offers tools to determine if the request is valid or not, which data was matched according to your validators.

It is based on the popular js/express library express-validator

Support

This version of ginvalidator requires that your application is running on Go 1.16+.
It's also verified to work with Gin 1.x.x.

Rationale

Why not use?

Handwritten Validators: You could write your own validation logic manually, but that gets repetitive and messy fast. Every time you need a new validation, you’re writing the same kind of code over and over. It’s easy to make mistakes, and it’s a pain to maintain.
Gin's Built-in Model Binding and Validation: Gin has validation built in, but it’s not ideal for everyone. Struct tags are limiting and make your code harder to read, especially when you need complex rules. Plus, the validation gets tied too tightly to your models, which isn't great for flexibility.
Other Libraries (like Galidator): There are other libraries out there, but they often feel too complex for what they do. They require more setup and work than you’d expect, especially when you just want a simple, straightforward solution for validation.

Installation

Make sure you have Go installed on your machine.

Step 1: Create a New Go Module

Create an empty folder with a name of your choice.
Open a terminal, navigate (cd) into that folder, and initialize a new Go module:

go mod init example.com/learning

Step 2: Install Required Packages

Use go get to install the necessary packages.

Install Gin:

go get -u github.com/gin-gonic/gin

Install ginvalidator:

go get -u github.com/bube054/ginvalidator

Getting Started

One of the best ways to learn something is by example! So let's roll the sleeves up and get some coding happening.

Setup

The first thing that one needs is a Gin server running. Let's implement one that says hi to someone; for this, create a main.go then add the following code:

package main

import (
    "net/http"

    "github.com/gin-gonic/gin"
)

func main() {
    r := gin.Default()

    r.GET("/hello", func(ctx *gin.Context) {
        person := ctx.Query("person")
        ctx.String(http.StatusOK, "Hello, %s!", person)
    })

    r.Run() // listen and serve on 0.0.0.0:8080
}

Now run this file by executing go run main.go on your terminal.

go run main.go

The HTTP server should be running, and you can open http://localhost:8080/hello?person=John to salute John!

💡 Tip:
You can use Air with Go and Gin to implement live reload. These automatically restart the server whenever a file is changed, so you don't have to do this yourself!

Adding a validator

So the server is working, but there are problems with it. Most notably, you don't want to say hello to someone when the person's name is not set.
For example, going to http://localhost:8080/hello will print "Hello, ".

That's where ginvalidator comes in handy. It provides validators, sanitizers and modifiers that are used to validate your request.
Let's add a validator and a modifier that checks that the person query string cannot be empty, with the validator named Empty and modifier named Not:

package main

import (
    "net/http"

    gv "github.com/bube054/ginvalidator"
    "github.com/gin-gonic/gin"
)

func main() {
    r := gin.Default()

    r.GET("/hello", gv.NewQuery("person", nil).
        Chain().
        Not().
        Empty(nil).
        Validate(), func(ctx *gin.Context) {
            person := ctx.Query("person")
            ctx.String(http.StatusOK, "Hello, %s!", person)
        })

    r.Run()
}

📝 Note:

For brevity, gv is used as an alias for ginvalidator in the code examples.

Now, restart your server, and go to http://localhost:8080/hello again. Hmm, it still prints "Hello, !"... why?

Handling validation errors

ginvalidator validation chain does not report validation errors to users automatically.
The reason for this is simple: as you add more validators, or for more fields, how do you want to collect the errors? Do you want a list of all errors, only one per field, only one overall...?

So the next obvious step is to change the above code again, this time verifying the validation result with the ValidationResult function:

package main

import (
    "net/http"

    gv "github.com/bube054/ginvalidator"
    "github.com/gin-gonic/gin"
)

func main() {
    r := gin.Default()

    r.GET("/hello",
        gv.NewQuery("person", nil).
            Chain().
            Not().
            Empty(nil).
            Validate(),
        func(ctx *gin.Context) {
            result, err := gv.ValidationResult(ctx)
            if err != nil {
                ctx.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{
                    "message": "The server encountered an unexpected error.",
                })
                return
            }

            if len(result) != 0 {
                ctx.AbortWithStatusJSON(http.StatusUnprocessableEntity, gin.H{
                    "errors": result,
                })
                return
            }

            person := ctx.Query("person")
            ctx.String(http.StatusOK, "Hello, %s!", person)
        })

    r.Run()
}

Now, if you access http://localhost:8080/hello again, you’ll see the following JSON content, formatted for clarity:

{
  "errors": [
    {
      "location": "queries",
      "message": "Invalid value",
      "field": "person",
      "value": ""
    }
  ]
}

Now, what this is telling us is that

there's been exactly one error in this request;
this field is called person;
it's located in the query string (location: "queries");
the error message that was given was "Invalid value".

This is a better scenario, but it can still be improved. Let's continue.

Creating better error messages

All request location validators accept an optional second argument, which is a function used to format the error message. If nil is provided, a default, generic error message will be used, as shown in the example above.

package main

import (
    "net/http"

    gv "github.com/bube054/ginvalidator"
    "github.com/gin-gonic/gin"
)

func main() {
    r := gin.Default()

    r.GET("/hello",
        gv.NewQuery("person",
            func(initialValue, sanitizedValue, validatorName string) string {
                return "Please enter your name."
            },
        ).Chain().
            Not().
            Empty(nil).
            Validate(),
        func(ctx *gin.Context) {
            result, err := gv.ValidationResult(ctx)
            if err != nil {
                ctx.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{
                    "message": "The server encountered an unexpected error.",
                })
                return
            }

            if len(result) != 0 {
                ctx.AbortWithStatusJSON(http.StatusUnprocessableEntity, gin.H{
                    "errors": result,
                })
                return
            }

            person := ctx.Query("person")
            ctx.String(http.StatusOK, "Hello, %s!", person)
        })

    r.Run()
}

Now if you access http://localhost:8080/hello again, what you'll see is the following JSON content, with the new error message:

{
  "errors": [
    {
      "location": "queries",
      "message": "Please enter your name.",
      "field": "person",
      "value": ""
    }
  ]
}

Accessing validated/sanitized data

You can use GetMatchedData, which automatically collects all data that ginvalidator has validated and/or sanitized. This data can then be accessed using the Get method of MatchedData:

package main

import (
    "net/http"

    gv "github.com/bube054/ginvalidator"
    "github.com/gin-gonic/gin"
)

func main() {
    r := gin.Default()

    r.GET("/hello",
        gv.NewQuery("person",
            func(initialValue, sanitizedValue, validatorName string) string {
                return "Please enter your name."
            },
        ).Chain().
            Not().
            Empty(nil).
            Validate(),
        func(ctx *gin.Context) {
            result, err := gv.ValidationResult(ctx)
            if err != nil {
                ctx.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{
                    "message": "The server encountered an unexpected error.",
                })
                return
            }

            if len(result) != 0 {
                ctx.AbortWithStatusJSON(http.StatusUnprocessableEntity, gin.H{
                    "errors": result,
                })
                return
            }

            data, err := gv.GetMatchedData(ctx)
            if err != nil {
                ctx.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{
                    "message": "The server encountered an unexpected error.",
                })
                return
            }

            person, ok := data.Get(gv.QueryLocation, "person")
            if !ok {
                ctx.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{
                    "message": "The server encountered an unexpected error.",
                })
                return
            }

            ctx.String(http.StatusOK, "Hello, %s!", person)
        })

    r.Run()
}

open http://localhost:8080/hello?person=John to salute John!

The available locations are BodyLocation, CookieLocation QueryLocation, ParamLocation and HeaderLocation.
Each of these locations includes a String method that returns the location where validated/sanitized data is being stored.

Sanitizing inputs

While the user can no longer send empty person names, it can still inject HTML into your page! This is known as the Cross-Site Scripting vulnerability (XSS).
Let's see how it works. Go to http://localhost:8080/hello?person=<b>John</b>, and you should see "Hello, John!".
While this example is fine, an attacker could change the person query string to a <script> tag which loads its own JavaScript that could be harmful.
In this scenario, one way to mitigate the issue with ginvalidator is to use a sanitizer, most specifically Escape, which transforms special HTML characters with others that can be represented as text.

package main

import (
    "net/http"

    gv "github.com/bube054/ginvalidator"
    "github.com/gin-gonic/gin"
)

func main() {
    r := gin.Default()

    r.GET("/hello",
        gv.NewQuery("person",
            func(initialValue, sanitizedValue, validatorName string) string {
                return "Please enter your name."
            },
        ).Chain().
            Not().
            Empty(nil).
            Escape(). // Added sanitizer
            Validate(),
        func(ctx *gin.Context) {
            result, err := gv.ValidationResult(ctx)
            if err != nil {
                ctx.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{
                    "message": "The server encountered an unexpected error.",
                })
                return
            }

            if len(result) != 0 {
                ctx.AbortWithStatusJSON(http.StatusUnprocessableEntity, gin.H{
                    "errors": result,
                })
                return
            }

            data, err := gv.GetMatchedData(ctx)
            if err != nil {
                ctx.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{
                    "message": "The server encountered an unexpected error.",
                })
                return
            }

            person, ok := data.Get(gv.QueryLocation, "person")
            if !ok {
                ctx.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{
                    "message": "The server encountered an unexpected error.",
                })
                return
            }

            ctx.String(http.StatusOK, "Hello, %s!", person)
        })

    r.Run()
}

Now, if you restart the server and refresh the page, what you'll see is "Hello, <b>John<b>!". Our example page is no longer vulnerable to XSS!

⚠️ Caution:

ginvalidator does not modify http.Request values during sanitization. To access sanitized data, always use the GetMatchedData function.

The Validation Chain

The validation chain is one of the main concepts in ginvalidator, therefore it's useful to learn about it, so that you can use it effectively.

But don't worry: if you've read through the Getting Started guide, you have already used validation chains without even noticing!

What are validation chains?

Validation chains are created using the following functions, each targeting a specific location in the HTTP request:

NewBody: Validates data from the http.Request body. Its location is BodyLocation.
NewCookie: Validates data from the http.Request cookies. Its location is CookieLocation.
NewHeader: Validates data from the http.Request headers. Its location is HeaderLocation.
NewParam: Validates data from the Gin route parameters. Its location is ParamLocation.
NewQuery: Validates data from the http.Request query parameters. Its location is QueryLocation.

They have this name because they wrap the value of a field with validations (or sanitizations), and each of its methods returns itself.
This pattern is usually called method chaining, hence why the name validation chain.

Validation chains not only have a number of useful methods for defining validations, sanitizations and modifications but they also have methods Validate which returns the Gin middleware handler function.

This is an example of how validation chains are usually used, and how you can read one:

  r.Get(
    "newsletter",
    // For the `email` field in ctx.GetRawData()...
    gv.NewBody("email", nil)
    // the actual validation chain
    .Chain()
    // ...mark the field as optional
    .Optional()
    // ...and when it's present, trim its value, then validate it as an email address
    .Trim("")
    .Email(nil),
    maybeSubscribeToNewsletter,
  )

Features

A validation chain has three kinds of methods: validators, sanitizers and modifiers.

Validators determine if the value of a request field is valid. This means checking if the field is in the format that you expect it to be. For example, if you're building a sign up form, your requirements could be that the username must be an e-mail address, and that passwords must be at least 8 characters long.

If the value is invalid, an error is recorded for that field using some error message. This validation error can then be retrieved at a later point in the Gin route handler and returned to the user.

They are:

Sanitizers transform the field value. They are useful to remove noise from the value and perhaps even to provide some basic line of defense against threats.

Sanitizers persist the updated fields value back into the Gin Contexts, so that it's usable by other ginvalidator functions, your own route handler code, and even other middlewares.

They are:

Modifiers define how validation chains behave when they are run.

They are:

📝 Note:

These methods are thoroughly documented using GoDoc within the pkg.go.dev ginvalidator documentation. If any details are unclear, you may also want to refer to related functions within the validatorgo package for additional context, which I’ll be explaining below.

Standard validators/sanitizers

All of the functionality exposed by the validation chain actually comes from validatorgo, one of my other open source go packages which specializes in string validation/sanitation. Please check it out, star and share 🙏🙏🙏, Thank You.

This includes all of validatorgo validators and sanitizers, from commonly used IsEmail, IsLength, and Trim to the more niche IsISBN, IsMultibyte and StripLow!

These are called standard validators and standard sanitizers in ginvalidator. But without the Is prefix from validatorgo.

Chaining order

The order in which you call methods on a validation chain usually matters.
They are almost always run in the order that they are specified, therefore you can tell what a validation chain will do just by reading its definition, from first chained method to last.

Take the following snippet as an example:

// Validate if search_query is not empty, then trim it
NewQuery("search_query", nil).Chain().Not().Empty().Trim("").Validate();

In this case, if the user passes a "search_query" value that is composed of whitespaces only, it won't be empty, therefore the validation passes. But since the .Trim() sanitizer is there, the whitespace's will be removed, and the field will become empty, so you actually end up with a false positive.

Now, compare it with the below snippet:

// Trim search_query, then validate if it's not empty
NewQuery("search_query", nil).Chain().Trim("").Not().Empty().Validate();

This chain will more sensibly remove whitespace's, and then validate if the value is not empty.

One exception to this rule is .Optional(): It can be placed at any point in the chain and it will mark the chain as optional.

Reusing validation chains

If you wish to reuse the same chain, it's a good idea to return them from functions:

func createEmailValidator() gin.HandlerFunc {
  return gv.NewBody("email", nil).Chain().Email(nil).Validate()
}

func handleLoginRoute(ctx *gin.Context) {
  // Handle login route
}

func handleSignupRoute(ctx *gin.Context) {
  // Handle signup route
}

r.POST("/login", createEmailValidator(), handleLoginRoute)
r.POST("/signup", createEmailValidator(), handleSignupRoute)

Field Selection

In ginvalidator, a field is any value that is either validated or sanitized and it is string.

Pretty much every function or value returned by ginvalidator reference fields in some way. For this reason, it's important to understand the field path syntax both for when selecting fields for validation, and when accessing the validation errors or validated data.

Syntax

Body fields are only valid for the following Content-Types:
- application/json: This uses GJSON path syntax for extracting values. Please refer to the linked documentation for details.
- Example:
```
  {
    "user": {
      "name": "John",
      "email": "john.doe@example.com"
    }
  }
```
With path user.name, the extracted value would be "John".
- application/x-www-form-urlencoded: Typically used for HTML form submissions. Fields are submitted as key-value pairs in the body.
- Example:
```
  Content-Type: application/x-www-form-urlencoded
```
Body:
```
  name=John&email=john.doe@example.com
```
Field "name" would have the value "John", and "email" would have the value "john.doe@example.com".
- multipart/form-data: Commonly used for file uploads or when submitting form data with files.
- Example:
```
  Content-Type: multipart/form-data
```
Body:
```
  --boundary
  Content-Disposition: form-data; name="name"

  John
  --boundary
  Content-Disposition: form-data; name="file"; filename="resume.pdf"
  Content-Type: application/pdf

  [binary data]
  --boundary--
```
Field "name" would have the value "John", and "file" would be the uploaded file.
Query fields correspond to URL search parameters, and their values are automatically url unescaped by Gin.

Examples:
- Field: "name", Value: "John"
```
/hello?name=John
```
- Field: "full_name", Value: "John Doe"
```
/hello?full_name=John%20Doe
```
Param fields represent URL path parameters, and their values are automatically unescaped by ginvalidator.

Example:
- Field: "id", Value: "123"
```
/users/:id
```
Header fields are HTTP request headers, and their values are not unescaped. A log warning will appear if you provide a non-canonical header key.

Example:
- Field: "User-Agent", Value: "Mozilla/5.0"
```
Header: "User-Agent", Value: "Mozilla/5.0"
```
Cookies fields are HTTP cookies, and their values are automatically url unescaped by Gin.

Example:
- Field: "session_id", Value: "abc 123"
```
Cookie: "session_id=abc%20123"
```

Customizing express-validator

If the server you're building is anything but a very simple one, you'll need validators, sanitizers and error messages beyond the ones built into ginvalidator sooner or later.

Custom Validators and Sanitizers

A classic need that ginvalidator can't fulfill for you, and that you might run into, is validating whether an e-mail address is in use or not when a user signing up.

It's possible to do this in ginvalidator by implementing a custom validator.

A CustomValidator is a method available on the validation chain, that receives a special function CustomValidatorFunc, and have to returns a boolean that will determine if the field is valid or not.

A CustomSanitizer is also a method available on the validation chain, that receives a special function CustomSanitizerFunc, and have to returns the new sanitized value.

Implementing a custom validator

A CustomValidator can be asynchronous by using goroutines and a sync.WaitGroup to handle concurrent operations. Within the validator, you can spin up goroutines for each asynchronous task, adding each task to the WaitGroup. Once all tasks complete, the validator should return a boolean.

For example, in order to check that an e-mail is not in use:

func isUserPresent(email string) bool {
    return email == "existing@example.com"
}

r.POST("/create-user",
    gv.
      NewBody("email", nil).
      Chain().
      CustomValidator(
        func(req *http.Request, initialValue, sanitizedValue string) bool {
          var exists bool
          var wg sync.WaitGroup
          wg.Add(1)

          go func() {
            defer wg.Done()
            exists = isUserPresent(sanitizedValue)
          }()

          wg.Wait()

          return !exists
        },
      ).
      Validate(),

    func(ctx *gin.Context) {
      // Handle the request
    },
)

Or maybe you could also verify that the password matches the repeat:

type createUser struct {
  Password             string `json:"password"`
  PasswordConfirmation string `json:"passwordConfirmation"`
}

r.POST("/create-user",
    gv.NewBody("password", nil).
    Chain().
    Matches(regexp.MustCompile(`^[A-Za-z\d]{8,}$`)).
    Validate(),
  gv.NewBody("passwordConfirmation", nil).
    Chain().
    CustomValidator(func(req *http.Request, initialValue, sanitizedValue string) bool {
      data, err := io.ReadAll(req.Body)
      if err != nil {
      return false
      }

      // Refill the request body to allow further reads, if needed.
      req.Body = io.NopCloser(bytes.NewBuffer(data))

      var user createUser
      json.Unmarshal(data, &user)

      return sanitizedValue == user.PasswordConfirmation
    }).
    Validate(),
  func(ctx *gin.Context) {
    // Handle request
  },
)

⚠️ Caution:
If the request body will be accessed multiple times—whether in the same validation chain, in another validation chain for the same request context, or in subsequent handlers—ensure you reset the request body after each read. Failing to do so can lead to errors or missing data when the body is read again.

Implementing a custom sanitizer

CustomSanitizer don't have many rules. Whatever the value that they return, is the new value that the field will acquire.
Custom sanitizers can also be asynchronous by using goroutines and a sync.WaitGroup to handle concurrent operations.

r.POST("/user/:id",
    gv.NewParam("id", nil).
      Chain().
      CustomSanitizer(
        func(req *http.Request, initialValue, sanitizedValue string) string {
          return strings.Repeat(sanitizedValue, 3) // some string manipulation
        },
      ).
      Validate(),

    func(ctx *gin.Context) {
      // Handle request
    },
)

Error Messages

Whenever a field value is invalid, an error message is recorded for it.
The default error message is "Invalid value", which is not descriptive at all of what the error is, so you might need to customize it. You can customize by

gv.NewBody("email",
    func(initialValue, sanitizedValue, validatorName string) string {
        switch validatorName {
        case gv.EmailValidatorName:
            return "Email is not valid."
        case gv.EmptyValidatorName:
            return "Email is empty."
        default:
            return gv.DefaultValChainErrMsg
        }
    },
).
Chain().
Not().Empty(nil).
Email(nil).
Validate()

initialValue is the original value extracted from the request (before any sanitization).
sanitizedValue is the value after it has been sanitized (if applicable).
validatorName is the name of the validator that failed, which helps identify the validation rule that did not pass.

For a complete list of validator names, refer to the ginvalidator constants.

Maintainers

bube054 - Attah Gbubemi David (author)

DEV Community: Gbubemi Attah

Introducing jsonvx: The Most Customisable JSON Parser, Querier & Formatter for Go

Why jsonvx Stands Out

Quick Start Example

Feature Highlights at a Glance

Getting Started

Customization Options

Number Handling

Strings & Keys

Comments

JSON5 Preset

Closing Thoughts

I Built a Beam Analysis Tool Using Slope-Deflection! 🚀

Developing a Simple RESTful API with Gin, ginvalidator, and validatorgo

API endpoint design

Writing the Code

Final thoughts

Full Code

Simplifying String Validation in Go: Introducing validatorgo

Why Choose validatorgo?

1. Compared to go-playground/validator

2. Compared to asaskevich/govalidator

Project Motivation

Installation

Simple validator example

Some Validators

Simple sanitizer example

Sanitizers

Summary

Maintainers

Simplify Gin Input Validation in Go with ginvalidator

Overview

Support

Rationale

Installation

Step 1: Create a New Go Module

Step 2: Install Required Packages

Getting Started

Setup

Adding a validator

Handling validation errors

Creating better error messages

Accessing validated/sanitized data

Sanitizing inputs

The Validation Chain

What are validation chains?

Features

Standard validators/sanitizers

Chaining order

Reusing validation chains

Field Selection

Syntax

Customizing express-validator

Custom Validators and Sanitizers

Implementing a custom validator

Implementing a custom sanitizer

Error Messages

Maintainers

1. Compared to `go-playground/validator`

2. Compared to `asaskevich/govalidator`