Swift WebPush

dependencies: [
    .package(
        url: "https://github.com/mochidev/swift-webpush.git", 
        .upToNextMinor(from: "0.4.1")
    ),
],
...
targets: [
    .target(
        name: "MyPackage",
        dependencies: [
            .product(name: "WebPush", package: "swift-webpush"),
            ...
        ]
    ),
    .testTarget(
        name: "MyPackageTests",
        dependencies: [
            .product(name: "WebPushTesting", package: "swift-webpush"),
            ...
        ]
    ),
]

import WebPush

...

guard
    let rawVAPIDConfiguration = ProcessInfo.processInfo.environment["VAPID-CONFIG"],
    let vapidConfiguration = try? JSONDecoder().decode(VAPID.Configuration.self, from: Data(rawVAPIDConfiguration.utf8))
else { fatalError("VAPID keys are unavailable, please generate one and add it to the environment.") }

let manager = WebPushManager(
    vapidConfiguration: vapidConfiguration,
    backgroundActivityLogger: logger
    /// If you customized the event loop group your app uses, you can set it here:
    // eventLoopGroupProvider: .shared(app.eventLoopGroup)
)

try await ServiceGroup(
    services: [
        /// Your other services here
        manager
    ],
    gracefulShutdownSignals: [.sigint],
    logger: logger
).run()

import WebPush

...

/// Listen somewhere for a VAPID key request. This path can be anything you want, and should be available to all parties you with to serve push messages to.
app.get("vapidKey", use: loadVapidKey)

...

/// A wrapper for the VAPID key that Vapor can encode.
struct WebPushOptions: Codable, Content, Hashable, Sendable {
    static let defaultContentType = HTTPMediaType(type: "application", subType: "webpush-options+json")

    var vapid: VAPID.Key.ID
}

/// The route handler, usually part of a route controller.
@Sendable func loadVapidKey(request: Request) async throws -> WebPushOptions {
    WebPushOptions(vapid: manager.nextVAPIDKeyID)
}

import WebPush

...

/// Listen somewhere for new registrations. This path can be anything you want, and should be available to all parties you with to serve push messages to.
app.get("registerSubscription", use: registerSubscription)

...

/// A custom type for communicating the status of your subscription. Fill this out with any options you'd like to communicate back to the user.
struct SubscriptionStatus: Codable, Content, Hashable, Sendable {
    var subscribed = true
}

/// The route handler, usually part of a route controller.
@Sendable func registerSubscription(request: Request) async throws -> SubscriptionStatus {
    let subscriptionRequest = try request.content.decode(Subscriber.self, as: .jsonAPI)
    
    // TODO: Persist subscriptionRequest!
    
    return SubscriptionStatus()
}

import WebPush

...

do {
    try await manager.send(
        json: ["title": "Test Notification", "body": "Hello, World!"],
        to: subscriber
        /// If sent from a request, pass the request's logger here to maintain its metadata.
        // logger: request.logger
    )
} catch is BadSubscriberError {
    /// The subscription is no longer valid and should be removed.
} catch is MessageTooLargeError {
    /// The message was too long and should be shortened.
} catch let error as PushServiceError {
    /// The push service ran into trouble. error.response may help here.
} catch {
    /// An unknown error occurred.
}

import Testing
import WebPushTesting

@Test func sendSuccessfulNotifications() async throws {
    try await confirmation { requestWasMade in
        let mockedManager = WebPushManager.makeMockedManager { message, subscriber, topic, expiration, urgency in
            #expect(message.string == "hello")
            #expect(subscriber.endpoint.absoluteString == "https://example.com/expectedSubscriber")
            #expect(subscriber.vapidKeyID == .mockedKeyID1)
            #expect(topic == nil)
            #expect(expiration == .recommendedMaximum)
            #expect(urgency == .high)
            requestWasMade()
        }
        
        let myController = MyController(pushManager: mockedManager)
        try await myController.sendNotifications()
    }
}

@Test func catchBadSubscriptions() async throws {
    /// Mocked managers accept multiple handlers, and will cycle through them each time a push message is sent:
    let mockedManager = WebPushManager.makeMockedManager(messageHandlers:
        { _, _, _, _, _ in throw BadSubscriberError() },
        { _, _, _, _, _ in },
        { _, _, _, _, _ in throw BadSubscriberError() },
    )
    
    let myController = MyController(pushManager: mockedManager)
    #expect(myController.subscribers.count == 3)
    try await myController.sendNotifications()
    #expect(myController.subscribers.count == 1)
}