Cheap and reliable Node.js hosting starts at $3/month, and $1/month static HTML hosting

Created with love in Canada, visit hostnodejs.com today

Feel like to post an Ad? Learn Details

All Projects → teambition → Gear

teambition / Gear

Licence: mit

A lightweight, composable and high performance web service framework for Go.

Programming Languages

31211 projects - #10 most used programming language

Labels

framework web logging middleware router hooks http2

Projects that are alternatives of or similar to Gear

Twig - less is more's web server for golang

Stars: ✭ 98 (-81.99%)

Mutual labels: middleware, framework, router, http2

⚡A powerful HTTP router and URL matcher for building Deno web servers.

Stars: ✭ 56 (-89.71%)

Mutual labels: middleware, framework, router

⛳️ The Golf web framework

Stars: ✭ 248 (-54.41%)

Mutual labels: middleware, framework, router

A minimalistic web framework with route grouping and middleware chaining

Stars: ✭ 95 (-82.54%)

Mutual labels: middleware, framework, router

Gin is a HTTP web framework written in Go (Golang). It features a Martini-like API with much better performance -- up to 40 times faster. If you need smashing performance, get yourself some Gin.

Stars: ✭ 53,971 (+9821.14%)

Mutual labels: middleware, framework, router

The fast, easy to use & typescript ready web framework for Node.js

Stars: ✭ 138 (-74.63%)

Mutual labels: middleware, framework, router

The fastest HTTP/2 Go Web Framework. AWS Lambda, gRPC, MVC, Unique Router, Websockets, Sessions, Test suite, Dependency Injection and more. A true successor of expressjs and laravel | 谢谢 https://github.com/kataras/iris/issues/1329 |

Stars: ✭ 21,587 (+3868.2%)

Mutual labels: middleware, framework, router

✨ The simple web framework for Node.js with zero dependencies.

Stars: ✭ 139 (-74.45%)

Mutual labels: middleware, framework, router

zen is a elegant and lightweight web framework for Go

Stars: ✭ 257 (-52.76%)

Mutual labels: middleware, framework, router

Transmittable Thread Local

📌 TransmittableThreadLocal (TTL), the missing Java™ std lib(simple & 0-dependency) for framework/middleware, provide an enhanced InheritableThreadLocal that transmits values between threads even using thread pooling components.

Stars: ✭ 4,678 (+759.93%)

Mutual labels: middleware, framework

High performance, minimalist Go web framework

Stars: ✭ 21,297 (+3814.89%)

Mutual labels: middleware, http2

🗺 Universal router for web applications.

Stars: ✭ 541 (-0.55%)

Mutual labels: middleware, router

Ultra performant API Gateway with middlewares. A project hosted at The Linux Foundation

Stars: ✭ 4,752 (+773.53%)

Mutual labels: middleware, router

Modern infrastructure of complex SPA

Stars: ✭ 374 (-31.25%)

Mutual labels: middleware, router

A tiny, fast and modular node.js web framework. Good for making fast & scalable apps and apis.

Stars: ✭ 394 (-27.57%)

Mutual labels: middleware, router

An out the box activity logger for your Laravel or Lumen application. Laravel logger is an activity event logger for your laravel application. It comes out the box with ready to use with dashboard to view your activity. Laravel logger can be added as a middleware or called through a trait. This package is easily configurable and customizable. Supports Laravel 5.3, 5.4, 5.5, 5.6, 5.7, 5.8, 6, and 7+

Stars: ✭ 366 (-32.72%)

Mutual labels: middleware, logging

An extremely fast Go (golang) HTTP router that supports regular expression route matching. Comes with full support for building RESTful APIs.

Stars: ✭ 398 (-26.84%)

Mutual labels: framework, router

Productivity-oriented collection of lightweight fancy stuff for Scala toolchain

Stars: ✭ 423 (-22.24%)

Mutual labels: framework, logging

A modern, MVC-powered WordPress as a CMS workflow. 🚀

