Skip to content

A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.

TypeScript fluxerfluxerapp
9.6 KB
Raw Blame
%% SPDX-License-Identifier: AGPL-3.0-or-later

-module(guild_data_normalize).
-typing([eqwalizer]).

-export([
    guild_data/1,
    member/1,
    role/1,
    channel/1,
    thread/1,
    thread_member/1
]).

-spec guild_data(term()) -> term().
guild_data(Data) when is_map(Data) ->
    normalize_nested_map(<<"guild">>, fun guild/1, Data);
guild_data(Data) ->
    Data.

-spec member(term()) -> term().
member(Member) when is_map(Member) ->
    Member1 = normalize_nested_map(<<"user">>, fun user/1, Member),
    Member2 = normalize_snowflake_list_field(<<"roles">>, Member1),
    guild_data_normalize_schema:normalize_nullable_int_fields(
        [<<"accent_color">>, <<"profile_flags">>, <<"mention_flags">>],
        Member2
    );
member(Member) ->
    Member.

-spec role(term()) -> term().
role(Role) when is_map(Role) ->
    Role1 = normalize_required_snowflake_field(<<"id">>, Role),
    Role2 = normalize_permission_field(<<"permissions">>, Role1),
    Role3 = guild_data_normalize_schema:normalize_int_fields(
        [<<"color">>, <<"position">>],
        Role2
    ),
    guild_data_normalize_schema:normalize_nullable_int_fields([<<"hoist_position">>], Role3);
role(Role) ->
    Role.

-spec channel(T) -> T | map().
channel(Channel) when is_map(Channel) ->
    Channel1 = normalize_required_snowflake_field(<<"id">>, Channel),
    Channel2 = normalize_optional_snowflake_field(<<"guild_id">>, Channel1),
    Channel3 = normalize_nullable_snowflake_fields(
        [<<"owner_id">>, <<"parent_id">>, <<"last_message_id">>],
        Channel2
    ),
    Channel4 = normalize_recipient_list(Channel3),
    Channel5 = normalize_nick_map(Channel4),
    Channel6 = normalize_overwrite_list(Channel5),
    Channel7 = guild_data_normalize_schema:normalize_int_fields(
        [
            <<"type">>,
            <<"position">>,
            <<"content_warning_level">>,
            <<"rate_limit_per_user">>,
            <<"flags">>,
            <<"default_thread_rate_limit_per_user">>,
            <<"default_forum_layout">>
        ],
        Channel6
    ),
    guild_data_normalize_schema:normalize_nullable_int_fields(
        [
            <<"bitrate">>,
            <<"user_limit">>,
            <<"voice_connection_limit">>,
            <<"default_auto_archive_duration">>,
            <<"default_sort_order">>
        ],
        Channel7
    );
channel(Channel) ->
    Channel.

-spec thread(term()) -> term().
thread(Thread) when is_map(Thread) ->
    Thread1 = channel(
        maps:without(
            [
                <<"member">>,
                <<"newly_created">>,
                <<"position">>,
                <<"permission_overwrites">>,
                <<"nsfw">>,
                <<"topic">>
            ],
            Thread
        )
    ),
    Thread2 = normalize_snowflake_list_field(<<"applied_tags">>, Thread1),
    Thread3 = normalize_snowflake_list_field(<<"member_ids_preview">>, Thread2),
    Thread4 = guild_data_normalize_schema:normalize_int_fields(
        [<<"message_count">>, <<"total_message_sent">>, <<"member_count">>],
        Thread3
    ),
    maps:filter(fun(Key, _Value) -> not internal_key(Key) end, Thread4);
thread(Thread) ->
    Thread.

-spec thread_member(T) -> T | map().
thread_member(Member) when is_map(Member) ->
    Member1 = normalize_required_snowflake_fields([<<"id">>, <<"user_id">>], Member),
    Member2 = guild_data_normalize_schema:normalize_int_fields([<<"flags">>], Member1),
    maps:without([<<"member">>, <<"presence">>, <<"guild_id">>], Member2);
thread_member(Member) ->
    Member.

-spec internal_key(term()) -> boolean().
internal_key(<<"_fluxer_", _/binary>>) -> true;
internal_key(<<"__thread_", _/binary>>) -> true;
internal_key(_) -> false.

-spec guild(map()) -> map().
guild(Guild) ->
    Guild1 = normalize_required_snowflake_fields([<<"id">>, <<"owner_id">>], Guild),
    Guild2 = normalize_nullable_snowflake_fields(
        [<<"system_channel_id">>, <<"rules_channel_id">>, <<"afk_channel_id">>],
        Guild1
    ),
    Guild3 = normalize_permission_field(<<"permissions">>, Guild2),
    Guild4 = guild_data_normalize_schema:normalize_int_fields(
        [
            <<"system_channel_flags">>,
            <<"afk_timeout">>,
            <<"verification_level">>,
            <<"mfa_level">>,
            <<"nsfw_level">>,
            <<"content_warning_level">>,
            <<"explicit_content_filter">>,
            <<"default_message_notifications">>,
            <<"disabled_operations">>,
            <<"member_count">>,
            <<"online_count">>
        ],
        Guild3
    ),
    guild_data_normalize_schema:normalize_nullable_int_fields(
        [
            <<"banner_width">>,
            <<"banner_height">>,
            <<"splash_width">>,
            <<"splash_height">>,
            <<"embed_splash_width">>,
            <<"embed_splash_height">>
        ],
        Guild4
    ).

-spec user(map()) -> map().
user(User) ->
    user_utils:normalize_user(User).

