2 files changed, 55 insertions, 7 deletions

diff --git a/src/http/Response.zig b/src/http/Response.zig
index 5745899..2105e16 100644
--- a/src/http/Response.zig
+++ b/src/http/Response.zig
@@ -27,11 +27,24 @@ pub const Message = union(enum) {
 
 status: std.http.Status,
 message: Message,
+headers: []const std.http.Header = &.{},
 
 pub fn with(status: std.http.Status, message: Message) @This() {
     return .{ .status = status, .message = message };
 }
 
+pub fn withHeaders(
+    status: std.http.Status,
+    message: Message,
+    headers: []const std.http.Header,
+) @This() {
+    return .{
+        .status = status,
+        .message = message,
+        .headers = headers,
+    };
+}
+
 pub fn ok(message: Message) @This() {
     return with(.ok, message);
 }
@@ -44,17 +57,40 @@ pub fn badRequest(message: Message) @This() {
     return with(.bad_request, message);
 }
 
+pub const SendOptions = struct {
+    headers: []const std.http.Header,
+};
+
 pub fn send(
     self: *const @This(),
     io: std.Io,
+    arena: std.mem.Allocator,
     request: *std.http.Server.Request,
+    options: SendOptions,
 ) !void {
+    const headers = hdrs: {
+        if (options.headers.len == 0) {
+            break :hdrs self.headers;
+        }
+
+        const h = try arena.alloc(std.http.Header, options.headers.len + self.headers.len);
+        @memcpy(h[0..options.headers.len], options.headers);
+        @memcpy(h[options.headers.len..], self.headers);
+        break :hdrs h;
+    };
+
     switch (self.message) {
         .void => {
-            try request.respond("", .{ .status = self.status });
+            try request.respond("", .{
+                .status = self.status,
+                .extra_headers = headers,
+            });
         },
         .static => |content| {
-            try request.respond(content, .{ .status = self.status });
+            try request.respond(content, .{
+                .status = self.status,
+                .extra_headers = headers,
+            });
         },
         .streaming => |file| {
             var write_buffer: [1024]u8 = undefined;
@@ -63,6 +99,7 @@ pub fn send(
             var body_writer = try request.respondStreaming(&write_buffer, .{
                 .respond_options = .{
                     .status = self.status,
+                    .extra_headers = headers,
                     .transfer_encoding = .chunked,
                 },
             });
diff --git a/src/http/serve.zig b/src/http/serve.zig
index 587f4a3..036eecd 100644
--- a/src/http/serve.zig
+++ b/src/http/serve.zig
@@ -1,20 +1,30 @@
 const std = @import("std");
 
+const Response = @import("Response.zig");
 const RouteSet = @import("RouteSet.zig");
 
+pub const Options = struct {
+    address: std.Io.net.IpAddress,
+    headers: []const std.http.Header = &.{},
+};
+
 pub fn serve(
     gpa: std.mem.Allocator,
     comptime routes: RouteSet,
-    address: std.Io.net.IpAddress,
+    options: Options,
 ) !void {
     var threaded: std.Io.Threaded = .init(gpa, .{});
     var group: std.Io.Group = .init;
     const io = threaded.io();
-    var server = try address.listen(io, .{ .reuse_address = true });
+    var server = try options.address.listen(io, .{ .reuse_address = true });
+
+    const send_options: Response.SendOptions = .{
+        .headers = options.headers,
+    };
 
     while (true) {
         const stream = try server.accept(io);
-        group.async(io, handle, .{ io, gpa, stream, &routes });
+        group.async(io, handle, .{ io, gpa, stream, &routes, send_options });
     }
 }
 
@@ -23,6 +33,7 @@ pub fn handle(
     gpa: std.mem.Allocator,
     stream: std.Io.net.Stream,
     routes: *const RouteSet,
+    send_options: Response.SendOptions,
 ) void {
     var read_buffer: [1024 * 8]u8 = undefined;
     var write_buffer: [1024 * 8]u8 = undefined;
@@ -44,8 +55,8 @@ pub fn handle(
     std.debug.print("{s} {s}\n", .{ @tagName(request.head.method), request.head.target });
 
     if (routes.getInterface(request.head.target)) |interface| {
-        const message = interface.handle(gpa, arena.allocator(), io, &request);
-        message.send(io, &request) catch return;
+        const response = interface.handle(gpa, arena.allocator(), io, &request);
+        response.send(io, arena.allocator(), &request, send_options) catch return;
     } else {
         request.respond("", .{ .status = .not_found }) catch return;
     }