@trpc/server 11.0.0-next.323 → 11.0.0-next.325

package/src/adapters/next-app-dir/nextAppDirCaller.ts

@@ -0,0 +1,120 @@
+import { getTRPCErrorFromUnknown, TRPCError } from '../../@trpc/server';
+// FIXME: fix lint rule, this is ok
+// eslint-disable-next-line no-restricted-imports
+import type { ErrorHandlerOptions } from '../../unstable-core-do-not-import/procedure';
+// FIXME: fix lint rule, this is ok
+// eslint-disable-next-line no-restricted-imports
+import type { CallerOverride } from '../../unstable-core-do-not-import/procedureBuilder';
+// FIXME: fix lint rule, this is ok
+// eslint-disable-next-line no-restricted-imports
+import type {
+  MaybePromise,
+  Simplify,
+} from '../../unstable-core-do-not-import/types';
+import { formDataToObject } from './formDataToObject';
+import { rethrowNextErrors } from './rethrowNextErrors';
+
+type ContextCallback<TContext> = object extends TContext
+  ? {
+      createContext?: () => MaybePromise<TContext>;
+    }
+  : {
+      createContext: () => MaybePromise<TContext>;
+    };
+
+/**
+ * Create a caller that works with Next.js React Server Components & Server Actions
+ */
+export function nextAppDirCaller<TContext>(
+  config: Simplify<
+    {
+      /**
+       * Transform form data to a `Record` before passing it to the procedure
+       * @default true
+       */
+      normalizeFormData?: boolean;
+      /**
+       * Called when an error occurs in the handler
+       */
+      onError?: (opts: ErrorHandlerOptions<TContext>) => void;
+    } & ContextCallback<TContext>
+  >,
+): CallerOverride<TContext> {
+  const {
+    normalizeFormData = true,
+
+    // rethrowNextErrors = true
+  } = config;
+  const createContext = async (): Promise<TContext> => {
+    return config?.createContext?.() ?? ({} as TContext);
+  };
+  return async (opts) => {
+    const ctx: TContext = await createContext().catch((cause) => {
+      const error = new TRPCError({
+        code: 'INTERNAL_SERVER_ERROR',
+        message: 'Failed to create context',
+        cause,
+      });
+
+      throw error;
+    });
+
+    const handleError = (cause: unknown) => {
+      const error = getTRPCErrorFromUnknown(cause);
+
+      config.onError?.({
+        ctx,
+        error,
+        input: opts.args[0],
+        path: '',
+        type: opts._def.type,
+      });
+
+      rethrowNextErrors(error);
+
+      throw error;
+    };
+    switch (opts._def.type) {
+      case 'mutation': {
+        /**
+         * When you wrap an action with useFormState, it gets an extra argument as its first argument.
+         * The submitted form data is therefore its second argument instead of its first as it would usually be.
+         * The new first argument that gets added is the current state of the form.
+         * @see https://react.dev/reference/react-dom/hooks/useFormState#my-action-can-no-longer-read-the-submitted-form-data
+         */
+        let input = opts.args.length === 1 ? opts.args[0] : opts.args[1];
+        if (normalizeFormData && input instanceof FormData) {
+          input = formDataToObject(input);
+        }
+
+        return await opts
+          .invoke({
+            type: opts._def.type,
+            ctx,
+            getRawInput: async () => input,
+            path: '',
+            input,
+          })
+          .catch(handleError);
+      }
+      case 'query': {
+        const input = opts.args[0];
+        return await opts
+          .invoke({
+            type: opts._def.type,
+            ctx,
+            getRawInput: async () => input,
+            path: '',
+            input,
+          })
+          .catch(handleError);
+      }
+      default: {
+        throw new TRPCError({
+          code: 'NOT_IMPLEMENTED',
+          message: `Not implemented for type ${opts._def.type}`,
+        });
+      }
+    }
+  };
+}

package/src/adapters/next-app-dir/notFound.ts

