149 lines
4.4 KiB
Zig
149 lines
4.4 KiB
Zig
const std = @import("std");
|
|
const util = @import("util");
|
|
|
|
const db = @import("./db.zig");
|
|
|
|
pub const models = @import("./models.zig");
|
|
pub const DateTime = util.DateTime;
|
|
pub const Uuid = util.Uuid;
|
|
|
|
// Frees an api struct and its fields allocated from alloc
|
|
pub fn free(alloc: std.mem.Allocator, val: anytype) void {
|
|
switch (@typeInfo(@TypeOf(val))) {
|
|
.Pointer => |ptr_info| switch (ptr_info.size) {
|
|
.One => {
|
|
free(alloc, val.*);
|
|
alloc.destroy(val);
|
|
},
|
|
.Slice => {
|
|
for (val) |elem| free(alloc, elem);
|
|
alloc.free(val);
|
|
},
|
|
else => unreachable,
|
|
},
|
|
.Struct => inline for (std.meta.fields(@TypeOf(val))) |f| free(alloc, @field(val, f.name)),
|
|
.Array => for (val) |elem| free(alloc, elem),
|
|
.Optional => if (val) |opt| free(alloc, opt),
|
|
.Bool, .Int, .Float, .Enum => {},
|
|
else => unreachable,
|
|
}
|
|
}
|
|
|
|
pub fn CreateInfo(comptime T: type) type {
|
|
const t_fields = std.meta.fields(T);
|
|
var fields: [t_fields.len - 1]std.builtin.Type.StructField = undefined;
|
|
var count = 0;
|
|
|
|
inline for (t_fields) |f| {
|
|
if (std.mem.eql(u8, f.name, "id")) continue;
|
|
|
|
fields[count] = f;
|
|
count += 1;
|
|
}
|
|
|
|
return @Type(.{ .Struct = .{
|
|
.layout = .Auto,
|
|
.fields = &fields,
|
|
.decls = &[0]std.builtin.Type.Declaration{},
|
|
.is_tuple = false,
|
|
} });
|
|
}
|
|
|
|
fn reify(comptime T: type, id: Uuid, val: CreateInfo(T)) T {
|
|
var result: T = undefined;
|
|
result.id = id;
|
|
inline for (std.meta.fields(CreateInfo(T))) |f| {
|
|
@field(result, f.name) = @field(val, f.name);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
pub const ApiContext = struct {
|
|
user_context: struct {
|
|
user: models.User,
|
|
},
|
|
|
|
alloc: std.mem.Allocator,
|
|
};
|
|
|
|
pub const NoteCreate = struct {
|
|
content: []const u8,
|
|
};
|
|
|
|
pub const ApiServer = struct {
|
|
prng: std.rand.DefaultPrng,
|
|
db: db.Database,
|
|
|
|
pub fn init(_: std.mem.Allocator) !ApiServer {
|
|
return ApiServer{
|
|
.prng = std.rand.DefaultPrng.init(@bitCast(u64, std.time.milliTimestamp())),
|
|
.db = try db.Database.init(),
|
|
};
|
|
}
|
|
|
|
pub fn makeApiContext(self: *ApiServer, token: []const u8, alloc: std.mem.Allocator) !ApiContext {
|
|
if (token.len == 0) return error.InvalidToken;
|
|
|
|
const user_handle = token;
|
|
|
|
const user = (try self.db.getBy(models.User, .handle, user_handle, alloc)) orelse return error.InvalidToken;
|
|
|
|
return ApiContext{
|
|
.user_context = .{
|
|
.user = user,
|
|
},
|
|
|
|
.alloc = alloc,
|
|
};
|
|
}
|
|
|
|
pub fn createNoteUser(self: *ApiServer, info: NoteCreate, ctx: ApiContext) !models.Note {
|
|
const id = Uuid.randV4(self.prng.random());
|
|
// TODO: check for dupes
|
|
std.debug.print("user {s} making a note\n", .{ctx.user_context.user.handle});
|
|
|
|
const note = models.Note{
|
|
.id = id,
|
|
.author_id = ctx.user_context.user.id,
|
|
.content = info.content,
|
|
|
|
.created_at = DateTime.now(),
|
|
};
|
|
try self.db.insert(models.Note, note);
|
|
|
|
return note;
|
|
}
|
|
|
|
pub fn createUser(self: *ApiServer, info: CreateInfo(models.User)) !models.User {
|
|
const id = Uuid.randV4(self.prng.random());
|
|
|
|
if (try self.db.existsWhereEq(models.User, .handle, info.handle)) {
|
|
return error.HandleNotAvailable;
|
|
}
|
|
|
|
const user = reify(models.User, id, info);
|
|
try self.db.insert(models.User, user);
|
|
|
|
return user;
|
|
}
|
|
|
|
pub fn getNote(self: *ApiServer, id: Uuid, alloc: std.mem.Allocator) !?models.Note {
|
|
return self.db.getBy(models.Note, .id, id, alloc);
|
|
}
|
|
|
|
pub fn getUser(self: *ApiServer, id: Uuid, alloc: std.mem.Allocator) !?models.User {
|
|
return self.db.getBy(models.User, .id, id, alloc);
|
|
}
|
|
|
|
pub fn getUserByHandle(self: *ApiServer, handle: []const u8, alloc: std.mem.Allocator) !?models.User {
|
|
return self.db.getBy(models.User, .handle, handle, alloc);
|
|
}
|
|
|
|
pub fn react(self: *ApiServer, note_id: Uuid, ctx: ApiContext) !void {
|
|
try self.db.insert(models.Reaction, .{ .note_id = note_id, .reactor_id = ctx.user_context.user.id });
|
|
}
|
|
|
|
pub fn listReacts(self: *ApiServer, note_id: Uuid, ctx: ApiContext) ![]models.Reaction {
|
|
return try self.db.getWhereEq(models.Reaction, .note_id, note_id, ctx.alloc);
|
|
}
|
|
};
|