heartles/fediglam
1
1
Fork 0
Code Issues 64 Pull requests Projects Releases Packages Wiki Activity

Refactoring

Browse source
This commit is contained in:
jaina heartles 2022-07-20 20:39:43 -07:00
parent 73662d675a
commit 7b1e4030b0
1 changed files with 35 additions and 31 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

66
src/main/controllers.zig
View file

@ -20,8 +20,8 @@ const utils = struct {
}; };
// Responds to a request with a json value // Responds to a request with a json value
fn respondJson(ctx: *http.server.Context, status: http.Status, value: anytype, alloc: std.mem.Allocator) !void { fn respondJson(ctx: *http.server.Context, status: http.Status, value: anytype) !void {
var headers = http.Headers.init(alloc); var headers = http.Headers.init(ctx.alloc);
defer headers.deinit(); defer headers.deinit();
// Don't need to free this k/v pair because they aren't dynamically allocated // 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(); 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; const body = ctx.request.body orelse return error.BodyRequired;
var tokens = std.json.TokenStream.init(body); 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; return parsed;
} }
@ -53,8 +57,8 @@ const utils = struct {
const token = header[("bearer ").len..]; const token = header[("bearer ").len..];
return try srv.api.makeApiContext(token, srv.alloc); return try srv.api.makeApiContext(token, ctx.alloc);
// TODO: defer api.free(srv.alloc, user_ctx); // 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 { pub fn createNote(srv: *RequestServer, ctx: *http.server.Context, _: RouteArgs) !void {
const user_context = try utils.getApiContext(srv, ctx); const user_context = try utils.getApiContext(srv, ctx);
// TODO: defer free ApiContext // TODO: defer free ApiContext
const info = try utils.parseRequestBody(api.NoteCreate, ctx, srv.alloc); const info = try utils.parseRequestBody(api.NoteCreate, ctx);
defer utils.freeRequestBody(info, srv.alloc); defer utils.freeRequestBody(info, ctx.alloc);
const note = try srv.api.createNoteUser(info, user_context); 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 { pub fn createUser(srv: *RequestServer, ctx: *http.server.Context, _: RouteArgs) !void {
const info = try utils.parseRequestBody(api.CreateInfo(models.User), ctx, srv.alloc); const info = try utils.parseRequestBody(api.CreateInfo(models.User), ctx);
defer utils.freeRequestBody(info, srv.alloc); defer utils.freeRequestBody(info, ctx.alloc);
const user = srv.api.createUser(info) catch |err| switch (err) { 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, 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 { pub fn getNote(srv: *RequestServer, ctx: *http.server.Context, args: RouteArgs) !void {
const id_str = args.get("id") orelse return error.NotFound; 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 id = Uuid.parse(id_str) catch return utils.respondError(ctx, .bad_request, "Invalid UUID");
const note = (try srv.api.getNote(id, srv.alloc)) orelse return utils.respondJson(ctx, .not_found, .{ .@"error" = "Note not found" }, srv.alloc); const note = (try srv.api.getNote(id, ctx.alloc)) orelse return utils.respondError(ctx, .not_found, "Note not found");
defer api.free(srv.alloc, note); 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 { pub fn getUser(srv: *RequestServer, ctx: *http.server.Context, args: RouteArgs) !void {
const id_str = args.get("id") orelse return error.NotFound; 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 id = Uuid.parse(id_str) catch return utils.respondError(ctx, .bad_request, "Invalid UUID");
const user = (try srv.api.getUser(id, srv.alloc)) orelse return utils.respondJson(ctx, .not_found, .{ .@"error" = "Note not found" }, srv.alloc); const user = (try srv.api.getUser(id, ctx.alloc)) orelse return utils.respondError(ctx, .not_found, "Note not found");
defer api.free(srv.alloc, user); 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 { 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 // TODO: defer free ApiContext
const note_id = args.get("id") orelse return error.NotFound; 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 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 { 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 // TODO: defer free ApiContext
const note_id = args.get("id") orelse return error.NotFound; 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); 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 { pub fn authenticate(srv: *RequestServer, ctx: *http.server.Context, _: RouteArgs) !void {
const user_ctx = try utils.getApiContext(srv, ctx); 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 { pub fn healthcheck(_: *RequestServer, ctx: *http.server.Context, _: RouteArgs) !void {
try utils.respondJson(ctx, .ok, .{ .status = "ok" }, srv.alloc); try utils.respondJson(ctx, .ok, .{ .status = "ok" });
} }
pub fn notFound(srv: *RequestServer, ctx: *http.server.Context) void { pub fn notFound(_: *RequestServer, ctx: *http.server.Context) void {
utils.respondJson(ctx, .not_found, .{ .@"error" = "Not Found" }, srv.alloc) catch unreachable; utils.respondError(ctx, .not_found, "Not Found") catch unreachable;
} }