Packages
gleamrpc

2.1.5
2.1.5 2.1.4 2.1.3 2.1.2 2.1.1 2.1.0 2.0.1 2.0.0 1.0.0
Remote Procedure Calls in Gleam
HexDocs
Current section
Files
Jump to
Readme 9 Versions 2 Dependencies Dependants Files Activity
gleamrpc src gleamrpc.erl
Raw
src/gleamrpc.erl

-module(gleamrpc).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export(['query'/2, mutation/2, params/2, returns/2, with_client/2, call/3, with_server/1, with_context/2, with_middleware/2, serve/1, with_implementation/3]).
-export_type([procedure_type/0, procedure/2, procedure_identity/0, gleam_rpc_error/1, procedure_error/0, gleam_rpc_server_error/1, router/0, procedure_client/3, procedure_call/3, procedure_server/3, procedure_server_instance/4]).

-type procedure_type() :: 'query' | mutation.

-type procedure(FWJ, FWK) :: {procedure,
        binary(),
        gleam@option:option(router()),
        procedure_type(),
        convert:converter(FWJ),
        convert:converter(FWK)}.

-type procedure_identity() :: {procedure_identity,
        binary(),
        gleam@option:option(router()),
        procedure_type()}.

-type gleam_rpc_error(FWL) :: {gleam_rpc_error, FWL}.

-type procedure_error() :: {procedure_error, binary()}.

-type gleam_rpc_server_error(FWM) :: wrong_procedure |
    {procedure_exec_error, procedure_error()} |
    {get_identity_error, FWM} |
    {get_params_error, list(gleam@dynamic:decode_error())}.

-type router() :: {router, binary(), gleam@option:option(router())}.

-type procedure_client(FWN, FWO, FWP) :: {procedure_client,
        fun((procedure(FWN, FWO), FWN, fun(({ok, FWO} |
            {error, gleam_rpc_error(FWP)}) -> nil)) -> nil)}.

-type procedure_call(FWQ, FWR, FWS) :: {procedure_call,
        procedure(FWQ, FWR),
        procedure_client(FWQ, FWR, FWS)}.

-type procedure_server(FWT, FWU, FWV) :: {procedure_server,
        fun((FWT) -> {ok, procedure_identity()} |
            {error, gleam_rpc_server_error(FWV)}),
        fun((FWT) -> fun((procedure_type(), convert:glitr_type()) -> {ok,
                convert:glitr_value()} |
            {error, gleam_rpc_server_error(FWV)})),
        fun((gleam_rpc_server_error(FWV)) -> FWU),
        fun((convert:glitr_value()) -> FWU)}.

-type procedure_server_instance(FWW, FWX, FWY, FWZ) :: {procedure_server_instance,
        procedure_server(FWW, FWX, FWZ),
        fun((procedure_identity(), fun((procedure_type(), convert:glitr_type()) -> {ok,
                convert:glitr_value()} |
            {error, gleam_rpc_server_error(FWZ)}), FWY) -> {ok,
                convert:glitr_value()} |
            {error, gleam_rpc_server_error(FWZ)}),
        fun((FWW) -> FWY),
        list(fun((FWW, fun((FWW) -> FWX)) -> FWX))}.

-file("/home/runner/work/gleamrpc/gleamrpc/src/gleamrpc.gleam", 121).
-spec 'query'(binary(), gleam@option:option(router())) -> procedure(nil, nil).
'query'(Name, Router) ->
    {procedure, Name, Router, 'query', convert:null(), convert:null()}.

-file("/home/runner/work/gleamrpc/gleamrpc/src/gleamrpc.gleam", 126).
-spec mutation(binary(), gleam@option:option(router())) -> procedure(nil, nil).
mutation(Name, Router) ->
    {procedure, Name, Router, mutation, convert:null(), convert:null()}.

-file("/home/runner/work/gleamrpc/gleamrpc/src/gleamrpc.gleam", 134).
-spec params(procedure(any(), FXR), convert:converter(FXU)) -> procedure(FXU, FXR).
params(Procedure, Params_converter) ->
    _record = Procedure,
    {procedure,
        erlang:element(2, _record),
        erlang:element(3, _record),
        erlang:element(4, _record),
        Params_converter,
        erlang:element(6, _record)}.

