From 7b1e4030b017402a0a06adaa51e579af7f00883d Mon Sep 17 00:00:00 2001 From: jaina heartles Date: Wed, 20 Jul 2022 20:39:43 -0700 Subject: [PATCH] Refactoring --- src/main/controllers.zig | 66 +++++++++++++++++++++------------------- 1 file changed, 35 insertions(+), 31 deletions(-) diff --git a/src/main/controllers.zig b/src/main/controllers.zig index f77063e..40fdd76 100644 --- a/src/main/controllers.zig +++ b/src/main/controllers.zig @@ -20,8 +20,8 @@ const utils = struct { }; // Responds to a request with a json value - fn respondJson(ctx: *http.server.Context, status: http.Status, value: anytype, alloc: std.mem.Allocator) !void { - var headers = http.Headers.init(alloc); + fn respondJson(ctx: *http.server.Context, status: http.Status, value: anytype) !void { + var headers = http.Headers.init(ctx.alloc); defer headers.deinit(); // Don't need to free this k/v pair because they aren't dynamically allocated @@ -36,10 +36,14 @@ const utils = struct { try stream.finish(); } - fn parseRequestBody(comptime T: type, ctx: *http.server.Context, alloc: std.mem.Allocator) !T { + fn respondError(ctx: *http.server.Context, status: http.Status, err: []const u8) !void { + return respondJson(ctx, status, .{ .@"error" = err }); + } + + fn parseRequestBody(comptime T: type, ctx: *http.server.Context) !T { const body = ctx.request.body orelse return error.BodyRequired; var tokens = std.json.TokenStream.init(body); - const parsed = try std.json.parse(T, &tokens, .{ .allocator = alloc }); + const parsed = try std.json.parse(T, &tokens, .{ .allocator = ctx.alloc }); return parsed; } @@ -53,8 +57,8 @@ const utils = struct { const token = header[("bearer ").len..]; - return try srv.api.makeApiContext(token, srv.alloc); - // TODO: defer api.free(srv.alloc, user_ctx); + return try srv.api.makeApiContext(token, ctx.alloc); + // TODO: defer api.free(ctx.alloc, user_ctx); } }; @@ -64,42 +68,42 @@ const RouteArgs = http.RouteArgs; pub fn createNote(srv: *RequestServer, ctx: *http.server.Context, _: RouteArgs) !void { const user_context = try utils.getApiContext(srv, ctx); // TODO: defer free ApiContext - const info = try utils.parseRequestBody(api.NoteCreate, ctx, srv.alloc); - defer utils.freeRequestBody(info, srv.alloc); + const info = try utils.parseRequestBody(api.NoteCreate, ctx); + defer utils.freeRequestBody(info, ctx.alloc); const note = try srv.api.createNoteUser(info, user_context); - try utils.respondJson(ctx, .created, note, srv.alloc); + try utils.respondJson(ctx, .created, note); } pub fn createUser(srv: *RequestServer, ctx: *http.server.Context, _: RouteArgs) !void { - const info = try utils.parseRequestBody(api.CreateInfo(models.User), ctx, srv.alloc); - defer utils.freeRequestBody(info, srv.alloc); + const info = try utils.parseRequestBody(api.CreateInfo(models.User), ctx); + defer utils.freeRequestBody(info, ctx.alloc); const user = srv.api.createUser(info) catch |err| switch (err) { - error.HandleNotAvailable => return try utils.respondJson(ctx, .bad_request, .{ .@"error" = "handle not available" }, srv.alloc), + error.HandleNotAvailable => return try utils.respondError(ctx, .bad_request, "handle not available"), else => return err, }; - try utils.respondJson(ctx, .created, user, srv.alloc); + try utils.respondJson(ctx, .created, user); } pub fn getNote(srv: *RequestServer, ctx: *http.server.Context, args: RouteArgs) !void { const id_str = args.get("id") orelse return error.NotFound; - const id = Uuid.parse(id_str) catch return utils.respondJson(ctx, .bad_request, .{ .@"error" = "Invalid UUID" }, srv.alloc); - const note = (try srv.api.getNote(id, srv.alloc)) orelse return utils.respondJson(ctx, .not_found, .{ .@"error" = "Note not found" }, srv.alloc); - defer api.free(srv.alloc, note); + const id = Uuid.parse(id_str) catch return utils.respondError(ctx, .bad_request, "Invalid UUID"); + const note = (try srv.api.getNote(id, ctx.alloc)) orelse return utils.respondError(ctx, .not_found, "Note not found"); + defer api.free(ctx.alloc, note); - try utils.respondJson(ctx, .ok, note, srv.alloc); + try utils.respondJson(ctx, .ok, note); } pub fn getUser(srv: *RequestServer, ctx: *http.server.Context, args: RouteArgs) !void { const id_str = args.get("id") orelse return error.NotFound; - const id = Uuid.parse(id_str) catch return utils.respondJson(ctx, .bad_request, .{ .@"error" = "Invalid UUID" }, srv.alloc); - const user = (try srv.api.getUser(id, srv.alloc)) orelse return utils.respondJson(ctx, .not_found, .{ .@"error" = "Note not found" }, srv.alloc); - defer api.free(srv.alloc, user); + const id = Uuid.parse(id_str) catch return utils.respondError(ctx, .bad_request, "Invalid UUID"); + const user = (try srv.api.getUser(id, ctx.alloc)) orelse return utils.respondError(ctx, .not_found, "Note not found"); + defer api.free(ctx.alloc, user); - try utils.respondJson(ctx, .ok, user, srv.alloc); + try utils.respondJson(ctx, .ok, user); } pub fn react(srv: *RequestServer, ctx: *http.server.Context, args: RouteArgs) !void { @@ -107,10 +111,10 @@ pub fn react(srv: *RequestServer, ctx: *http.server.Context, args: RouteArgs) !v // TODO: defer free ApiContext const note_id = args.get("id") orelse return error.NotFound; - const id = Uuid.parse(note_id) catch return utils.respondJson(ctx, .bad_request, .{ .@"error" = "Invalid UUID" }, srv.alloc); + const id = Uuid.parse(note_id) catch return utils.respondError(ctx, .bad_request, "Invalid UUID"); try srv.api.react(id, user_context); - try utils.respondJson(ctx, .created, .{}, srv.alloc); + try utils.respondJson(ctx, .created, .{}); } pub fn listReacts(srv: *RequestServer, ctx: *http.server.Context, args: RouteArgs) !void { @@ -118,23 +122,23 @@ pub fn listReacts(srv: *RequestServer, ctx: *http.server.Context, args: RouteArg // TODO: defer free ApiContext const note_id = args.get("id") orelse return error.NotFound; - const id = Uuid.parse(note_id) catch return utils.respondJson(ctx, .bad_request, .{ .@"error" = "Invalid UUID" }, srv.alloc); + const id = Uuid.parse(note_id) catch return utils.respondError(ctx, .bad_request, "Invalid UUID"); const reacts = try srv.api.listReacts(id, user_context); - try utils.respondJson(ctx, .ok, .{ .items = reacts }, srv.alloc); + try utils.respondJson(ctx, .ok, .{ .items = reacts }); } pub fn authenticate(srv: *RequestServer, ctx: *http.server.Context, _: RouteArgs) !void { const user_ctx = try utils.getApiContext(srv, ctx); - // TODO: defer api.free(srv.alloc, user_ctx); + // TODO: defer api.free(ctx.alloc, user_ctx); - try utils.respondJson(ctx, .ok, user_ctx.user_context, srv.alloc); + try utils.respondJson(ctx, .ok, user_ctx.user_context); } -pub fn healthcheck(srv: *RequestServer, ctx: *http.server.Context, _: RouteArgs) !void { - try utils.respondJson(ctx, .ok, .{ .status = "ok" }, srv.alloc); +pub fn healthcheck(_: *RequestServer, ctx: *http.server.Context, _: RouteArgs) !void { + try utils.respondJson(ctx, .ok, .{ .status = "ok" }); } -pub fn notFound(srv: *RequestServer, ctx: *http.server.Context) void { - utils.respondJson(ctx, .not_found, .{ .@"error" = "Not Found" }, srv.alloc) catch unreachable; +pub fn notFound(_: *RequestServer, ctx: *http.server.Context) void { + utils.respondError(ctx, .not_found, "Not Found") catch unreachable; }