gleamrpc - v2.0.1

gleamrpc

Types

GleamRPCError

</> 
pub type GleamRPCError(error) {
  GleamRPCError(error: error)
}

Constructors 

  • GleamRPCError(error: error)

Procedure

</> 
pub type Procedure(params, return) {
  Procedure(
    name: String,
    router: option.Option(Router),
    type_: ProcedureType,
    params_type: convert.Converter(params),
    return_type: convert.Converter(return),
  )
}

Constructors 

  • Procedure(
  name: String,
  router: option.Option(Router),
  type_: ProcedureType,
  params_type: convert.Converter(params),
  return_type: convert.Converter(return),
)

ProcedureCall

</> 
pub type ProcedureCall(params, return, error) {
  ProcedureCall(
    procedure: Procedure(params, return),
    server: ProcedureClient(params, return, error),
  )
}

Constructors 

  • ProcedureCall(
  procedure: Procedure(params, return),
  server: ProcedureClient(params, return, error),
)

ProcedureClient

</> 
pub type ProcedureClient(params, return, error) {
  ProcedureClient(
    call: fn(
      Procedure(params, return),
      params,
      fn(Result(return, GleamRPCError(error))) -> Nil,
    ) ->
      Nil,
  )
}

Constructors 

  • ProcedureClient(
  call: fn(
    Procedure(params, return),
    params,
    fn(Result(return, GleamRPCError(error))) -> Nil,
  ) ->
    Nil,
)

ProcedureType

</> 
pub type ProcedureType {
  Query
  Mutation
}

Constructors 

  • Query
  • Mutation

Router

</> 
pub type Router {
  Router(name: String, parent: option.Option(Router))
}

Constructors 

  • Router(name: String, parent: option.Option(Router))

Functions

call

</> 
pub fn call(
  procedure_call: ProcedureCall(a, b, c),
  params: a,
  callback: fn(Result(b, GleamRPCError(c))) -> Nil,
) -> Nil

mutation

</> 
pub fn mutation(
  name: String,
  router: Option(Router),
) -> Procedure(Nil, Nil)

params

</> 
pub fn params(
  procedure: Procedure(a, b),
  params_converter: Converter(a),
) -> Procedure(a, b)

query

</> 
pub fn query(
  name: String,
  router: Option(Router),
) -> Procedure(Nil, Nil)

returns

</> 
pub fn returns(
  procedure: Procedure(a, b),
  return_converter: Converter(b),
) -> Procedure(a, b)

with_client

</> 
pub fn with_client(
  procedure: Procedure(a, b),
  server: ProcedureClient(a, b, c),
) -> ProcedureCall(a, b, c)
✨ Search Document