Free, Open Source, Self-Hosted WhatsApp API Gateway
TypeScript apibotgatewayself-hostedwhatsappwhatsapp-apiwhatsapp-automationwhatsapp-botwhatsapp-gatewaywhatsapp-gateway-apiwhatsapp-webwhatsapp-web-api
package openwa
import (
"net/http"
"time"
)
// RoundTripperFunc adapts a function to an http.RoundTripper, so a middleware
// can be written as a closure instead of a named type.
type RoundTripperFunc func(*http.Request) (*http.Response, error)
// RoundTrip implements http.RoundTripper.
func (f RoundTripperFunc) RoundTrip(req *http.Request) (*http.Response, error) {
return f(req)
}
// Middleware wraps an http.RoundTripper to add behavior (retry, logging,
// metrics, tracing, custom auth). Middlewares compose into a pipeline: the
// first one passed to WithMiddleware is the outermost (runs first on the way
// out, last on the way back). Inject cross-cutting concerns like this instead
// of subclassing the client.
//
// client, _ := openwa.New(baseURL, apiKey,
// openwa.WithMiddleware(tracingMiddleware, metricsMiddleware),
// )
type Middleware func(next http.RoundTripper) http.RoundTripper
// buildTransport composes the request pipeline from the base transport outward:
//
// base -> auth -> logging -> retry -> user middlewares (index 0 outermost)
//
// Auth sits innermost so every attempt — including retries — carries the API
// key. Retry wraps logging+auth so each attempt is logged and re-authenticated.
func buildTransport(cfg *config, base http.RoundTripper) http.RoundTripper {
rt := base
rt = authMiddleware(cfg)(rt)
rt = loggingMiddleware(cfg.logger)(rt)
if cfg.retry != nil {
rt = retryMiddleware(*cfg.retry, cfg.logger)(rt)
}
for i := len(cfg.middlewares) - 1; i >= 0; i-- {
rt = cfg.middlewares[i](rt)
}
return rt
}
// authMiddleware injects the API key and default headers on every outbound
// request. Caller-supplied default headers are applied first so the auth and
// content headers below always win and can never be clobbered.
func authMiddleware(cfg *config) Middleware {
return func(next http.RoundTripper) http.RoundTripper {
return RoundTripperFunc(func(req *http.Request) (*http.Response, error) {
// Clone so we never mutate the caller's request headers.
r := req.Clone(req.Context())
for k, vs := range cfg.headers {
// Only apply defaults for a header the caller has not already
// set. The check runs once per key so all default values are
// added (not just the first, which the earlier per-value check
// silently dropped).
if r.Header.Get(k) != "" {
continue
}
for _, v := range vs {
r.Header.Add(k, v)
}
}
r.Header.Set("X-API-Key", cfg.apiKey)
if cfg.userAgent != "" && r.Header.Get("User-Agent") == "" {
r.Header.Set("User-Agent", cfg.userAgent)
}
return next.RoundTrip(r)
})
}
}
// loggingMiddleware logs one record per attempt at debug level, and errors at
// error level. It is a no-op in practice when the injected logger is nopLogger.
func loggingMiddleware(log Logger) Middleware {
return func(next http.RoundTripper) http.RoundTripper {
return RoundTripperFunc(func(req *http.Request) (*http.Response, error) {
start := time.Now()
resp, err := next.RoundTrip(req)
dur := time.Since(start)
if err != nil {
log.Log(req.Context(), LevelError, "openwa request failed",
"method", req.Method, "url", req.URL.Redacted(),
"duration_ms", dur.Milliseconds(), "error", err.Error())
return resp, err
}
log.Log(req.Context(), LevelDebug, "openwa request",
"method", req.Method, "url", req.URL.Redacted(),
"status", resp.StatusCode, "duration_ms", dur.Milliseconds())
return resp, nil
})
}
}