Stars: ✭ 348 (-36.03%)

Mutual labels: middleware, framework

Concurrency Logger

Log HTTP requests/responses separately, visualize their concurrency and report logs/errors in context of a request.

Stars: ✭ 400 (-26.47%)

Mutual labels: middleware, logging

View All Similar Projects ➔

A lightweight, composable and high performance web service framework for Go.

Features

Effective and flexible middlewares flow control, create anything by middleware
Powerful and smart HTTP error handling
Trie base gear.Router, as faster as HttpRouter, support regexp parameters and group routes
Integrated timeout context.Context
Integrated response content compress
Integrated structured logging middleware
Integrated request body parser
Integrated signed cookies
Integrated JSON, JSONP, XML and HTML renderer
Integrated CORS, Secure, Favicon and Static middlewares
More useful methods on gear.Context to manipulate HTTP Request/Response
Run HTTP and gRPC on the same port
Completely HTTP/2.0 supported

Documentation

Go-Documentation

Import

// package gear
import "github.com/teambition/gear"

Design

FAQ

Demo

Hello

https://github.com/teambition/gear/tree/master/example/hello

  app := gear.New()

  // Add logging middleware
  app.UseHandler(logging.Default(true))

  // Add router middleware
  router := gear.NewRouter()

  // try: http://127.0.0.1:3000/hello
  router.Get("/hello", func(ctx *gear.Context) error {
    return ctx.HTML(200, "<h1>Hello, Gear!</h1>")
  })

  // try: http://127.0.0.1:3000/test?query=hello
  router.Otherwise(func(ctx *gear.Context) error {
    return ctx.JSON(200, map[string]interface{}{
      "Host":    ctx.Host,
      "Method":  ctx.Method,
      "Path":    ctx.Path,
      "URI":     ctx.Req.RequestURI,
      "Headers": ctx.Req.Header,
    })
  })
  app.UseHandler(router)
  app.Error(app.Listen(":3000"))

HTTP2 with Push

https://github.com/teambition/gear/tree/master/example/http2

package main

import (
  "net/http"

  "github.com/teambition/gear"
  "github.com/teambition/gear/logging"
  "github.com/teambition/gear/middleware/favicon"
)

// go run example/http2/app.go
// Visit: https://127.0.0.1:3000/
func main() {
  const htmlBody = `
<!DOCTYPE html>
<html>
  <head>
    <link href="/hello.css" rel="stylesheet" type="text/css">
  </head>
  <body>
    <h1>Hello, Gear!</h1>
  </body>
</html>`

  const pushBody = `
h1 {
  color: red;
}
`

  app := gear.New()

  app.UseHandler(logging.Default(true))
  app.Use(favicon.New("./testdata/favicon.ico"))

  router := gear.NewRouter()
  router.Get("/", func(ctx *gear.Context) error {
    ctx.Res.Push("/hello.css", &http.PushOptions{Method: "GET"})
    return ctx.HTML(200, htmlBody)
  })
  router.Get("/hello.css", func(ctx *gear.Context) error {
    ctx.Type("text/css")
    return ctx.End(200, []byte(pushBody))
  })
  app.UseHandler(router)
  app.Error(app.ListenTLS(":3000", "./testdata/out/test.crt", "./testdata/out/test.key"))
}

A CMD tool: static server

https://github.com/teambition/gear/tree/master/example/staticgo

Install it with go:

go install github.com/teambition/gear/example/staticgo

It is a useful CMD tool that serve your local files as web server (support TLS). You can build osx, linux, windows version with make build.

package main

import (
  "flag"

  "github.com/teambition/gear"
  "github.com/teambition/gear/logging"
  "github.com/teambition/gear/middleware/cors"
  "github.com/teambition/gear/middleware/static"
)

var (
  address  = flag.String("addr", "127.0.0.1:3000", `address to listen on.`)
  path     = flag.String("path", "./", `static files path to serve.`)
  certFile = flag.String("certFile", "", `certFile path, used to create TLS static server.`)
  keyFile  = flag.String("keyFile", "", `keyFile path, used to create TLS static server.`)
)