-spec normalize_overwrite_list(map()) -> map().
normalize_overwrite_list(Channel) ->
    case maps:get(<<"permission_overwrites">>, Channel, undefined) of
        Overwrites when is_list(Overwrites) ->
            Normalized = lists:filtermap(fun normalize_overwrite/1, Overwrites),
            Channel#{<<"permission_overwrites">> => Normalized};
        _ ->
            Channel
    end.

-spec normalize_recipient_list(map()) -> map().
normalize_recipient_list(Channel) ->
    case maps:get(<<"recipients">>, Channel, undefined) of
        Recipients when is_list(Recipients) ->
            Normalized = [user(Recipient) || Recipient <- Recipients, is_map(Recipient)],
            Channel#{<<"recipients">> => Normalized};
        _ ->
            Channel
    end.

-spec normalize_nick_map(map()) -> map().
normalize_nick_map(Channel) ->
    case maps:get(<<"nicks">>, Channel, undefined) of
        Nicks when is_map(Nicks) ->
            Channel#{<<"nicks">> => normalize_snowflake_keyed_map(Nicks)};
        _ ->
            Channel
    end.

-spec normalize_snowflake_keyed_map(map()) -> map().
normalize_snowflake_keyed_map(Map) ->
    maps:fold(fun add_snowflake_keyed_value/3, #{}, Map).

-spec add_snowflake_keyed_value(term(), term(), map()) -> map().
add_snowflake_keyed_value(Key, Value, Acc) ->
    Acc#{snowflake_id:parse(Key) => Value}.

-spec normalize_overwrite(term()) -> false | {true, map()}.
normalize_overwrite(Overwrite) when is_map(Overwrite) ->
    Id = snowflake_id:parse_optional(maps:get(<<"id">>, Overwrite, undefined)),
    Allow = bitset:parse_optional(maps:get(<<"allow">>, Overwrite, undefined)),
    Deny = bitset:parse_optional(maps:get(<<"deny">>, Overwrite, undefined)),
    Type = overwrite_type(maps:get(<<"type">>, Overwrite, undefined)),
    case {Id, Type, Allow, Deny} of
        {OverwriteId, OverwriteType, AllowBits, DenyBits} when
            is_integer(OverwriteId),
            is_integer(OverwriteType),
            is_integer(AllowBits),
            is_integer(DenyBits)
        ->
            {true, #{
                <<"id">> => OverwriteId,
                <<"type">> => OverwriteType,
                <<"allow">> => AllowBits,
                <<"deny">> => DenyBits
            }};
        _ ->
            false
    end;
normalize_overwrite(_) ->
    false.

-spec overwrite_type(term()) -> 0 | 1 | undefined.
overwrite_type(0) ->
    0;
overwrite_type(1) ->
    1;
overwrite_type(<<"0">>) ->
    0;
overwrite_type(<<"1">>) ->
    1;
overwrite_type("0") ->
    0;
overwrite_type("1") ->
    1;
overwrite_type(_) ->
    undefined.

-spec normalize_nested_map(binary(), fun((map()) -> map()), map()) -> map().
normalize_nested_map(Key, Fun, Map) ->
    case maps:get(Key, Map, undefined) of
        Nested when is_map(Nested) -> Map#{Key => Fun(Nested)};
        _ -> Map
    end.

-spec normalize_required_snowflake_fields([binary()], map()) -> map().
normalize_required_snowflake_fields(Keys, Map) ->
    lists:foldl(fun normalize_required_snowflake_field/2, Map, Keys).

-spec normalize_nullable_snowflake_fields([binary()], map()) -> map().
normalize_nullable_snowflake_fields(Keys, Map) ->
    lists:foldl(fun normalize_nullable_snowflake_field/2, Map, Keys).

-spec normalize_required_snowflake_field(binary(), map()) -> map().
normalize_required_snowflake_field(Key, Map) ->
    case maps:find(Key, Map) of
        {ok, Value} -> put_normalized_snowflake(Key, Value, Map);
        error -> Map
    end.

-spec normalize_optional_snowflake_field(binary(), map()) -> map().
normalize_optional_snowflake_field(Key, Map) ->
    case maps:find(Key, Map) of
        {ok, null} -> maps:remove(Key, Map);
        {ok, undefined} -> maps:remove(Key, Map);
        {ok, Value} -> put_normalized_snowflake(Key, Value, Map);
        error -> Map
    end.

-spec normalize_nullable_snowflake_field(binary(), map()) -> map().
normalize_nullable_snowflake_field(Key, Map) ->
    case maps:find(Key, Map) of
        {ok, null} -> Map#{Key => null};
        {ok, Value} -> put_normalized_snowflake(Key, Value, Map);
        error -> Map
    end.

-spec put_normalized_snowflake(binary(), term(), map()) -> map().
put_normalized_snowflake(Key, Value, Map) ->
    Map#{Key => snowflake_id:parse(Value)}.

-spec normalize_permission_field(binary(), map()) -> map().
normalize_permission_field(Key, Map) ->
    case maps:find(Key, Map) of
        {ok, Value} -> put_normalized_permission(Key, Value, Map);
        error -> Map
    end.

-spec put_normalized_permission(binary(), term(), map()) -> map().
put_normalized_permission(Key, Value, Map) ->
    Map#{Key => bitset:parse(Value)}.

-spec normalize_snowflake_list_field(binary(), map()) -> map().
normalize_snowflake_list_field(Key, Map) ->
    case maps:find(Key, Map) of
        {ok, Value} -> Map#{Key => snowflake_id:parse_list(Value)};
        error -> Map
    end.