@trpc/server 11.0.0-next.91 → 11.0.0-rc.329

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

@@ -0,0 +1,94 @@
+// zod / typeschema
+export type ParserZodEsque<TInput, TParsedInput> = {
+  _input: TInput;
+  _output: TParsedInput;
+};
+
+export type ParserMyZodEsque<TInput> = {
+  parse: (input: any) => TInput;
+};
+
+export type ParserSuperstructEsque<TInput> = {
+  create: (input: unknown) => TInput;
+};
+
+export type ParserCustomValidatorEsque<TInput> = (
+  input: unknown,
+) => Promise<TInput> | TInput;
+
+export type ParserYupEsque<TInput> = {
+  validateSync: (input: unknown) => TInput;
+};
+
+export type ParserScaleEsque<TInput> = {
+  assert(value: unknown): asserts value is TInput;
+};
+
+export type ParserWithoutInput<TInput> =
+  | ParserCustomValidatorEsque<TInput>
+  | ParserMyZodEsque<TInput>
+  | ParserScaleEsque<TInput>
+  | ParserSuperstructEsque<TInput>
+  | ParserYupEsque<TInput>;
+
+export type ParserWithInputOutput<TInput, TParsedInput> = ParserZodEsque<
+  TInput,
+  TParsedInput
+>;
+
+export type Parser = ParserWithInputOutput<any, any> | ParserWithoutInput<any>;
+
+export type inferParser<TParser extends Parser> =
+  TParser extends ParserWithInputOutput<infer $TIn, infer $TOut>
+    ? {
+        in: $TIn;
+        out: $TOut;
+      }
+    : TParser extends ParserWithoutInput<infer $InOut>
+    ? {
+        in: $InOut;
+        out: $InOut;
+      }
+    : never;
+
+export type ParseFn<TType> = (value: unknown) => Promise<TType> | TType;
+
+export function getParseFn<TType>(procedureParser: Parser): ParseFn<TType> {
+  const parser = procedureParser as any;
+
+  if (typeof parser === 'function') {
+    // ParserCustomValidatorEsque
+    return parser;
+  }
+
+  if (typeof parser.parseAsync === 'function') {
+    // ParserZodEsque
+    return parser.parseAsync.bind(parser);
+  }
+
+  if (typeof parser.parse === 'function') {
+    // ParserZodEsque
+    // ParserValibotEsque (<= v0.12.X)
+    return parser.parse.bind(parser);
+  }
+
+  if (typeof parser.validateSync === 'function') {
+    // ParserYupEsque
+    return parser.validateSync.bind(parser);
+  }
+
+  if (typeof parser.create === 'function') {
+    // ParserSuperstructEsque
+    return parser.create.bind(parser);
+  }
+
+  if (typeof parser.assert === 'function') {
+    // ParserScaleEsque
+    return (value) => {
+      parser.assert(value);
+      return value as TType;
+    };
+  }
+
+  throw new Error('Could not find a validator fn');
+}

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

@@ -1,6 +1,11 @@
-import { AnyRootConfig } from './internals/config';
-import { ProcedureCallOptions } from './internals/procedureBuilder';
-import { ProcedureType } from './types';
+import type { TRPCError } from './error/TRPCError';
+import type { ProcedureCallOptions } from './procedureBuilder';
+
+export const procedureTypes = ['query', 'mutation', 'subscription'] as const;
+/**
+ * @public
+ */
+export type ProcedureType = (typeof procedureTypes)[number];
 
 type ClientContext = Record<string, unknown>;
 
@@ -15,39 +20,11 @@ export interface ProcedureOptions {
   signal?: AbortSignal;
 }
 
-/**
- * @internal
- * @deprecated
- */
-export type AnyProcedureParams = {
-  _config: AnyRootConfig;
-  _meta: unknown;
-  _ctx_out: unknown;
-  _input_in: unknown;
-  _input_out: unknown;
-  _output_in: unknown;
-  _output_out: unknown;
-};
-
-/**
- * @deprecated
- */
-export type ProcedureParams<TParams extends AnyProcedureParams> = TParams;
-
-/**
- * @internal
- */
-export type ProcedureArgs<TParams extends AnyProcedure['_def']> =
-  void extends TParams['_input_in']
-    ? [input?: undefined | void, opts?: ProcedureOptions]
-    : undefined extends TParams['_input_in']
-    ? [input?: TParams['_input_in'] | void, opts?: ProcedureOptions]
-    : [input: TParams['_input_in'], opts?: ProcedureOptions];
-
 interface BuiltProcedureDef {
   input: unknown;
   output: unknown;
 }
+
 /**
  *
  * @internal
@@ -57,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;
     /**
@@ -66,11 +45,12 @@ export interface Procedure<
      * Meta is not inferrable on individual procedures, only on the router
      */
     meta: unknown;
+    experimental_caller: boolean;
   };
   /**
    * @internal
    */
-  (opts: ProcedureCallOptions): Promise<unknown>;
+  (opts: ProcedureCallOptions<unknown>): Promise<TDef['output']>;
 }
 
 export interface QueryProcedure<TDef extends BuiltProcedureDef>
@@ -86,3 +66,25 @@ export type AnyQueryProcedure = QueryProcedure<any>;
 export type AnyMutationProcedure = MutationProcedure<any>;
 export type AnySubscriptionProcedure = SubscriptionProcedure<any>;
 export type AnyProcedure = Procedure<ProcedureType, any>;
+
+export type inferProcedureInput<TProcedure extends AnyProcedure> =
+  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>['$types']['output'];
+
+/**
+ * @internal
+ */
+export interface ErrorHandlerOptions<TContext> {
+  error: TRPCError;
+  type: ProcedureType | 'unknown';
+  path: string | undefined;
+  input: unknown;
+  ctx: TContext | undefined;
+}