-file("/home/runner/work/gleamrpc/gleamrpc/src/gleamrpc.gleam", 142).
-spec returns(procedure(FXY, any()), convert:converter(FYC)) -> procedure(FXY, FYC).
returns(Procedure, Return_converter) ->
    _record = Procedure,
    {procedure,
        erlang:element(2, _record),
        erlang:element(3, _record),
        erlang:element(4, _record),
        erlang:element(5, _record),
        Return_converter}.

-file("/home/runner/work/gleamrpc/gleamrpc/src/gleamrpc.gleam", 150).
-spec with_client(procedure(FYG, FYH), procedure_client(FYG, FYH, FYK)) -> procedure_call(FYG, FYH, FYK).
with_client(Procedure, Client) ->
    {procedure_call, Procedure, Client}.

-file("/home/runner/work/gleamrpc/gleamrpc/src/gleamrpc.gleam", 167).
-spec call(
    procedure_call(FYR, FYS, FYT),
    FYR,
    fun(({ok, FYS} | {error, gleam_rpc_error(FYT)}) -> nil)
) -> nil.
call(Procedure_call, Params, Callback) ->
    (erlang:element(2, erlang:element(3, Procedure_call)))(
        erlang:element(2, Procedure_call),
        Params,
        Callback
    ).

-file("/home/runner/work/gleamrpc/gleamrpc/src/gleamrpc.gleam", 183).
-spec with_server(procedure_server(FZA, FZB, FZC)) -> procedure_server_instance(FZA, FZB, FZA, FZC).
with_server(Server) ->
    {procedure_server_instance,
        Server,
        fun(_, _, _) -> {error, wrong_procedure} end,
        fun gleam@function:identity/1,
        []}.

-file("/home/runner/work/gleamrpc/gleamrpc/src/gleamrpc.gleam", 196).
-spec with_context(
    procedure_server_instance(FZK, FZL, any(), FZN),
    fun((FZK) -> FZS)
) -> procedure_server_instance(FZK, FZL, FZS, FZN).
with_context(Server, Context_factory) ->
    {procedure_server_instance,
        erlang:element(2, Server),
        fun(_, _, _) -> {error, wrong_procedure} end,
        Context_factory,
        erlang:element(5, Server)}.

-file("/home/runner/work/gleamrpc/gleamrpc/src/gleamrpc.gleam", 210).
-spec with_middleware(
    procedure_server_instance(FZX, FZY, FZZ, GAA),
    fun((FZX, fun((FZX) -> FZY)) -> FZY)
) -> procedure_server_instance(FZX, FZY, FZZ, GAA).
with_middleware(Server, Middleware) ->
    _record = Server,
    {procedure_server_instance,
        erlang:element(2, _record),
        erlang:element(3, _record),
        erlang:element(4, _record),
        [Middleware | erlang:element(5, Server)]}.

-file("/home/runner/work/gleamrpc/gleamrpc/src/gleamrpc.gleam", 265).
-spec execute_middlewares(
    GBL,
    list(fun((GBL, fun((GBL) -> GBM)) -> GBM)),
    fun((GBL) -> GBM)
) -> GBM.
execute_middlewares(In, Middlewares, Next) ->
    case Middlewares of
        [] ->
            Next(In);

        [Middleware | Rest] ->
            Middleware(
                In,
                fun(New_in) -> execute_middlewares(New_in, Rest, Next) end
            )
    end.

-file("/home/runner/work/gleamrpc/gleamrpc/src/gleamrpc.gleam", 243).
-spec serve(procedure_server_instance(GBD, GBE, any(), any())) -> fun((GBD) -> GBE).
serve(Server) ->
    fun(In) ->
        execute_middlewares(
            In,
            erlang:element(5, Server),
            fun(In@1) ->
                Result = begin
                    gleam@result:'try'(
                        (erlang:element(2, erlang:element(2, Server)))(In@1),
                        fun(Identity) ->
                            Params_fn = (erlang:element(
                                3,
                                erlang:element(2, Server)
                            ))(In@1),
                            Context = (erlang:element(4, Server))(In@1),
                            _pipe = (erlang:element(3, Server))(
                                Identity,
                                Params_fn,
                                Context
                            ),
                            gleam@result:map(
                                _pipe,
                                erlang:element(5, erlang:element(2, Server))
                            )
                        end
                    )
                end,
                case Result of
                    {ok, Out} ->
                        Out;

                    {error, Err} ->
                        (erlang:element(4, erlang:element(2, Server)))(Err)
                end
            end
        )
    end.