@@ -0,0 +1,12 @@
+import type { notFound as __notFound } from 'next/navigation';
+import { TRPCError } from '../../@trpc/server';
+
+/**
+ * Like `next/navigation`'s `notFound()` but throws a `TRPCError` that later will be handled by Next.js
+ * @public
+ */
+export const notFound: typeof __notFound = () => {
+  throw new TRPCError({
+    code: 'NOT_FOUND',
+  });
+};

package/src/adapters/next-app-dir/redirect.ts

@@ -0,0 +1,27 @@
+import type { redirect as __redirect } from 'next/navigation';
+import { TRPCError } from '../../@trpc/server';
+
+/**
+ * @internal
+ */
+export class TRPCRedirectError extends TRPCError {
+  public readonly args;
+  constructor(...args: Parameters<typeof __redirect>) {
+    const [url] = args;
+    super({
+      // TODO(?): This should maybe a custom error code
+      code: 'UNPROCESSABLE_CONTENT',
+      message: `Redirect error to "${url}" that will be handled by Next.js`,
+    });
+
+    this.args = args;
+  }
+}
+
+/**
+ * Like `next/navigation`'s `redirect()` but throws a `TRPCError` that later will be handled by Next.js
+ * @public
+ */
+export const redirect: typeof __redirect = (...args) => {
+  throw new TRPCRedirectError(...args);
+};

package/src/adapters/next-app-dir/rethrowNextErrors.ts

@@ -0,0 +1,25 @@
+import { isNotFoundError } from 'next/dist/client/components/not-found';
+import { isRedirectError } from 'next/dist/client/components/redirect';
+import {
+  notFound as __notFound,
+  redirect as __redirect,
+} from 'next/navigation';
+import type { TRPCError } from '../../@trpc/server';
+import { TRPCRedirectError } from './redirect';
+
+/**
+ * Rethrow errors that should be handled by Next.js
+ */
+
+export const rethrowNextErrors = (error: TRPCError) => {
+  if (error.code === 'NOT_FOUND') {
+    __notFound();
+  }
+  if (error instanceof TRPCRedirectError) {
+    __redirect(...error.args);
+  }
+  const { cause } = error;
+  if (isRedirectError(cause) || isNotFoundError(cause)) {
+    throw error.cause;
+  }
+};

package/src/adapters/next-app-dir.ts

@@ -0,0 +1,3 @@
+export { nextAppDirCaller as experimental_nextAppDirCaller } from './next-app-dir/nextAppDirCaller';
+export { redirect as experimental_redirect } from './next-app-dir/redirect';
+export { notFound as experimental_notFound } from './next-app-dir/notFound';

package/src/unstable-core-do-not-import/clientish/inference.ts

@@ -1,5 +1,9 @@
 import type { inferObservableValue } from '../../observable';
