Struct Client 

pub struct Client { /* private fields */ }

An instance of a Client is a connection to a single perspective_server::Server, whether locally in-memory or remote over some transport like a WebSocket.

The browser and node.js libraries both support the websocket(url) constructor, which connects to a remote perspective_server::Server instance over a WebSocket transport.

In the browser, the worker() constructor creates a new Web Worker perspective_server::Server and returns a Client connected to it.

In node.js, a pre-instantied Client connected synhronously to a global singleton perspective_server::Server is the default module export.

JavaScript Examples

Create a Web Worker perspective_server::Server in the browser and return a Client instance connected for it:

import perspective from "@finos/perspective";
const client = await perspective.worker();

Create a WebSocket connection to a remote perspective_server::Server:

import perspective from "@finos/perspective";
const client = await perspective.websocket("ws://locahost:8080/ws");

Access the synchronous client in node.js:

import { default as client } from "@finos/perspective";

Implementations

impl Client

pub fn __get_classname() -> &'static str

impl Client

pub fn __js_get_classname(&self) -> String

impl Client

pub fn get_client(&self) -> &Client

impl Client

pub fn new(send_request: Function, close: Option<Function>) -> ApiResult<Self>

pub fn new_proxy_session(&self, on_response: &Function) -> ProxySession

pub async fn handle_response(&self, value: &JsValue) -> ApiResult<()>

pub async fn handle_error( &self, error: String, reconnect: Option<Function>, ) -> ApiResult<()>

pub async fn on_error(&self, callback: Function) -> ApiResult<u32>

pub async fn table( &self, value: &JsTableInitData, options: Option<JsTableInitOptions>, ) -> ApiResult<Table>

Creates a new Table from either a schema or data.

The Client::table factory function can be initialized with either a schema (see Table::schema), or data in one of these formats:

• Apache Arrow
• CSV
• JSON row-oriented
• JSON column-oriented
• NDJSON

When instantiated with data, the schema is inferred from this data. While this is convenient, inferrence is sometimes imperfect e.g. when the input is empty, null or ambiguous. For these cases, Client::table can first be instantiated with a explicit schema.

When instantiated with a schema, the resulting Table is empty but with known column names and column types. When subsqeuently populated with Table::update, these columns will be coerced to the schema’s type. This behavior can be useful when Client::table’s column type inferences doesn’t work.

The resulting Table is virtual, and invoking its methods dispatches events to the perspective_server::Server this Client connects to, where the data is stored and all calculation occurs.

Arguments

• arg - Either schema or initialization data.
• options - Optional configuration which provides one of:
  • limit - The max number of rows the resulting Table can store.
  • index - The column name to use as an index column. If this Table is being instantiated by data, this column name must be present in the data.
  • name - The name of the table. This will be generated if it is not provided.
  • format - The explicit format of the input data, can be one of "json", "columns", "csv" or "arrow". This overrides language-specific type dispatch behavior, which allows stringified and byte array alternative inputs.

JavaScript Examples

Load a CSV from a string:

const table = await client.table("x,y\n1,2\n3,4");

Load an Arrow from an ArrayBuffer:

import * as fs from "node:fs/promises";
const table2 = await client.table(await fs.readFile("superstore.arrow"));

Load a CSV from a UInt8Array (the default for this type is Arrow) using a format override:

const enc = new TextEncoder();
const table = await client.table(enc.encode("x,y\n1,2\n3,4"), {
    format: "csv",
});

Create a table with an index:

const table = await client.table(data, { index: "Row ID" });

pub fn terminate(&self) -> ApiResult<JsValue>

Terminates this Client, cleaning up any crate::View handles the Client has open as well as its callbacks.

pub async fn open_table(&self, entity_id: String) -> ApiResult<Table>

Opens a Table that is hosted on the perspective_server::Server that is connected to this Client.

The name property of TableInitOptions is used to identify each Table. Table names can be looked up for each Client via Client::get_hosted_table_names.

JavaScript Examples

Get a virtual Table named “table_one” from this Client

const tables = await client.open_table("table_one");

pub async fn get_hosted_table_names(&self) -> ApiResult<JsValue>

Retrieves the names of all tables that this client has access to.

