381 lines
13 KiB
Erlang
381 lines
13 KiB
Erlang
%% Copyright (C) 2026 Fluxer Contributors
|
|
%%
|
|
%% This file is part of Fluxer.
|
|
%%
|
|
%% Fluxer is free software: you can redistribute it and/or modify
|
|
%% it under the terms of the GNU Affero General Public License as published by
|
|
%% the Free Software Foundation, either version 3 of the License, or
|
|
%% (at your option) any later version.
|
|
%%
|
|
%% Fluxer is distributed in the hope that it will be useful,
|
|
%% but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
%% GNU Affero General Public License for more details.
|
|
%%
|
|
%% You should have received a copy of the GNU Affero General Public License
|
|
%% along with Fluxer. If not, see <https://www.gnu.org/licenses/>.
|
|
|
|
-module(guild_member_storage).
|
|
|
|
-export([
|
|
new/0,
|
|
insert_member/2,
|
|
remove_member/2,
|
|
get_member/2,
|
|
get_members_by_ids/2,
|
|
search_members/3,
|
|
get_range/3,
|
|
count/1,
|
|
compute_list_id/1
|
|
]).
|
|
|
|
-type storage() :: #{
|
|
members_table := ets:tid(),
|
|
display_name_index := gb_trees:tree({binary(), user_id()}, user_id())
|
|
}.
|
|
-type user_id() :: integer().
|
|
-type member() :: map().
|
|
-type index_key() :: {binary(), user_id()}.
|
|
|
|
-export_type([storage/0]).
|
|
|
|
-spec new() -> storage().
|
|
new() ->
|
|
MembersTable = ets:new(members, [set, private, {read_concurrency, true}]),
|
|
DisplayNameIndex = gb_trees:empty(),
|
|
#{
|
|
members_table => MembersTable,
|
|
display_name_index => DisplayNameIndex
|
|
}.
|
|
|
|
-spec insert_member(member(), storage()) -> storage().
|
|
insert_member(Member, Storage) ->
|
|
case extract_user_id(Member) of
|
|
undefined ->
|
|
Storage;
|
|
UserId ->
|
|
OldMember = get_member(UserId, Storage),
|
|
Storage1 = remove_from_index(OldMember, Storage),
|
|
#{members_table := MembersTable} = Storage1,
|
|
ets:insert(MembersTable, {UserId, Member}),
|
|
add_to_index(UserId, Member, Storage1)
|
|
end.
|
|
|
|
-spec remove_member(user_id(), storage()) -> storage().
|
|
remove_member(UserId, Storage) ->
|
|
case get_member(UserId, Storage) of
|
|
undefined ->
|
|
Storage;
|
|
Member ->
|
|
Storage1 = remove_from_index(Member, Storage),
|
|
#{members_table := MembersTable} = Storage1,
|
|
ets:delete(MembersTable, UserId),
|
|
Storage1
|
|
end.
|
|
|
|
-spec get_member(user_id(), storage()) -> member() | undefined.
|
|
get_member(UserId, Storage) ->
|
|
#{members_table := MembersTable} = Storage,
|
|
case ets:lookup(MembersTable, UserId) of
|
|
[{UserId, Member}] -> Member;
|
|
[] -> undefined
|
|
end.
|
|
|
|
-spec get_members_by_ids([user_id()], storage()) -> [member()].
|
|
get_members_by_ids(UserIds, Storage) ->
|
|
lists:filtermap(
|
|
fun(UserId) ->
|
|
case get_member(UserId, Storage) of
|
|
undefined -> false;
|
|
Member -> {true, Member}
|
|
end
|
|
end,
|
|
UserIds
|
|
).
|
|
|
|
-spec search_members(binary(), non_neg_integer(), storage()) -> [member()].
|
|
search_members(Query, Limit, Storage) when is_binary(Query), Limit > 0 ->
|
|
NormalizedQuery = normalize_display_name(Query),
|
|
case NormalizedQuery of
|
|
<<>> -> [];
|
|
_ -> search_by_prefix(NormalizedQuery, Limit, Storage)
|
|
end;
|
|
search_members(_, _, _) ->
|
|
[].
|
|
|
|
-spec get_range(non_neg_integer(), non_neg_integer(), storage()) -> [member()].
|
|
get_range(Offset, Limit, Storage) when is_integer(Offset), is_integer(Limit), Limit > 0 ->
|
|
#{display_name_index := Index} = Storage,
|
|
Size = gb_trees:size(Index),
|
|
case Offset >= Size of
|
|
true -> [];
|
|
false -> get_range_from_index(Offset, Limit, Size, Index, Storage)
|
|
end;
|
|
get_range(_, _, _) ->
|
|
[].
|
|
|
|
-spec get_range_from_index(
|
|
non_neg_integer(), non_neg_integer(), non_neg_integer(), gb_trees:tree(), storage()
|
|
) ->
|
|
[member()].
|
|
get_range_from_index(Offset, Limit, Size, Index, Storage) ->
|
|
AllKeys = gb_trees:keys(Index),
|
|
EndIdx = min(Offset + Limit, Size),
|
|
SelectedKeys = lists:sublist(AllKeys, Offset + 1, EndIdx - Offset),
|
|
lists:filtermap(
|
|
fun(Key) ->
|
|
UserId = gb_trees:get(Key, Index),
|
|
case get_member(UserId, Storage) of
|
|
undefined -> false;
|
|
Member -> {true, Member}
|
|
end
|
|
end,
|
|
SelectedKeys
|
|
).
|
|
|
|
-spec count(storage()) -> non_neg_integer().
|
|
count(Storage) ->
|
|
#{members_table := MembersTable} = Storage,
|
|
ets:info(MembersTable, size).
|
|
|
|
-spec compute_list_id([user_id()]) -> integer().
|
|
compute_list_id(UserIds) ->
|
|
SortedIds = lists:sort(UserIds),
|
|
Combined = lists:foldl(
|
|
fun(Id, Acc) -> <<Acc/binary, (integer_to_binary(Id))/binary, ",">> end,
|
|
<<>>,
|
|
SortedIds
|
|
),
|
|
erlang:phash2(Combined, 16#FFFFFFFF).
|
|
|
|
-spec extract_user_id(member()) -> user_id() | undefined.
|
|
extract_user_id(Member) when is_map(Member) ->
|
|
User = maps:get(<<"user">>, Member, #{}),
|
|
map_utils:get_integer(User, <<"id">>, undefined);
|
|
extract_user_id(_) ->
|
|
undefined.
|
|
|
|
-spec get_display_name(member()) -> binary().
|
|
get_display_name(Member) when is_map(Member) ->
|
|
case maps:get(<<"nick">>, Member, undefined) of
|
|
undefined -> get_display_name_from_user(Member);
|
|
Nick -> Nick
|
|
end.
|
|
|
|
-spec get_display_name_from_user(member()) -> binary().
|
|
get_display_name_from_user(Member) ->
|
|
User = maps:get(<<"user">>, Member, #{}),
|
|
case maps:get(<<"global_name">>, User, undefined) of
|
|
undefined -> maps:get(<<"username">>, User, <<>>);
|
|
GlobalName -> GlobalName
|
|
end.
|
|
|
|
-spec normalize_display_name(binary()) -> binary().
|
|
normalize_display_name(Name) when is_binary(Name) ->
|
|
LowerName = string:lowercase(binary_to_list(Name)),
|
|
list_to_binary(LowerName).
|
|
|
|
-spec add_to_index(user_id(), member(), storage()) -> storage().
|
|
add_to_index(UserId, Member, Storage) ->
|
|
DisplayName = get_display_name(Member),
|
|
NormalizedName = normalize_display_name(DisplayName),
|
|
Key = make_index_key(NormalizedName, UserId),
|
|
#{display_name_index := Index} = Storage,
|
|
NewIndex = gb_trees:enter(Key, UserId, Index),
|
|
Storage#{display_name_index => NewIndex}.
|
|
|
|
-spec remove_from_index(member() | undefined, storage()) -> storage().
|
|
remove_from_index(undefined, Storage) ->
|
|
Storage;
|
|
remove_from_index(Member, Storage) ->
|
|
UserId = extract_user_id(Member),
|
|
DisplayName = get_display_name(Member),
|
|
NormalizedName = normalize_display_name(DisplayName),
|
|
Key = make_index_key(NormalizedName, UserId),
|
|
#{display_name_index := Index} = Storage,
|
|
case gb_trees:is_defined(Key, Index) of
|
|
true ->
|
|
NewIndex = gb_trees:delete(Key, Index),
|
|
Storage#{display_name_index => NewIndex};
|
|
false ->
|
|
Storage
|
|
end.
|
|
|
|
-spec make_index_key(binary(), user_id()) -> index_key().
|
|
make_index_key(NormalizedName, UserId) ->
|
|
{NormalizedName, UserId}.
|
|
|
|
-spec search_by_prefix(binary(), non_neg_integer(), storage()) -> [member()].
|
|
search_by_prefix(Prefix, Limit, Storage) ->
|
|
#{display_name_index := Index} = Storage,
|
|
AllKeys = gb_trees:keys(Index),
|
|
PrefixLen = byte_size(Prefix),
|
|
Matches = find_prefix_matches(AllKeys, Prefix, PrefixLen, Storage, []),
|
|
lists:sublist(Matches, Limit).
|
|
|
|
-spec find_prefix_matches([index_key()], binary(), non_neg_integer(), storage(), [member()]) ->
|
|
[member()].
|
|
find_prefix_matches([], _Prefix, _PrefixLen, _Storage, Acc) ->
|
|
lists:reverse(Acc);
|
|
find_prefix_matches([{Name, UserId} | Rest], Prefix, PrefixLen, Storage, Acc) ->
|
|
case Name of
|
|
<<Prefix:PrefixLen/binary, _/binary>> ->
|
|
case get_member(UserId, Storage) of
|
|
undefined ->
|
|
find_prefix_matches(Rest, Prefix, PrefixLen, Storage, Acc);
|
|
Member ->
|
|
find_prefix_matches(Rest, Prefix, PrefixLen, Storage, [Member | Acc])
|
|
end;
|
|
_ ->
|
|
find_prefix_matches(Rest, Prefix, PrefixLen, Storage, Acc)
|
|
end.
|
|
|
|
-ifdef(TEST).
|
|
-include_lib("eunit/include/eunit.hrl").
|
|
|
|
new_creates_empty_storage_test() ->
|
|
Storage = new(),
|
|
?assertEqual(0, count(Storage)).
|
|
|
|
insert_and_get_member_test() ->
|
|
Storage = new(),
|
|
Member = #{
|
|
<<"user">> => #{
|
|
<<"id">> => <<"123">>,
|
|
<<"username">> => <<"testuser">>
|
|
},
|
|
<<"roles">> => []
|
|
},
|
|
Storage1 = insert_member(Member, Storage),
|
|
?assertEqual(1, count(Storage1)),
|
|
Retrieved = get_member(123, Storage1),
|
|
?assertEqual(Member, Retrieved).
|
|
|
|
remove_member_test() ->
|
|
Storage = new(),
|
|
Member = #{
|
|
<<"user">> => #{
|
|
<<"id">> => <<"123">>,
|
|
<<"username">> => <<"testuser">>
|
|
}
|
|
},
|
|
Storage1 = insert_member(Member, Storage),
|
|
Storage2 = remove_member(123, Storage1),
|
|
?assertEqual(0, count(Storage2)),
|
|
?assertEqual(undefined, get_member(123, Storage2)).
|
|
|
|
get_members_by_ids_test() ->
|
|
Storage = new(),
|
|
Member1 = #{<<"user">> => #{<<"id">> => <<"1">>, <<"username">> => <<"alice">>}},
|
|
Member2 = #{<<"user">> => #{<<"id">> => <<"2">>, <<"username">> => <<"bob">>}},
|
|
Storage1 = insert_member(Member1, Storage),
|
|
Storage2 = insert_member(Member2, Storage1),
|
|
Members = get_members_by_ids([1, 2, 999], Storage2),
|
|
?assertEqual(2, length(Members)).
|
|
|
|
search_members_by_prefix_test() ->
|
|
Storage = new(),
|
|
Member1 = #{<<"user">> => #{<<"id">> => <<"1">>, <<"username">> => <<"alice">>}},
|
|
Member2 = #{<<"user">> => #{<<"id">> => <<"2">>, <<"username">> => <<"bob">>}},
|
|
Member3 = #{<<"user">> => #{<<"id">> => <<"3">>, <<"username">> => <<"alicia">>}},
|
|
Storage1 = insert_member(Member1, Storage),
|
|
Storage2 = insert_member(Member2, Storage1),
|
|
Storage3 = insert_member(Member3, Storage2),
|
|
Results = search_members(<<"ali">>, 10, Storage3),
|
|
?assertEqual(2, length(Results)).
|
|
|
|
display_name_nick_priority_test() ->
|
|
Member = #{
|
|
<<"user">> => #{
|
|
<<"id">> => <<"1">>,
|
|
<<"username">> => <<"user">>,
|
|
<<"global_name">> => <<"Global">>
|
|
},
|
|
<<"nick">> => <<"Nickname">>
|
|
},
|
|
?assertEqual(<<"Nickname">>, get_display_name(Member)).
|
|
|
|
display_name_global_name_fallback_test() ->
|
|
Member = #{
|
|
<<"user">> => #{
|
|
<<"id">> => <<"1">>,
|
|
<<"username">> => <<"user">>,
|
|
<<"global_name">> => <<"Global">>
|
|
}
|
|
},
|
|
?assertEqual(<<"Global">>, get_display_name(Member)).
|
|
|
|
display_name_username_fallback_test() ->
|
|
Member = #{
|
|
<<"user">> => #{
|
|
<<"id">> => <<"1">>,
|
|
<<"username">> => <<"user">>
|
|
}
|
|
},
|
|
?assertEqual(<<"user">>, get_display_name(Member)).
|
|
|
|
compute_list_id_deterministic_test() ->
|
|
Id1 = compute_list_id([1, 2, 3]),
|
|
Id2 = compute_list_id([3, 2, 1]),
|
|
?assertEqual(Id1, Id2).
|
|
|
|
compute_list_id_different_for_different_lists_test() ->
|
|
Id1 = compute_list_id([1, 2, 3]),
|
|
Id2 = compute_list_id([1, 2, 4]),
|
|
?assertNotEqual(Id1, Id2).
|
|
|
|
get_range_test() ->
|
|
Storage = new(),
|
|
Member1 = #{<<"user">> => #{<<"id">> => <<"1">>, <<"username">> => <<"alice">>}},
|
|
Member2 = #{<<"user">> => #{<<"id">> => <<"2">>, <<"username">> => <<"bob">>}},
|
|
Member3 = #{<<"user">> => #{<<"id">> => <<"3">>, <<"username">> => <<"charlie">>}},
|
|
Storage1 = insert_member(Member1, Storage),
|
|
Storage2 = insert_member(Member2, Storage1),
|
|
Storage3 = insert_member(Member3, Storage2),
|
|
Results = get_range(1, 2, Storage3),
|
|
?assertEqual(2, length(Results)).
|
|
|
|
get_range_offset_beyond_size_test() ->
|
|
Storage = new(),
|
|
Member1 = #{<<"user">> => #{<<"id">> => <<"1">>, <<"username">> => <<"alice">>}},
|
|
Storage1 = insert_member(Member1, Storage),
|
|
Results = get_range(10, 5, Storage1),
|
|
?assertEqual([], Results).
|
|
|
|
search_members_empty_query_test() ->
|
|
Storage = new(),
|
|
Member1 = #{<<"user">> => #{<<"id">> => <<"1">>, <<"username">> => <<"alice">>}},
|
|
Storage1 = insert_member(Member1, Storage),
|
|
Results = search_members(<<>>, 10, Storage1),
|
|
?assertEqual([], Results).
|
|
|
|
search_members_limit_test() ->
|
|
Storage = new(),
|
|
Member1 = #{<<"user">> => #{<<"id">> => <<"1">>, <<"username">> => <<"aaa">>}},
|
|
Member2 = #{<<"user">> => #{<<"id">> => <<"2">>, <<"username">> => <<"aab">>}},
|
|
Member3 = #{<<"user">> => #{<<"id">> => <<"3">>, <<"username">> => <<"aac">>}},
|
|
Storage1 = insert_member(Member1, Storage),
|
|
Storage2 = insert_member(Member2, Storage1),
|
|
Storage3 = insert_member(Member3, Storage2),
|
|
Results = search_members(<<"aa">>, 2, Storage3),
|
|
?assertEqual(2, length(Results)).
|
|
|
|
normalize_display_name_test() ->
|
|
?assertEqual(<<"hello">>, normalize_display_name(<<"HELLO">>)),
|
|
?assertEqual(<<"hello">>, normalize_display_name(<<"Hello">>)),
|
|
?assertEqual(<<"hello">>, normalize_display_name(<<"hello">>)).
|
|
|
|
insert_member_updates_index_test() ->
|
|
Storage = new(),
|
|
Member1 = #{<<"user">> => #{<<"id">> => <<"1">>, <<"username">> => <<"alice">>}},
|
|
Storage1 = insert_member(Member1, Storage),
|
|
Member2 = #{<<"user">> => #{<<"id">> => <<"1">>, <<"username">> => <<"bob">>}},
|
|
Storage2 = insert_member(Member2, Storage1),
|
|
?assertEqual(1, count(Storage2)),
|
|
AliceResults = search_members(<<"alice">>, 10, Storage2),
|
|
?assertEqual(0, length(AliceResults)),
|
|
BobResults = search_members(<<"bob">>, 10, Storage2),
|
|
?assertEqual(1, length(BobResults)).
|
|
|
|
-endif.
|