// REST API handlers for /events endpoints // separate from events.zig which handles websocket connections const std = @import("std"); const mem = std.mem; const wap = @import("wap"); const log = @import("../logging.zig"); const db_events = @import("../db/events.zig"); const json_nav = @import("../utilities/json.zig"); // dot-path navigation for freeform filter blobs const encoding = @import("../utilities/encoding.zig"); const broker = @import("../broker.zig"); const text_search = @import("../utilities/text_search.zig"); const EVENTS_TOPIC = "events"; const PAGE_SIZE: usize = 50; fn sendError(res: *wap.Response, status: std.http.Status, detail: []const u8) !void { _ = res.setStatus(status); try res.writeJson(.{ .detail = detail }); } // POST /events/filter - query events with filters // GET /events/filter/next?page-token=... - get next page // GET /events/count - count total events pub fn handle(req: *wap.Request, res: *wap.Response) !void { const target = req.path; const method = @tagName(req.method); // GET /events/filter/next?page-token=... if (mem.eql(u8, method, "GET") and mem.indexOf(u8, target, "/filter/next") != null) { try filterNext(req, res); return; } // POST /events/filter if (mem.eql(u8, method, "POST") and mem.endsWith(u8, target, "/filter")) { try filter(req, res); return; } // POST /events/count-by/{time|event} if (mem.eql(u8, method, "POST") and mem.indexOf(u8, target, "/count-by/") != null) { try countBy(req, res, target); return; } // GET /events/count if (mem.eql(u8, method, "GET") and mem.endsWith(u8, target, "/count")) { try count(res); return; } // POST /events — HTTP ingest fallback. Body is a JSON array of Event // objects. Mirrors python's `create_events`: publish each event to the // broker (event_persister consumes), return 204. if (mem.eql(u8, method, "POST") and (mem.eql(u8, target, "/events") or mem.eql(u8, target, "/api/events"))) { try createEvents(req, res); return; } try sendError(res, .not_found, "not found"); } fn createEvents(req: *wap.Request, res: *wap.Response) !void { const alloc = req.arena; const parsed = std.json.parseFromSlice(std.json.Value, alloc, req.body, .{}) catch |err| { if (err == error.OutOfMemory) return err; try sendError(res, .bad_request, "invalid json"); return; }; if (parsed.value != .array) { try sendError(res, .bad_request, "request body must be a JSON array of events"); return; } const b = broker.getBroker() orelse { try sendError(res, .service_unavailable, "broker not available"); return; }; for (parsed.value.array.items) |item| { if (item != .object) continue; publishEvent(alloc, b, item) catch |err| { log.warn("events-api", "publish failed: {}", .{err}); // Per python's `create_events`, ingest is fire-and-forget — on // partial failure we still 204 (clients are expected to retry on // missing events via the resilient event id). }; } try res.sendEmpty(.no_content); } fn publishEvent(alloc: std.mem.Allocator, b: broker.Broker, event: std.json.Value) !void { const obj = event.object; const id = strField(obj, "id") orelse return error.MissingId; const occurred = strField(obj, "occurred") orelse return error.MissingOccurred; const event_name = strField(obj, "event") orelse return error.MissingEvent; var resource_id: []const u8 = ""; if (obj.get("resource")) |r| if (r == .object) { resource_id = strField(r.object, "prefect.resource.id") orelse ""; }; const resource_json = stringifyOrDefault(alloc, obj.get("resource"), "{}"); const payload_json = stringifyOrDefault(alloc, obj.get("payload"), "{}"); const related_json = stringifyOrDefault(alloc, obj.get("related"), "[]"); const follows = strField(obj, "follows"); const follows_json = if (follows) |f| try jsonString(alloc, f) else "null"; // every string is written as a JSON string: an event name or resource id // with a quote or backslash in it must not break the message apart const event_json = try std.fmt.allocPrint( alloc, \\{{"id":{s},"occurred":{s},"event":{s},"resource_id":{s},"resource":{s},"payload":{s},"related":{s},"follows":{s}}} , .{ try jsonString(alloc, id), try jsonString(alloc, occurred), try jsonString(alloc, event_name), try jsonString(alloc, resource_id), resource_json, payload_json, related_json, follows_json }, ); try b.publish(EVENTS_TOPIC, id, event_json); } /// `s` as a quoted, escaped JSON string pub fn jsonString(alloc: std.mem.Allocator, s: []const u8) ![]const u8 { return std.json.Stringify.valueAlloc(alloc, s, .{}); } fn strField(obj: std.json.ObjectMap, key: []const u8) ?[]const u8 { const v = obj.get(key) orelse return null; return switch (v) { .string => |s| s, else => null, }; } fn stringifyOrDefault(alloc: std.mem.Allocator, val: ?std.json.Value, default: []const u8) []const u8 { if (val) |v| { const formatted = std.fmt.allocPrint(alloc, "{f}", .{std.json.fmt(v, .{})}) catch return default; return formatted; } return default; } fn filter(req: *wap.Request, res: *wap.Response) !void { const alloc = req.arena; // parse request body const parsed = std.json.parseFromSlice(std.json.Value, alloc, req.body, .{}) catch |err| { if (err == error.OutOfMemory) return err; try sendError(res, .bad_request, "invalid json"); return; }; // parse limit (default PAGE_SIZE, max PAGE_SIZE for pagination) const limit: usize = blk: { if (json_nav.getInt(parsed.value, "limit")) |l| { if (l > 0 and l <= PAGE_SIZE) break :blk @intCast(l); } break :blk PAGE_SIZE; }; // parse filter object const filter_opts = parseFilterOptions(alloc, parsed.value) catch |err| switch (err) { error.InvalidTextFilter => return sendError(res, .unprocessable_entity, "invalid text filter"), else => return err, }; // get total count first const total = try db_events.countWithFilter(alloc, filter_opts); // query first page (offset 0) const events = db_events.queryWithFilter(alloc, filter_opts, limit, 0) catch |err| { log.err("events-api", "query error: {}", .{err}); try sendError(res, .internal_server_error, "database error"); return; }; // generate next_page URL if there are more results const next_page = try generateNextPageUrl(alloc, req, filter_opts, total, limit, 0); // send response try sendEventPage(res, alloc, events, total, next_page); } fn filterNext(req: *wap.Request, res: *wap.Response) !void { const alloc = req.arena; // extract page-token from query string const query = req.query orelse ""; const token_start = mem.indexOf(u8, query, "page-token=") orelse { try sendError(res, .forbidden, "missing page token"); return; }; const token_value_start = token_start + "page-token=".len; var token_end = query.len; if (mem.indexOf(u8, query[token_value_start..], "&")) |amp| { token_end = token_value_start + amp; } const url_encoded_token = query[token_value_start..token_end]; // URL decode (handle %2B -> +, %2F -> /, %3D -> =) const decoded_token = encoding.urlDecode(alloc, url_encoded_token) catch |err| { if (err == error.OutOfMemory) return err; try sendError(res, .forbidden, "invalid page token"); return; }; // first base64 decode (URL layer) const inner_token = encoding.base64Decode(alloc, decoded_token) catch |err| { if (err == error.OutOfMemory) return err; try sendError(res, .forbidden, "invalid page token"); return; }; // second base64 decode (token layer) const token_json = encoding.base64Decode(alloc, inner_token) catch |err| { if (err == error.OutOfMemory) return err; try sendError(res, .forbidden, "invalid page token"); return; }; // parse token JSON const token_parsed = std.json.parseFromSlice(std.json.Value, alloc, token_json, .{}) catch |err| { if (err == error.OutOfMemory) return err; try sendError(res, .forbidden, "invalid page token"); return; }; if (token_parsed.value != .object) { try sendError(res, .forbidden, "invalid page token"); return; } // extract token fields using path helpers const total: usize = if (json_nav.getInt(token_parsed.value, "count")) |c| if (c >= 0) @intCast(c) else 0 else 0; const page_size: usize = if (json_nav.getInt(token_parsed.value, "page_size")) |ps| if (ps > 0) @intCast(ps) else PAGE_SIZE else PAGE_SIZE; const offset: usize = if (json_nav.getInt(token_parsed.value, "offset")) |o| if (o >= 0) @intCast(o) else 0 else 0; // parse filter from token var filter_opts = db_events.FilterOptions{}; filter_opts.occurred_since = json_nav.getString(token_parsed.value, "filter.occurred_since"); filter_opts.occurred_until = json_nav.getString(token_parsed.value, "filter.occurred_until"); filter_opts.order_asc = json_nav.getBool(token_parsed.value, "filter.order_asc") orelse false; if (json_nav.getPath(token_parsed.value, "filter.event_prefixes")) |v| { filter_opts.event_prefixes = try db_events.parseJsonStringArray(alloc, v); } if (json_nav.getPath(token_parsed.value, "filter.event_names")) |v| { filter_opts.event_names = try db_events.parseJsonStringArray(alloc, v); } if (json_nav.getPath(token_parsed.value, "filter.resource_ids")) |v| { filter_opts.resource_ids = try db_events.parseJsonStringArray(alloc, v); } if (json_nav.getPath(token_parsed.value, "filter.resource_id_prefixes")) |v| { filter_opts.resource_id_prefixes = try db_events.parseJsonStringArray(alloc, v); } filter_opts.text = json_nav.getString(token_parsed.value, "filter.text"); // query this page const events = db_events.queryWithFilter(alloc, filter_opts, page_size, offset) catch |err| { log.err("events-api", "query next page error: {}", .{err}); try sendError(res, .internal_server_error, "database error"); return; }; // generate next_page URL if there are more results const next_page = try generateNextPageUrl(alloc, req, filter_opts, total, page_size, offset); // send response try sendEventPage(res, alloc, events, total, next_page); } pub fn parseFilterOptions(alloc: std.mem.Allocator, value: std.json.Value) !db_events.FilterOptions { var opts = db_events.FilterOptions{}; // occurred filter opts.occurred_since = json_nav.getString(value, "filter.occurred.since"); opts.occurred_until = json_nav.getString(value, "filter.occurred.until"); // event filter if (json_nav.getPath(value, "filter.event.prefix")) |v| { opts.event_prefixes = try db_events.parseJsonStringArray(alloc, v); } if (json_nav.getPath(value, "filter.event.name")) |v| { opts.event_names = try db_events.parseJsonStringArray(alloc, v); } // resource filter if (json_nav.getPath(value, "filter.resource.id")) |v| { opts.resource_ids = try db_events.parseJsonStringArray(alloc, v); } if (json_nav.getPath(value, "filter.resource.id_prefix")) |v| { opts.resource_id_prefixes = try db_events.parseJsonStringArray(alloc, v); } if (json_nav.getPath(value, "filter.any_resource.id")) |v| { opts.any_resource_ids = try db_events.parseJsonStringArray(alloc, v); } if (json_nav.getPath(value, "filter.any_resource.id_prefix")) |v| { opts.any_resource_id_prefixes = try db_events.parseJsonStringArray(alloc, v); } if (json_nav.getPath(value, "filter.text")) |text| { opts.text = try text_search.queryFromJson(text); } // order if (json_nav.getString(value, "filter.order")) |order| { opts.order_asc = mem.eql(u8, order, "ASC"); } return opts; } fn generateNextPageUrl(alloc: std.mem.Allocator, req: *wap.Request, filter_opts: db_events.FilterOptions, total: usize, page_size: usize, current_offset: usize) !?[]const u8 { const next_offset = current_offset + page_size; if (next_offset >= total) return null; // build token JSON: {"filter": {...}, "count": N, "page_size": N, "offset": N} const filter_json = try filter_opts.toJson(alloc); defer alloc.free(filter_json); const token_json = try std.fmt.allocPrint(alloc, "{{\"filter\":{s},\"count\":{d},\"page_size\":{d},\"offset\":{d}}}", .{ filter_json, total, page_size, next_offset, }); defer alloc.free(token_json); // base64 encode the token const inner_token = try encoding.base64Encode(alloc, token_json); defer alloc.free(inner_token); // base64 encode again for URL const url_token = try encoding.base64Encode(alloc, inner_token); defer alloc.free(url_token); // build URL const host = req.header("host") orelse "localhost:4200"; return try std.fmt.allocPrint(alloc, "http://{s}/api/events/filter/next?page-token={s}", .{ host, url_token }); } fn sendEventPage(res: *wap.Response, alloc: std.mem.Allocator, events: []const []const u8, total: usize, next_page: ?[]const u8) !void { var output: std.Io.Writer.Allocating = .init(alloc); defer output.deinit(); var jw: std.json.Stringify = .{ .writer = &output.writer }; try jw.beginObject(); // "events": [...] try jw.objectField("events"); try jw.beginArray(); for (events) |event_json| { try jw.print("{s}", .{event_json}); } try jw.endArray(); // "total": N try jw.objectField("total"); try jw.write(total); // "next_page": "..." or null try jw.objectField("next_page"); if (next_page) |url| { try jw.write(url); } else { try jw.write(null); } try jw.endObject(); _ = res.setHeader("content-type", "application/json"); try res.sendBody(output.written()); } fn count(res: *wap.Response) !void { const total = try db_events.count(); try res.writeJson(.{ .count = total }); } fn countBy(req: *wap.Request, res: *wap.Response, target: []const u8) !void { if (mem.endsWith(u8, target, "/count-by/event")) { try countByEvent(req, res); return; } if (mem.endsWith(u8, target, "/count-by/time")) { try countByTime(req, res); return; } try sendError(res, .not_found, "not found"); } fn countByEvent(req: *wap.Request, res: *wap.Response) !void { const alloc = req.arena; const filter_opts = parseRequestFilter(alloc, req) catch |err| switch (err) { error.OutOfMemory => return err, error.InvalidTextFilter => return sendError(res, .unprocessable_entity, "invalid text filter"), else => return sendError(res, .bad_request, "invalid json"), }; const counts = db_events.countByEvent(alloc, filter_opts, 200) catch |err| { log.err("events-api", "count-by event error: {}", .{err}); try sendError(res, .internal_server_error, "database error"); return; }; var output: std.Io.Writer.Allocating = .init(alloc); var jw: std.json.Stringify = .{ .writer = &output.writer }; try jw.beginArray(); for (counts) |item| { try jw.beginObject(); try jw.objectField("value"); try jw.write(item.value); try jw.objectField("count"); try jw.write(item.count); try jw.endObject(); } try jw.endArray(); _ = res.setHeader("content-type", "application/json"); try res.sendBody(try output.toOwnedSlice()); } fn countByTime(req: *wap.Request, res: *wap.Response) !void { const alloc = req.arena; const filter_opts = parseRequestFilter(alloc, req) catch |err| switch (err) { error.OutOfMemory => return err, error.InvalidTextFilter => return sendError(res, .unprocessable_entity, "invalid text filter"), else => return sendError(res, .bad_request, "invalid json"), }; const total = try db_events.countWithFilter(alloc, filter_opts); const start_time = filter_opts.occurred_since orelse "1970-01-01T00:00:00.000Z"; try res.writeJson(&[_]struct { start_time: []const u8, count: usize, }{.{ .start_time = start_time, .count = total, }}); } fn parseRequestFilter(alloc: std.mem.Allocator, req: *wap.Request) !db_events.FilterOptions { if (req.body.len == 0) return db_events.FilterOptions{}; const parsed = try std.json.parseFromSlice(std.json.Value, alloc, req.body, .{}); return try parseFilterOptions(alloc, parsed.value); } test "event page serialization propagates allocation failure without sending partial JSON" { const Check = struct { fn send(res: *wap.Response, alloc: std.mem.Allocator) !void { const message: [4096]u8 = @splat('x'); var buffer: [8192]u8 = undefined; const event = try std.fmt.bufPrint(&buffer, "{{\"message\":\"{s}\"}}", .{message}); try sendEventPage(res, alloc, &.{ event, event }, 2, null); } }; try @import("response_test.zig").checkJsonResponse(Check.send); } test "event filters propagate allocation failure without dropping constraints" { try @import("json_test.zig").checkFilterStrings(db_events.parseJsonStringArray); } test "next event page cannot disappear on allocation failure" { const Check = struct { fn run(alloc: std.mem.Allocator) !void { var req: wap.Request = .{ .method = .POST, .target = "/api/events/filter", .path = "/api/events/filter", .query = null, .body = "", .headers = .{ .keys = &.{}, .values = &.{} }, .arena = alloc, }; const url = (generateNextPageUrl(alloc, &req, .{ .event_names = &.{"preserved.event"} }, 120, 10, 0) catch |err| return switch (err) { error.WriteFailed => error.OutOfMemory, else => err, }) orelse return error.MissingNextPage; defer alloc.free(url); const prefix = "http://localhost:4200/api/events/filter/next?page-token="; try std.testing.expect(mem.startsWith(u8, url, prefix)); var read_arena = std.heap.ArenaAllocator.init(std.testing.allocator); defer read_arena.deinit(); const inner = try encoding.base64Decode(read_arena.allocator(), url[prefix.len..]); const raw = try encoding.base64Decode(read_arena.allocator(), inner); const parsed = try std.json.parseFromSlice(std.json.Value, std.testing.allocator, raw, .{}); defer parsed.deinit(); try std.testing.expectEqual(@as(i64, 10), parsed.value.object.get("offset").?.integer); try std.testing.expectEqual(@as(i64, 120), parsed.value.object.get("count").?.integer); try std.testing.expectEqualStrings("preserved.event", parsed.value.object.get("filter").?.object.get("event_names").?.array.items[0].string); } }; try std.testing.checkAllAllocationFailures(std.testing.allocator, Check.run, .{}); }