Notification Library for Go

One Go API for chat, email, SMS, push, and on-call alerts.
Features · Quick Start · Drivers · Installation · Examples · API
Features
| Feature | What you get |
|---|---|
| Send a title and body through a configured driver. | |
| Optionally resolve recipients and apply channel preferences and fallback. | |
| Render channel-specific content with typed renderers and transports. | |
| Optional process-local deduplication preserves accepted channels. | |
| Built-in errors and logs omit endpoints, credentials and message content. | |
| Capture messages through the Sender interface. |
Quick Start
Requires Go 1.24+. Try the complete example without credentials or an external service:
git clone --branch v0.1.0 --depth 1 https://github.com/goforj/notification.git
cd notification
go run ./examples/quickstartConfigure a driver once, then send a title and body. The complete program includes the imports:
driver := log.New(slog.New(slog.NewTextHandler(io.Discard, nil)))
notifier := notification.New(driver)
err := notifier.Send(context.Background(), notification.Message{
Title: "Ticket updated",
Body: "Ticket T-42 has a new owner.",
})
if err != nil {
panic(err)
}
fmt.Println("message captured")
// message capturedThe log driver records a local capture without logging message content. Replace it with a provider driver to use the same Send call for real notifications. Send is synchronous and performs no retries or background work. Success means the driver handled the message, not that the recipient received it.
For your own application, use the installation commands below. The commands use @latest to select the newest published release.
Drivers
| Driver | Acceptance | Verification |
|---|---|---|
| Native SNS message ID | Protocol tests | |
| HTTP/2 acceptance and request ID | Protocol tests | |
| Non-streaming relay acceptance | Protocol tests | |
| Native response code | Protocol tests | |
| Native incident ID; actions preserve ID | Protocol tests | |
| Native envelope and per-message result | Protocol tests | |
| Robot response code | Protocol tests | |
| Message ID | Protocol tests | |
| Native push ticket; not a delivery receipt | Protocol tests | |
| Bot response code | Protocol tests | |
| Project-scoped native message name | Protocol tests | |
| Native Signals acceptance | Protocol tests | |
| Generic Incoming acceptance | Protocol tests | |
| Message resource | Protocol tests | |
| Message ID and content | Gotify 3.1.1 | |
| Notify service response | Protocol tests | |
| Event-trigger acknowledgement | Protocol tests | |
| HTTP 202 event acceptance | Protocol tests | |
| Correlated event acceptance | Protocol tests | |
| Async request ID | Protocol tests | |
| Native success flag | Protocol tests | |
| Push acknowledgement | Protocol tests | |
| Local capture | Local capture | |
| Mailer acceptance | Composition tests | |
| Event ID; fresh transaction per Send | Synapse 1.164.2 | |
| Native ok acknowledgement | Protocol tests | |
| OCS status and message ID | Protocol tests | |
| Message ID and topic | ntfy 2.37.2 | |
| Native message ID and recipient checks | Protocol tests | |
| Async request ID | Protocol tests | |
| Event and incident key | Protocol tests | |
| Native integration acceptance | Protocol tests | |
| Native request and message UUID | Protocol tests | |
| Native push ID | Protocol tests | |
| Native status and request ID | Protocol tests | |
| Native success flag | Protocol tests | |
| Native send timestamp | Protocol tests | |
| Native webhook acceptance | Protocol tests | |
| ok acknowledgement | Protocol tests | |
| HTTP acceptance | Protocol tests | |
| Message ID | Protocol tests | |
| Recipient-correlated message status | Protocol tests | |
| Message SID and status | Protocol tests | |
| All SMS segments accepted | Protocol tests | |
| HTTP acceptance | Protocol tests | |
| Encrypted push-service acceptance | Protocol tests | |
| HTTP acceptance | Protocol tests | |
| Robot response code | Protocol tests | |
| Send acknowledgement | Protocol tests | |
| Native message and recipient acknowledgement | Protocol tests | |
| Success result and message ID | Protocol tests |
All drivers have local tests. ntfy, Gotify and Matrix also pass real-server tests; hosted and paired-session verification remains pending for other providers. See driver configuration and delivery contracts for details and integration evidence for exact server versions.
Mail reuses your configured GoForj Mailer for SMTP, SendGrid, Resend, Mailgun, Postmark, or Amazon SES. Teams uses Workflows, LINE uses the Messaging API, and Opsgenie provides legacy integration support.
The root module uses only the standard library. Mail, APNs, SNS and Web Push are optional modules. Drivers own their configured destinations; a Message contains only content. Errors preserve cancellation and provider classifications without exposing provider response text. See delivery contracts for bounds and ownership.
Installation
Install the latest release:
go get github.com/goforj/notification@latestAll drivers except Mail, APNs, SNS and Web Push are packages in the root module. Import them from github.com/goforj/notification/driver/<name>; they need no separate installation.
Install only the optional modules you use:
# Mail
go get github.com/goforj/notification/driver/mail@latest
# Apple APNs
go get github.com/goforj/notification/driver/apns@latest
# Amazon SNS
go get github.com/goforj/notification/driver/sns@latest
# Web Push
go get github.com/goforj/notification/driver/webpush@latestMail borrows an application-owned *mail.Mailer and configured recipients. Mail owns sender defaults, email composition and transport. The other optional modules isolate their AWS SDK or cryptographic dependencies from the root module. See Mail integration and provider capabilities for supported operations and limits.
Runnable Examples
| Program | Run from the repository root | Demonstrates |
|---|---|---|
| Quick start | go run ./examples/quickstart | A title and body through the log driver |
| Webhook | go run ./examples/webhook | A message sent to a configured local HTTP provider |
| cd examples/mail && go run . | A real Mail Resend driver and Slack composed through Fanout against local fixtures | |
| Provider catalog | go run ./examples/providers | Native root-provider configurations and a push/chat fanout |
| WhatsApp templates | go run ./examples/whatsapp | Explicit approved-template sends against a local fixture |
| APNs | cd examples/apns && go run . | Signed alerts over real HTTP/2 and TLS |
| SNS | cd examples/sns && go run . | A borrowed AWS SDK client and a native local response |
| Web Push | cd examples/webpush && go run . | Encrypted browser push and VAPID authentication |
| Fake | go run ./examples/fake | Application testing through Sender |
| Composition | go run ./examples/composition | Fanout, conservative fallback and safe retry advice |
| Custom HTTP transport | go run ./examples/transport | Caller-owned transport and TLS trust roots |
| Decorator | go run ./examples/decorator | Application metrics through SenderFunc |
| Incident | go run ./examples/incident | Stable lifecycle keys with a local PagerDuty protocol fixture |
| Advanced fallback | go run ./examples/fallback | Optional recipient planning, fallback, and identity |
These programs run locally without hosted-provider credentials. The test suite executes them and checks their output. Provider examples use local protocol fixtures, which verify request and response handling rather than live delivery.
API Index
Webhook delivery
The URL is driver configuration. AllowPrivate below permits the local test server; the default destination policy rejects private and special addresses.
provider := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusAccepted)
}))
defer provider.Close()
driver, err := webhook.New(webhook.Config{
URL: provider.URL,
AllowPrivate: true,
})
if err != nil {
panic(err)
}
defer driver.Close()
notifier := notification.New(driver)
err = notifier.Send(context.Background(), notification.Message{
Title: "Ticket updated",
Body: "Ticket T-42 has a new owner.",
})
if err != nil {
panic(err)
}
fmt.Println("message accepted")
// message acceptedCustom HTTP transport
Set HTTPConfig.Transport to any concurrency-safe http.RoundTripper. Drivers borrow it unchanged; the caller owns its configuration and cleanup. This example uses a local TLS server and a certificate pool named roots:
transport := &http.Transport{
TLSClientConfig: &tls.Config{
RootCAs: roots,
MinVersion: tls.VersionTLS12,
},
ForceAttemptHTTP2: true,
}
defer transport.CloseIdleConnections()
driver, err := slack.New(slack.Config{
URL: provider.URL,
HTTP: notification.HTTPConfig{
Transport: transport,
},
})
if err != nil {
panic(err)
}
defer driver.Close()
err = driver.Send(context.Background(), notification.Message{
Title: "Ticket updated",
Body: "Ticket T-42 has a new owner.",
})
if err != nil {
panic(err)
}
fmt.Println("accepted through custom transport")
// accepted through custom transportWebhook exposes the same option directly as webhook.Config.Transport. The library retains its client timeout, redirect rejection, response body bounds, and safe errors. With an injected transport, dialing, DNS, TLS, proxies, and retries belong to that transport; AllowPrivate and Resolver apply only to the default transport. See transport ownership for details.
Composition
Use Fanout to send through every configured destination, or Fallback to try destinations in order. Both return a Sender, borrow their configured senders, and never retry. Fanout attempts every target with at most eight concurrent calls.
Fallback advances only after permanent rejection, unauthorized access or unsupported rendering. Uncertainty and transient failures stop it to avoid duplicates. Check ErrOutcomeUnknown before deciding whether to retry: a server can fail after accepting a notification.
Use compositions directly. Wrap a custom handler with New when it needs common validation and safe errors.
chat := notificationfake.New()
push := notificationfake.New()
sender := notification.Fanout(chat, push)
message := notification.Message{
Title: "Monitor down",
Body: "API health check failed.",
}
if err := sender.Send(context.Background(), message); err != nil {
panic(err)
}
fmt.Println("captured targets:", len(chat.Messages())+len(push.Messages()))
// captured targets: 2
chat.Respond(notification.ErrPermanent)
backup := notification.Fallback(chat, push)
if err := backup.Send(context.Background(), message); err != nil {
panic(err)
}
fmt.Println("backup captures:", len(push.Messages()))
// backup captures: 2
push.Respond(notification.NewDeliveryError("push", notification.Outcome{
Status: notification.Failed,
RetryAfter: 30 * time.Second,
}, notification.ErrThrottled))
err := notification.New(push).Send(context.Background(), message)
var failure *notification.DeliveryError
if errors.As(err, &failure) {
fmt.Println("retry advice:", failure.RetryAfter())
// retry advice: 30s
}
push.Respond(notification.NewDeliveryError("push", notification.Outcome{
Status: notification.Unknown,
}, notification.ErrRetryable))
err = notification.New(push).Send(context.Background(), message)
if errors.Is(err, notification.ErrOutcomeUnknown) {
fmt.Println("delivery uncertain: reconcile before retrying")
// delivery uncertain: reconcile before retrying
}Custom senders
Use SenderFunc to adapt an existing service or decorate a configured sender with application metrics or tracing. Preserve the caller's context and returned error. New applies validation and safe errors around the custom handler, so invalid messages do not reach it.
driver := notificationfake.New()
var attempts atomic.Int64
instrumented := notification.SenderFunc(func(ctx context.Context, message notification.Message) error {
attempts.Add(1)
return driver.Send(ctx, message)
})
notifier := notification.New(instrumented)
err := notifier.Send(context.Background(), notification.Message{
Title: "Ticket updated",
Body: "Ticket T-42 has a new owner.",
})
if err != nil {
panic(err)
}
fmt.Println("attempted sends:", attempts.Load())
// attempted sends: 1
err = notifier.Send(context.Background(), notification.Message{})
fmt.Println("invalid message:", errors.Is(err, notification.ErrInvalidMessage))
// invalid message: true
fmt.Println("attempted sends:", attempts.Load())
// attempted sends: 1Incident lifecycle
PagerDuty, JSM, legacy Opsgenie, SIGNL4, PagerTree and ilert additionally implement IncidentSender. Construct keys from stable scoped IDs and use the same key for trigger, acknowledge and resolve. Ordinary Send requires a fixed configured key on these drivers. JSM and Opsgenie return asynchronous acceptance, without polling for completion.
ctx := context.Background()
key := notification.IncidentKey("tenant:42:monitor:17")
err = driver.Trigger(ctx, notification.Incident{
Key: key,
Title: "API unavailable",
Body: "Health check failed.",
Source: "health-checks",
Severity: notification.SeverityCritical,
})
if err != nil {
panic(err)
}
fmt.Println("trigger accepted by local fixture")
// trigger accepted by local fixture
if err := driver.Acknowledge(ctx, key); err != nil {
panic(err)
}
if err := driver.Resolve(ctx, key); err != nil {
panic(err)
}
fmt.Println("acknowledge and resolve use the same stable key")
// acknowledge and resolve use the same stable keyMail delivery
Reuse the application-owned GoForj Mailer and configure notification recipients once. Mail owns provider credentials, sender defaults, MIME and transport. This example runs real Resend and Slack drivers against local HTTP fixtures, then composes them through Fanout. It sends no hosted email or chat message.
transport, err := mailresend.New(mailresend.Config{
APIKey: "local-fixture-key",
Endpoint: provider.URL + "/email",
HTTPClient: provider.Client(),
})
if err != nil {
panic(err)
}
mailer := mail.New(transport, mail.WithDefaultFrom("[email protected]", "Helpdesk"))
email := notificationmail.New(mailer, "[email protected]")
chat, err := slack.New(slack.Config{
URL: provider.URL + "/slack",
HTTP: notification.HTTPConfig{
AllowPrivate: true,
},
})
if err != nil {
panic(err)
}
defer chat.Close()
sender := notification.Fanout(email, chat)
err = sender.Send(context.Background(), notification.Message{
Title: "Ticket updated",
Body: "Ticket T-42 has a new owner.",
})
if err != nil {
panic(err)
}
fmt.Println("accepted email and chat:", emails.Load(), chats.Load())
// accepted email and chat: 1 1See Mail integration for provider choices, rich email, lifecycle and verification details.
Native provider configuration
All providers share the same Sender interface. Configure destinations once and compose senders with Fanout or Fallback. The runnable catalog demonstrates root-provider configuration against local protocol fixtures.
connection := notification.HTTPConfig{
AllowPrivate: true,
}
mobile, err := pushover.New(pushover.Config{
BaseURL: server.URL + "/pushover",
Token: "fixture-application-token",
User: "fixture-user-key",
HTTP: connection,
})
if err != nil {
panic(err)
}
defer mobile.Close()
room, err := mattermost.New(mattermost.Config{
URL: server.URL + "/mattermost",
HTTP: connection,
})
if err != nil {
panic(err)
}
defer room.Close()
sender := notification.Fanout(mobile, room)
err = sender.Send(context.Background(), notification.Message{
Title: "Ticket updated",
Body: "Ticket T-42 has a new owner.",
})
if err != nil {
panic(err)
}
fmt.Println("accepted through push and chat:", accepted.Load())
// accepted through push and chat: 2Application push
APNs owns and refreshes its provider JWT, or borrows an explicitly configured certificate transport. SNS borrows an AWS SDK v2 publisher, preserving the SDK credential model. Web Push encrypts the standard browser subscription payload and signs VAPID authentication. These optional modules do not add dependencies to the root module.
Apple APNs
driver, err := apns.New(apns.Config{
Key: key,
KeyID: "KEY0000042",
TeamID: "TEAM000042",
Topic: "example.app",
DeviceToken: strings.Repeat("ab", 32),
BaseURL: service.URL,
HTTP: notification.HTTPConfig{
Transport: service.Client().Transport,
},
})
if err != nil {
panic(err)
}
defer driver.Close()
err = driver.Send(context.Background(), notification.Message{
Title: "Ticket updated",
Body: "Ticket T-42 has a new owner.",
})
if err != nil {
panic(err)
}
fmt.Println("APNs accepted over HTTP/2")
// APNs accepted over HTTP/2Amazon SNS
publisher := sns.New(sns.Options{
Region: "us-east-1",
BaseEndpoint: aws.String(service.URL),
HTTPClient: service.Client(),
Credentials: aws.CredentialsProviderFunc(func(context.Context) (aws.Credentials, error) {
return aws.Credentials{
AccessKeyID: "fixture",
SecretAccessKey: "local-fixture-secret",
}, nil
}),
})
driver, err := notificationsns.New(notificationsns.Config{
Client: publisher,
TopicARN: "arn:aws:sns:us-east-1:123456789012:alerts",
})
if err != nil {
panic(err)
}
err = driver.Send(context.Background(), notification.Message{
Title: "Ticket updated",
Body: "Ticket T-42 has a new owner.",
})
if err != nil {
panic(err)
}
fmt.Println("SNS accepted through the borrowed AWS client")
// SNS accepted through the borrowed AWS clientWeb Push
driver, err := webpush.New(webpush.Config{
Subscription: subscription,
Subscriber: "[email protected]",
VAPIDPrivateKey: base64.RawURLEncoding.EncodeToString(signingKey.Bytes()),
VAPIDPublicKey: base64.RawURLEncoding.EncodeToString(signingKey.PublicKey().Bytes()),
TTL: 60,
Urgency: webpush.UrgencyHigh,
HTTP: notification.HTTPConfig{
Transport: service.Client().Transport,
},
})
if err != nil {
panic(err)
}
defer driver.Close()
err = driver.Send(context.Background(), notification.Message{
Title: "Ticket updated",
Body: "Ticket T-42 has a new owner.",
})
if err != nil {
panic(err)
}
fmt.Println("encrypted browser push accepted")
// encrypted browser push acceptedFCM HTTP v1 accepts a caller-supplied TokenSource function for refreshed OAuth access tokens. OneSignal and Expo submit native push requests. Acceptance means the service accepted the request or ticket; the library does not poll delivery receipts.
WhatsApp Cloud
Ordinary Send uses free-form text within the recipient's customer-service window. Use SendTemplate with an already approved template outside that window. Configure the Graph API version explicitly. The library does not create templates or verify service-window eligibility.
driver, err := whatsapp.New(whatsapp.Config{
Token: "local-fixture-token",
PhoneNumberID: "123456789",
To: "+12125550101",
APIVersion: "v24.0",
BaseURL: service.URL,
HTTP: notification.HTTPConfig{
AllowPrivate: true,
},
})
if err != nil {
panic(err)
}
defer driver.Close()
err = driver.SendTemplate(context.Background(), whatsapp.Template{
Name: "ticket_updated",
Language: "en_US",
BodyParameters: []string{
"T-42",
},
})
if err != nil {
panic(err)
}
fmt.Println("accepted WhatsApp template:", accepted.Load())
// accepted WhatsApp template: 1Application testing
Application services depend on notification.Sender. The fake validates and captures messages without contacting providers. Use fake.Respond(err) to test a failure.
fake := notificationfake.New()
var sender notification.Sender = fake
err := sender.Send(context.Background(), notification.Message{
Title: "Ticket updated",
Body: "Ticket T-42 has a new owner.",
})
if err != nil {
panic(err)
}
fmt.Println("captured messages:", len(fake.Messages()))
// captured messages: 1Advanced dispatch
Applications that need recipient lookup, preferences, localized templates, per-recipient fallback, or deduplication can use NewDispatcher. These capabilities are optional and keep their explicit delivery results. Use Fallback for ordered configured destinations; use NewDispatcher when fallback must follow application recipient policy. See advanced dispatch for the complete runnable example and migration from the earlier API.
Driver constructors
The API index includes every driver in the driver table. These constructor expressions are extracted from the executable programs in Runnable Examples. Their local fixture URLs, HTTP settings, credentials and borrowed clients are defined in those programs. Replace fixture values with your own configuration, and handle returned errors and resource ownership as shown in the complete examples.
notificationsns.New
notificationsns.New(notificationsns.Config{
Client: publisher,
TopicARN: "arn:aws:sns:us-east-1:123456789012:alerts",
})apns.New
apns.New(apns.Config{
Key: key,
KeyID: "KEY0000042",
TeamID: "TEAM000042",
Topic: "example.app",
DeviceToken: strings.Repeat("ab", 32),
BaseURL: service.URL,
HTTP: notification.HTTPConfig{
Transport: service.Client().Transport,
},
})apprise.New
apprise.New(apprise.Config{
URL: baseURL + "/apprise",
Key: "fixture",
Tag: "alerts",
Username: "fixture",
Password: "secret",
HTTP: connection,
})bark.New
bark.New(bark.Config{
URL: baseURL + "/bark",
DeviceKey: "fixture",
Group: "alerts",
HTTP: connection,
})betterstack.New
betterstack.New(betterstack.Config{
BaseURL: baseURL + "/betterstack",
Token: "fixture",
RequesterEmail: "[email protected]",
PolicyID: "policy",
TeamName: "Helpdesk",
Email: true,
HTTP: connection,
})clicksend.New
clicksend.New(clicksend.Config{
BaseURL: baseURL + "/clicksend",
Username: "fixture",
APIKey: "secret",
From: "Helpdesk",
To: "+12125550101",
HTTP: connection,
})dingtalk.New
dingtalk.New(dingtalk.Config{
URL: baseURL + "/dingtalk",
HTTP: connection,
})discord.New
discord.New(discord.Config{
URL: baseURL + "/discord",
HTTP: connection,
})expo.New
expo.New(expo.Config{
BaseURL: baseURL + "/expo",
PushToken: "ExpoPushToken[fixture]",
AccessToken: "fixture",
HTTP: connection,
})feishu.New
feishu.New(feishu.Config{
URL: baseURL + "/feishu",
HTTP: connection,
})fcm.New
fcm.New(fcm.Config{
BaseURL: baseURL + "/fcm",
ProjectID: "project",
DeviceToken: "device",
TokenSource: func(context.Context) (string, error) { return "fixture", nil },
HTTP: connection,
})firehydrant.New
firehydrant.New(firehydrant.Config{
URL: baseURL + "/firehydrant",
Key: "monitor/42",
HTTP: connection,
})goalert.New
goalert.New(goalert.Config{
URL: baseURL + "/goalert",
Token: "fixture",
Key: "monitor/42",
HTTP: connection,
})googlechat.New
googlechat.New(googlechat.Config{
URL: baseURL + "/googlechat",
HTTP: connection,
})gotify.New
gotify.New(gotify.Config{
URL: baseURL + "/gotify",
Token: "fixture",
Priority: 5,
HTTP: connection,
})homeassistant.New
homeassistant.New(homeassistant.Config{
URL: baseURL + "/homeassistant",
Token: "fixture",
Service: "mobile_app_phone",
HTTP: connection,
})ifttt.New
ifttt.New(ifttt.Config{
BaseURL: baseURL + "/ifttt",
Key: "fixture",
Event: "ticket_updated",
HTTP: connection,
})ilert.New
ilert.New(ilert.Config{
URL: baseURL + "/ilert",
IntegrationKey: "fixture",
Key: "monitor/42",
HTTP: connection,
})incidentio.New
incidentio.New(incidentio.Config{
BaseURL: baseURL + "/incidentio",
Token: "fixture",
SourceID: "source",
Key: "monitor/42",
HTTP: connection,
})jsm.New
jsm.New(jsm.Config{
BaseURL: baseURL + "/jsm",
CloudID: "cloud",
Email: "[email protected]",
Token: "fixture",
Key: "monitor/42",
HTTP: connection,
})join.New
join.New(join.Config{
BaseURL: baseURL + "/join",
APIKey: "fixture",
DeviceID: "device",
HTTP: connection,
})line.New
line.New(line.Config{
BaseURL: baseURL + "/line",
Token: "fixture",
To: "U00000000000000000000000000000000",
HTTP: connection,
})log.New
log.New(slog.New(slog.NewTextHandler(io.Discard, nil)))notificationmail.New
notificationmail.New(mailer, "[email protected]")matrix.New
matrix.New(matrix.Config{
URL: baseURL + "/matrix",
Token: "fixture",
RoomID: "!room:example.com",
HTTP: connection,
})mattermost.New
mattermost.New(mattermost.Config{
URL: baseURL + "/mattermost",
HTTP: connection,
})nextcloudtalk.New
nextcloudtalk.New(nextcloudtalk.Config{
URL: baseURL + "/nextcloudtalk",
Username: "fixture",
Password: "secret",
RoomToken: "room42",
HTTP: connection,
})ntfy.New
ntfy.New(ntfy.Config{
URL: baseURL + "/ntfy",
Topic: "alerts",
HTTP: connection,
})onesignal.New
onesignal.New(onesignal.Config{
BaseURL: baseURL + "/onesignal",
AppID: "application",
Token: "fixture",
SubscriptionID: "device",
HTTP: connection,
})opsgenie.New
opsgenie.New(opsgenie.Config{
BaseURL: baseURL + "/opsgenie",
Token: "fixture",
Key: "monitor/42",
HTTP: connection,
})pagerduty.New
pagerduty.New(pagerduty.Config{
RoutingKey: strings.Repeat("a", 32),
URL: server.URL,
HTTP: notification.HTTPConfig{
AllowPrivate: true,
},
})pagertree.New
pagertree.New(pagertree.Config{
URL: baseURL + "/pagertree",
Key: "monitor/42",
HTTP: connection,
})plivo.New
plivo.New(plivo.Config{
BaseURL: baseURL + "/plivo",
AuthID: "fixture",
AuthToken: "secret",
From: "+12125550100",
To: "+12125550101",
HTTP: connection,
})pushbullet.New
pushbullet.New(pushbullet.Config{
BaseURL: baseURL + "/pushbullet",
Token: "fixture",
DeviceID: "device",
HTTP: connection,
})pushover.New
pushover.New(pushover.Config{
BaseURL: baseURL + "/pushover",
Token: "fixture",
User: "user",
Device: "phone",
HTTP: connection,
})rocketchat.New
rocketchat.New(rocketchat.Config{
URL: baseURL + "/rocketchat",
HTTP: connection,
})signal.New
signal.New(signal.Config{
URL: baseURL + "/signal",
Number: "+12125550100",
Recipient: "+12125550101",
Token: "fixture",
HTTP: connection,
})signl4.New
signl4.New(signl4.Config{
URL: baseURL + "/signl4",
Key: "monitor/42",
HTTP: connection,
})slack.New
slack.New(slack.Config{
URL: provider.URL,
HTTP: notification.HTTPConfig{
Transport: transport,
},
})teams.New
teams.New(teams.Config{
URL: baseURL + "/teams",
HTTP: connection,
})telegram.New
telegram.New(telegram.Config{
BaseURL: baseURL + "/telegram",
Token: "123456:fixture",
ChatID: "42",
HTTP: connection,
})telnyx.New
telnyx.New(telnyx.Config{
BaseURL: baseURL + "/telnyx",
Token: "fixture",
From: "+12125550100",
To: "+12125550101",
MessagingProfileID: "profile",
HTTP: connection,
})twilio.New
twilio.New(twilio.Config{
BaseURL: baseURL + "/twilio",
AccountSID: "AC00000000000000000000000000000000",
AuthToken: "fixture",
From: "+12125550100",
To: "+12125550101",
HTTP: connection,
})vonage.New
vonage.New(vonage.Config{
BaseURL: baseURL + "/vonage",
APIKey: "fixture1",
APISecret: "secret",
From: "Helpdesk",
To: "+12125550101",
HTTP: connection,
})waha.New
waha.New(waha.Config{
URL: baseURL + "/waha",
APIKey: "fixture",
Session: "default",
ChatID: "[email protected]",
HTTP: connection,
})webpush.New
webpush.New(webpush.Config{
Subscription: subscription,
Subscriber: "[email protected]",
VAPIDPrivateKey: base64.RawURLEncoding.EncodeToString(signingKey.Bytes()),
VAPIDPublicKey: base64.RawURLEncoding.EncodeToString(signingKey.PublicKey().Bytes()),
TTL: 60,
Urgency: webpush.UrgencyHigh,
HTTP: notification.HTTPConfig{
Transport: service.Client().Transport,
},
})webhook.New
webhook.New(webhook.Config{
URL: provider.URL,
AllowPrivate: true,
})wecom.New
wecom.New(wecom.Config{
URL: baseURL + "/wecom",
HTTP: connection,
})whapi.New
whapi.New(whapi.Config{
BaseURL: baseURL + "/whapi",
Token: "fixture",
To: "12125550101",
HTTP: connection,
})whatsapp.New
whatsapp.New(whatsapp.Config{
BaseURL: baseURL + "/whatsapp",
Token: "fixture",
PhoneNumberID: "123456789",
To: "+12125550101",
APIVersion: "v24.0",
HTTP: connection,
})zulip.New
zulip.New(zulip.Config{
URL: baseURL + "/zulip",
Email: "[email protected]",
APIKey: "fixture",
Channel: "alerts",
Topic: "Tickets",
HTTP: connection,
})Development
make test
make test-race
make test-integration # Requires Docker.
make vet
make check-generated
make securityDocumentation is generated by the Go tools in docs/, using the runnable examples as the source of truth. make test validates every module, executes the example programs, and enforces exact 100% library unit statement coverage. See development and release for independent module tags, delivery contracts for guarantees and limits, and the API review for the simplicity and composition decisions.
See the current release gates for completed checks and outstanding verification.
The original framework proposal records the larger roadmap. Durable Queue integration, SQL persistence, inboxes, and GoForj generation remain future work.