@rspc/client
TypeScript API reference for @rspc/client, version 0.0.0-main-7c0a67c1.
0.0.0-main-7c0a67c1
Generated from the published type declarations for this exact release.
Public exports of @rspc/client at version 0.0.0-main-7c0a67c1.
This page documents 0.0.0-main-7c0a67c1. The documented version is 0.3.1.
Classes
RSPCError
declare class RSPCError extends Error {
readonly cause: Error | undefined;
readonly shape: any;
readonly data: any;
readonly meta: Record<string, unknown> | undefined;
readonly code: number;
constructor(message: string, opts?: {
result?: any;
cause?: Error;
meta?: Record<string, unknown>;
});
static from(cause: Error, // TODO: | TRPCErrorResponse<any>,
opts?: {
meta?: Record<string, unknown>;
}): RSPCError;
}
Interfaces
ClientArgs
interface ClientArgs {
/**
* Data transformer
* @link https://trpc.io/docs/data-transformers
**/
transformer?: ClientDataTransformerOptions;
/**
* TODO
* @link https://rspc.dev/todo
**/
links: TRPCLink<any>[];
/**
* TODO
* @link https://rspc.dev/todo
**/
onError?: OnErrorFunction;
}
CustomHooks
interface CustomHooks {
mapQueryKey?(keyAndInput: [
string
] | [
string,
any
]): [
string
] | [
string,
any
];
doQuery?(keyAndInput: [
string
] | [
string,
any
], next: (keyAndInput: [
string
] | [
string,
any
]) => Promise<any>): Promise<any>;
doMutation?(keyAndInput: [
string
] | [
string,
any
], next: (keyAndInput: [
string
] | [
string,
any
]) => Promise<any>): Promise<any>;
dangerous?: {
useQuery?(keyAndInput: [
string
] | [
string,
any
], handler: () => Promise<any>, opts?: any): any;
useMutation?(handler: (input: any) => Promise<any>, opts?: any): any;
};
}
HttpBatchLinkOptions
interface HttpBatchLinkOptions extends HTTPLinkOptions {
maxURLLength?: number;
}
// Referenced local context (not public exports):
interface HTTPLinkOptions {
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
* @link http://trpc.io/docs/v10/header
*/
headers?: HTTPHeaders | (() => HTTPHeaders | Promise<HTTPHeaders>);
}
LoggerLinkOptions
interface LoggerLinkOptions<TProcedures extends ProceduresDef> {
logger?: LoggerLinkFn<TProcedures>;
enabled?: EnabledFn<TProcedures>;
/**
* Used in the built-in defaultLogger
*/
console?: ConsoleEsque;
}
// Referenced local context (not public exports):
declare type LoggerLinkFn<TProcedures extends ProceduresDef> = (opts: LoggerLinkFnOptions<TProcedures>) => void;
declare type EnabledFn<TProcedures extends ProceduresDef> = (opts: EnableFnOptions<TProcedures>) => boolean;
declare type ConsoleEsque = {
log: (...args: any[]) => void;
error: (...args: any[]) => void;
};
declare type LoggerLinkFnOptions<TProcedures extends ProceduresDef> = Operation & ({
/**
* Request was just initialized
*/
direction: "up";
} | {
/**
* Request result
*/
direction: "down";
result: OperationResultEnvelope<unknown> | RSPCError;
elapsedMs: number;
});
// … truncated, see the source link
Observable
interface Observable<TValue, TError> extends Subscribable<TValue, TError> {
pipe(): Observable<TValue, TError>;
pipe<TValue1, TError1>(op1: OperatorFunction<TValue, TError, TValue1, TError1>): Observable<TValue1, TError1>;
pipe<TValue1, TError1, TValue2, TError2>(op1: OperatorFunction<TValue, TError, TValue1, TError1>, op2: OperatorFunction<TValue1, TError1, TValue2, TError2>): Observable<TValue2, TError2>;
pipe<TValue1, TError1, TValue2, TError2, TValue3, TError3>(op1: OperatorFunction<TValue, TError, TValue1, TError1>, op2: OperatorFunction<TValue1, TError1, TValue2, TError2>, op3: OperatorFunction<TValue2, TError2, TValue3, TError3>): Observable<TValue2, TError2>;
// … truncated, see the source link
Observer
interface Observer<TValue, TError> {
next: (value: TValue) => void;
error: (err: TError) => void;
complete: () => void;
}
OperationResultEnvelope
/**
* @internal
*/
interface OperationResultEnvelope<TOutput> {
result: TRPCSuccessResponse<TOutput>["result"] | TRPCResultMessage<TOutput>["result"];
context?: OperationContext;
}
// Referenced local context (not public exports):
declare type TRPCSuccessResponse<T> = any;
declare type TRPCResultMessage<T> = any;
@internal
Subscribable
interface Subscribable<TValue, TError> {
subscribe(observer: Partial<Observer<TValue, TError>>): Unsubscribable;
}
SubscriptionLike
interface SubscriptionLike extends Unsubscribable {
unsubscribe(): void;
readonly closed: boolean;
}
TRPCClientRuntime
interface TRPCClientRuntime {
transformer: DataTransformer$1;
onError?: OnErrorFunction;
}
// Referenced local context (not public exports):
declare type DataTransformer$1 = any;
TRPCRequestOptions
interface TRPCRequestOptions {
/**
* Pass additional context to links
*/
context?: OperationContext;
signal?: AbortSignal;
}
TRPCSubscriptionObserver
interface TRPCSubscriptionObserver<TValue, TError> {
onStarted: () => void;
onData: (value: TValue) => void;
onError: (err: TError) => void;
onStopped: () => void;
onComplete: () => void;
}
Unsubscribable
interface Unsubscribable {
unsubscribe(): void;
}
WebSocketClientOptions
interface WebSocketClientOptions {
url: string;
WebSocket?: typeof WebSocket;
retryDelayMs?: typeof retryDelay;
onOpen?: () => void;
onClose?: (cause?: {
code?: number;
}) => void;
}
WebSocketLinkOptions
interface WebSocketLinkOptions {
client: TRPCWebSocketClient;
}
Type aliases
_inferInfiniteQueryProcedureHandlerInput
declare type _inferInfiniteQueryProcedureHandlerInput<TProcedures extends ProceduresLike, K extends inferInfiniteQueries<TProcedures>["key"]> = inferInfiniteQueryInput<TProcedures, K> extends never ? [
] : [
inferInfiniteQueryInput<TProcedures, K>
];
_inferProcedureHandlerInput
declare 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"]
];
CancelFn
/** * @internal */ declare type CancelFn = () => void;
@internal
Client
declare type Client<TBaseProceduresLike extends ProceduresLike, TQueries extends ProcedureDef = inferProcedures<TBaseProceduresLike>["queries"], TMutations extends ProcedureDef = inferProcedures<TBaseProceduresLike>["mutations"], TSubscriptions extends ProcedureDef = inferProcedures<TBaseProceduresLike>["subscriptions"]> = ReturnType<typeof createClient<TBaseProceduresLike, TQueries, TMutations, TSubscriptions>>;
ClientDataTransformerOptions
/** * @public */ declare type ClientDataTransformerOptions = DataTransformer | CombinedDataTransformerClient;
@public
CombinedDataTransformer
/**
* @public
*/
declare type CombinedDataTransformer = {
input: DataTransformer;
output: DataTransformer;
};
@public
CombinedDataTransformerClient
/**
* @public
*/
declare type CombinedDataTransformerClient = {
input: Pick<DataTransformer, "serialize">;
output: Pick<DataTransformer, "deserialize">;
};
@public
DataTransformer
/**
* @public
*/
declare type DataTransformer = {
serialize(object: any): any;
deserialize(object: any): any;
};
@public
DataTransformerOptions
/** * @public */ declare type DataTransformerOptions = DataTransformer | CombinedDataTransformer;
@public
HookCreateFunction
/** * TODO * * @internal */ declare type HookCreateFunction<TContext, TBaseProcedures extends ProceduresDef = never, TQueries extends ProcedureDef = TBaseProcedures["queries"], TMutations extends ProcedureDef = TBaseProcedures["mutations"], TSubscriptions extends ProcedureDef = TBaseProcedures["subscriptions"]> = (hookOpts?: HookOptions) => Hooks<TContext, TBaseProcedures, TQueries, TMutations, TSubscriptions>;
TODO @internal
HookOptions
/**
* TODO
*
* @internal
*/
declare type HookOptions = {
/**
* TODO
*
* @internal
*/
internal?: {
/**
* WARNING: Using these hooks to modify data may result in incorrect types.
*/
customHooks?: () => CustomHooks;
};
};
TODO @internal
Hooks
/**
* TODO
*
* @internal
*/
declare type Hooks<TContext, TBaseProcedures extends ProceduresDef = never, TQueries extends ProcedureDef = TBaseProcedures["queries"], TMutations extends ProcedureDef = TBaseProcedures["mutations"], TSubscriptions extends ProcedureDef = TBaseProcedures["subscriptions"]> = {
createClient(opts: ClientArgs): Client<TBaseProcedures, TQueries, TMutations, TSubscriptions>;
useContext(): TContext;
};
TODO @internal
HTTPHeaders
/** * @internal */ declare type HTTPHeaders = Record<string, string | string[] | undefined>;
@internal
inferInfiniteQueries
declare type inferInfiniteQueries<TProcedures extends ProceduresLike> = Exclude<Extract<inferProcedures<TProcedures>["queries"], {
input: {
cursor: any;
};
}>, {
input: never;
}>;
inferInfiniteQuery
declare type inferInfiniteQuery<TProcedures extends ProceduresLike, K extends inferInfiniteQueries<TProcedures>["key"]> = Extract<inferInfiniteQueries<TProcedures>, {
key: K;
}>;
inferInfiniteQueryInput
declare type inferInfiniteQueryInput<TProcedures extends ProceduresLike, K extends inferInfiniteQueries<TProcedures>["key"]> = EmptyObjToNever<Omit<inferInfiniteQuery<TProcedures, K>["input"], "cursor">>; // Referenced local context (not public exports): declare type EmptyObjToNever<T> = keyof T extends never ? never : T;
inferInfiniteQueryResult
declare type inferInfiniteQueryResult<TProcedures extends ProceduresLike, K extends inferInfiniteQueries<TProcedures>["key"]> = inferInfiniteQuery<TProcedures, K>["result"];
inferMutationInput
declare type inferMutationInput<TProcedures extends ProceduresLike, T extends inferProcedures<TProcedures>["mutations"]["key"][0]> = inferProcedureInput<inferProcedures<TProcedures>, "mutations", T>;
inferMutationResult
declare type inferMutationResult<TProcedures extends ProceduresLike, T extends inferProcedures<TProcedures>["mutations"]["key"][0]> = inferProcedureResult<inferProcedures<TProcedures>, "mutations", T>;
inferObservableValue
declare type inferObservableValue<TObservable> = TObservable extends Observable<infer TValue, unknown> ? TValue : never;
inferProcedure
declare type inferProcedure<TProcedures extends ProceduresLike, TOperation extends keyof ProceduresDef, K extends inferProcedureKey<TProcedures, TOperation>> = Extract<inferProcedures<TProcedures>[TOperation], {
key: K;
}>;
inferProcedureInput
declare type inferProcedureInput<TProcedures extends ProceduresLike, TOperation extends keyof ProceduresDef, K extends inferProcedureKey<TProcedures, TOperation>> = inferProcedure<TProcedures, TOperation, K>["input"];
inferProcedureKey
declare type inferProcedureKey<TProcedures extends ProceduresLike, TOperation extends keyof ProceduresDef> = inferProcedures<TProcedures>[TOperation]["key"];
inferProcedureResult
declare 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>
*/
declare 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
declare type inferQueryInput<TProcedures extends ProceduresLike, T extends inferProcedures<TProcedures>["queries"]["key"][0]> = inferProcedureInput<inferProcedures<TProcedures>, "queries", T>;
inferQueryResult
declare type inferQueryResult<TProcedures extends ProceduresLike, T extends inferProcedures<TProcedures>["queries"]["key"][0]> = inferProcedureResult<inferProcedures<TProcedures>, "queries", T>;
inferSubscriptionInput
declare type inferSubscriptionInput<TProcedures extends ProceduresLike, T extends inferProcedures<TProcedures>["subscriptions"]["key"][0]> = inferProcedureInput<inferProcedures<TProcedures>, "subscriptions", T>;
inferSubscriptionResult
declare type inferSubscriptionResult<TProcedures extends ProceduresLike, T extends inferProcedures<TProcedures>["subscriptions"]["key"][0]> = inferProcedureResult<inferProcedures<TProcedures>, "subscriptions", T>;
MonoTypeOperatorFunction
declare type MonoTypeOperatorFunction<TValue, TError> = OperatorFunction<TValue, TError, TValue, TError>;
OnErrorFunction
declare type OnErrorFunction = (opts: {
error: RSPCError;
type: string;
path: string | undefined;
input: unknown;
ctx: undefined | any;
}) => void;
Operation
/**
* @internal
*/
declare type Operation<TInput = unknown> = {
id: number;
type: "query" | "mutation" | "subscription";
input: TInput;
path: string;
context: OperationContext;
};
@internal
OperationContext
/** * @internal */ declare type OperationContext = Record<string, unknown>;
@internal
OperationLink
/**
* @internal
*/
declare type OperationLink<TRouter extends AnyRouter, TInput = unknown, TOutput = unknown> = (opts: {
op: Operation<TInput>;
next: (op: Operation<TInput>) => OperationResultObservable<TRouter, TOutput>;
}) => OperationResultObservable<TRouter, TOutput>;
// Referenced local context (not public exports):
declare type AnyRouter = any;
@internal
OperationResultObservable
/** * @internal */ declare type OperationResultObservable<TRouter extends AnyRouter, TOutput> = Observable<OperationResultEnvelope<TOutput>, RSPCError>; // Referenced local context (not public exports): declare type AnyRouter = any;
@internal
OperationResultObserver
/** * @internal */ declare type OperationResultObserver<TRouter extends AnyRouter, TOutput> = Observer<OperationResultEnvelope<TOutput>, RSPCError>; // Referenced local context (not public exports): declare type AnyRouter = any;
@internal
OperationType
declare type OperationType = "query" | "mutation" | "subscription" | "subscriptionStop";
OperatorFunction
declare type OperatorFunction<TValueBefore, TErrorBefore, TValueAfter, TErrorAfter> = UnaryFunction<Subscribable<TValueBefore, TErrorBefore>, Subscribable<TValueAfter, TErrorAfter>>;
ProcedureDef
declare type ProcedureDef = {
key: string;
input: any;
result: any;
};
ProceduresDef
/**
* This type represents the Typescript bindings which are generated from the router by Rust.
*
* @internal
*/
declare type ProceduresDef = {
queries: ProcedureDef;
mutations: ProcedureDef;
subscriptions: ProcedureDef;
};
This type represents the Typescript bindings which are generated from the router by Rust. @internal
ProceduresLike
/**
* A type which allows inferring the type of the bindings
*/
declare type ProceduresLike = {
_rspc_def: ProceduresDef;
} | ProceduresDef;
A type which allows inferring the type of the bindings
ProcedureType
declare type ProcedureType = any;
PromiseAndCancel
/**
* @internal
*/
declare type PromiseAndCancel<TValue> = {
promise: Promise<TValue>;
cancel: CancelFn;
};
@internal
TCallbacks
declare type TCallbacks = WSCallbackObserver<ProceduresDef, unknown>;
TeardownLogic
declare type TeardownLogic = Unsubscribable | UnsubscribeFn | void;
TRPCClientOutgoingMessage
declare type TRPCClientOutgoingMessage = any;
TRPCFetch
/** * The default `fetch` implementation has an overloaded signature. By convention this library * only uses the overload taking a string and options object. */ declare type TRPCFetch = (url: string, options?: RequestInit) => Promise<Response>;
The default fetch implementation has an overloaded signature. By convention this library
only uses the overload taking a string and options object.
TRPCLink
/** * @public */ declare type TRPCLink<TRouter extends AnyRouter> = (opts: TRPCClientRuntime) => OperationLink<TRouter>; // Referenced local context (not public exports): declare type AnyRouter = any;
@public
TRPCRequestMessage
declare type TRPCRequestMessage = any;
TRPCResponseMessage
declare type TRPCResponseMessage<A = unknown, B = unknown> = any;
TRPCWebSocketClient
declare type TRPCWebSocketClient = {
close(): void;
request(op: Operation, callbacks: TCallbacks): UnsubscribeFn;
};
UnaryFunction
declare type UnaryFunction<TSource, TReturn> = (source: TSource) => TReturn;
UnsubscribeFn
declare type UnsubscribeFn = () => void;
WSCallbackObserver
declare type WSCallbackObserver<TProcedures extends ProceduresDef, TOutput> = Observer<WSCallbackResult<TProcedures, TOutput>, RSPCError>; // Referenced local context (not public exports): declare type WSCallbackResult<TProcedures extends ProceduresDef, TOutput> = TRPCResponseMessage<TOutput, inferRouterError<TProcedures>>; declare type inferRouterError<A> = any;
Functions
createClient
declare function createClient<TBaseProceduresLike extends ProceduresLike, TQueries extends ProcedureDef = inferProcedures<TBaseProceduresLike>["queries"], TMutations extends ProcedureDef = inferProcedures<TBaseProceduresLike>["mutations"], TSubscriptions extends ProcedureDef = inferProcedures<TBaseProceduresLike>["subscriptions"]>(opts: ClientArgs): {
_rspc_def: {
queries: TQueries;
mutations: TMutations;
subscriptions: TSubscriptions;
};
query: <K extends TQueries["key"] & string>(keyAndInput: [
key: K,
...input: Extract<TQueries, {
key: K;
}>["input"] extends never ? [
] : [
Extract<TQueries, {
key: K;
}>["input"]
]
], opts?: TRPCRequestOptions) => Promise<Extract<TQueries, {
key: K;
}>["result"]>;
mutation: <K_1 extends TMutations["key"] & string>(keyAndInput: [
key: K_1,
...input: Extract<TMutations, {
// … truncated, see the source link
createWSClient
declare function createWSClient(opts: WebSocketClientOptions): {
close: () => void;
request: (op: Operation, callbacks: TCallbacks) => UnsubscribeFn;
getConnection(): WebSocket;
};
getCauseFromUnknown
declare function getCauseFromUnknown(cause: unknown): Error | undefined;
getErrorFromUnknown
declare function getErrorFromUnknown(cause: unknown): Error;
getMessageFromUnkownError
declare function getMessageFromUnkownError(err: unknown, fallback: string): string;
getTRPCErrorFromUnknown
declare function getTRPCErrorFromUnknown(cause: unknown): RSPCError;
httpBatchLink
declare function httpBatchLink<TProcedures extends ProceduresDef>(opts: HttpBatchLinkOptions): TRPCLink<TProcedures>;
httpLink
declare function httpLink<TProcedures extends ProcedureDef>(opts: HTTPLinkOptions): TRPCLink<TProcedures>;
// Referenced local context (not public exports):
interface HTTPLinkOptions {
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
* @link http://trpc.io/docs/v10/header
*/
headers?: HTTPHeaders | (() => HTTPHeaders | Promise<HTTPHeaders>);
}
isObservable
declare function isObservable(x: unknown): x is Observable<unknown, unknown>;
loggerLink
declare function loggerLink<TProcedures extends ProceduresDef = ProceduresDef>(opts?: LoggerLinkOptions<TProcedures>): TRPCLink<TProcedures>;
map
declare function map<TValueBefore, TError, TValueAfter>(project: (value: TValueBefore, index: number) => TValueAfter): OperatorFunction<TValueBefore, TError, TValueAfter, TError>;
observable
declare function observable<TValue, TError = unknown>(subscribe: (observer: Observer<TValue, TError>) => TeardownLogic): Observable<TValue, TError>;
observableToPromise
/** @internal */
declare function observableToPromise<TValue>(observable: Observable<TValue, unknown>): {
promise: Promise<TValue>;
abort: () => void;
};
@internal
share
declare function share<TValue, TError>(_opts?: ShareConfig): MonoTypeOperatorFunction<TValue, TError>;
// Referenced local context (not public exports):
interface ShareConfig {
}
splitLink
declare function splitLink<TProcedures extends ProceduresDef = ProceduresDef>(opts: {
condition: (op: Operation) => boolean;
/**
* The link to execute next if the test function returns `true`.
*/
true: TRPCLink<TProcedures> | TRPCLink<TProcedures>[];
/**
* The link to execute next if the test function returns `false`.
*/
false: TRPCLink<TProcedures> | TRPCLink<TProcedures>[];
}): TRPCLink<TProcedures>;
tap
declare function tap<TValue, TError>(observer: Partial<Observer<TValue, TError>>): MonoTypeOperatorFunction<TValue, TError>;
wsLink
declare function wsLink<TProcedures extends ProceduresDef>(opts: WebSocketLinkOptions): TRPCLink<TProcedures>;
Variables
retryDelay
retryDelay: (attemptIndex: number) => number