switchLink | tRPC

switchLink({ name, links, pick }) sends each call down one of several named branches. pick chooses the branch for a call, and name becomes a typed call option, so one call can override pick:

const const client: TrpcClient<{
    report: BuildProcedure<RootDef<Context, {}>, "query", {
        output: {
            views: number;
        };
        errors: never;
        services: never;
        unmapped: never;
    }>;
}, {
    transport?: "http" | "ws" | undefined;
}, undefined, LinksTypes<readonly [TrpcLink<SwitchLinkDecl<"transport", {
    readonly http: TrpcLink<HttpLinkDecl<{
        url: string;
        batch: true;
    }>, any>;
    readonly ws: SocketLink<{
        form: JsonForm;
    }>;
}>, {
    report: BuildProcedure<RootDef<Context, {}>, "query", {
        output: {
            views: number;
        };
        errors: never;
        services: never;
        unmapped: never;
    }>;
}>]>>client = createTrpcClient<RouterType<{
    report: BuildProcedure<RootDef<Context, {}>, "query", {
        output: {
            views: number;
        };
        errors: never;
        services: never;
        unmapped: never;
    }>;
}>, readonly [TrpcLink<SwitchLinkDecl<"transport", {
    readonly http: TrpcLink<HttpLinkDecl<{
        url: string;
        batch: true;
    }>, any>;
    readonly ws: SocketLink<{
        form: JsonForm;
    }>;
}>, {
    report: BuildProcedure<RootDef<Context, {}>, "query", {
        output: {
            views: number;
        };
        errors: never;
        services: never;
        unmapped: never;
    }>;
}>]>(opts: TypedClientOptions<...>): TrpcClient<...>createTrpcClient({
  TypedClientOptions<RouterType<{ report: BuildProcedure<RootDef<Context, {}>, "query", { output: { views: number; }; errors: never; services: never; unmapped: never; }>; }>, readonly [...]>.router: RouterType<{
    report: BuildProcedure<RootDef<Context, {}>, "query", {
        output: {
            views: number;
        };
        errors: never;
        services: never;
        unmapped: never;
    }>;
}>router: routerType<{
    report: BuildProcedure<RootDef<Context, {}>, "query", {
        output: {
            views: number;
        };
        errors: never;
        services: never;
        unmapped: never;
    }>;
}>(): RouterType<{
    report: BuildProcedure<RootDef<Context, {}>, "query", {
        output: {
            views: number;
        };
        errors: never;
        services: never;
        unmapped: never;
    }>;
}>routerType<type AppRouter = {
    report: BuildProcedure<RootDef<Context, {}>, "query", {
        output: {
            views: number;
        };
        errors: never;
        services: never;
        unmapped: never;
    }>;
}AppRouter>(),
  TypedClientOptions<RouterType<{ report: BuildProcedure<RootDef<Context, {}>, "query", { output: { views: number; }; errors: never; services: never; unmapped: never; }>; }>, readonly [...]>.links: readonly [TrpcLink<SwitchLinkDecl<"transport", {
    readonly http: TrpcLink<HttpLinkDecl<{
        url: string;
        batch: true;
    }>, any>;
    readonly ws: SocketLink<{
        form: JsonForm;
    }>;
}>, {
    report: BuildProcedure<RootDef<Context, {}>, "query", {
        output: {
            views: number;
        };
        errors: never;
        services: never;
        unmapped: never;
    }>;
}>]links: [
    switchLink<"transport", {
    readonly http: TrpcLink<HttpLinkDecl<{
        url: string;
        batch: true;
    }>, any>;
    readonly ws: SocketLink<{
        form: JsonForm;
    }>;
}, {
    report: BuildProcedure<RootDef<Context, {}>, "query", {
        output: {
            views: number;
        };
        errors: never;
        services: never;
        unmapped: never;
    }>;
}>(opts: SwitchLinkOptions<"transport", {
    readonly http: TrpcLink<HttpLinkDecl<{
        url: string;
        batch: true;
    }>, any>;
    readonly ws: SocketLink<{
        form: JsonForm;
    }>;
}, {
    report: BuildProcedure<RootDef<Context, {}>, "query", {
        output: {
            views: number;
        };
        errors: never;
        services: never;
        unmapped: never;
    }>;
}>): TrpcLink<...>switchLink({
      SwitchLinkOptions<"transport", { readonly http: TrpcLink<HttpLinkDecl<{ url: string; batch: true; }>, any>; readonly ws: SocketLink<{ form: JsonForm; }>; }, { report: BuildProcedure<RootDef<Context, {}>, "query", { output: { views: number; }; errors: never; services: never; unmapped: never; }>; }>.name: "transport"name: 'transport',
      SwitchLinkOptions<"transport", { readonly http: TrpcLink<HttpLinkDecl<{ url: string; batch: true; }>, any>; readonly ws: SocketLink<{ form: JsonForm; }>; }, { report: BuildProcedure<RootDef<Context, {}>, "query", { output: { views: number; }; errors: never; services: never; unmapped: never; }>; }>.links: {
    readonly http: TrpcLink<HttpLinkDecl<{
        url: string;
        batch: true;
    }>, any>;
    readonly ws: SocketLink<{
        form: JsonForm;
    }>;
}links: {
        http: TrpcLink<HttpLinkDecl<{
    url: string;
    batch: true;
}>, any>http: httpLink<{
    url: string;
    batch: true;
}>(opts: {
    url: string;
    batch: true;
}): TrpcLink<HttpLinkDecl<{
    url: string;
    batch: true;
}>, any>httpLink({ url: stringurl, batch: truebatch: true }),
        ws: SocketLink<{
    form: JsonForm;
}>ws: wsLink<{
    url: string;
}>(opts: {
    url: string;
}): SocketLink<{
    form: JsonForm;
}>wsLink({ url: stringurl: const wsUrl: stringwsUrl }),
      },
      SwitchLinkOptions<"transport", { readonly http: TrpcLink<HttpLinkDecl<{ url: string; batch: true; }>, any>; readonly ws: SocketLink<{ form: JsonForm; }>; }, { report: BuildProcedure<RootDef<Context, {}>, "query", { output: { views: number; }; errors: never; services: never; unmapped: never; }>; }>.pick: (op: Operation<{}> & {
    readonly path: "report";
}) => "http" | "ws"pick: (op: Operation<{}> & {
    readonly path: "report";
}op) => (op: Operation<{}> & {
    readonly path: "report";
}op.Operation<{}>.type: ProcedureTypetype === 'subscription' ? 'ws' : 'http'),
    }),
  ],
});
await const client: TrpcClient<{
    report: BuildProcedure<RootDef<Context, {}>, "query", {
        output: {
            views: number;
        };
        errors: never;
        services: never;
        unmapped: never;
    }>;
}, {
    transport?: "http" | "ws" | undefined;
}, undefined, LinksTypes<readonly [TrpcLink<SwitchLinkDecl<"transport", {
    readonly http: TrpcLink<HttpLinkDecl<{
        url: string;
        batch: true;
    }>, any>;
    readonly ws: SocketLink<{
        form: JsonForm;
    }>;
}>, {
    report: BuildProcedure<RootDef<Context, {}>, "query", {
        output: {
            views: number;
        };
        errors: never;
        services: never;
        unmapped: never;
    }>;
}>]>>client.report: {
    query(input?: undefined, opts?: CallOptions<{
        transport?: "http" | "ws" | undefined;
    }> | undefined): TrpcPromise<{
        views: number;
    }, UnexpectedError>;
}report.function query(input?: undefined, opts?: CallOptions<{
    transport?: "http" | "ws" | undefined;
}> | undefined): TrpcPromise<{
    views: number;
}, UnexpectedError>query(const input: undefinedinput, { transport?: "http" | "ws" | undefinedtransport: 'http' });

A branch can be a chain (an array of links), including another switchLink. On a client made with router:, pick sees typed paths.

The name can't be signal, lastEventId, init, headers or reconnect, and two switch links on one chain can't share a name; both are type errors and throw when the link is made.

Like splitLink, calls get the call options and errors of every branch's links (Custom links).