- 
-
-
-
-
diff --git a/src/jetzig.zig b/src/jetzig.zig
index a2b8d77..1801eee 100644
--- a/src/jetzig.zig
+++ b/src/jetzig.zig
@@ -10,6 +10,12 @@ pub const views = @import("jetzig/views.zig");
pub const colors = @import("jetzig/colors.zig");
pub const App = @import("jetzig/App.zig");
+// Convenience for view function parameters.
+pub const Request = http.Request;
+pub const StaticRequest = http.StaticRequest;
+pub const Data = data.Data;
+pub const View = views.View;
+
pub const config = struct {
pub const max_bytes_request_body: usize = std.math.pow(usize, 2, 16);
pub const max_bytes_static_content: usize = std.math.pow(usize, 2, 16);
@@ -97,6 +103,7 @@ pub fn route(comptime routes: anytype) []views.Route {
.static = false,
.uri_path = dynamic_route.uri_path,
.template = dynamic_route.template,
+ .json_params = &.{},
};
index += 1;
}
@@ -110,6 +117,11 @@ pub fn route(comptime routes: anytype) []views.Route {
),
};
+ comptime var params_size = 0;
+ inline for (static_route.params) |_| params_size += 1;
+ comptime var static_params: [params_size][]const u8 = undefined;
+ inline for (static_route.params, 0..) |json, params_index| static_params[params_index] = json;
+
detected[index] = .{
.name = static_route.name,
.action = @field(views.Route.Action, static_route.action),
@@ -117,6 +129,7 @@ pub fn route(comptime routes: anytype) []views.Route {
.static = true,
.uri_path = static_route.uri_path,
.template = static_route.template,
+ .json_params = &static_params,
};
index += 1;
}
diff --git a/src/jetzig/App.zig b/src/jetzig/App.zig
index 061c173..419660c 100644
--- a/src/jetzig/App.zig
+++ b/src/jetzig/App.zig
@@ -24,6 +24,15 @@ pub fn start(self: Self, routes: []jetzig.views.Route, templates: []jetzig.Templ
templates,
);
+ for (routes) |*route| {
+ var mutable = @constCast(route); // FIXME
+ try mutable.initParams(self.allocator);
+ }
+ defer for (routes) |*route| {
+ var mutable = @constCast(route); // FIXME
+ mutable.deinitParams();
+ };
+
defer server.deinit();
defer self.allocator.free(self.root_path);
defer self.allocator.free(self.host);
diff --git a/src/jetzig/http.zig b/src/jetzig/http.zig
index 1519888..98c2b63 100644
--- a/src/jetzig/http.zig
+++ b/src/jetzig/http.zig
@@ -7,4 +7,6 @@ pub const Response = @import("http/Response.zig");
pub const Session = @import("http/Session.zig");
pub const Cookies = @import("http/Cookies.zig");
pub const Headers = @import("http/Headers.zig");
+pub const Query = @import("http/Query.zig");
pub const status_codes = @import("http/status_codes.zig");
+pub const middleware = @import("http/middleware.zig");
diff --git a/src/jetzig/http/Query.zig b/src/jetzig/http/Query.zig
new file mode 100644
index 0000000..5faaaff
--- /dev/null
+++ b/src/jetzig/http/Query.zig
@@ -0,0 +1,157 @@
+const std = @import("std");
+const jetzig = @import("../../jetzig.zig");
+
+const Self = @This();
+
+allocator: std.mem.Allocator,
+query_string: []const u8,
+query_items: std.ArrayList(QueryItem),
+data: *jetzig.data.Data,
+
+pub const QueryItem = struct {
+ key: []const u8,
+ value: []const u8,
+};
+
+pub fn init(allocator: std.mem.Allocator, query_string: []const u8, data: *jetzig.data.Data) Self {
+ return .{
+ .allocator = allocator,
+ .query_string = query_string,
+ .query_items = std.ArrayList(QueryItem).init(allocator),
+ .data = data,
+ };
+}
+
+pub fn deinit(self: *Self) void {
+ self.query_items.deinit();
+ self.data.deinit();
+}
+
+pub fn parse(self: *Self) !void {
+ var pairs_it = std.mem.splitScalar(u8, self.query_string, '&');
+
+ while (pairs_it.next()) |pair| {
+ var key_value_it = std.mem.splitScalar(u8, pair, '=');
+ var count: u2 = 0;
+ var key: []const u8 = undefined;
+ var value: []const u8 = undefined;
+
+ while (key_value_it.next()) |key_or_value| {
+ switch (count) {
+ 0 => key = key_or_value,
+ 1 => value = key_or_value,
+ else => return error.JetzigQueryParseError,
+ }
+ count += 1;
+ }
+ try self.query_items.append(.{ .key = key, .value = value });
+ }
+
+ var params = try self.data.object();
+ for (self.query_items.items) |item| {
+ // TODO: Allow nested array/mapping params (`foo[bar][baz]=abc`)
+ if (arrayParam(item.key)) |key| {
+ if (params.get(key)) |value| {
+ switch (value.*) {
+ .array => try value.array.append(self.data.string(item.value)),
+ else => return error.JetzigQueryParseError,
+ }
+ } else {
+ var array = try self.data.createArray();
+ try array.append(self.data.string(item.value));
+ try params.put(key, array);
+ }
+ } else if (mappingParam(item.key)) |mapping| {
+ if (params.get(mapping.key)) |value| {
+ switch (value.*) {
+ .object => try value.object.put(mapping.field, self.data.string(item.value)),
+ else => return error.JetzigQueryParseError,
+ }
+ } else {
+ var object = try self.data.createObject();
+ try object.put(mapping.field, self.data.string(item.value));
+ try params.put(mapping.key, object);
+ }
+ } else {
+ try params.put(item.key, self.data.string(item.value));
+ }
+ }
+}
+
+fn arrayParam(key: []const u8) ?[]const u8 {
+ if (key.len >= 3 and std.mem.eql(u8, key[key.len - 2 ..], "[]")) {
+ return key[0 .. key.len - 2];
+ } else {
+ return null;
+ }
+}
+
+fn mappingParam(input: []const u8) ?struct { key: []const u8, field: []const u8 } {
+ if (input.len < 4) return null; // Must be at least `a[b]`
+
+ const open = std.mem.indexOfScalar(u8, input, '[');
+ const close = std.mem.lastIndexOfScalar(u8, input, ']');
+ if (open == null or close == null) return null;
+
+ const open_index = open.?;
+ const close_index = close.?;
+ if (close_index < open_index) return null;
+
+ return .{
+ .key = input[0..open_index],
+ .field = input[open_index + 1 .. close_index],
+ };
+}
+
+test "simple query string" {
+ const allocator = std.testing.allocator;
+ const query_string = "foo=bar&baz=qux";
+ var data = jetzig.data.Data.init(allocator);
+
+ var query = init(allocator, query_string, &data);
+ defer query.deinit();
+
+ try query.parse();
+ try std.testing.expectEqualStrings((try data.get("foo")).string.value, "bar");
+ try std.testing.expectEqualStrings((try data.get("baz")).string.value, "qux");
+}
+
+test "query string with array values" {
+ const allocator = std.testing.allocator;
+ const query_string = "foo[]=bar&foo[]=baz";
+ var data = jetzig.data.Data.init(allocator);
+
+ var query = init(allocator, query_string, &data);
+ defer query.deinit();
+
+ try query.parse();
+
+ const value = try data.get("foo");
+ switch (value.*) {
+ .array => |array| {
+ try std.testing.expectEqualStrings(array.get(0).?.string.value, "bar");
+ try std.testing.expectEqualStrings(array.get(1).?.string.value, "baz");
+ },
+ else => unreachable,
+ }
+}
+
+test "query string with mapping values" {
+ const allocator = std.testing.allocator;
+ const query_string = "foo[bar]=baz&foo[qux]=quux";
+ var data = jetzig.data.Data.init(allocator);
+
+ var query = init(allocator, query_string, &data);
+ defer query.deinit();
+
+ try query.parse();
+
+ const value = try data.get("foo");
+ switch (value.*) {
+ .object => |object| {
+ try std.testing.expectEqualStrings(object.get("bar").?.string.value, "baz");
+ try std.testing.expectEqualStrings(object.get("qux").?.string.value, "quux");
+ },
+ else => unreachable,
+ }
+}
diff --git a/src/jetzig/http/Request.zig b/src/jetzig/http/Request.zig
index 76dc220..cda2934 100644
--- a/src/jetzig/http/Request.zig
+++ b/src/jetzig/http/Request.zig
@@ -18,29 +18,18 @@ server: *jetzig.http.Server,
session: *jetzig.http.Session,
status_code: jetzig.http.status_codes.StatusCode = undefined,
response_data: *jetzig.data.Data,
+query_data: *jetzig.data.Data,
+query: *jetzig.http.Query,
cookies: *jetzig.http.Cookies,
+body: []const u8,
pub fn init(
allocator: std.mem.Allocator,
server: *jetzig.http.Server,
- response: ?*std.http.Server.Response,
+ response: *std.http.Server.Response,
+ body: []const u8,
) !Self {
- if (response) |_| {} else {
- return .{
- .allocator = allocator,
- .path = "/",
- .method = .GET,
- .headers = jetzig.http.Headers.init(allocator, std.http.Headers{ .allocator = allocator }),
- .server = server,
- .segments = std.ArrayList([]const u8).init(allocator),
- .cookies = try allocator.create(jetzig.http.Cookies),
- .session = try allocator.create(jetzig.http.Session),
- .response_data = try allocator.create(jetzig.data.Data),
- };
- }
-
- const resp = response.?;
- const method = switch (resp.request.method) {
+ const method = switch (response.request.method) {
.DELETE => Method.DELETE,
.GET => Method.GET,
.PATCH => Method.PATCH,
@@ -53,14 +42,14 @@ pub fn init(
_ => return error.JetzigUnsupportedHttpMethod,
};
- var it = std.mem.splitScalar(u8, resp.request.target, '/');
+ var it = std.mem.splitScalar(u8, response.request.target, '/');
var segments = std.ArrayList([]const u8).init(allocator);
while (it.next()) |segment| try segments.append(segment);
var cookies = try allocator.create(jetzig.http.Cookies);
cookies.* = jetzig.http.Cookies.init(
allocator,
- resp.request.headers.getFirstValue("Cookie") orelse "",
+ response.request.headers.getFirstValue("Cookie") orelse "",
);
try cookies.parse();
@@ -79,16 +68,24 @@ pub fn init(
const response_data = try allocator.create(jetzig.data.Data);
response_data.* = jetzig.data.Data.init(allocator);
+ const query_data = try allocator.create(jetzig.data.Data);
+ query_data.* = jetzig.data.Data.init(allocator);
+
+ const query = try allocator.create(jetzig.http.Query);
+
return .{
.allocator = allocator,
- .path = resp.request.target,
+ .path = response.request.target,
.method = method,
- .headers = jetzig.http.Headers.init(allocator, resp.request.headers),
+ .headers = jetzig.http.Headers.init(allocator, response.request.headers),
.server = server,
.segments = segments,
.cookies = cookies,
.session = session,
.response_data = response_data,
+ .query_data = query_data,
+ .query = query,
+ .body = body,
};
}
@@ -111,6 +108,56 @@ pub fn getHeader(self: *Self, key: []const u8) ?[]const u8 {
return self.headers.getFirstValue(key);
}
+/// Provides a `Value` representing request parameters. Parameters are normalized, meaning that
+/// both the JSON request body and query parameters are accessed via the same interface.
+/// Note that query parameters are supported for JSON requests if no request body is present,
+/// otherwise the parsed JSON request body will take precedence and query parameters will be
+/// ignored.
+pub fn params(self: *Self) !*jetzig.data.Value {
+ switch (self.requestFormat()) {
+ .JSON => {
+ if (self.body.len == 0) return self.queryParams();
+
+ var data = try self.allocator.create(jetzig.data.Data);
+ data.* = jetzig.data.Data.init(self.allocator);
+ data.fromJson(self.body) catch |err| {
+ switch (err) {
+ error.UnexpectedEndOfInput => return error.JetzigBodyParseError,
+ else => return err,
+ }
+ };
+ return data.value.?;
+ },
+ .HTML, .UNKNOWN => return self.queryParams(),
+ }
+}
+
+fn queryParams(self: *Self) !*jetzig.data.Value {
+ if (!try self.parseQueryString()) {
+ self.query.data = try self.allocator.create(jetzig.data.Data);
+ self.query.data.* = jetzig.data.Data.init(self.allocator);
+ _ = try self.query.data.object();
+ }
+ return self.query.data.value.?;
+}
+
+fn parseQueryString(self: *Self) !bool {
+ const delimiter_index = std.mem.indexOfScalar(u8, self.path, '?');
+ if (delimiter_index) |index| {
+ if (self.path.len - 1 < index + 1) return false;
+
+ self.query.* = jetzig.http.Query.init(
+ self.server.allocator,
+ self.path[index + 1 ..],
+ self.query_data,
+ );
+ try self.query.parse();
+ return true;
+ }
+
+ return false;
+}
+
fn extensionFormat(self: *Self) ?jetzig.http.Request.Format {
const extension = std.fs.path.extension(self.path);
@@ -168,6 +215,9 @@ pub fn resourceName(self: *Self) []const u8 {
if (self.segments.items.len == 0) return "default";
const basename = std.fs.path.basename(self.segments.items[self.segments.items.len - 1]);
+ if (std.mem.indexOfScalar(u8, basename, '?')) |index| {
+ return basename[0..index];
+ }
const extension = std.fs.path.extension(basename);
return basename[0 .. basename.len - extension.len];
}
@@ -181,35 +231,53 @@ pub fn resourcePath(self: *Self) ![]const u8 {
return try std.mem.concat(self.allocator, u8, &[_][]const u8{ "/", path });
}
+/// For a path `/foo/bar/baz/123.json`, returns `"123"`.
pub fn resourceId(self: *Self) []const u8 {
return self.resourceName();
}
+// Determine if a given route matches the current request.
pub fn match(self: *Self, route: jetzig.views.Route) !bool {
switch (self.method) {
.GET => {
return switch (route.action) {
- .index => std.mem.eql(u8, self.pathWithoutExtension(), route.uri_path),
- .get => std.mem.eql(u8, self.pathWithoutResourceId(), route.uri_path),
+ .index => self.isMatch(.exact, route),
+ .get => self.isMatch(.resource_id, route),
else => false,
};
},
- .POST => return route.action == .post,
- .PUT => return route.action == .put,
- .PATCH => return route.action == .patch,
- .DELETE => return route.action == .delete,
+ .POST => return self.isMatch(.exact, route),
+ .PUT => return self.isMatch(.resource_id, route),
+ .PATCH => return self.isMatch(.resource_id, route),
+ .DELETE => return self.isMatch(.resource_id, route),
else => return false,
}
return false;
}
-fn pathWithoutExtension(self: *Self) []const u8 {
- const index = std.mem.indexOfScalar(u8, self.path, '.');
- if (index) |capture| return self.path[0..capture] else return self.path;
+fn isMatch(self: *Self, match_type: enum { exact, resource_id }, route: jetzig.views.Route) bool {
+ const path = switch (match_type) {
+ .exact => self.pathWithoutExtension(),
+ .resource_id => self.pathWithoutExtensionAndResourceId(),
+ };
+
+ return (std.mem.eql(u8, path, route.uri_path));
}
-fn pathWithoutResourceId(self: *Self) []const u8 {
+// TODO: Be a bit more deterministic in identifying extension, e.g. deal with `.` characters
+// elsewhere in the path (e.g. in query string).
+fn pathWithoutExtension(self: *Self) []const u8 {
+ const extension_index = std.mem.lastIndexOfScalar(u8, self.path, '.');
+ if (extension_index) |capture| return self.path[0..capture];
+
+ const query_index = std.mem.indexOfScalar(u8, self.path, '?');
+ if (query_index) |capture| return self.path[0..capture];
+
+ return self.path;
+}
+
+fn pathWithoutExtensionAndResourceId(self: *Self) []const u8 {
const path = self.pathWithoutExtension();
const index = std.mem.lastIndexOfScalar(u8, self.path, '/');
if (index) |capture| {
diff --git a/src/jetzig/http/Server.zig b/src/jetzig/http/Server.zig
index 5a2ae5c..670f7a5 100644
--- a/src/jetzig/http/Server.zig
+++ b/src/jetzig/http/Server.zig
@@ -3,8 +3,11 @@ const std = @import("std");
const jetzig = @import("../../jetzig.zig");
const root_file = @import("root");
-const jetzig_server_options = if (@hasDecl(root_file, "jetzig_options")) root_file.jetzig_options else struct {};
-const middlewares: []const type = if (@hasDecl(jetzig_server_options, "middlewares")) jetzig_server_options.middlewares else &.{};
+
+pub const jetzig_server_options = if (@hasDecl(root_file, "jetzig_options"))
+ root_file.jetzig_options
+else
+ struct {};
pub const ServerOptions = struct {
cache: jetzig.caches.Cache,
@@ -94,38 +97,15 @@ fn processNextRequest(self: *Self, response: *std.http.Server.Response) !void {
var arena = std.heap.ArenaAllocator.init(self.allocator);
defer arena.deinit();
- var request = try jetzig.http.Request.init(arena.allocator(), self, response);
+ var request = try jetzig.http.Request.init(arena.allocator(), self, response, body);
defer request.deinit();
- var middleware_data = std.BoundedArray(*anyopaque, middlewares.len).init(0) catch unreachable;
- inline for (middlewares, 0..) |middleware, index| {
- if (comptime !@hasDecl(middleware, "init")) continue;
- const data = try @call(.always_inline, middleware.init, .{&request});
- middleware_data.insert(index, data) catch unreachable; // We cannot overflow here because we know the length of the array
- }
-
- inline for (middlewares, 0..) |middleware, index| {
- if (comptime !@hasDecl(middleware, "beforeRequest")) continue;
- if (comptime @hasDecl(middleware, "init")) {
- const data = middleware_data.get(index);
- try @call(.always_inline, middleware.beforeRequest, .{ @as(*middleware, @ptrCast(@alignCast(data))), &request });
- } else {
- try @call(.always_inline, middleware.beforeRequest, .{&request});
- }
- }
+ var middleware_data = try jetzig.http.middleware.beforeMiddleware(&request);
var result = try self.pageContent(&request);
defer result.deinit();
- 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(.always_inline, middleware.afterRequest, .{ @as(*middleware, @ptrCast(@alignCast(data))), &request, &result });
- } else {
- try @call(.always_inline, middleware.afterRequest, .{ &request, &result });
- }
- }
+ try jetzig.http.middleware.afterMiddleware(&middleware_data, &request, &result);
response.transfer_encoding = .{ .content_length = result.value.content.len };
var cookie_it = request.cookies.headerIterator();
@@ -133,28 +113,22 @@ fn processNextRequest(self: *Self, response: *std.http.Server.Response) !void {
// FIXME: Skip setting cookies that are already present ?
try response.headers.append("Set-Cookie", header);
}
+
try response.headers.append("Content-Type", result.value.content_type);
+
response.status = switch (result.value.status_code) {
inline else => |status_code| @field(std.http.Status, @tagName(status_code)),
};
try response.send();
try response.writeAll(result.value.content);
-
try response.finish();
const log_message = try self.requestLogMessage(&request, result);
defer self.allocator.free(log_message);
self.logger.debug("{s}", .{log_message});
- inline for (middlewares, 0..) |middleware, index| {
- if (comptime @hasDecl(middleware, "init")) {
- if (comptime @hasDecl(middleware, "deinit")) {
- const data = middleware_data.get(index);
- @call(.always_inline, middleware.deinit, .{ @as(*middleware, @ptrCast(@alignCast(data))), &request });
- }
- }
- }
+ jetzig.http.middleware.deinit(&middleware_data, &request);
}
fn pageContent(self: *Self, request: *jetzig.http.Request) !jetzig.caches.Result {
@@ -171,7 +145,7 @@ fn pageContent(self: *Self, request: *jetzig.http.Request) !jetzig.caches.Result
fn renderResponse(self: *Self, request: *jetzig.http.Request) !jetzig.http.Response {
const static = self.matchStaticResource(request) catch |err| {
if (isUnhandledError(err)) return err;
- const rendered = try self.internalServerError(request, err);
+ const rendered = try self.renderInternalServerError(request, err);
return .{
.allocator = self.allocator,
.status_code = .internal_server_error,
@@ -182,7 +156,7 @@ fn renderResponse(self: *Self, request: *jetzig.http.Request) !jetzig.http.Respo
if (static) |resource| return try self.renderStatic(request, resource);
- const route = try self.matchRoute(request);
+ const route = try self.matchRoute(request, false);
switch (request.requestFormat()) {
.HTML => return self.renderHTML(request, route),
@@ -273,13 +247,21 @@ fn renderView(
const view = route.render(route, request) catch |err| {
self.logger.debug("Encountered error: {s}", .{@errorName(err)});
if (isUnhandledError(err)) return err;
- return try self.internalServerError(request, err);
+ if (isBadRequest(err)) return try self.renderBadRequest(request);
+ return try self.renderInternalServerError(request, err);
};
const content = if (template) |capture| try capture.render(view.data) else "";
return .{ .view = view, .content = content };
}
+fn isBadRequest(err: anyerror) bool {
+ return switch (err) {
+ error.JetzigBodyParseError, error.JetzigQueryParseError => true,
+ else => false,
+ };
+}
+
fn isUnhandledError(err: anyerror) bool {
return switch (err) {
error.OutOfMemory => true,
@@ -287,7 +269,7 @@ fn isUnhandledError(err: anyerror) bool {
};
}
-fn internalServerError(self: *Self, request: *jetzig.http.Request, err: anyerror) !RenderedView {
+fn renderInternalServerError(self: *Self, request: *jetzig.http.Request, err: anyerror) !RenderedView {
request.response_data.reset();
var object = try request.response_data.object();
@@ -301,6 +283,20 @@ fn internalServerError(self: *Self, request: *jetzig.http.Request, err: anyerror
.content = "Internal Server Error\n",
};
}
+
+fn renderBadRequest(self: *Self, request: *jetzig.http.Request) !RenderedView {
+ _ = self;
+ request.response_data.reset();
+
+ var object = try request.response_data.object();
+ try object.put("error", request.response_data.string("Bad Request"));
+
+ return .{
+ .view = jetzig.views.View{ .data = request.response_data, .status_code = .bad_request },
+ .content = "Bad Request\n",
+ };
+}
+
fn logStackTrace(
self: *Self,
stack: *std.builtin.StackTrace,
@@ -341,18 +337,31 @@ fn duration(self: *Self) i64 {
return @intCast(std.time.nanoTimestamp() - self.start_time);
}
-fn matchRoute(self: *Self, request: *jetzig.http.Request) !?jetzig.views.Route {
+fn matchRoute(self: *Self, request: *jetzig.http.Request, static: bool) !?jetzig.views.Route {
for (self.routes) |route| {
- if (route.action == .index and try request.match(route)) return route;
+ // .index routes always take precedence.
+ if (route.static == static and route.action == .index and try request.match(route)) return route;
}
for (self.routes) |route| {
- if (try request.match(route)) return route;
+ if (route.static == static and try request.match(route)) return route;
}
return null;
}
+fn matchStaticParams(self: *Self, request: *jetzig.http.Request, route: jetzig.views.Route) !?usize {
+ _ = self;
+ const params = try request.params();
+
+ for (route.params.items, 0..) |static_params, index| {
+ if (try static_params.getValue("params")) |expected_params| {
+ if (expected_params.eql(params)) return index;
+ }
+ }
+ return null;
+}
+
const StaticResource = struct { content: []const u8, mime_type: []const u8 = "application/octet-stream" };
fn matchStaticResource(self: *Self, request: *jetzig.http.Request) !?StaticResource {
@@ -383,8 +392,10 @@ fn matchPublicContent(self: *Self, request: *jetzig.http.Request) !?[]const u8 {
else => return err,
}
};
+ defer iterable_dir.close();
var walker = try iterable_dir.walk(request.allocator);
+ defer walker.deinit();
while (try walker.next()) |file| {
if (file.kind != .file) continue;
@@ -410,19 +421,14 @@ fn matchStaticContent(self: *Self, request: *jetzig.http.Request) !?[]const u8 {
};
defer static_dir.close();
- // TODO: Use a hashmap to avoid O(n)
- for (self.routes) |route| {
- if (route.static and try request.match(route)) {
- const extension = switch (request.requestFormat()) {
- .HTML, .UNKNOWN => ".html",
- .JSON => ".json",
- };
-
- const path = try std.mem.concat(request.allocator, u8, &[_][]const u8{ route.name, extension });
+ const matched_route = try self.matchRoute(request, true);
+ if (matched_route) |route| {
+ const static_path = try self.staticPath(request, route);
+ if (static_path) |capture| {
return static_dir.readFileAlloc(
request.allocator,
- path,
+ capture,
jetzig.config.max_bytes_static_content,
) catch |err| {
switch (err) {
@@ -430,8 +436,55 @@ fn matchStaticContent(self: *Self, request: *jetzig.http.Request) !?[]const u8 {
else => return err,
}
};
- }
+ } else return null;
}
return null;
}
+
+fn staticPath(self: *Self, request: *jetzig.http.Request, route: jetzig.views.Route) !?[]const u8 {
+ _ = self;
+ const params = try request.params();
+ const extension = switch (request.requestFormat()) {
+ .HTML, .UNKNOWN => ".html",
+ .JSON => ".json",
+ };
+
+ for (route.params.items, 0..) |static_params, index| {
+ if (try static_params.getValue("params")) |expected_params| {
+ switch (route.action) {
+ .index, .post => {},
+ inline else => {
+ if (try static_params.getValue("id")) |id| {
+ switch (id.*) {
+ .string => |capture| {
+ if (!std.mem.eql(u8, capture.value, request.resourceId())) continue;
+ },
+ // Should be unreachable but we want to avoid a runtime panic.
+ inline else => continue,
+ }
+ }
+ },
+ }
+ if (!expected_params.eql(params)) continue;
+
+ const index_fmt = try std.fmt.allocPrint(request.allocator, "{}", .{index});
+ defer request.allocator.free(index_fmt);
+
+ return try std.mem.concat(
+ request.allocator,
+ u8,
+ &[_][]const u8{ route.name, "_", index_fmt, extension },
+ );
+ }
+ }
+
+ switch (route.action) {
+ .index, .post => return try std.mem.concat(
+ request.allocator,
+ u8,
+ &[_][]const u8{ route.name, "_", extension },
+ ),
+ else => return null,
+ }
+}
diff --git a/src/jetzig/http/Session.zig b/src/jetzig/http/Session.zig
index 777e1ed..9dd55e3 100644
--- a/src/jetzig/http/Session.zig
+++ b/src/jetzig/http/Session.zig
@@ -65,21 +65,21 @@ pub fn deinit(self: *Self) void {
if (self.cookie) |*ptr| self.allocator.free(ptr.*.value);
}
-pub fn get(self: *Self, key: []const u8) !?jetzig.data.Value {
+pub fn get(self: *Self, key: []const u8) !?*jetzig.data.Value {
if (self.state != .parsed) return error.UnparsedSessionCookie;
- return switch (self.data.value.?) {
+ return switch (self.data.value.?.*) {
.object => self.data.value.?.object.get(key),
else => unreachable,
};
}
-pub fn put(self: *Self, key: []const u8, value: jetzig.data.Value) !void {
+pub fn put(self: *Self, key: []const u8, value: *jetzig.data.Value) !void {
if (self.state != .parsed) return error.UnparsedSessionCookie;
- switch (self.data.value.?) {
+ switch (self.data.value.?.*) {
.object => |*object| {
- try object.put(key, value);
+ try object.*.put(key, value);
},
else => unreachable,
}
diff --git a/src/jetzig/http/StaticRequest.zig b/src/jetzig/http/StaticRequest.zig
index 674283b..261d73c 100644
--- a/src/jetzig/http/StaticRequest.zig
+++ b/src/jetzig/http/StaticRequest.zig
@@ -4,11 +4,13 @@ const jetzig = @import("../../jetzig.zig");
response_data: *jetzig.data.Data,
allocator: std.mem.Allocator,
+json: []const u8,
-pub fn init(allocator: std.mem.Allocator) !Self {
+pub fn init(allocator: std.mem.Allocator, json: []const u8) !Self {
return .{
.allocator = allocator,
.response_data = try allocator.create(jetzig.data.Data),
+ .json = json,
};
}
@@ -20,7 +22,23 @@ pub fn render(self: *Self, status_code: jetzig.http.status_codes.StatusCode) jet
return .{ .data = self.response_data, .status_code = status_code };
}
-pub fn resourceId(self: *Self) []const u8 {
- _ = self;
- return "TODO";
+pub fn resourceId(self: *Self) ![]const u8 {
+ var data = try self.allocator.create(jetzig.data.Data);
+ data.* = jetzig.data.Data.init(self.allocator);
+ defer self.allocator.destroy(data);
+ defer data.deinit();
+
+ try data.fromJson(self.json);
+ // Routes generator rejects missing `.id` option so this should always be present.
+ // Note that static requests are never rendered at runtime so we can be unsafe here and risk
+ // failing a build (which would not be coherent if we allowed it to complete).
+ return data.value.?.get("id").?.string.value;
+}
+
+/// Returns the static params defined by `pub const static_params` in the relevant view.
+pub fn params(self: *Self) !*jetzig.data.Value {
+ var data = try self.allocator.create(jetzig.data.Data);
+ data.* = jetzig.data.Data.init(self.allocator);
+ try data.fromJson(self.json);
+ return data.value.?.get("params") orelse data.object();
}
diff --git a/src/jetzig/http/middleware.zig b/src/jetzig/http/middleware.zig
new file mode 100644
index 0000000..f0f817f
--- /dev/null
+++ b/src/jetzig/http/middleware.zig
@@ -0,0 +1,73 @@
+const std = @import("std");
+const jetzig = @import("../../jetzig.zig");
+
+const server_options = jetzig.http.Server.jetzig_server_options;
+
+const middlewares: []const type = if (@hasDecl(server_options, "middleware"))
+ server_options.middleware
+else
+ &.{};
+
+const MiddlewareData = std.BoundedArray(*anyopaque, middlewares.len);
+
+pub fn beforeMiddleware(request: *jetzig.http.Request) !MiddlewareData {
+ var middleware_data = MiddlewareData.init(0) catch unreachable;
+
+ inline for (middlewares, 0..) |middleware, index| {
+ if (comptime !@hasDecl(middleware, "init")) continue;
+ const data = try @call(.always_inline, middleware.init, .{request});
+ // We cannot overflow here because we know the length of the array
+ middleware_data.insert(index, data) catch unreachable;
+ }
+
+ inline for (middlewares, 0..) |middleware, index| {
+ if (comptime !@hasDecl(middleware, "beforeRequest")) continue;
+ if (comptime @hasDecl(middleware, "init")) {
+ const data = middleware_data.get(index);
+ try @call(
+ .always_inline,
+ middleware.beforeRequest,
+ .{ @as(*middleware, @ptrCast(@alignCast(data))), request },
+ );
+ } else {
+ try @call(.always_inline, middleware.beforeRequest, .{request});
+ }
+ }
+
+ return middleware_data;
+}
+
+pub fn afterMiddleware(
+ middleware_data: *MiddlewareData,
+ request: *jetzig.http.Request,
+ result: *jetzig.caches.Result,
+) !void {
+ 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(
+ .always_inline,
+ middleware.afterRequest,
+ .{ @as(*middleware, @ptrCast(@alignCast(data))), request, result },
+ );
+ } else {
+ try @call(.always_inline, middleware.afterRequest, .{ request, result });
+ }
+ }
+}
+
+pub fn deinit(middleware_data: *MiddlewareData, request: *jetzig.http.Request) void {
+ inline for (middlewares, 0..) |middleware, index| {
+ if (comptime @hasDecl(middleware, "init")) {
+ if (comptime @hasDecl(middleware, "deinit")) {
+ const data = middleware_data.get(index);
+ @call(
+ .always_inline,
+ middleware.deinit,
+ .{ @as(*middleware, @ptrCast(@alignCast(data))), request },
+ );
+ }
+ }
+ }
+}
diff --git a/src/jetzig/views/Route.zig b/src/jetzig/views/Route.zig
index 91f7b3c..75061e5 100644
--- a/src/jetzig/views/Route.zig
+++ b/src/jetzig/views/Route.zig
@@ -45,6 +45,25 @@ static: bool,
render: RenderFn = renderFn,
renderStatic: RenderStaticFn = renderStaticFn,
template: []const u8,
+json_params: [][]const u8,
+params: std.ArrayList(*jetzig.data.Data) = undefined,
+
+/// Initializes a route's static params on server launch. Converts static params (JSON strings)
+/// to `jetzig.data.Data` values. Memory is owned by caller (`App.start()`).
+pub fn initParams(self: *Self, allocator: std.mem.Allocator) !void {
+ self.params = std.ArrayList(*jetzig.data.Data).init(allocator);
+ for (self.json_params) |params| {
+ var data = try allocator.create(jetzig.data.Data);
+ data.* = jetzig.data.Data.init(allocator);
+ try self.params.append(data);
+ try data.fromJson(params);
+ }
+}
+
+pub fn deinitParams(self: *const Self) void {
+ for (self.params.items) |data| data.deinit();
+ self.params.deinit();
+}
fn renderFn(self: Self, request: *jetzig.http.Request) anyerror!jetzig.views.View {
switch (self.view.?) {
@@ -70,10 +89,10 @@ fn renderStaticFn(self: Self, request: *jetzig.http.StaticRequest) anyerror!jetz
switch (self.view.?.static) {
.index => |view| return try view(request, request.response_data),
- .get => |view| return try view(request.resourceId(), request, request.response_data),
+ .get => |view| return try view(try request.resourceId(), request, request.response_data),
.post => |view| return try view(request, request.response_data),
- .patch => |view| return try view(request.resourceId(), request, request.response_data),
- .put => |view| return try view(request.resourceId(), request, request.response_data),
- .delete => |view| return try view(request.resourceId(), request, request.response_data),
+ .patch => |view| return try view(try request.resourceId(), request, request.response_data),
+ .put => |view| return try view(try request.resourceId(), request, request.response_data),
+ .delete => |view| return try view(try request.resourceId(), request, request.response_data),
}
}
diff --git a/src/main.zig b/src/main.zig
deleted file mode 100644
index 228e1dd..0000000
--- a/src/main.zig
+++ /dev/null
@@ -1,59 +0,0 @@
-const std = @import("std");
-
-pub const jetzig = @import("jetzig.zig");
-pub const templates = @import("app/views/zmpl.manifest.zig").templates;
-pub const routes = @import("routes").routes;
-
-pub const jetzig_options = struct {
- pub const middleware: []const type = &.{ TestMiddleware, IncompleteMiddleware, IncompleteMiddleware2 };
-};
-
-pub fn main() !void {
- var gpa = std.heap.GeneralPurposeAllocator(.{}){};
- defer std.debug.assert(gpa.deinit() == .ok);
- const allocator = gpa.allocator();
-
- const app = try jetzig.init(allocator);
- defer app.deinit();
-
- try app.start(
- comptime jetzig.route(routes),
- comptime jetzig.loadTemplates(templates),
- );
-}
-
-const TestMiddleware = struct {
- my_data: u8,
- pub fn init(request: *jetzig.http.Request) !*TestMiddleware {
- var mw = try request.allocator.create(TestMiddleware);
- mw.my_data = 42;
- return mw;
- }
-
- pub fn beforeRequest(middleware: *TestMiddleware, request: *jetzig.http.Request) !void {
- request.server.logger.debug("Before request, custom data: {d}", .{middleware.my_data});
- middleware.my_data = 43;
- }
-
- pub fn afterRequest(middleware: *TestMiddleware, request: *jetzig.http.Request, result: *jetzig.caches.Result) !void {
- request.server.logger.debug("After request, custom data: {d}", .{middleware.my_data});
- request.server.logger.debug("{s}", .{result.value.content_type});
- }
-
- pub fn deinit(middleware: *TestMiddleware, request: *jetzig.http.Request) void {
- request.allocator.destroy(middleware);
- }
-};
-
-const IncompleteMiddleware = struct {
- pub fn beforeRequest(request: *jetzig.http.Request) !void {
- request.server.logger.debug("Before request", .{});
- }
-};
-
-const IncompleteMiddleware2 = struct {
- pub fn afterRequest(request: *jetzig.http.Request, result: *jetzig.caches.Result) !void {
- request.server.logger.debug("After request", .{});
- _ = result;
- }
-};
diff --git a/src/tests.zig b/src/tests.zig
index 8b51ac2..6bf0a52 100644
--- a/src/tests.zig
+++ b/src/tests.zig
@@ -1,4 +1,5 @@
test {
_ = @import("jetzig.zig");
+ _ = @import("jetzig/http/Query.zig");
@import("std").testing.refAllDeclsRecursive(@This());
}
-
-
-
-
- {.message}
-
-
-
-
- Take a look at the src/app/ directory to see how this application works.
- Visit jetzig.dev to get started.
-