-import type { AnyProcedure, inferProcedureInput } from '../procedure';
+import type {
+  AnyProcedure,
+  inferProcedureInput,
+  inferProcedureOutput,
+} from '../procedure';
 import type { AnyRouter, RouterRecord } from '../router';
 import type {
   AnyClientTypes,
@@ -16,16 +20,16 @@ export type inferTransformedProcedureOutput<
   TInferrable extends InferrableClientTypes,
   TProcedure extends AnyProcedure,
 > = inferClientTypes<TInferrable>['transformer'] extends false
-  ? Serialize<TProcedure['_def']['_output_out']>
-  : TProcedure['_def']['_output_out'];
+  ? Serialize<inferProcedureOutput<TProcedure>>
+  : inferProcedureOutput<TProcedure>;
 /** @internal */
 
 export type inferTransformedSubscriptionOutput<
   TInferrable extends InferrableClientTypes,
   TProcedure extends AnyProcedure,
 > = inferClientTypes<TInferrable>['transformer'] extends false
-  ? Serialize<inferObservableValue<TProcedure['_def']['_output_out']>>
-  : inferObservableValue<TProcedure['_def']['_output_out']>;
+  ? Serialize<inferObservableValue<inferProcedureOutput<TProcedure>>>
+  : inferObservableValue<inferProcedureOutput<TProcedure>>;
 
 export type GetInferenceHelpers<
   TType extends 'input' | 'output',

package/src/unstable-core-do-not-import/initTRPC.ts

@@ -1,4 +1,3 @@
-import { createFlatProxy } from './createProxy';
 import {
   defaultFormatter,
   type DefaultErrorShape,
@@ -16,6 +15,7 @@ import {
 import type { DataTransformerOptions } from './transformer';
 import { defaultTransformer, getDataTransformer } from './transformer';
 import type { Unwrap, ValidateShape } from './types';
+import { $typesProxy } from './utils';
 
 type inferErrorFormatterShape<TType> = TType extends ErrorFormatter<
   any,
@@ -95,11 +95,7 @@ class TRPCBuilder<TContext extends object, TMeta extends object> {
        * These are just types, they can't be used at runtime
        * @internal
        */
-      $types: createFlatProxy((key) => {
-        throw new Error(
-          `Tried to access "$types.${key}" which is not available at runtime`,
-        );
-      }),
+      $types: $typesProxy,
     };
 
     {

package/src/unstable-core-do-not-import/procedure.ts

@@ -23,7 +23,6 @@ export interface ProcedureOptions {
 interface BuiltProcedureDef {
   input: unknown;
   output: unknown;
-  experimental_caller?: true;
 }
 
 /**
@@ -35,8 +34,10 @@ export interface Procedure<
   TDef extends BuiltProcedureDef,
 > {
   _def: {
-    _input_in: TDef['input'];
-    _output_out: TDef['output'];
+    $types: {
+      input: TDef['input'];
+      output: TDef['output'];
+    };
     procedure: true;
     type: TType;
     /**
@@ -44,17 +45,12 @@ export interface Procedure<
      * Meta is not inferrable on individual procedures, only on the router
      */
     meta: unknown;
+    experimental_caller: boolean;
   };
   /**
    * @internal
    */
-  (
-    opts: TDef['experimental_caller'] extends true
-      ? TDef['input']
-      : ProcedureCallOptions,
-  ): Promise<
-    TDef['experimental_caller'] extends true ? TDef['output'] : unknown
-  >;
+  (opts: ProcedureCallOptions<unknown>): Promise<TDef['output']>;
 }
 
 export interface QueryProcedure<TDef extends BuiltProcedureDef>
@@ -72,15 +68,15 @@ export type AnySubscriptionProcedure = SubscriptionProcedure<any>;
 export type AnyProcedure = Procedure<ProcedureType, any>;
 
 export type inferProcedureInput<TProcedure extends AnyProcedure> =
-  undefined extends inferProcedureParams<TProcedure>['_input_in']
-    ? void | inferProcedureParams<TProcedure>['_input_in']
-    : inferProcedureParams<TProcedure>['_input_in'];
+  undefined extends inferProcedureParams<TProcedure>['$types']['input']
+    ? void | inferProcedureParams<TProcedure>['$types']['input']
+    : inferProcedureParams<TProcedure>['$types']['input'];
 
 export type inferProcedureParams<TProcedure> = TProcedure extends AnyProcedure
   ? TProcedure['_def']
   : never;
 export type inferProcedureOutput<TProcedure> =
-  inferProcedureParams<TProcedure>['_output_out'];
+  inferProcedureParams<TProcedure>['$types']['output'];
 
 /**
  * @internal

package/src/unstable-core-do-not-import/procedureBuilder.ts

@@ -30,7 +30,7 @@ import type {
   Simplify,
   TypeError,
 } from './types';
-import { mergeWithoutOverrides } from './utils';
+import { $typesProxy, mergeWithoutOverrides } from './utils';
 
 type IntersectIfDefined<TType, TWith> = TType extends UnsetMarker
   ? TWith
@@ -45,9 +45,9 @@ type DefaultValue<TValue, TFallback> = TValue extends UnsetMarker
   ? TFallback
   : TValue;
 
-export type CallerOverride = (opts: {
+export type CallerOverride<TContext> = (opts: {
   args: unknown[];
-  invoke: (opts: ProcedureCallOptions) => Promise<unknown>;
+  invoke: (opts: ProcedureCallOptions<TContext>) => Promise<unknown>;
   _def: AnyProcedure['_def'];
 }) => Promise<unknown>;
 type ProcedureBuilderDef<TMeta> = {
@@ -70,7 +70,7 @@ type ProcedureBuilderDef<TMeta> = {
    */
   subscription?: boolean;
   type?: ProcedureType;
-  caller?: CallerOverride;
+  caller?: CallerOverride<unknown>;
 };
 
 type AnyProcedureBuilderDef = ProcedureBuilderDef<any>;
@@ -301,18 +301,14 @@ export interface ProcedureBuilder<
       TOutputIn,
       $Output
     >,
-  ): QueryProcedure<
-    TCaller extends true
-      ? {
-          experimental_caller: true;
-          input: DefaultValue<TInputIn, void>;
-          output: DefaultValue<TOutputOut, $Output>;
-        }
-      : {
-          input: DefaultValue<TInputIn, void>;
-          output: DefaultValue<TOutputOut, $Output>;
-        }
-  >;
+  ): TCaller extends true
+    ? (
+        input: DefaultValue<TInputIn, void>,
+      ) => Promise<DefaultValue<TOutputOut, $Output>>
+    : QueryProcedure<{
+        input: DefaultValue<TInputIn, void>;
+        output: DefaultValue<TOutputOut, $Output>;
+      }>;
 
   /**
    * Mutation procedure
@@ -327,18 +323,14 @@ export interface ProcedureBuilder<
       TOutputIn,
       $Output
     >,
-  ): MutationProcedure<
-    TCaller extends true
-      ? {
-          experimental_caller: true;
-          input: DefaultValue<TInputIn, void>;
-          output: DefaultValue<TOutputOut, $Output>;
-        }
-      : {
-          input: DefaultValue<TInputIn, void>;
-          output: DefaultValue<TOutputOut, $Output>;
-        }
-  >;
+  ): TCaller extends true
+    ? (
+        input: DefaultValue<TInputIn, void>,
+      ) => Promise<DefaultValue<TOutputOut, $Output>>
+    : MutationProcedure<{
+        input: DefaultValue<TInputIn, void>;
+        output: DefaultValue<TOutputOut, $Output>;
+      }>;
 
   /**
    * Subscription procedure
@@ -353,25 +345,19 @@ export interface ProcedureBuilder<
       TOutputIn,
       $Output
     >,
-  ): SubscriptionProcedure<
-    TCaller extends true
-      ? {
-          experimental_caller: true;
-          input: DefaultValue<TInputIn, void>;
-          output: DefaultValue<TOutputOut, inferObservableValue<$Output>>;
-        }
-      : {
-          input: DefaultValue<TInputIn, void>;
-          output: DefaultValue<TOutputOut, inferObservableValue<$Output>>;
-        }
-  >;
+  ): TCaller extends true
+    ? TypeError<'Not implemented'>
+    : SubscriptionProcedure<{
+        input: DefaultValue<TInputIn, void>;
+        output: DefaultValue<TOutputOut, inferObservableValue<$Output>>;
+      }>;
 
   /**
    * Overrides the way a procedure is invoked
    * Do not use this unless you know what you're doing - this is an experimental API
    */
   experimental_caller(
-    caller: CallerOverride,
+    caller: CallerOverride<TContext>,
   ): ProcedureBuilder<
     TContext,
     TMeta,
