fediglam/src/main/api.zig

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

const db = @import("./db.zig");
const models = @import("./db/models.zig");
pub const DateTime = util.DateTime;
pub const Uuid = util.Uuid;
const Config = @import("./main.zig").Config;

const PwHash = std.crypto.pwhash.scrypt;
const pw_hash_params = PwHash.Params.interactive;
const pw_hash_encoding = .phc;
const pw_hash_buf_size = 128;

const token_len = 20;
const token_str_len = std.base64.standard.Encoder.calcSize(token_len);

const invite_code_len = 16;
const invite_code_str_len = std.base64.url_safe.Encoder.calcSize(invite_code_len);

const services = struct {
    const communities = @import("./api/communities.zig");
    const users = @import("./api/users.zig");
    const auth = @import("./api/auth.zig");
};

// 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 firstIndexOf(str: []const u8, ch: u8) ?usize {
    for (str) |c, i| {
        if (c == ch) return i;
    }

    return null;
}

pub const Scheme = models.Community.Scheme;

pub const RegistrationInfo = struct {
    username: []const u8,
    password: []const u8,
    email: ?[]const u8,
    invite_code: ?[]const u8,
};

pub const LoginResult = struct {
    user_id: Uuid,
    token: [token_str_len]u8,
    issued_at: DateTime,
};

pub const InviteOptions = struct {
    name: []const u8 = "",
    max_uses: ?i64 = null,
    lifetime: ?i64 = null, // unix seconds, TODO make a TimeSpan type
    to_community: ?[]const u8,
};

threadlocal var prng: std.rand.DefaultPrng = undefined;

pub fn initThreadPrng(seed: u64) void {
    prng = std.rand.DefaultPrng.init(seed +% std.Thread.getCurrentId());
}

pub fn getRandom() std.rand.Random {
    return prng.random();
}

// Returned slice points into buf
fn hashPassword(password: []const u8, alloc: std.mem.Allocator, buf: *[pw_hash_buf_size]u8) ![]const u8 {
    return PwHash.strHash(password, .{ .allocator = alloc, .params = pw_hash_params, .encoding = pw_hash_encoding }, buf);
}

pub const ApiSource = struct {
    db: db.Database,
    internal_alloc: std.mem.Allocator,
    config: Config,

    pub const Conn = ApiConn(db.Database);

    const root_username = "root";
    const root_password_envvar = "CLUSTER_ROOT_PASSWORD";

    pub fn init(alloc: std.mem.Allocator, cfg: Config) !ApiSource {
        var self = ApiSource{
            .db = try db.Database.init(),
            .internal_alloc = alloc,
            .config = cfg,
        };

        if ((try services.users.lookupByUsername(&self.db, root_username, null)) == null) {
            std.log.info("No cluster root user detected. Creating...", .{});

            const root_password = std.os.getenv(root_password_envvar) orelse {
                std.log.err(
                    "No root user created and no password specified. Please provide the password for the root user by the ${s} environment variable for initial startup. This only needs to be done once",
                    .{root_password_envvar},
                );
                @panic("No root password provided");
            };

            _ = try services.users.create(&self.db, root_username, root_password, null, .{}, alloc);
        }

        return self;
    }

    fn getCommunityFromHost(self: *ApiSource, host: []const u8) !?Uuid {
        if (try self.db.execRow(
            &.{Uuid},
            "SELECT id FROM community WHERE host = ?",
            .{host},
            null,
        )) |result| return result[0];

        // Test for cluster admin community
        if (util.ciutf8.eql(self.config.cluster_host, host)) {
            return null;
        }

        return error.NoCommunity;
    }

    pub fn connectUnauthorized(self: *ApiSource, host: []const u8, alloc: std.mem.Allocator) !Conn {
        const community_id = try self.getCommunityFromHost(host);

        return Conn{
            .db = self.db,
            .internal_alloc = self.internal_alloc,
            .user_id = null,
            .community_id = community_id,
            .arena = std.heap.ArenaAllocator.init(alloc),
        };
    }

    pub fn connectToken(self: *ApiSource, host: []const u8, token: []const u8, alloc: std.mem.Allocator) !Conn {
        const community_id = try self.getCommunityFromHost(host);

        const token_info = try services.auth.tokens.verify(&self.db, token, community_id);

        return Conn{
            .db = self.db,
            .internal_alloc = self.internal_alloc,
            .user_id = token_info.user_id,
            .community_id = community_id,
            .arena = std.heap.ArenaAllocator.init(alloc),
        };
    }
};

fn ApiConn(comptime DbConn: type) type {
    return struct {
        const Self = @This();

        db: DbConn,
        internal_alloc: std.mem.Allocator, // used *only* for large, internal buffers
        user_id: ?Uuid,
        community_id: ?Uuid,
        arena: std.heap.ArenaAllocator,

        pub fn close(self: *Self) void {
            self.arena.deinit();
        }

        pub fn login(self: *Self, username: []const u8, password: []const u8) !LoginResult {
            const user_id = (try services.users.lookupByUsername(&self.db, username, self.community_id)) orelse return error.InvalidLogin;
            try services.auth.passwords.verify(&self.db, user_id, password, self.internal_alloc);

            const token = try services.auth.tokens.create(&self.db, user_id);

            return LoginResult{
                .user_id = user_id,
                .token = token.value,
                .issued_at = token.info.issued_at,
            };
        }

        const TokenInfo = struct {
            username: []const u8,
        };
        pub fn getTokenInfo(self: *Self) !TokenInfo {
            if (self.user_id) |user_id| {
                const result = (try self.db.execRow(
                    &.{[]const u8},
                    "SELECT username FROM user WHERE id = ?",
                    .{user_id},
                    self.arena.allocator(),
                )) orelse {
                    return error.UserNotFound;
                };
                return TokenInfo{ .username = result[0] };
            }

            return error.Unauthorized;
        }

        pub fn createCommunity(self: *Self, origin: []const u8) !services.communities.Community {
            if (self.community_id != null) {
                return error.NotAdminHost;
            }

            return services.communities.create(&self.db, origin, null);
        }

        pub fn createInvite(self: *Self, options: InviteOptions) !models.Invite {
            const id = Uuid.randV4(prng.random());

            const user = try self.getAuthenticatedUser();

            // Users can only make invites to their own community, unless they
            // are system users
            const community_id = if (options.to_community) |host| blk: {
                const desired_community = (try self.db.execRow(
                    &.{Uuid},
                    "SELECT id FROM community WHERE host = ?",
                    .{host},
                    null,
                )) orelse return error.CommunityNotFound;

                if (user.community_id != null and !Uuid.eql(desired_community[0], user.community_id.?)) {
                    return error.WrongCommunity;
                }

                break :blk desired_community[0];
            } else null;

            if (user.community_id != null and community_id == null) {
                return error.WrongCommunity;
            }

            var code: [invite_code_len]u8 = undefined;
            std.crypto.random.bytes(&code);

            var code_str = try self.arena.allocator().alloc(u8, invite_code_str_len);
            _ = std.base64.url_safe.Encoder.encode(code_str, &code);

            const now = DateTime.now();
            const expires_at = if (options.lifetime) |lifetime| DateTime{
                .seconds_since_epoch = lifetime + now.seconds_since_epoch,
            } else null;

            const invite = models.Invite{
                .id = id,

                .name = try self.arena.allocator().dupe(u8, options.name),
                .created_by = user.id,
                .invite_code = code_str,
                .to_community = community_id,

                .max_uses = options.max_uses,

                .created_at = now,
                .expires_at = expires_at,
            };

            try self.db.insert(models.Invite, invite);

            return invite;
        }
    };
}