@trpc/client 11.0.0-next-beta.248 → 11.0.0-next-beta.285

package/src/links/internals/httpUtils.ts

@@ -1,4 +1,6 @@
 import type {
+  AnyRootTypes,
+  CombinedDataTransformer,
   ProcedureType,
   TRPCResponse,
 } from '@trpc/server/unstable-core-do-not-import';
@@ -12,17 +14,17 @@ import type {
   ResponseEsque,
 } from '../../internals/types';
 import { TRPCClientError } from '../../TRPCClientError';
+import type { TransformerOptions } from '../../unstable-internals';
+import { getTransformer } from '../../unstable-internals';
 import type { TextDecoderEsque } from '../internals/streamingUtils';
-import type {
-  HTTPHeaders,
-  PromiseAndCancel,
-  TRPCClientRuntime,
-} from '../types';
+import type { HTTPHeaders, PromiseAndCancel } from '../types';
 
 /**
  * @internal
  */
-export interface HTTPLinkBaseOptions {
+export type HTTPLinkBaseOptions<
+  TRoot extends Pick<AnyRootTypes, 'transformer'>,
+> = {
   url: string | URL;
   /**
    * Add ponyfill for fetch
@@ -32,21 +34,23 @@ export interface HTTPLinkBaseOptions {
    * Add ponyfill for AbortController
    */
   AbortController?: AbortControllerEsque | null;
-}
+} & TransformerOptions<TRoot>;
 
 export interface ResolvedHTTPLinkOptions {
   url: string;
   fetch?: FetchEsque;
   AbortController: AbortControllerEsque | null;
+  transformer: CombinedDataTransformer;
 }
 
 export function resolveHTTPLinkOptions(
-  opts: HTTPLinkBaseOptions,
+  opts: HTTPLinkBaseOptions<AnyRootTypes>,
 ): ResolvedHTTPLinkOptions {
   return {
     url: opts.url.toString().replace(/\/$/, ''), // Remove any trailing slashes
     fetch: opts.fetch,
     AbortController: getAbortController(opts.AbortController),
+    transformer: getTransformer(opts.transformer),
   };
 }
 
@@ -74,14 +78,14 @@ export interface HTTPResult {
 }
 
 type GetInputOptions = {
-  runtime: TRPCClientRuntime;
+  transformer: CombinedDataTransformer;
 } & ({ input: unknown } | { inputs: unknown[] });
 
 function getInput(opts: GetInputOptions) {
   return 'input' in opts
-    ? opts.runtime.transformer.serialize(opts.input)
+    ? opts.transformer.input.serialize(opts.input)
     : arrayToDict(
-        opts.inputs.map((_input) => opts.runtime.transformer.serialize(_input)),
+        opts.inputs.map((_input) => opts.transformer.input.serialize(_input)),
       );
 }
 

package/src/links/types.ts

@@ -1,8 +1,6 @@
 import type { Observable, Observer } from '@trpc/server/observable';
 import type {
-  AnyRouter,
-  CombinedDataTransformer,
-  DataTransformer,
+  TRPCInferrable,
   TRPCResultMessage,
   TRPCSuccessResponse,
 } from '@trpc/server/unstable-core-do-not-import';
@@ -59,9 +57,7 @@ export type TRPCFetch = (
 ) => Promise<ResponseEsque>;
 
 export interface TRPCClientRuntime {
-  transformer: DataTransformer;
-  // FIXME: we should be able to remove this - added as `withTRPC()` needs it, but we can have it as an extra option on SSR instead
-  combinedTransformer: CombinedDataTransformer;
+  // nothing here anymore
 }
 
 /**
@@ -78,33 +74,35 @@ export interface OperationResultEnvelope<TOutput> {
  * @internal
  */
 export type OperationResultObservable<
-  TRouter extends AnyRouter,
+  TInferrable extends TRPCInferrable,
   TOutput,
-> = Observable<OperationResultEnvelope<TOutput>, TRPCClientError<TRouter>>;
+> = Observable<OperationResultEnvelope<TOutput>, TRPCClientError<TInferrable>>;
 
 /**
  * @internal
  */
 export type OperationResultObserver<
-  TRouter extends AnyRouter,
+  TInferrable extends TRPCInferrable,
   TOutput,
-> = Observer<OperationResultEnvelope<TOutput>, TRPCClientError<TRouter>>;
+> = Observer<OperationResultEnvelope<TOutput>, TRPCClientError<TInferrable>>;
 
 /**
  * @internal
  */
 export type OperationLink<
-  TRouter extends AnyRouter,
+  TInferrable extends TRPCInferrable,
   TInput = unknown,
   TOutput = unknown,
 > = (opts: {
   op: Operation<TInput>;
-  next: (op: Operation<TInput>) => OperationResultObservable<TRouter, TOutput>;
-}) => OperationResultObservable<TRouter, TOutput>;
+  next: (
+    op: Operation<TInput>,
+  ) => OperationResultObservable<TInferrable, TOutput>;
+}) => OperationResultObservable<TInferrable, TOutput>;
 
 /**
  * @public
  */
