Live pages (SSE)

/// Mounted by `server.mountFeatures(features)` in src/main.zig. `.public`:
/// the home page stays open once the app has a login (spider g auth).
pub fn build() spider.Group {
    var g = spider.Group.init("");
    _ = g
        .get("/", controller.index, .{ .public = true })
        // The stream that tells a day view its day changed.
        .sseWith("/events/:day", controller.events, .{ .public = true, .quiet_log = true });
    return g;
}

/// The stream a day view listens to: one event, "changed", whenever a
/// booking of that day is made, confirmed, cancelled or expires. It says
/// that something changed, not what: each page then asks for its own grid,
/// because the grid is not the same for everyone (yours are marked as yours).
///
///     /events/2026-10-12
pub fn events(sse: *spider.Sse) !void {
    const day = sse.param("day") orelse return;
    if (!isDay(day)) return;
    try sse.join(try channelOf(sse.arena, day));
    sse.wait();
}

fn channelOf(a: std.mem.Allocator, day: []const u8) ![]const u8 {
    return std.fmt.allocPrint(a, "day:{s}", .{day});
}

/// Tells every page showing `day` that it changed.
pub fn announce(c: *spider.Ctx, day: []const u8) void {
    const channel = channelOf(c.arena, day) catch return;
    c.sseHub().emitTo(channel, "changed", .{ .day = day });
}

/// Gives a booking up.
pub fn cancel(c: *spider.Ctx, mine_: Mine) !Response {
    const booking = mine_.value;
    _ = try repository.cancel(c.arena, booking.id);
    day_view.announce(c, booking.day);
    return c.redirect(try std.fmt.allocPrint(c.arena, "/bookings/{d}", .{booking.id}));
}

/// Releases the holds that ran out and tells the pages showing their days.
/// It runs on a thread of its own, outside any request, so it brings its
/// own memory and reports its own errors: there is nobody to return one to.
pub fn expireHolds(hub: *spider.Hub) void {
    var arena_state: std.heap.ArenaAllocator = .init(std.heap.smp_allocator);
    defer arena_state.deinit();
    const arena = arena_state.allocator();

    const days = repository.expireStale(arena) catch |err| {
        std.log.warn("bookings: could not release the holds that ran out: {s}", .{@errorName(err)});
        return;
    };
    for (days) |day| {
        const channel = std.fmt.allocPrint(arena, "day:{s}", .{day}) catch continue;
        hub.emitTo(channel, "changed", .{ .day = day });
    }
    if (days.len > 0) std.log.info("bookings: {d} hold(s) ran out and were released", .{days.len});
}

HTTP/1.1 200 OK
Content-Type: text/event-stream
Cache-Control: no-cache
Connection: keep-alive

retry: 3000

: heartbeat

id: 6
event: changed
data: {"day":"2033-03-07"}

<div hx-sse:connect="/events/{ day.day }" hx-swap="none"></div>

<div id="day" hx-get="{ self }" hx-trigger="changed from:body, every 60s" hx-select="#day" hx-swap="outerHTML">
    ...
</div>

<script>
    const stream = new EventSource("/events/2033-03-07");
    stream.addEventListener("changed", (event) => {
        const data = JSON.parse(event.data);
        console.log("changed:", data.day);
    });
</script>

test "the day's stream says \"changed\" when a booking of that day is made, and only then" {
    const app = try app_test.running();
    const io = std.testing.io;
    var id_buf: [20]u8 = undefined;
    const cedar = try roomId(&id_buf, "Cedar");
    var buf: [1024]u8 = undefined;
    const ana = app.with(&.{try app_test.signUp(app, &buf, "Ana Ribeiro", "ana.stream3@example.com")});

    // What a day view does: open the stream of its day and keep it open.
    const address = try std.Io.net.IpAddress.parse("127.0.0.1", app.port);
    var stream = try address.connect(io, .{ .mode = .stream });
    defer stream.close(io);
    const timeout = std.posix.timeval{ .sec = 3, .usec = 0 };
    try std.posix.setsockopt(stream.socket.handle, std.posix.SOL.SOCKET, std.posix.SO.RCVTIMEO, std.mem.asBytes(&timeout));
    var write_buf: [256]u8 = undefined;
    var writer = stream.writer(io, &write_buf);
    try writer.interface.writeAll("GET /events/2032-07-05 HTTP/1.1\r\nHost: 127.0.0.1\r\nAccept: text/event-stream\r\n\r\n");
    try writer.interface.flush();
    var read_buf: [2048]u8 = undefined;
    var reader = stream.reader(io, &read_buf);
    var seen: std.ArrayList(u8) = .empty;
    defer seen.deinit(std.testing.allocator);
    try readUntil(&reader.interface, &seen, "text/event-stream");
    try readUntil(&reader.interface, &seen, "retry:");
    // The stream opens for the client once its handler listens, so what is
    // made from here on is not missed.

    // A booking of another day says nothing here; one of this day does.
    var other = try ana.postForm("/bookings/create", Booking{ .room = cedar, .date = "2032-07-06", .start = "10:00", .end = "11:00", .title = "Another day" });
    defer other.deinit();
    try other.expectStatus(303);
    var made = try ana.postForm("/bookings/create", Booking{ .room = cedar, .date = "2032-07-05", .start = "10:00", .end = "11:00", .title = "Sprint demo" });
    defer made.deinit();
    try made.expectStatus(303);

    try readUntil(&reader.interface, &seen, "event: changed");
    try readUntil(&reader.interface, &seen, "2032-07-05");
    try std.testing.expect(std.mem.indexOf(u8, seen.items, "2032-07-06") == null);

    // And the page that asks again finds it there, pointed out as new.
    var day = try app.get("/?date=2032-07-05");
    defer day.deinit();
    try day.expectContains("ui-cell-changed");
    try day.expectContains("Just booked");
    try day.expectContains("hx-sse:connect=\"/events/2032-07-05\"");
    try day.expectContains("hx-trigger=\"changed from:body, every 60s\"");
}