@rspc/client
TypeScript API reference for @rspc/client, version 1.0.0-rc.1.
1.0.0-rc.1
Generated from the published type declarations for this exact release.
Public exports of @rspc/client at version 1.0.0-rc.1.
This page documents 1.0.0-rc.1. The documented version is 0.3.1.
Classes
AlphaClient
declare class AlphaClient<P extends ProceduresDef> {
_rspc_def: ProceduresDef;
private links;
private onError?;
private mapQueryKey?;
constructor(args: ClientArgs);
query<K extends P["queries"]["key"] & string>(keyAndInput: [
key: K,
...input: _inferProcedureHandlerInput<P, "queries", K>
], opts?: OperationOpts): Promise<inferQueryResult<P, K>>;
mutation<K extends P["mutations"]["key"] & string>(keyAndInput: [
key: K,
...input: _inferProcedureHandlerInput<P, "mutations", K>
], opts?: OperationOpts): Promise<inferMutationResult<P, K>>;
addSubscription<K extends P["subscriptions"]["key"] & string, TData = inferProcedureResult<P, "subscriptions", K>>(keyAndInput: [
K,
..._inferProcedureHandlerInput<P, "subscriptions", K>
], opts: SubscriptionOptions<TData> & {
context?: OperationContext;
}): () => void;
dangerouslyHookIntoInternals<P2 extends ProceduresDef = P>(opts?: {
// … truncated, see the source link
RSPCError
declare class RSPCError extends Error {
code: number;
message: string;
constructor(code: number, message: string);
}
Interfaces
LinkOperation
/**
* The argument to a link. Contains information about the current operation and a function to call the next link.
*
* @internal
*/
interface LinkOperation {
op: Operation;
next(op: {
op: Operation;
}): LinkResult;
}
The argument to a link. Contains information about the current operation and a function to call the next link. @internal
SubscriptionOptions
interface SubscriptionOptions<TOutput> {
onData: (data: TOutput) => void;
onError?: (err: RSPCError | Error) => void;
}
Type aliases
_inferInfiniteQueryProcedureHandlerInput
type _inferInfiniteQueryProcedureHandlerInput<TProcedures extends ProceduresLike, K extends inferInfiniteQueries<TProcedures>["key"]> = inferInfiniteQueryInput<TProcedures, K> extends never ? [
] : [
inferInfiniteQueryInput<TProcedures, K>
];
_inferProcedureHandlerInput
type _inferProcedureHandlerInput<TProcedures extends ProceduresLike, TOperation extends keyof ProceduresDef, K extends inferProcedures<TProcedures>[TOperation]["key"]> = inferProcedure<TProcedures, TOperation, K>["input"] extends never ? [
] : [
inferProcedure<TProcedures, TOperation, K>["input"]
];
AbortFn
/** * TODO * * @internal */ type AbortFn = () => void;
TODO @internal
FakeObservable
/**
* TODO
*
* @internal
*/
type FakeObservable = {
exec: () => PromiseAndCancel<any>;
};
TODO @internal
inferInfiniteQueries
type inferInfiniteQueries<TProcedures extends ProceduresLike> = Exclude<Extract<inferProcedures<TProcedures>["queries"], {
input: {
cursor: any;
};
}>, {
input: never;
}>;
inferInfiniteQuery
type inferInfiniteQuery<TProcedures extends ProceduresLike, K extends inferInfiniteQueries<TProcedures>["key"]> = Extract<inferInfiniteQueries<TProcedures>, {
key: K;
}>;
inferInfiniteQueryInput
type inferInfiniteQueryInput<TProcedures extends ProceduresLike, K extends inferInfiniteQueries<TProcedures>["key"]> = EmptyObjToNever<Omit<inferInfiniteQuery<TProcedures, K>["input"], "cursor">>; // Referenced local context (not public exports): type EmptyObjToNever<T> = keyof T extends never ? never : T;
inferInfiniteQueryResult
type inferInfiniteQueryResult<TProcedures extends ProceduresLike, K extends inferInfiniteQueries<TProcedures>["key"]> = inferInfiniteQuery<TProcedures, K>["result"];
inferMutationInput
type inferMutationInput<TProcedures extends ProceduresLike, T extends inferProcedures<TProcedures>["mutations"]["key"][0]> = inferProcedureInput<inferProcedures<TProcedures>, "mutations", T>;
inferMutationResult
type inferMutationResult<TProcedures extends ProceduresLike, T extends inferProcedures<TProcedures>["mutations"]["key"][0]> = inferProcedureResult<inferProcedures<TProcedures>, "mutations", T>;
inferProcedure
type inferProcedure<TProcedures extends ProceduresLike, TOperation extends keyof ProceduresDef, K extends inferProcedureKey<TProcedures, TOperation>> = Extract<inferProcedures<TProcedures>[TOperation], {
key: K;
}>;
inferProcedureInput
type inferProcedureInput<TProcedures extends ProceduresLike, TOperation extends keyof ProceduresDef, K extends inferProcedureKey<TProcedures, TOperation>> = inferProcedure<TProcedures, TOperation, K>["input"];
inferProcedureKey
type inferProcedureKey<TProcedures extends ProceduresLike, TOperation extends keyof ProceduresDef> = inferProcedures<TProcedures>[TOperation]["key"];
inferProcedureResult
type inferProcedureResult<TProcedures extends ProceduresLike, TOperation extends keyof ProceduresDef, K extends inferProcedureKey<TProcedures, TOperation>> = inferProcedure<TProcedures, TOperation, K>["result"];
inferProcedures
/**
* This is a helper method to infer the type of bindings for this router off other rspc types.
* The inferred type is what is generated by Rust.
* @example
* const rspc = createReactQueryHooks<Operations>();
* type Bindings = inferBindingsType<typeof rspc>
*/
type inferProcedures<TProcedures extends ProceduresLike> = TProcedures extends {
_rspc_def: ProceduresDef;
} ? TProcedures["_rspc_def"] : TProcedures;
This is a helper method to infer the type of bindings for this router off other rspc types. The inferred type is what is generated by Rust. @example const rspc = createReactQueryHooks<Operations>(); type Bindings = inferBindingsType<typeof rspc>
inferQueryInput
type inferQueryInput<TProcedures extends ProceduresLike, T extends inferProcedures<TProcedures>["queries"]["key"][0]> = inferProcedureInput<inferProcedures<TProcedures>, "queries", T>;
inferQueryResult
type inferQueryResult<TProcedures extends ProceduresLike, T extends inferProcedures<TProcedures>["queries"]["key"][0]> = inferProcedureResult<inferProcedures<TProcedures>, "queries", T>;
inferSubscriptionInput
type inferSubscriptionInput<TProcedures extends ProceduresLike, T extends inferProcedures<TProcedures>["subscriptions"]["key"][0]> = inferProcedureInput<inferProcedures<TProcedures>, "subscriptions", T>;
inferSubscriptionResult
type inferSubscriptionResult<TProcedures extends ProceduresLike, T extends inferProcedures<TProcedures>["subscriptions"]["key"][0]> = inferProcedureResult<inferProcedures<TProcedures>, "subscriptions", T>;
Link
/** * TODO * * @internal */ type Link = (p: LinkOperation) => LinkResult;
TODO @internal
LinkResult
/**
* TODO
*
* @internal
*/
type LinkResult = {
exec: (resolve: (result: any) => void, reject: (error: Error | RSPCError) => void) => void;
abort: () => void;
};
TODO @internal
Operation
/**
* TODO
*
* @internal
*/
type Operation = {
method: "query" | "mutation" | "subscription";
path: string;
input: any | null;
context: OperationContext;
};
TODO @internal
OperationContext
/** * A map of data that can be used by links to store metadata about the current operation. * This allows links to communicate with each other. * * @internal */ type OperationContext = Record<string, unknown>;
A map of data that can be used by links to store metadata about the current operation. This allows links to communicate with each other. @internal
OperationType
type OperationType = "query" | "mutation" | "subscription" | "subscriptionStop";
ProcedureDef
/**
* Represents a Typescript procedure file which is generated by the Rust code.
* This is codegenerated Typescript file is how we can validate the types on the frontend match Rust.
*
* @internal
*/
type ProcedureDef = {
key: string;
input: any;
result: any;
};
Represents a Typescript procedure file which is generated by the Rust code. This is codegenerated Typescript file is how we can validate the types on the frontend match Rust. @internal
ProceduresDef
/**
* This type represents the Typescript bindings which are generated from the router by Rust.
*/
type ProceduresDef = {
queries: ProcedureDef;
mutations: ProcedureDef;
subscriptions: ProcedureDef;
};
This type represents the Typescript bindings which are generated from the router by Rust.
ProceduresLike
/**
* A type which allows inferring the type of the bindings
*/
type ProceduresLike = {
_rspc_def: ProceduresDef;
} | ProceduresDef;
A type which allows inferring the type of the bindings
PromiseAndCancel
/**
* TODO
*
* @internal
*/
type PromiseAndCancel<TValue> = {
promise: Promise<TValue>;
abort: AbortFn;
};
TODO @internal
Request
/**
* The type of a request to rspc.
*
* @internal
*/
type Request = {
method: "query";
id: number;
path: string;
input: any | null;
} | {
method: "mutation";
id: number;
path: string;
input: any | null;
} | {
method: "subscription";
id: number;
path: string;
input: any | null;
} | {
method: "subscriptionStop";
id: number;
};
The type of a request to rspc. @internal
Response
/**
* The type of a response from rspc.
*
* @internal
*/
type Response = ({
type: "value";
value: any;
} | {
type: "error";
value: ResponseError;
} | {
type: "complete";
}) & {
id: number;
};
The type of a response from rspc. @internal
ResponseError
/**
* An error that can be returned by rspc.
*
* @internal
*/
type ResponseError = {
code: number;
message: string;
data: any | null;
};
An error that can be returned by rspc. @internal
ResponseInner
/**
* A value that can be a successful result or an error.
*
* @internal
*/
type ResponseInner = {
type: "value";
value: any;
} | {
type: "error";
value: ResponseError;
} | {
type: "complete";
};
A value that can be a successful result or an error. @internal
Functions
_internal_fireResponse
/**
* @internal
*/
declare function _internal_fireResponse(resp: ResponseInner, i: BatchedItem | {
resolve: (result: any) => void;
reject: (error: Error | RSPCError) => void;
}): Promise<void>;
// Referenced local context (not public exports):
type BatchedItem = {
op: Operation;
resolve: (result: any) => void;
reject: (error: Error | RSPCError) => void;
abort: AbortController;
};
@internal
_internal_wsLinkInternal
/**
* @internal
*/
declare function _internal_wsLinkInternal([activeMap, send]: ReturnType<typeof newWsManager>): Link;
// Referenced local context (not public exports):
declare function newWsManager(opts: WsLinkOpts): readonly [
Map<number, {
resolve: (result: any) => void;
reject: (error: Error | RSPCError) => void;
}>,
(data: Request | Request[]) => Promise<void>
];
type WsLinkOpts = {
url: string;
/**
* Add ponyfill for WebSocket
*/
WebSocket?: typeof WebSocket;
};
@internal
httpLink
/**
* HTTP Fetch link for rspc
*/
declare function httpLink(opts: HttpLinkOpts): Link;
// Referenced local context (not public exports):
type HttpLinkOpts = {
url: string;
/**
* Add ponyfill for fetch
*/
fetch?: typeof fetch;
/**
* Add ponyfill for AbortController
*/
AbortController?: typeof AbortController | null;
} & ({
/**
* Headers to be set on outgoing requests or a callback that of said headers
*/
headers?: HTTPHeaders | ((opts: {
op: Operation;
}) => HTTPHeaders);
} | {
/**
* Headers to be set on outgoing requests or a callback that of said headers
*/
headers?: HTTPHeaders | ((opts: {
ops: Operation[];
}) => HTTPHeaders);
/**
* Batch multiple rspc queries into a single HTTP request. Disabled by default.
*
* NOTE: This is great for performance but may be problematic if your using HTTP caching.
*/
batch: true | {
maxBatchSize?: number;
// … truncated, see the source link
HTTP Fetch link for rspc
initRspc
declare function initRspc<P extends ProceduresDef>(args: ClientArgs): AlphaClient<P>;
// Referenced local context (not public exports):
interface ClientArgs {
links: Link[];
onError?: (err: RSPCError) => void | Promise<void>;
}
loggerLink
/** * Link for logging operations. * * This must go before the terminating link for it to work! * */ declare function loggerLink(): Link;
Link for logging operations.
This must go before the terminating link for it to work!
wsLink
/**
* Websocket link for rspc
*
* Note: This link applies request batching by default.
*/
declare function wsLink(opts: WsLinkOpts): Link;
// Referenced local context (not public exports):
type WsLinkOpts = {
url: string;
/**
* Add ponyfill for WebSocket
*/
WebSocket?: typeof WebSocket;
};
Websocket link for rspc
Note: This link applies request batching by default.