Functions in a remote interface are just regular functions in Swift that, when connected to a Web Frame, can be invoked from the web layer.

Functions can be declared any number of ways. The following examples are for a remote function that responds with the data that is sent to it from the web layer.

func echo(call: Call) {
    call.respond(with: call.request.data)
}

class Echo {
    func echo(call: Call) {
        call.respond(with: call.request.data)
    }
}

functions: [
    "echo": { call in
        call.respond(with: call.request.data)
    }
],

For the following example, we’ll be using a function declared like the following:

func echo(call: Call) {
    call.respond(with: call.request.data)
}

Since functions have first-class support in Swift, we can pass them as references to the Web Frame configuration.

let configuration = WebFrame.Configuration(
    baseURL: ...
    functions: [
        "echo": echo,
    ],
    observables: [:]
)

typealias RemoteFunction = (_: Call) -> Void

An instance of the Call class represents a single invocation of a remote function.

The Request instance associated with this call.

Complete the call by responding with empty data.

Complete the call by responding with a UTF-8 encoded string.

Complete the call by responding with arbitrary data.

Complete the call by responding with an encodable object.

Structs (or classes) must implement the Encodable protocol from Swift:

struct SizeResponse: Encodable {
    let width: Double
    let height: Double
}

Then, objects can be passed to .respond() directly:

call.respond(with: SizeResponse(width: 100, height: 100))

This function will throw an error if encoding fails (highly unlikely).

Complete the call (marking it as failed) by responding with an error message and code.

This will cause the web client to throw a ClientError exception.

Contains the request data from the web layer and helpers to extract it.

The raw data from the web layer.

The data decoded as a UTF-8 string.

The data converted to a decodable object.

Structs (or classes) must implement the Decodable protocol from Swift:

struct SizeRequest: Decodable {
    let name: String
}

Then, pass the type to .json():

let sizeRequest = try call.request.json(SizeRequest.self)
let shapeName = sizeRequest.name

This function will throw an error if decoding fails.