chore: nuke some deprecated stuff (#3513)

examples/next-prisma-websockets-starter/src/utils/trpc.ts

@@ -2,7 +2,7 @@ import { httpBatchLink } from '@trpc/client/links/httpBatchLink';
 import { loggerLink } from '@trpc/client/links/loggerLink';
 import { wsLink, createWSClient } from '@trpc/client/links/wsLink';
 import { createTRPCNext } from '@trpc/next';
-import type { inferProcedureOutput } from '@trpc/server';
+import type { inferRouterOutputs } from '@trpc/server';
 import { NextPageContext } from 'next';
 import getConfig from 'next/config';
 import type { AppRouter } from 'server/routers/_app';
@@ -83,8 +83,6 @@ export const trpc = createTRPCNext<AppRouter>({
 // export const transformer = superjson;
 /**
  * This is a helper method to infer the output of a query resolver
- * @example type HelloOutput = inferQueryOutput<'hello'>
+ * @example type HelloOutput = RouterOutputs['hello']
  */
-export type inferQueryOutput<
-  TRouteKey extends keyof AppRouter['_def']['queries'],
-> = inferProcedureOutput<AppRouter['_def']['queries'][TRouteKey]>;
+export type RouterOutputs = inferRouterOutputs<AppRouter>;

packages/react-query/src/ssg/index.ts

@@ -1,4 +1,2 @@
-export { createSSGHelpers } from './ssg';
-export type { CreateSSGHelpersOptions } from './ssg';
 export { createProxySSGHelpers } from './ssgProxy';
 export type { DecoratedProcedureSSGRecord } from './ssgProxy';

packages/react-query/src/ssg/ssgProxy.ts

@@ -3,21 +3,35 @@ import {
   DehydratedState,
   InfiniteData,
   QueryClient,
+  dehydrate,
 } from '@tanstack/react-query';
 import {
   AnyProcedure,
   AnyQueryProcedure,
   AnyRouter,
+  ClientDataTransformerOptions,
   Filter,
   ProtectedIntersection,
+  callProcedure,
   inferHandlerInput,
+  inferRouterContext,
 } from '@trpc/server';
 import {
   createFlatProxy,
   createRecursiveProxy,
   inferTransformedProcedureOutput,
 } from '@trpc/server/shared';
-import { CreateSSGHelpersOptions, createSSGHelpers } from './ssg';
+import { getArrayQueryKey } from '../internals/getArrayQueryKey';
+import { getQueryKey } from '../internals/getQueryKey';
+import { CreateTRPCReactQueryClientConfig, getQueryClient } from '../shared';
+
+interface CreateSSGHelpersOptionsBase<TRouter extends AnyRouter> {
+  router: TRouter;
+  ctx: inferRouterContext<TRouter>;
+  transformer?: ClientDataTransformerOptions;
+}
+export type CreateSSGHelpersOptions<TRouter extends AnyRouter> =
+  CreateSSGHelpersOptionsBase<TRouter> & CreateTRPCReactQueryClientConfig;
 
 type DecorateProcedure<TProcedure extends AnyProcedure> = {
   /**
@@ -66,7 +80,25 @@ type AnyDecoratedProcedure = DecorateProcedure<any>;
 export function createProxySSGHelpers<TRouter extends AnyRouter>(
   opts: CreateSSGHelpersOptions<TRouter>,
 ) {
-  const helpers = createSSGHelpers(opts);
+  const { router, transformer, ctx } = opts;
+  const queryClient = getQueryClient(opts);
+
+  const serialize = transformer
+    ? ('input' in transformer ? transformer.input : transformer).serialize
+    : (obj: unknown) => obj;
+
+  function _dehydrate(
+    opts: DehydrateOptions = {
+      shouldDehydrateQuery() {
+        // makes sure to serialize errors
+        return true;
+      },
+    },
+  ): DehydratedState {
+    const before = dehydrate(queryClient, opts);
+    const after = serialize(before);
+    return after;
+  }
 
   type CreateProxySSGHelpers = ProtectedIntersection<
     {
@@ -77,36 +109,43 @@ export function createProxySSGHelpers<TRouter extends AnyRouter>(
   >;
 
   return createFlatProxy<CreateProxySSGHelpers>((key) => {
-    if (key === 'queryClient') {
-      return helpers.queryClient;
-    }
+    if (key === 'queryClient') return queryClient;
+    if (key === 'dehydrate') return _dehydrate;
 
-    if (key === 'dehydrate') {
-      return helpers.dehydrate;
-    }
     return createRecursiveProxy((opts) => {
       const args = opts.args;
-
+      const input = args[0];
       const pathCopy = [key, ...opts.path];
-
       const utilName = pathCopy.pop() as keyof AnyDecoratedProcedure;
-
       const fullPath = pathCopy.join('.');
 
-      switch (utilName) {
-        case 'fetch': {
-          return helpers.fetchQuery(fullPath, ...(args as any));
-        }
-        case 'fetchInfinite': {
-          return helpers.fetchInfiniteQuery(fullPath, ...(args as any));
-        }
-        case 'prefetch': {
-          return helpers.prefetchQuery(fullPath, ...(args as any));
-        }
-        case 'prefetchInfinite': {
-          return helpers.prefetchInfiniteQuery(fullPath, ...(args as any));
-        }
-      }
+      const _callProcedure = () =>
+        callProcedure({
+          procedures: router._def.procedures,
+          path: fullPath,
+          rawInput: input,
+          ctx,
+          type: 'query',
+        });
+
+      // TODO: Come back when we have sorted out all the querykey stuff
+      const queryKey = getArrayQueryKey(
+        getQueryKey(fullPath, input),
+        ['fetchInfinite', 'prefetchInfinite'].includes(utilName)
+          ? 'infinite'
+          : 'query',
+      );
+
+      const helperMap: Record<keyof AnyDecoratedProcedure, () => unknown> = {
+        fetch: () => queryClient.fetchQuery(queryKey, _callProcedure),
+        fetchInfinite: () =>
+          queryClient.fetchInfiniteQuery(queryKey, _callProcedure),
+        prefetch: () => queryClient.prefetchQuery(queryKey, _callProcedure),
+        prefetchInfinite: () =>
+          queryClient.prefetchInfiniteQuery(queryKey, _callProcedure),
+      };
+
+      return helperMap[utilName]();
     });
   });
 }

packages/server/src/core/internals/procedureBuilder.ts

@@ -386,7 +386,6 @@ function createProcedureCaller(_def: AnyProcedureBuilderDef): AnyProcedure {
     return result.data;
   };
   procedure._def = _def;
-  procedure.meta = _def.meta;
 
   return procedure as AnyProcedure;
 }

packages/server/src/core/procedure.ts

@@ -79,10 +79,6 @@ export interface Procedure<
 > {
   _type: TType;
   _def: TParams & ProcedureBuilderDef<TParams>;
-  /**
-   * @deprecated use `._def.meta` instead
-   */
-  meta?: TParams['_meta'];
   _procedure: true;
   /**
    * @internal