Docs

self.addEventListener("push", (event) => {
  const data = event.data?.json() ?? {};
  event.waitUntil(
    self.registration.showNotification(data.title ?? "Notification", {
      body: data.body,
      icon: data.icon,
      image: data.image,
      // Action buttons (id + title + optional icon) — surfaced on the
      // notification UI. The id comes back on `notificationclick` via
      // `event.action` so you can branch on the chosen action.
      actions: data.actions ?? [],
      data: data.data,
    })
  );
});

self.addEventListener("notificationclick", (event) => {
  const { notification_id, device_id, deep_link } = event.notification.data ?? {};
  const action_id = event.action || null;
  const url = deep_link || event.notification.data?.url || "/";

  event.waitUntil(Promise.all([
    // POST the open/click back so the panel counters tick + outbound
    // webhooks fire. Best-effort: we still openWindow on transient
    // network failure.
    fetch("https://nitroping.dev/api/v1/events", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({
        notification_id,
        device_id,
        type: action_id ? "clicked" : "opened",
        action_id,
      }),
    }).catch(() => {}),
    event.notification.close(),
    clients.openWindow(url),
  ]));
});

const VAPID_PUBLIC_KEY = "<paste-your-vapid-public-key>";
const NITROPING_PUBLIC_KEY = "pk_...";

async function subscribeToPush() {
  const registration = await navigator.serviceWorker.register("/sw.js");

  const subscription = await registration.pushManager.subscribe({
    userVisibleOnly: true,
    applicationServerKey: urlBase64ToUint8Array(VAPID_PUBLIC_KEY),
  });

  await fetch("https://nitroping.dev/api/v1/public/devices", {
    method: "POST",
    headers: {
      "Authorization": `Public ${NITROPING_PUBLIC_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      platform: "web",
      token: subscription.endpoint,
      web_push_p256dh: bufToBase64Url(subscription.getKey("p256dh")),
      web_push_auth: bufToBase64Url(subscription.getKey("auth")),
    }),
  });
}

// VAPID keys are base64url; PushManager wants a Uint8Array.
function urlBase64ToUint8Array(b64) {
  const pad = "=".repeat((4 - (b64.length % 4)) % 4);
  const base64 = (b64 + pad).replace(/-/g, "+").replace(/_/g, "/");
  return Uint8Array.from(atob(base64), (c) => c.charCodeAt(0));
}

function bufToBase64Url(buf) {
  return btoa(String.fromCharCode(...new Uint8Array(buf)))
    .replace(/\+/g, "-")
    .replace(/\//g, "_")
    .replace(/=+$/, "");
}

curl -X POST https://nitroping.dev/api/v1/notifications \
  -H "Authorization: ApiKey np_..." \
  -H "Content-Type: application/json" \
  -d '{
    "title": "Welcome to nitroping",
    "body": "Your first push works.",
    "target": {"all": true}
  }'

import UIKit
import UserNotifications

final class NotificationRouter: NSObject, UNUserNotificationCenterDelegate {
  func userNotificationCenter(
    _ center: UNUserNotificationCenter,
    didReceive response: UNNotificationResponse,
    withCompletionHandler completionHandler: @escaping () -> Void
  ) {
    let userInfo = response.notification.request.content.userInfo

    // `deep_link` is the body-tap URL — open it directly.
    if response.actionIdentifier == UNNotificationDefaultActionIdentifier,
       let raw = userInfo["deep_link"] as? String,
       let url = URL(string: raw) {
      UIApplication.shared.open(url)
    }

    // `actions_json` carries the per-action list as a JSON string.
    // The chosen action's id is in `response.actionIdentifier`.
    if let actionsJSON = userInfo["actions_json"] as? String,
       let data = actionsJSON.data(using: .utf8),
       let actions = try? JSONSerialization.jsonObject(with: data) as? [[String: Any]] {
      let chosenId = response.actionIdentifier
      if let action = actions.first(where: { $0["id"] as? String == chosenId }) {
        // Route to your action handler — e.g. "reply", "track", etc.
        print("user picked action: \(action["title"] ?? "?")")
      }
    }

    completionHandler()
  }
}

import android.app.PendingIntent
import android.content.Intent
import android.net.Uri
import androidx.core.app.NotificationCompat
import com.google.firebase.messaging.FirebaseMessagingService
import com.google.firebase.messaging.RemoteMessage
import org.json.JSONArray

class NitropingMessagingService : FirebaseMessagingService() {
  override fun onMessageReceived(message: RemoteMessage) {
    val data = message.data

    // Body tap → open `deep_link` via ACTION_VIEW.
    val deepLink = data["deep_link"]
    val tapIntent = deepLink
      ?.let { Intent(Intent.ACTION_VIEW, Uri.parse(it)) }
      ?.apply { flags = Intent.FLAG_ACTIVITY_NEW_TASK }
    val tapPI = tapIntent?.let {
      PendingIntent.getActivity(
        this, 0, it,
        PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT
      )
    }

    val builder = NotificationCompat.Builder(this, "default")
      .setContentTitle(data["title"])
      .setContentText(data["body"])
      .setSmallIcon(android.R.drawable.ic_dialog_info)
      .setAutoCancel(true)
    if (tapPI != null) builder.setContentIntent(tapPI)

    // `actions_json` carries the action button list.
    data["actions_json"]?.let { raw ->
      val arr = JSONArray(raw)
      for (i in 0 until arr.length()) {
        val a = arr.getJSONObject(i)
        val id = a.getString("id")
        val title = a.getString("title")
        val actionIntent = Intent(this, NotificationActionReceiver::class.java)
          .putExtra("action_id", id)
          .putExtra("deep_link", deepLink)
        val pi = PendingIntent.getBroadcast(
          this, id.hashCode(), actionIntent,
          PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT
        )
        builder.addAction(0, title, pi)
      }
    }

    // notify(...) is intentionally elided for brevity.
  }
}