/g,n(o))),lookbehind:!0,inside:null}],"builtin-type":{pattern:/\b(?:anyerror|bool|c_u?(?:int|long|longlong|short)|c_longdouble|c_void|comptime_(?:float|int)|f(?:16|32|64|128)|[iu](?:8|16|32|64|128|size)|noreturn|type|void)\b/,alias:"keyword"},keyword:r,function:/\b(?!\d)\w+(?=\s*\()/,number:/\b(?:0b[01]+|0o[0-7]+|0x[a-fA-F\d]+(?:\.[a-fA-F\d]*)?(?:[pP][+-]?[a-fA-F\d]+)?|\d+(?:\.\d*)?(?:[eE][+-]?\d+)?)\b/,boolean:/\b(?:false|true)\b/,operator:/\.[*?]|\.{2,3}|[-=]>|\*\*|\+\+|\|\||(?:<<|>>|[-+*]%|[-+*/%^&|<>!=])=?|[?~]/,punctuation:/[.:,;(){}[\]]/},e.languages.zig["class-name"].forEach((function(n){null===n.inside&&(n.inside=e.languages.zig)}))}(Prism);
diff --git a/src/jetzig.zig b/src/jetzig.zig
index de8af9e..db5a2c1 100644
--- a/src/jetzig.zig
+++ b/src/jetzig.zig
@@ -23,6 +23,7 @@ pub const testing = @import("jetzig/testing.zig");
pub const config = @import("jetzig/config.zig");
pub const auth = @import("jetzig/auth.zig");
pub const callbacks = @import("jetzig/callbacks.zig");
+pub const debug = @import("jetzig/debug.zig");
pub const TemplateContext = @import("jetzig/TemplateContext.zig");
pub const DateTime = jetcommon.types.DateTime;
diff --git a/src/jetzig/debug.zig b/src/jetzig/debug.zig
new file mode 100644
index 0000000..80d634e
--- /dev/null
+++ b/src/jetzig/debug.zig
@@ -0,0 +1,218 @@
+const std = @import("std");
+const builtin = @import("builtin");
+
+pub const ErrorInfo = struct {
+ stack_trace: ?*std.builtin.StackTrace = null,
+ err: ?anyerror = null,
+};
+
+pub fn sourceLocations(
+ allocator: std.mem.Allocator,
+ debug_info: *std.debug.SelfInfo,
+ stack_trace: *std.builtin.StackTrace,
+) ![]const std.debug.SourceLocation {
+ var source_locations = std.ArrayList(std.debug.SourceLocation).init(allocator);
+
+ if (builtin.strip_debug_info) return error.MissingDebugInfo;
+
+ var frame_index: usize = 0;
+ var frames_left: usize = @min(stack_trace.index, stack_trace.instruction_addresses.len);
+
+ while (frames_left != 0) : ({
+ frames_left -= 1;
+ frame_index = (frame_index + 1) % stack_trace.instruction_addresses.len;
+ }) {
+ const return_address = stack_trace.instruction_addresses[frame_index];
+ const address = return_address - 1;
+ const module = try debug_info.getModuleForAddress(address);
+ const symbol_info = try module.getSymbolAtAddress(debug_info.allocator, address);
+
+ if (symbol_info.source_location) |source_location| {
+ try source_locations.append(source_location);
+ }
+ }
+
+ return try source_locations.toOwnedSlice();
+}
+
+pub const HtmlStackTrace = struct {
+ allocator: std.mem.Allocator,
+ stack_trace: *std.builtin.StackTrace,
+
+ pub fn format(self: HtmlStackTrace, _: anytype, _: anytype, writer: anytype) !void {
+ const debug_info = try std.debug.getSelfDebugInfo();
+ const source_locations = try sourceLocations(
+ self.allocator,
+ debug_info,
+ self.stack_trace,
+ );
+ for (source_locations) |source_location| {
+ defer debug_info.allocator.free(source_location.file_name);
+ try writer.print(
+ \\
+ \\ {s}:{d}
+ \\
+ ,
+ .{
+ source_location.file_name,
+ source_location.line,
+ },
+ );
+ const surrounding_previous = try surroundingLinesFromFile(
+ self.allocator,
+ .previous,
+ 3,
+ source_location.file_name,
+ source_location.line,
+ );
+ const surrounding_next = try surroundingLinesFromFile(
+ self.allocator,
+ .next,
+ 3,
+ source_location.file_name,
+ source_location.line,
+ );
+ const target_source_line = try readLineFromFile(
+ self.allocator,
+ source_location.file_name,
+ source_location.line,
+ );
+
+ for (surrounding_previous) |source_line| {
+ try writer.print(surrounding_line_template, .{ source_line.line, source_line.content });
+ }
+ try writer.print(target_line_template, .{ target_source_line.line, target_source_line.content });
+ for (surrounding_next) |source_line| {
+ try writer.print(surrounding_line_template, .{ source_line.line, source_line.content });
+ }
+
+ try writer.print(
+ \\
+ \\
+ , .{});
+ }
+ }
+};
+
+const SourceLine = struct { content: []const u8, line: usize };
+
+pub fn readLineFromFile(allocator: std.mem.Allocator, path: []const u8, line: usize) !SourceLine {
+ const file = try std.fs.openFileAbsolute(path, .{});
+ var buf: [std.mem.page_size]u8 = undefined;
+
+ var count: usize = 1;
+ var cursor: usize = 0;
+
+ seek: {
+ while (true) {
+ const bytes_read = try file.readAll(buf[0..]);
+ for (buf[0..bytes_read]) |char| {
+ if (char == '\n') count += 1;
+ cursor += 1;
+ if (count == line) {
+ cursor += 1;
+ break :seek;
+ }
+ }
+ if (bytes_read < buf.len) return error.EndOfFile;
+ }
+ }
+
+ var size: usize = 0;
+ try file.seekTo(cursor);
+ read: {
+ const bytes_read = try file.readAll(buf[0..]);
+ if (std.mem.indexOf(u8, buf[0..bytes_read], "\n")) |index| {
+ size += index;
+ break :read;
+ } else if (bytes_read < buf.len) {
+ size += bytes_read;
+ break :read;
+ } else {
+ while (true) {
+ const more_bytes_read = try file.readAll(buf[0..]);
+ if (std.mem.indexOf(u8, buf[0..more_bytes_read], "\n")) |index| {
+ size += index;
+ break :read;
+ } else if (more_bytes_read < buf.len) {
+ size += more_bytes_read;
+ break :read;
+ } else {
+ size += more_bytes_read;
+ }
+ }
+ }
+ }
+ const line_content = try allocator.alloc(u8, size);
+ try file.seekTo(cursor);
+ const bytes_read = try file.readAll(line_content[0..]);
+
+ std.debug.assert(bytes_read == size);
+
+ return .{ .content = line_content[0..], .line = line };
+}
+
+fn surroundingLinesFromFile(
+ allocator: std.mem.Allocator,
+ context: enum { previous, next },
+ desired_count: usize,
+ path: []const u8,
+ target_line: usize,
+) ![]SourceLine {
+ // This isn't very efficient but we only use it in debug mode so not a huge deal.
+ const start = switch (context) {
+ .previous => if (target_line > desired_count)
+ target_line - desired_count
+ else
+ target_line,
+ .next => target_line + 2,
+ };
+
+ var lines = std.ArrayList(SourceLine).init(allocator);
+
+ switch (context) {
+ .previous => {
+ for (start..target_line) |line| {
+ try lines.append(try readLineFromFile(allocator, path, line));
+ }
+ },
+ .next => {
+ for (0..desired_count, start..) |_, line| {
+ try lines.append(try readLineFromFile(allocator, path, line));
+ }
+ },
+ }
+
+ return try lines.toOwnedSlice();
+}
+
+pub const console_template =
+ \\
+ \\
+ \\
+ \\
+ \\
+ \\
+ \\ Encountered Error: {0s}
+ \\
+ \\ {1}
+ \\
+ \\ Response Data
+ \\
+ \\
+ \\
+ \\
+;
+
+const surrounding_line_template =
+ \\
+ \\
+;
+const target_line_template =
+ \\
+ \\
+;
diff --git a/src/jetzig/http/Request.zig b/src/jetzig/http/Request.zig
index b864913..41de5c9 100644
--- a/src/jetzig/http/Request.zig
+++ b/src/jetzig/http/Request.zig
@@ -11,6 +11,16 @@ pub const Method = enum { DELETE, GET, PATCH, POST, HEAD, PUT, CONNECT, OPTIONS,
pub const Modifier = enum { edit, new };
pub const Format = enum { HTML, JSON, UNKNOWN };
pub const Protocol = enum { http, https };
+pub const RequestState = enum {
+ initial, // No processing has taken place
+ processed, // Request headers have been processed
+ after_request, // Initial middleware processing
+ rendered, // Rendered by middleware or view
+ redirected, // Redirected by middleware or view
+ failed, // Failed by middleware or view
+ before_response, // Post middleware processing
+ finalized, // Response generated
+};
allocator: std.mem.Allocator,
path: jetzig.http.Path,
@@ -30,19 +40,12 @@ parsed_multipart: ?*jetzig.data.Data = null,
_cookies: ?*jetzig.http.Cookies = null,
_session: ?*jetzig.http.Session = null,
body: []const u8 = undefined,
-state: enum { initial, processed } = .initial,
-response_started: bool = false,
+state: RequestState = .initial,
dynamic_assigned_template: ?[]const u8 = null,
layout: ?[]const u8 = null,
layout_disabled: bool = false,
-// TODO: Squash rendered/redirected/failed into
-// `state: enum { initial, rendered, redirected, failed }`
-rendered: bool = false,
-redirected: bool = false,
-failed: bool = false,
redirect_state: ?RedirectState = null,
middleware_rendered: ?struct { name: []const u8, action: []const u8 } = null,
-middleware_rendered_during_response: bool = false,
middleware_data: jetzig.http.middleware.MiddlewareData = undefined,
rendered_multiple: bool = false,
rendered_view: ?jetzig.views.View = null,
@@ -177,6 +180,7 @@ pub fn respond(self: *Request) !void {
const status = jetzig.http.status_codes.get(self.response.status_code);
self.httpz_response.status = try status.getCodeInt();
self.httpz_response.body = self.response.content;
+ self.state = .finalized;
}
/// Set the root value for response data.
@@ -191,10 +195,9 @@ pub fn data(self: Request, comptime root: @TypeOf(.enum_literal)) !*jetzig.Data.
/// Render a response. This function can only be called once per request (repeat calls will
/// trigger an error).
pub fn render(self: *Request, status_code: jetzig.http.status_codes.StatusCode) jetzig.views.View {
- if (self.rendered or self.failed) self.rendered_multiple = true;
+ if (self.isRendered()) self.rendered_multiple = true;
- self.rendered = true;
- if (self.response_started) self.middleware_rendered_during_response = true;
+ self.state = .rendered;
self.rendered_view = .{ .data = self.response_data, .status_code = status_code };
return self.rendered_view.?;
}
@@ -202,15 +205,20 @@ pub fn render(self: *Request, status_code: jetzig.http.status_codes.StatusCode)
/// Render an error. This function can only be called once per request (repeat calls will
/// trigger an error).
pub fn fail(self: *Request, status_code: jetzig.http.status_codes.StatusCode) jetzig.views.View {
- if (self.rendered or self.redirected) self.rendered_multiple = true;
+ if (self.isRendered()) self.rendered_multiple = true;
- self.rendered = true;
- self.failed = true;
- if (self.response_started) self.middleware_rendered_during_response = true;
+ self.state = .failed;
self.rendered_view = .{ .data = self.response_data, .status_code = status_code };
return self.rendered_view.?;
}
+pub inline fn isRendered(self: *const Request) bool {
+ return switch (self.state) {
+ .initial, .processed, .after_request, .before_response => false,
+ .rendered, .redirected, .failed, .finalized => true,
+ };
+}
+
/// Issue a redirect to a new location.
/// ```zig
/// return request.redirect("https://www.example.com/", .moved_permanently);
@@ -224,11 +232,9 @@ pub fn redirect(
location: []const u8,
redirect_status: enum { moved_permanently, found },
) jetzig.views.View {
- if (self.rendered or self.failed) self.rendered_multiple = true;
+ if (self.isRendered()) self.rendered_multiple = true;
- self.rendered = true;
- self.redirected = true;
- if (self.response_started) self.middleware_rendered_during_response = true;
+ self.state = .redirected;
const status_code = switch (redirect_status) {
.moved_permanently => jetzig.http.status_codes.StatusCode.moved_permanently,
@@ -687,6 +693,19 @@ pub fn setTemplate(self: *Request, name: []const u8) void {
self.dynamic_assigned_template = name;
}
+/// Set a custom template and render the response.
+/// ```zig
+/// return request.renderTemplate("blogs/comments/get", .ok);
+/// ```
+pub fn renderTemplate(
+ self: *Request,
+ name: []const u8,
+ status_code: jetzig.http.StatusCode,
+) jetzig.views.View {
+ self.dynamic_assigned_template = name;
+ return self.render(status_code);
+}
+
pub fn joinPath(self: *const Request, args: anytype) ![]const u8 {
const fields = std.meta.fields(@TypeOf(args));
var buf: [fields.len][]const u8 = undefined;
diff --git a/src/jetzig/http/Server.zig b/src/jetzig/http/Server.zig
index 819067a..ca0c5d4 100644
--- a/src/jetzig/http/Server.zig
+++ b/src/jetzig/http/Server.zig
@@ -138,7 +138,8 @@ pub fn processNextRequest(
var middleware_data = try jetzig.http.middleware.afterRequest(&request);
- if (request.middleware_rendered) |_| { // Request processing ends when a middleware renders or redirects.
+ if (request.middleware_rendered) |_| {
+ // Request processing ends when a middleware renders or redirects.
if (request.redirect_state) |state| {
try request.renderRedirect(state);
} else if (request.rendered_view) |rendered| {
@@ -150,8 +151,8 @@ pub fn processNextRequest(
} else {
try self.renderResponse(&request);
try request.response.headers.append("Content-Type", response.content_type);
- try jetzig.http.middleware.beforeResponse(&middleware_data, &request);
+ try jetzig.http.middleware.beforeResponse(&middleware_data, &request);
try request.respond();
try jetzig.http.middleware.afterResponse(&middleware_data, &request);
jetzig.http.middleware.deinit(&middleware_data, &request);
@@ -197,9 +198,12 @@ fn renderResponse(self: *Server, request: *jetzig.http.Request) !void {
for (route.before_callbacks) |callback| {
try callback(request, route);
if (request.rendered_view) |view| {
- if (request.failed) {
- request.setResponse(try self.renderError(request, view.status_code), .{});
- } else if (request.rendered) {
+ if (request.state == .failed) {
+ request.setResponse(
+ try self.renderError(request, view.status_code, .{}),
+ .{},
+ );
+ } else if (request.state == .rendered) {
// TODO: Allow callbacks to set content
}
return;
@@ -259,7 +263,9 @@ fn renderHTML(
return request.setResponse(rendered_error, .{});
};
- return if (request.redirected or request.failed or request.dynamic_assigned_template != null)
+ return if (request.state == .redirected or
+ request.state == .failed or
+ request.dynamic_assigned_template != null)
request.setResponse(rendered, .{})
else
request.setResponse(try self.renderNotFound(request), .{});
@@ -327,12 +333,12 @@ fn renderView(
return try self.renderInternalServerError(request, @errorReturnTrace(), err);
};
- if (request.failed) {
+ if (request.state == .failed) {
const view: jetzig.views.View = request.rendered_view orelse .{
.data = request.response_data,
.status_code = .internal_server_error,
};
- return try self.renderError(request, view.status_code);
+ return try self.renderError(request, view.status_code, .{});
}
const template: ?zmpl.Template = if (request.dynamic_assigned_template) |request_template|
@@ -343,7 +349,7 @@ fn renderView(
if (request.rendered_multiple) return error.JetzigMultipleRenderError;
if (request.rendered_view) |rendered_view| {
- if (request.redirected) return .{ .view = rendered_view, .content = "" };
+ if (request.state == .redirected) return .{ .view = rendered_view, .content = "" };
if (template) |capture| {
return .{
@@ -352,12 +358,21 @@ fn renderView(
};
} else {
return switch (request.requestFormat()) {
- .HTML, .UNKNOWN => try self.renderNotFound(request),
+ .HTML, .UNKNOWN => blk: {
+ try self.logger.DEBUG(
+ "Missing template for route `{s}.{s}`. Expected: `src/app/views/{s}.zmpl`.",
+ .{ route.view_name, @tagName(route.action), route.template },
+ );
+ if (comptime jetzig.build_options.debug_console) {
+ return error.ZmplTemplateNotFound;
+ }
+ break :blk try self.renderNotFound(request);
+ },
.JSON => .{ .view = rendered_view, .content = "" },
};
}
} else {
- if (!request.redirected) {
+ if (request.state == .processed) {
try self.logger.WARN("`request.render` was not invoked. Rendering empty content.", .{});
}
request.response_data.reset();
@@ -461,32 +476,42 @@ fn renderInternalServerError(
stack_trace: ?*std.builtin.StackTrace,
err: anyerror,
) !RenderedView {
- request.response_data.reset();
-
try self.logger.logError(stack_trace, err);
- const status = .internal_server_error;
- return try self.renderError(request, status);
+ const status = jetzig.http.StatusCode.internal_server_error;
+
+ return try self.renderError(request, status, .{ .stack_trace = stack_trace, .err = err });
}
fn renderNotFound(self: *Server, request: *jetzig.http.Request) !RenderedView {
request.response_data.reset();
const status: jetzig.http.StatusCode = .not_found;
- return try self.renderError(request, status);
+ return try self.renderError(request, status, .{});
}
fn renderBadRequest(self: *Server, request: *jetzig.http.Request) !RenderedView {
request.response_data.reset();
const status: jetzig.http.StatusCode = .bad_request;
- return try self.renderError(request, status);
+ return try self.renderError(request, status, .{});
}
fn renderError(
self: Server,
request: *jetzig.http.Request,
status_code: jetzig.http.StatusCode,
+ error_info: jetzig.debug.ErrorInfo,
+) !RenderedView {
+ if (comptime jetzig.build_options.debug_console) {
+ return try self.renderDebugConsole(request, status_code, error_info);
+ } else return try self.renderGeneralError(request, status_code);
+}
+
+fn renderGeneralError(
+ self: Server,
+ request: *jetzig.http.Request,
+ status_code: jetzig.http.StatusCode,
) !RenderedView {
if (try self.renderErrorView(request, status_code)) |view| return view;
if (try renderStaticErrorPage(request, status_code)) |view| return view;
@@ -494,6 +519,42 @@ fn renderError(
return try renderDefaultError(request, status_code);
}
+fn renderDebugConsole(
+ self: Server,
+ request: *jetzig.http.Request,
+ status_code: jetzig.http.StatusCode,
+ error_info: jetzig.debug.ErrorInfo,
+) !RenderedView {
+ if (comptime jetzig.build_options.debug_console) {
+ var buf = std.ArrayList(u8).init(request.allocator);
+ const writer = buf.writer();
+
+ if (error_info.stack_trace) |stack_trace| {
+ const debug_content = jetzig.debug.HtmlStackTrace{
+ .allocator = request.allocator,
+ .stack_trace = stack_trace,
+ };
+ const error_name = if (error_info.err) |err| @errorName(err) else "[UnknownError]";
+ try writer.print(
+ jetzig.debug.console_template,
+ .{
+ error_name,
+ debug_content,
+ try request.response_data.toJsonOptions(.{ .pretty = true }),
+ @embedFile("../../assets/debug.css"),
+ },
+ );
+ } else return try self.renderGeneralError(request, status_code);
+
+ const content = try buf.toOwnedSlice();
+
+ return .{
+ .view = .{ .data = request.response_data, .status_code = status_code },
+ .content = if (content.len == 0) "" else content,
+ };
+ } else unreachable;
+}
+
fn renderErrorView(
self: Server,
request: *jetzig.http.Request,
@@ -641,6 +702,13 @@ const StaticResource = struct {
};
fn matchStaticResource(self: *Server, request: *jetzig.http.Request) !?StaticResource {
+ if (comptime jetzig.build_options.debug_console) {
+ if (std.mem.eql(u8, request.path.path, "/_jetzig_debug.js")) return .{
+ .content = @embedFile("../../assets/debug.js"),
+ .mime_type = "text/javascript",
+ };
+ }
+
// TODO: Map public and static routes at launch to avoid accessing the file system when
// matching any route - currently every request causes file system traversal.
const public_resource = try self.matchPublicContent(request);
diff --git a/src/jetzig/http/middleware.zig b/src/jetzig/http/middleware.zig
index a6feace..e049a17 100644
--- a/src/jetzig/http/middleware.zig
+++ b/src/jetzig/http/middleware.zig
@@ -60,8 +60,11 @@ pub fn afterRequest(request: *jetzig.http.Request) !MiddlewareData {
}
}
+ request.state = .after_request;
+
inline for (middlewares, 0..) |middleware, index| {
if (comptime !@hasDecl(middleware, "afterRequest")) continue;
+
if (comptime @hasDecl(middleware, "init")) {
const data = middleware_data.get(index).?;
try @call(
@@ -72,7 +75,8 @@ pub fn afterRequest(request: *jetzig.http.Request) !MiddlewareData {
} else {
try @call(.always_inline, middleware.afterRequest, .{request});
}
- if (request.rendered or request.redirected) {
+
+ if (request.state != .after_request) {
request.middleware_rendered = .{ .name = @typeName(middleware), .action = "afterRequest" };
break;
}
@@ -86,11 +90,11 @@ pub fn beforeResponse(
middleware_data: *MiddlewareData,
request: *jetzig.http.Request,
) !void {
- request.response_started = true;
+ request.state = .before_response;
inline for (middlewares, 0..) |middleware, index| {
if (comptime !@hasDecl(middleware, "beforeResponse")) continue;
- if (!request.middleware_rendered_during_response) {
+ if (request.state == .before_response) {
if (comptime @hasDecl(middleware, "init")) {
const data = middleware_data.get(index).?;
try @call(
@@ -99,11 +103,19 @@ pub fn beforeResponse(
.{ @as(*middleware, @ptrCast(@alignCast(data))), request, request.response },
);
} else {
- try @call(.always_inline, middleware.beforeResponse, .{ request, request.response });
+ try @call(
+ .always_inline,
+ middleware.beforeResponse,
+ .{ request, request.response },
+ );
}
}
- if (request.middleware_rendered_during_response) {
- request.middleware_rendered = .{ .name = @typeName(middleware), .action = "beforeResponse" };
+
+ if (request.state != .before_response) {
+ request.middleware_rendered = .{
+ .name = @typeName(middleware),
+ .action = "beforeResponse",
+ };
break;
}
}
diff --git a/src/jetzig/loggers/DevelopmentLogger.zig b/src/jetzig/loggers/DevelopmentLogger.zig
index 3ae6ba9..8ff0dbf 100644
--- a/src/jetzig/loggers/DevelopmentLogger.zig
+++ b/src/jetzig/loggers/DevelopmentLogger.zig
@@ -107,7 +107,7 @@ pub fn logRequest(self: DevelopmentLogger, request: *const jetzig.http.Request)
if (request.middleware_rendered) |middleware| middleware.action else "",
if (request.middleware_rendered) |_| jetzig.colors.codes.escape ++ jetzig.colors.codes.white ++ ":" else "",
if (request.middleware_rendered) |_| jetzig.colors.codes.escape ++ jetzig.colors.codes.bright_cyan else "",
- if (request.middleware_rendered) |_| if (request.redirected) "redirect" else "render" else "",
+ if (request.middleware_rendered) |_| @tagName(request.state) else "",
if (request.middleware_rendered) |_| jetzig.colors.codes.escape ++ jetzig.colors.codes.reset else "",
if (request.middleware_rendered) |_| "]" else "",
request.path.path,
diff --git a/src/jetzig/loggers/ProductionLogger.zig b/src/jetzig/loggers/ProductionLogger.zig
index 6c7c51c..65c7ffb 100644
--- a/src/jetzig/loggers/ProductionLogger.zig
+++ b/src/jetzig/loggers/ProductionLogger.zig
@@ -86,7 +86,7 @@ pub fn logRequest(self: ProductionLogger, request: *const jetzig.http.Request) !
if (request.middleware_rendered) |_| ":" else "",
if (request.middleware_rendered) |middleware| middleware.action else "",
if (request.middleware_rendered) |_| ":" else "",
- if (request.middleware_rendered) |_| if (request.redirected) "redirect" else "render" else "",
+ if (request.middleware_rendered) |_| @tagName(request.state) else "",
if (request.middleware_rendered) |_| "]" else "",
request.path.path,
}, .stdout);
diff --git a/src/jetzig/middleware/HtmxMiddleware.zig b/src/jetzig/middleware/HtmxMiddleware.zig
index 022d010..a727f0e 100644
--- a/src/jetzig/middleware/HtmxMiddleware.zig
+++ b/src/jetzig/middleware/HtmxMiddleware.zig
@@ -20,7 +20,11 @@ pub fn afterRequest(request: *jetzig.http.Request) !void {
/// If a redirect was issued during request processing, reset any response data, set response
/// status to `200 OK` and replace the `Location` header with a `HX-Redirect` header.
pub fn beforeResponse(request: *jetzig.http.Request, response: *jetzig.http.Response) !void {
- if (response.status_code != .moved_permanently and response.status_code != .found) return;
+ switch (response.status_code) {
+ .moved_permanently, .found => {},
+ else => return,
+ }
+
if (request.headers.get("HX-Request") == null) return;
if (response.headers.get("Location")) |location| {