fix: apply Respond Fields directly to Response

mookums · web-flow · commit a6b9764ce3fe · 2025-02-16T14:08:35.000-08:00
This will make it so that Respond Fields are directly applied onto the Response. This will help prevent a common issue where a stack-allocated slice was being returned in the `Respond`
diff --git a/examples/basic/main.zig b/examples/basic/main.zig
@@ -15,12 +15,12 @@ const Context = http.Context;
 const Route = http.Route;
 const Respond = http.Respond;
 
-fn base_handler(_: *const Context, _: void) !Respond {
-    return Respond{ .standard = .{
+fn base_handler(ctx: *const Context, _: void) !Respond {
+    return ctx.response.apply(.{
         .status = .OK,
         .mime = http.Mime.HTML,
         .body = "Hello, world!",
-    } };
+    });
 }
 
 pub fn main() !void {
diff --git a/examples/cookies/main.zig b/examples/cookies/main.zig
@@ -22,15 +22,14 @@ fn base_handler(ctx: *const Context, _: void) !Respond {
     while (iter.next()) |kv| log.debug("cookie: k={s} v={s}", .{ kv.key_ptr.*, kv.value_ptr.* });
 
     const cookie = Cookie.init("example_cookie", "abcdef123");
-
-    return Respond{ .standard = .{
+    return ctx.response.apply(.{
         .status = .OK,
         .mime = http.Mime.HTML,
         .body = "Hello, world!",
         .headers = &.{
             .{ "Set-Cookie", try cookie.to_string_alloc(ctx.allocator) },
         },
-    } };
+    });
 }
 
 pub fn main() !void {
diff --git a/examples/form/main.zig b/examples/form/main.zig
@@ -17,7 +17,7 @@ const Form = http.Form;
 const Query = http.Query;
 const Respond = http.Respond;
 
-fn base_handler(_: *const Context, _: void) !Respond {
+fn base_handler(ctx: *const Context, _: void) !Respond {
     const body =
         \\<form>
         \\    <label for="fname">First name:</label>
@@ -33,11 +33,11 @@ fn base_handler(_: *const Context, _: void) !Respond {
         \\</form> 
     ;
 
-    return Respond{ .standard = .{
+    return ctx.response.apply(.{
         .status = .OK,
         .mime = http.Mime.HTML,
         .body = body,
-    } };
+    });
 }
 
 const UserInfo = struct {
@@ -69,11 +69,11 @@ fn generate_handler(ctx: *const Context, _: void) !Respond {
         },
     );
 
-    return Respond{ .standard = .{
+    return ctx.response.apply(.{
         .status = .OK,
         .mime = http.Mime.TEXT,
         .body = body,
-    } };
+    });
 }
 
 pub fn main() !void {
diff --git a/examples/fs/main.zig b/examples/fs/main.zig
@@ -19,7 +19,7 @@ const FsDir = http.FsDir;
 
 const Compression = http.Middlewares.Compression;
 
-fn base_handler(_: *const Context, _: void) !Respond {
+fn base_handler(ctx: *const Context, _: void) !Respond {
     const body =
         \\ <!DOCTYPE html>
         \\ <html>
@@ -29,11 +29,11 @@ fn base_handler(_: *const Context, _: void) !Respond {
         \\ </html>
     ;
 
-    return Respond{ .standard = .{
+    return try ctx.response.apply(.{
         .status = .OK,
         .mime = http.Mime.HTML,
         .body = body[0..],
-    } };
+    });
 }
 
 pub fn main() !void {
diff --git a/examples/middleware/main.zig b/examples/middleware/main.zig
@@ -32,11 +32,11 @@ fn root_handler(ctx: *const Context, id: i8) !Respond {
     // This is the standard response and what you
     // will usually be using. This will send to the
     // client and then continue to await more requests.
-    return Respond{ .standard = .{
+    return ctx.response.apply(.{
         .status = .OK,
         .mime = http.Mime.HTML,
         .body = body[0..],
-    } };
+    });
 }
 
 fn passing_middleware(next: *Next, _: void) !Respond {
diff --git a/examples/tls/main.zig b/examples/tls/main.zig
@@ -17,7 +17,7 @@ const Respond = http.Respond;
 
 const Compression = http.Middlewares.Compression;
 
-fn root_handler(_: *const Context, _: void) !Respond {
+fn root_handler(ctx: *const Context, _: void) !Respond {
     const body =
         \\ <!DOCTYPE html>
         \\ <html>
@@ -30,11 +30,11 @@ fn root_handler(_: *const Context, _: void) !Respond {
         \\ </html>
     ;
 
-    return Respond{ .standard = .{
+    return ctx.response.apply(.{
         .status = .OK,
         .mime = http.Mime.HTML,
         .body = body[0..],
-    } };
+    });
 }
 
 pub fn main() !void {
diff --git a/examples/unix/main.zig b/examples/unix/main.zig
@@ -15,16 +15,14 @@ const Route = http.Route;
 const Router = http.Router;
 const Respond = http.Respond;
 
-pub const std_options = .{
-    .log_level = .err,
-};
+pub const std_options = .{ .log_level = .err };
 
-pub fn root_handler(_: *const Context, _: void) !Respond {
-    return Respond{ .standard = .{
+pub fn root_handler(ctx: *const Context, _: void) !Respond {
+    return ctx.response.apply(.{
         .status = .OK,
         .mime = http.Mime.HTML,
         .body = "This is an HTTP benchmark",
-    } };
+    });
 }
 
 pub fn main() !void {
diff --git a/src/http/middlewares/compression.zig b/src/http/middlewares/compression.zig
@@ -18,26 +18,25 @@ pub fn Compression(comptime compression: Kind) Layer {
     const func: TypedMiddlewareFn(void) = switch (compression) {
         .gzip => |inner| struct {
             fn gzip_mw(next: *Next, _: void) !Respond {
-                var response = try next.run();
-                switch (response) {
-                    .standard => |*respond| {
-                        var compressed = std.ArrayList(u8).init(next.context.allocator);
+                const respond = try next.run();
+                const response = next.context.response;
+                if (response.body) |body| if (respond == .standard) {
+                    var compressed = try std.ArrayListUnmanaged(u8).initCapacity(next.context.allocator, body.len);
+                    errdefer compressed.deinit(next.context.allocator);
 
-                        var body_stream = std.io.fixedBufferStream(respond.body);
-                        try std.compress.gzip.compress(body_stream.reader(), compressed.writer(), inner);
+                    var body_stream = std.io.fixedBufferStream(body);
+                    try std.compress.gzip.compress(
+                        body_stream.reader(),
+                        compressed.writer(next.context.allocator),
+                        inner,
+                    );
 
-                        // TODO: consider having the headers be a part of the provision?
-                        // might be nice to reuse them as things go on??
-                        var header_list = std.ArrayList([2][]const u8).init(next.context.allocator);
-                        try header_list.appendSlice(respond.headers);
-                        try header_list.append(.{ "Content-Encoding", "gzip" });
+                    try response.headers.put("Content-Encoding", "gzip");
+                    response.body = try compressed.toOwnedSlice(next.context.allocator);
+                    return .standard;
+                };
 
-                        respond.body = try compressed.toOwnedSlice();
-                        respond.headers = try header_list.toOwnedSlice();
-                        return .{ .standard = respond.* };
-                    },
-                    else => return response,
-                }
+                return respond;
             }
         }.gzip_mw,
     };
diff --git a/src/http/middlewares/rate_limit.zig b/src/http/middlewares/rate_limit.zig
@@ -2,6 +2,7 @@ const std = @import("std");
 
 const Mime = @import("../mime.zig").Mime;
 const Respond = @import("../response.zig").Respond;
+const Response = @import("../response.zig").Response;
 const Middleware = @import("../router/middleware.zig").Middleware;
 const Next = @import("../router/middleware.zig").Next;
 const Layer = @import("../router/middleware.zig").Layer;
@@ -43,7 +44,7 @@ pub const RateLimitConfig = struct {
     map: std.AutoHashMap(u128, Bucket),
     tokens_per_sec: u16,
     max_tokens: u16,
-    response_on_limited: Respond,
+    response_on_limited: Response.Fields,
     mutex: std.Thread.Mutex = .{},
 
     pub fn init(
@@ -53,12 +54,10 @@ pub const RateLimitConfig = struct {
         response_on_limited: ?Respond,
     ) RateLimitConfig {
         const map = std.AutoHashMap(u128, Bucket).init(allocator);
-        const respond = response_on_limited orelse Respond{
-            .standard = .{
-                .status = .@"Too Many Requests",
-                .mime = Mime.TEXT,
-                .body = "",
-            },
+        const respond = response_on_limited orelse Response.Fields{
+            .status = .@"Too Many Requests",
+            .mime = Mime.TEXT,
+            .body = "",
         };
 
         return .{
diff --git a/src/http/response.zig b/src/http/response.zig
@@ -8,16 +8,9 @@ const Date = @import("lib.zig").Date;
 
 const Stream = @import("tardy").Stream;
 
-pub const Respond = union(enum) {
-    pub const Fields = struct {
-        status: Status = .OK,
-        mime: Mime = Mime.TEXT,
-        body: []const u8 = "",
-        headers: []const [2][]const u8 = &.{},
-    };
-
+pub const Respond = enum {
     // When we are returning a real HTTP request, we use this.
-    standard: Fields,
+    standard,
     // If we responded and we want to give control back to the HTTP engine.
     responded,
     // If we want the connection to close.
@@ -30,6 +23,13 @@ pub const Response = struct {
     body: ?[]const u8 = null,
     headers: AnyCaseStringMap,
 
+    pub const Fields = struct {
+        status: Status,
+        mime: Mime,
+        body: []const u8 = "",
+        headers: []const [2][]const u8 = &.{},
+    };
+
     pub fn init(allocator: std.mem.Allocator) Response {
         const headers = AnyCaseStringMap.init(allocator);
         return Response{ .headers = headers };
@@ -39,13 +39,12 @@ pub const Response = struct {
         self.headers.deinit();
     }
 
-    pub fn apply(self: *Response, into: Respond.Fields) !void {
+    pub fn apply(self: *Response, into: Fields) !Respond {
         self.status = into.status;
         self.mime = into.mime;
         self.body = into.body;
-
-        self.headers.clearRetainingCapacity();
         for (into.headers) |pair| try self.headers.put(pair[0], pair[1]);
+        return .standard;
     }
 
     pub fn clear(self: *Response) void {
diff --git a/src/http/router.zig b/src/http/router.zig
@@ -20,14 +20,13 @@ const AnyCaseStringMap = @import("../core/any_case_string_map.zig").AnyCaseStrin
 
 /// Default not found handler: send a plain text response.
 pub const default_not_found_handler = struct {
-    fn not_found_handler(_: *const Context, _: void) !Respond {
-        return Respond{
-            .standard = .{
-                .status = .@"Not Found",
-                .mime = Mime.TEXT,
-                .body = "404 | Not Found",
-            },
-        };
+    fn not_found_handler(ctx: *const Context, _: void) !Respond {
+        const response = ctx.response;
+        response.status = .@"Not Found";
+        response.mime = Mime.TEXT;
+        response.body = "404 | Not Found";
+
+        return .standard;
     }
 }.not_found_handler;
 
diff --git a/src/http/router/fs_dir.zig b/src/http/router/fs_dir.zig
@@ -18,17 +18,13 @@ const Stream = @import("tardy").Stream;
 
 pub const FsDir = struct {
     fn fs_dir_handler(ctx: *const Context, dir: Dir) !Respond {
-        if (ctx.captures.len == 0) {
-            return Respond{
-                .standard = .{
-                    .status = .@"Not Found",
-                    .mime = Mime.HTML,
-                    .body = "",
-                },
-            };
-        }
+        if (ctx.captures.len == 0) return ctx.response.apply(.{
+            .status = .@"Not Found",
+            .mime = Mime.HTML,
+        });
+
+        const response = ctx.response;
 
-        var header_list = try std.ArrayListUnmanaged([2][]const u8).initCapacity(ctx.allocator, 3);
         // Resolving the requested file.
         const search_path = ctx.captures[0].remaining;
         const file_path_z = try ctx.allocator.dupeZ(u8, search_path);
@@ -47,14 +43,10 @@ pub const FsDir = struct {
 
         const file = dir.open_file(ctx.runtime, file_path_z, .{ .mode = .read }) catch |e| switch (e) {
             error.NotFound => {
-                return Respond{
-                    .standard = .{
-                        .status = .@"Not Found",
-                        .mime = Mime.HTML,
-                        .body = "",
-                        .headers = try header_list.toOwnedSlice(ctx.allocator),
-                    },
-                };
+                return ctx.response.apply(.{
+                    .status = .@"Not Found",
+                    .mime = Mime.HTML,
+                });
             },
             else => return e,
         };
@@ -69,31 +61,24 @@ pub const FsDir = struct {
         const etag_hash = hash.final();
 
         const calc_etag = try std.fmt.allocPrint(ctx.allocator, "\"{d}\"", .{etag_hash});
-        try header_list.append(ctx.allocator, .{ "ETag", calc_etag });
+        try response.headers.put("ETag", calc_etag);
 
         // If we have an ETag on the request...
         if (ctx.request.headers.get("If-None-Match")) |etag| {
             if (std.mem.eql(u8, etag, calc_etag)) {
                 // If the ETag matches.
-                return Respond{
-                    .standard = .{
-                        .status = .@"Not Modified",
-                        .mime = Mime.HTML,
-                        .headers = try header_list.toOwnedSlice(ctx.allocator),
-                        .body = "",
-                    },
-                };
+                return ctx.response.apply(.{
+                    .status = .@"Not Modified",
+                    .mime = Mime.HTML,
+                });
             }
         }
 
         // apply the fields.
-        try ctx.response.apply(Respond.Fields{
-            .status = .OK,
-            .headers = try header_list.toOwnedSlice(ctx.allocator),
-            .mime = mime,
-        });
+        response.status = .OK;
+        response.mime = mime;
 
-        try ctx.response.headers_into_writer(ctx.header_buffer.writer(), stat.size);
+        try response.headers_into_writer(ctx.header_buffer.writer(), stat.size);
         const headers = ctx.header_buffer.items;
         const length = try ctx.socket.send_all(ctx.runtime, headers);
         if (headers.len != length) return error.SendingHeadersFailed;
diff --git a/src/http/router/route.zig b/src/http/router/route.zig
diff --git a/src/http/server.zig b/src/http/server.zig
diff --git a/src/http/sse.zig b/src/http/sse.zig