-export type TRPCLink<TRouter extends AnyRouter> = (
+export type TRPCLink<TInferrable extends TRPCInferrable> = (
   opts: TRPCClientRuntime,
-) => OperationLink<TRouter>;
+) => OperationLink<TInferrable>;

package/src/links/wsLink.ts

@@ -2,6 +2,7 @@ import type { Observer, UnsubscribeFn } from '@trpc/server/observable';
 import { observable } from '@trpc/server/observable';
 import type {
   AnyRouter,
+  inferRootTypes,
   inferRouterError,
   MaybePromise,
   ProcedureType,
@@ -13,6 +14,8 @@ import type {
 } from '@trpc/server/unstable-core-do-not-import';
 import { transformResult } from '@trpc/server/unstable-core-do-not-import';
 import { TRPCClientError } from '../TRPCClientError';
+import type { TransformerOptions } from '../unstable-internals';
+import { getTransformer } from '../unstable-internals';
 import type { Operation, TRPCLink } from './types';
 
 const run = <TResult>(fn: () => TResult): TResult => fn();
@@ -429,9 +432,9 @@ export function createWSClient(opts: WebSocketClientOptions) {
 }
 export type TRPCWebSocketClient = ReturnType<typeof createWSClient>;
 
-export interface WebSocketLinkOptions {
+export type WebSocketLinkOptions<TRouter extends AnyRouter> = {
   client: TRPCWebSocketClient;
-}
+} & TransformerOptions<inferRootTypes<TRouter>>;
 class TRPCWebSocketClosedError extends Error {
   constructor(message: string) {
     super(message);
@@ -444,15 +447,16 @@ class TRPCWebSocketClosedError extends Error {
  * @link https://trpc.io/docs/v11/client/links/wsLink
  */
 export function wsLink<TRouter extends AnyRouter>(
-  opts: WebSocketLinkOptions,
+  opts: WebSocketLinkOptions<TRouter>,
 ): TRPCLink<TRouter> {
-  return (runtime) => {
+  const transformer = getTransformer(opts.transformer);
+  return () => {
     const { client } = opts;
     return ({ op }) => {
       return observable((observer) => {
         const { type, path, id, context } = op;
 
-        const input = runtime.transformer.serialize(op.input);
+        const input = transformer.input.serialize(op.input);
 
         const unsub = client.request(
           { type, path, input, id, context },
@@ -465,7 +469,7 @@ export function wsLink<TRouter extends AnyRouter>(
               observer.complete();
             },
             next(message) {
-              const transformed = transformResult(message, runtime.transformer);
+              const transformed = transformResult(message, transformer.output);
 
               if (!transformed.ok) {
                 observer.error(TRPCClientError.from(transformed.error));

package/src/unstable-internals.ts

@@ -0,0 +1,67 @@
+import type {
+  AnyRootTypes,
+  CombinedDataTransformer,
+  DataTransformerOptions,
+  TypeError,
+} from '@trpc/server/unstable-core-do-not-import';
+
+export type CoercedTransformerParameters = {
+  transformer?: DataTransformerOptions;
+};
+
+type TransformerOptionYes = {
+  /**
+   * Data transformer
+   *
+   * You must use the same transformer on the backend and frontend
+   * @link https://trpc.io/docs/v11/data-transformers
+   **/
+  transformer: DataTransformerOptions;
+};
+type TransformerOptionNo = {
+  /**
+   * Data transformer
+   *
+   * You must use the same transformer on the backend and frontend
+   * @link https://trpc.io/docs/v11/data-transformers
+   **/
+  transformer?: TypeError<'You must define a transformer on your your `initTRPC`-object first'>;
+};
+
+export type TransformerOptions<
+  TRoot extends Pick<AnyRootTypes, 'transformer'>,
+> = TRoot['transformer'] extends true
+  ? TransformerOptionYes
+  : TransformerOptionNo;
+/**
+ * @internal
+ */
+
+export function getTransformer(
+  transformer:
+    | TransformerOptions<{ transformer: false }>['transformer']
+    | TransformerOptions<{ transformer: true }>['transformer']
+    | undefined,
+): CombinedDataTransformer {
+  const _transformer =
+    transformer as CoercedTransformerParameters['transformer'];
+  if (!_transformer) {
+    return {
+      input: {
+        serialize: (data) => data,
+        deserialize: (data) => data,
+      },
+      output: {
+        serialize: (data) => data,
+        deserialize: (data) => data,
+      },
+    };
+  }
+  if ('input' in _transformer) {
+    return _transformer;
+  }
+  return {
+    input: _transformer,
+    output: _transformer,
+  };
+}

package/unstable-internals/index.d.ts

@@ -0,0 +1 @@
+export * from '../dist/unstable-internals';

package/unstable-internals/index.js

@@ -0,0 +1 @@
+module.exports = require('../dist/unstable-internals');