-file("/home/runner/work/gleamrpc/gleamrpc/src/gleamrpc.gleam", 279).
-spec add_procedure(
    fun((procedure_identity(), fun((procedure_type(), convert:glitr_type()) -> {ok,
            convert:glitr_value()} |
        {error, gleam_rpc_server_error(GBR)}), GBQ) -> {ok,
            convert:glitr_value()} |
        {error, gleam_rpc_server_error(GBR)}),
    procedure(GBU, GBV),
    fun((GBU, GBQ) -> {ok, GBV} | {error, procedure_error()})
) -> fun((procedure_identity(), fun((procedure_type(), convert:glitr_type()) -> {ok,
        convert:glitr_value()} |
    {error, gleam_rpc_server_error(GBR)}), GBQ) -> {ok, convert:glitr_value()} |
    {error, gleam_rpc_server_error(GBR)}).
add_procedure(Handler, Procedure, Implementation) ->
    fun(Identity, Params_fn, Context) ->
        case Handler(Identity, Params_fn, Context) of
            {error, wrong_procedure} ->
                case Identity of
                    {procedure_identity, Name, Router, Type_} when ((Name =:= erlang:element(
                        2,
                        Procedure
                    )) andalso (Router =:= erlang:element(3, Procedure))) andalso (Type_ =:= erlang:element(
                        4,
                        Procedure
                    )) ->
                        gleam@result:'try'(
                            Params_fn(
                                erlang:element(4, Procedure),
                                begin
                                    _pipe = erlang:element(5, Procedure),
                                    convert:type_def(_pipe)
                                end
                            ),
                            fun(Params) -> _pipe@1 = Params,
                                _pipe@2 = (convert:decode(
                                    erlang:element(5, Procedure)
                                ))(_pipe@1),
                                _pipe@3 = gleam@result:map_error(
                                    _pipe@2,
                                    fun(Field@0) -> {get_params_error, Field@0} end
                                ),
                                _pipe@5 = gleam@result:then(
                                    _pipe@3,
                                    fun(Params@1) ->
                                        _pipe@4 = Implementation(
                                            Params@1,
                                            Context
                                        ),
                                        gleam@result:map_error(
                                            _pipe@4,
                                            fun(Field@0) -> {procedure_exec_error, Field@0} end
                                        )
                                    end
                                ),
                                gleam@result:map(
                                    _pipe@5,
                                    convert:encode(erlang:element(6, Procedure))
                                ) end
                        );

                    _ ->
                        {error, wrong_procedure}
                end;

            _ = Result ->
                Result
        end
    end.

-file("/home/runner/work/gleamrpc/gleamrpc/src/gleamrpc.gleam", 221).
-spec with_implementation(
    procedure_server_instance(GAL, GAM, GAN, GAO),
    procedure(GAT, GAU),
    fun((GAT, GAN) -> {ok, GAU} | {error, procedure_error()})
) -> procedure_server_instance(GAL, GAM, GAN, GAO).
with_implementation(Server, Procedure, Implementation) ->
    _record = Server,
    {procedure_server_instance,
        erlang:element(2, _record),
        add_procedure(erlang:element(3, Server), Procedure, Implementation),
        erlang:element(4, _record),
        erlang:element(5, _record)}.
Operator	Description	Example
name:	Match package name. Supports * wildcards and repo/package form	name:phx* or name:hexpm/phoenix
description:	Full-text search of package descriptions	description:auth
depends:	Packages depending on a given package. Supports repo:package form	depends:ecto or depends:hexpm:ecto
build_tool:	Filter by build tool	build_tool:mix
updated_after:	Packages updated after an ISO8601 datetime	updated_after:2025-01-01T00:00:00Z
extra:	Match custom metadata (key,value). Nested keys are separated by commas	extra:license,MIT