@@ -490,11 +476,10 @@ export function createBuilder<TContext, TMeta>(
 }
 
 function createResolver(
-  _def: AnyProcedureBuilderDef & { type: ProcedureType },
+  _defIn: AnyProcedureBuilderDef & { type: ProcedureType },
   resolver: AnyResolver,
 ) {
-  const finalBuilder = createNewBuilder(_def, {
-    type: _def.type,
+  const finalBuilder = createNewBuilder(_defIn, {
     resolver,
     middlewares: [
       async function resolveMiddleware(opts) {
@@ -508,28 +493,36 @@ function createResolver(
       },
     ],
   });
+  const _def: AnyProcedure['_def'] = {
+    ...finalBuilder._def,
+    type: _defIn.type,
+    experimental_caller: Boolean(finalBuilder._def.caller),
+    meta: finalBuilder._def.meta,
+    $types: $typesProxy,
+  };
+
   const invoke = createProcedureCaller(finalBuilder._def);
   const callerOverride = finalBuilder._def.caller;
   if (!callerOverride) {
     return invoke;
   }
-  const callerWrapper = (...args: unknown[]) => {
-    return callerOverride({
+  const callerWrapper = async (...args: unknown[]) => {
+    return await callerOverride({
       args,
       invoke,
-      _def: finalBuilder._def as unknown as AnyProcedure['_def'],
+      _def: _def,
     });
   };
 
-  callerWrapper._def = finalBuilder._def;
+  callerWrapper._def = _def;
   return callerWrapper;
 }
 
 /**
  * @internal
  */
-export interface ProcedureCallOptions {
-  ctx: unknown;
+export interface ProcedureCallOptions<TContext> {
+  ctx: TContext;
   getRawInput: GetRawInputFn;
   input?: unknown;
   path: string;
@@ -542,7 +535,7 @@ If you want to call this function on the server, see https://trpc.io/docs/v11/se
 `.trim();
 
 function createProcedureCaller(_def: AnyProcedureBuilderDef): AnyProcedure {
-  async function procedure(opts: ProcedureCallOptions) {
+  async function procedure(opts: ProcedureCallOptions<unknown>) {
     // is direct server-side call
     if (!opts || !('getRawInput' in opts)) {
       throw new Error(codeblock);

package/src/unstable-core-do-not-import/router.ts

@@ -6,6 +6,7 @@ import type {
   AnyProcedure,
   ErrorHandlerOptions,
   inferProcedureInput,
+  inferProcedureOutput,
 } from './procedure';
 import type { ProcedureCallOptions } from './procedureBuilder';
 import type { AnyRootTypes, RootConfig } from './rootConfig';
@@ -21,8 +22,8 @@ type DecorateProcedure<TProcedure extends AnyProcedure> = (
   input: inferProcedureInput<TProcedure>,
 ) => Promise<
   TProcedure['_def']['type'] extends 'subscription'
-    ? Observable<TProcedure['_def']['_output_out'], TRPCError>
-    : TProcedure['_def']['_output_out']
+    ? Observable<inferProcedureOutput<TProcedure>, TRPCError>
+    : inferProcedureOutput<TProcedure>
 >;
 
 /**
@@ -224,7 +225,7 @@ function isProcedure(
  * @internal
  */
 export function callProcedure(
-  opts: ProcedureCallOptions & {
+  opts: ProcedureCallOptions<unknown> & {
     procedures: RouterRecord;
     allowMethodOverride?: boolean;
   },

package/src/unstable-core-do-not-import/utils.ts

@@ -1,3 +1,5 @@
+import { createFlatProxy } from './createProxy';
+
 /**
  * Ensures there are no duplicate keys when building a procedure.
  * @internal
@@ -41,3 +43,13 @@ export function omitPrototype<TObj extends Record<string, unknown>>(
 ): TObj {
   return Object.assign(Object.create(null), obj);
 }
+
+/**
+ * Prevents access to `$types` at runtime
+ * @internal
+ */
+export const $typesProxy = createFlatProxy<any>((key) => {
+  throw new Error(
+    `Tried to access "$types.${key}" which is not available at runtime`,
+  );
+});