func main() {
  flag.Parse()
  app := gear.New()

  app.UseHandler(logging.Default(true))
  app.Use(cors.New())
  app.Use(static.New(static.Options{Root: *path}))

  logging.Println("staticgo v1.1.0, created by https://github.com/teambition/gear")
  logging.Printf("listen: %s, serve: %s\n", *address, *path)

  if *certFile != "" && *keyFile != "" {
    app.Error(app.ListenTLS(*address, *certFile, *keyFile))
  } else {
    app.Error(app.Listen(*address))
  }
}

HTTP2 & gRPC

https://github.com/teambition/gear/tree/master/example/grpc_server

https://github.com/teambition/gear/tree/master/example/grpc_client

About Router

gear.Router is a trie base HTTP request handler. Features:

Support named parameter
Support regexp
Support suffix matching
Support multi-router
Support router layer middlewares
Support fixed path automatic redirection
Support trailing slash automatic redirection
Automatic handle 405 Method Not Allowed
Automatic handle OPTIONS method
Best Performance

The registered path, against which the router matches incoming requests, can contain six types of parameters:

Syntax	Description
`:name`	named parameter
`:name(regexp)`	named with regexp parameter
`:name+suffix`	named parameter with suffix matching
`:name(regexp)+suffix`	named with regexp parameter and suffix matching
`:name*`	named with catch-all parameter
`::name`	not named parameter, it is literal `:name`

Named parameters are dynamic path segments. They match anything until the next '/' or the path end:

Defined: /api/:type/:ID

/api/user/123             matched: type="user", ID="123"
/api/user                 no match
/api/user/123/comments    no match

Named with regexp parameters match anything using regexp until the next '/' or the path end:

Defined: /api/:type/:ID(^\d+$)

/api/user/123             matched: type="user", ID="123"
/api/user                 no match
/api/user/abc             no match
/api/user/123/comments    no match

Named parameters with suffix, such as Google API Design:

Defined: /api/:resource/:ID+:undelete

/api/file/123                     no match
/api/file/123:undelete            matched: resource="file", ID="123"
/api/file/123:undelete/comments   no match

Named with regexp parameters and suffix:

Defined: /api/:resource/:ID(^\d+$)+:cancel

/api/task/123                   no match
/api/task/123:cancel            matched: resource="task", ID="123"
/api/task/abc:cancel            no match

Named with catch-all parameters match anything until the path end, including the directory index (the '/' before the catch-all). Since they match anything until the end, catch-all parameters must always be the final path element.

Defined: /files/:filepath*

/files                           no match
/files/LICENSE                   matched: filepath="LICENSE"
/files/templates/article.html    matched: filepath="templates/article.html"

The value of parameters is saved on the Matched.Params. Retrieve the value of a parameter by name:

type := matched.Params("type")
id   := matched.Params("ID")

More Middlewares

Structured logging: github.com/teambition/gear/logging
CORS handler: github.com/teambition/gear/middleware/cors
Secure handler: github.com/teambition/gear/middleware/secure
Static serving: github.com/teambition/gear/middleware/static
Favicon serving: github.com/teambition/gear/middleware/favicon
gRPC serving: github.com/teambition/gear/middleware/grpc
JWT and Crypto auth: Gear-Auth
Cookie session: Gear-Session
Session middleware: https://github.com/go-session/gear-session
Smart rate limiter: Gear-Ratelimiter
CSRF: Gear-CSRF
Opentracing with Zipkin: Gear-Tracing

License

Gear is licensed under the MIT license. Copyright © 2016-2021 Teambition.

Note that the project description data, including the texts, logos, images, and/or trademarks, for each open source project belongs to its rightful owner. If you wish to add or remove any projects, please contact us at [email protected].

Stars: ✭ 544

Visit Git Page 🔗Visit User Page 🔗Visit Issues Page (1) 🔗