name is a string identifier unique to the Table (per Client), which can be used in conjunction with Client::open_table to get a Table instance without the use of Client::table constructor directly (e.g., one created by another Client).

JavaScript Examples

const tables = await client.get_hosted_table_names();

pub async fn on_hosted_tables_update( &self, on_update_js: Function, ) -> ApiResult<u32>

Register a callback which is invoked whenever Client::table (on this Client) or Table::delete (on a Table belinging to this Client) are called.

pub async fn remove_hosted_tables_update(&self, update_id: u32) -> ApiResult<()>

Remove a callback previously registered via Client::on_hosted_tables_update.

pub async fn system_info(&self) -> ApiResult<JsSystemInfo>

Provides the SystemInfo struct, implementation-specific metadata about the [perspective_server::Server] runtime such as Memory and CPU usage.

For WebAssembly servers, this method includes the WebAssembly heap size.

JavaScript Examples

const info = await client.system_info();

Trait Implementations

impl Clone for Client

fn clone(&self) -> Client

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl From<Client> for JsValue

fn from(value: Client) -> Self

Converts to this type from the input type.

impl FromWasmAbi for Client

type Abi = u32

The Wasm ABI type that this converts from when coming back out from the ABI boundary.

unsafe fn from_abi(js: u32) -> Self

Recover a Self from Self::Abi.

impl IntoWasmAbi for Client

type Abi = u32

The Wasm ABI type that this converts into when crossing the ABI boundary.

fn into_abi(self) -> u32

Convert self into Self::Abi so that it can be sent across the wasm ABI boundary.

impl LongRefFromWasmAbi for Client

type Abi = u32

Same as RefFromWasmAbi::Abi

type Anchor = RcRef<Client>

Same as RefFromWasmAbi::Anchor

unsafe fn long_ref_from_abi(js: Self::Abi) -> Self::Anchor

Same as RefFromWasmAbi::ref_from_abi

impl OptionFromWasmAbi for Client

fn is_none(abi: &Self::Abi) -> bool

Tests whether the argument is a “none” instance. If so it will be deserialized as None, and otherwise it will be passed to FromWasmAbi.

impl OptionIntoWasmAbi for Client

fn none() -> Self::Abi

Returns an ABI instance indicating “none”, which JS will interpret as the None branch of this option.

impl PartialEq for Client

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl RefFromWasmAbi for Client

type Abi = u32

The Wasm ABI type references to Self are recovered from.

type Anchor = RcRef<Client>

The type that holds the reference to Self for the duration of the invocation of the function that has an &Self parameter. This is required to ensure that the lifetimes don’t persist beyond one function call, and so that they remain anonymous.

unsafe fn ref_from_abi(js: Self::Abi) -> Self::Anchor

Recover a Self::Anchor from Self::Abi.

impl RefMutFromWasmAbi for Client

type Abi = u32

Same as RefFromWasmAbi::Abi

type Anchor = RcRefMut<Client>

Same as RefFromWasmAbi::Anchor

unsafe fn ref_mut_from_abi(js: Self::Abi) -> Self::Anchor

Same as RefFromWasmAbi::ref_from_abi

impl TryFrom<&JsValue> for Client

type Error = String

The type returned in the event of a conversion error.

fn try_from(js: &JsValue) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFromJsValue for Client

type Error = JsValue

The type returned in the event of a conversion error.

fn try_from_js_value(value: JsValue) -> Result<Self, Self::Error>

Performs the conversion.

impl VectorFromWasmAbi for Client

type Abi = <Box<[JsValue]> as FromWasmAbi>::Abi

unsafe fn vector_from_abi(js: Self::Abi) -> Box<[Client]>

impl VectorIntoJsValue for Client

fn vector_into_jsvalue(vector: Box<[Client]>) -> JsValue

impl VectorIntoWasmAbi for Client

type Abi = <Box<[JsValue]> as IntoWasmAbi>::Abi

fn vector_into_abi(vector: Box<[Client]>) -> Self::Abi

impl WasmDescribe for Client

fn describe()

impl WasmDescribeVector for Client

fn describe_vector()

impl SupportsConstructor for Client

impl SupportsInstanceProperty for Client

impl SupportsStaticProperty for Client