fediglam/src/main/api.zig

const std = @import("std");
const util = @import("util");

const db = @import("./db.zig");

pub const models = @import("./models.zig");
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 {
    inline for (std.meta.fields(@TypeOf(val))) |f| {
        // TODO
        if (f.field_type == []u8 or f.field_type == []const u8) {
            alloc.free(@field(val, f.name));
        } else if (f.field_type == Uuid) {
            // nothing
        } else {
            @compileError("unsupported field type " ++ @typeName(f.field_type));
        }
    }
}

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 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 createNote(self: *ApiServer, info: CreateInfo(models.Note)) !models.Note {
        const id = Uuid.randV4(self.prng.random());
        // TODO: check for dupes

        const note = reify(models.Note, id, info);
        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);
    }
};