🥮 mooncakes.io

    moonbitstack/moongql/server does not have a README file

    GqlWs

    source
    pub struct GqlWs {
      schema : 
    Schema
      resolvers : 
    Resolvers
      subscribers : 
    Subscribers
      root_value : 
    Json
      context : 
    Json
      init_timeout : Int64
      ping_interval : Int64
      initialized : Bool
      params : 
    Json
      opened : Int64?
      pinged : Int64
      active : Map[String, Unit]
    }

    One graphql-transport-ws connection: the schema it serves plus the protocol state a connection carries — whether connection_init has arrived, the parameters it brought, the operation ids currently running, and the two timers the protocol defines.

    This package has no async runtime and no clock of its own, so the timers are state plus a transition and nothing more: a server drives them by calling tick with a millisecond reading of a monotonic clock, as often as it likes (once a second is plenty), and sending whatever frames come back. Nothing else starts the connection-init countdown or emits a keep-alive ping.

    GqlWs::claim

    source
    fn GqlWs::claim(self : GqlWs, id : String) -> Bool

    Claim operation id for an operation that is starting, answering false when the id is already running — the caller must then close the socket with 4409.

    recv claims and releases an id itself, because a pull source is drained before it returns. A server streaming a live source claims the id when it starts the task and calls release when the task sends its last frame; that is what keeps 4409 meaning "still running" rather than "used once".

    GqlWs::handler

    source

    The connection as a moonasgi WebSocketHandler, negotiating the graphql-transport-ws subprotocol when the client offers it.

    GqlWs::new

    source

    Open a connection's protocol state for schema / resolvers / subscribers. root_value and context are threaded to every operation the way execute threads them.

    init_timeout is how long a client may take to send connection_init before tick closes the socket with 4408, and ping_interval how long the server waits between keep-alive ping frames; both are milliseconds, and either is switched off by passing zero.

    GqlWs::recv

    source

    Handle one inbound message, returning the frames to send back.

    GqlWs::release

    source
    fn GqlWs::release(self : GqlWs, id : String) -> Unit

    Release operation id, freeing it for reuse. Called after the operation's terminating complete or error has been sent.

    GqlWs::tick

    source
    fn GqlWs::tick(self : GqlWs, now : Int64) -> Array[
    WsSend    ]

    Drive the connection's timers from a monotonic clock reading in milliseconds, returning the frames the elapsed time calls for: the 4408 close when connection_init did not arrive in time, or a keep-alive ping.

    The first call starts the clock, so a server should tick as soon as it has accepted the socket and keep ticking for as long as it holds it.

    Ide

    source
    pub(all) struct Ide {
      kind : IdeKind
      subscription_endpoint : String?
    }

    The IDE a GET without a ?query= is answered with. subscription_endpoint is where the IDE opens its WebSocket: left as None, each page derives one from the page's own location (the same host, wss: over HTTPS), which is right for an endpoint served next to the IDE.

    Ide::html

    source
    fn Ide::html(self : Ide, endpoint? : String) -> String

    The full HTML page mounting this IDE against endpoint. Off has no page, and answers the empty string.

    Ide::is_off

    source
    fn Ide::is_off(self : Ide) -> Bool

    Whether this configuration serves no IDE.

    Ide::title

    source
    fn Ide::title(self : Ide) -> String

    The page title the IDE's HTML carries.

    IdeKind

    source
    pub(all) enum IdeKind {
      Site
      GraphiQL
      ApolloSandbox
      Altair
      Off
    } derive(Eq)

    Which IDE the endpoint serves.

    IdeKind::equal

    source
    fn IdeKind::equal(IdeKind, IdeKind) -> Bool

    IdeKind::not_equal

    source
    fn IdeKind::not_equal(x : IdeKind, y : IdeKind) -> Bool

    altair

    source
    let altair : Ide

    Altair, the IDE with environments and saved collections.

    apollo_sandbox

    source
    let apollo_sandbox : Ide

    Apollo Sandbox, embedded as an iframe.

    graphiql

    source
    let graphiql : Ide

    GraphiQL, the reference IDE.

    graphiql_html

    source
    fn graphiql_html(endpoint? : String) -> String

    The GraphiQL IDE page, wired to fetch against endpoint. This is what site (the default Ide) serves; the pages are built in ide.mbt.

    graphql_app

    source

    Lift the GraphQL handler onto the load-bearing AsgiApp a server binds to.

    A POST on path runs the request with the asynchronous engine: one JSON response, or — when the client's Accept asks for multipart/mixed — the initial payload followed by one part per deferred fragment or streamed list item. A GET serves the IDE, or runs a query operation with ?query=.

    Mount it in mooncat (or any ASGI server) where the schema should be reachable; graphql_handler is the same endpoint as a plain request-to-response function.

    graphql_handler

    source

    Build the moonasgi request handler for a schema and its resolvers, following the GraphQL-over-HTTP specification.

    A POST on path executes an application/json body — one request object, or an array of them for a batch. A GET with a ?query= executes a query operation (only a query: a mutation there is a 405); a GET without one serves the IDE ide names (the MoonQL page by default, or off for a 405). The response media type is negotiated from Accept: a client asking for application/graphql-response+json gets it, and with it the status codes that separate a request error (400) from a field error (200); anything else gets application/json and a 200. Lift it onto an AsgiApp with graphql_app, or drive it directly with moonasgi's TestClient.

    graphql_ws_app

    source

    The application that serves graphql-transport-ws on path for schema, resolvers and subscribers.

    A request that is not a WebSocket upgrade on path is answered with a 404, so one application can be mounted beside a plain HTTP endpoint.

    graphql_ws_handler

    source

    Build a graphql-transport-ws WebSocket handler for schema / resolvers / subscribers. root_value and context are threaded to every operation the way execute threads them. Negotiates the graphql-transport-ws subprotocol when the client offers it.

    The handler owns its connection state, so nothing can drive the protocol's timers: build a GqlWs and take its handler when the server can tick.

    incremental_content_type

    source
    fn incremental_content_type(boundary : String) -> String

    The media type of an incremental response: one multipart document, the boundary the parts are separated by, and the version of the format, so a client knows how to read the parts.

    multipart_close

    source
    fn multipart_close(boundary : String) -> String

    The closing boundary of a multipart document.

    multipart_part

    source
    fn multipart_part(boundary : String, payload : 
    Json    ) -> String

    One payload as a multipart part: a boundary line, the part's headers, and the payload itself. Parts end with the closing boundary rather than each carrying it, so close_multipart writes the last one.

    off

    source
    let off : Ide

    No IDE at all: a GET without a ?query= is a 405.

    site

    source
    let site : Ide

    The MoonQL page: the library's own IDE, and the default.

    Source Files

    Powered by MoonBit

    Site sourceReport issueModulesSkillsCLIBuild queueStatistics

    © 2026 mooncakes.io