@trpc/server 10.0.0-alpha.29 → 10.0.0-alpha.31

package/src/core/internals/internalProcedure.ts

@@ -26,6 +26,9 @@ export interface InternalProcedure {
    * @deprecated use `._def.meta` instead
    */
   meta: ProcedureBuilderInternal['_def']['meta'];
+  mutation?: boolean;
+  query?: boolean;
+  subscription?: boolean;
   (opts: InternalProcedureCallOptions): Promise<unknown>;
 }
 
@@ -34,6 +37,8 @@ type ProcedureBuilderInternalResolver = (
 ) => Promise<unknown>;
 
 export type ProcedureBuilderInternalMiddleware = MiddlewareFunction<any, any>;
+type TResolver = (opts: ResolveOptions<any>) => MaybePromise<any>;
+
 interface ProcedureBuilderInternal {
   _def: {
     input?: Parser;
@@ -41,9 +46,10 @@ interface ProcedureBuilderInternal {
     meta?: Record<string, unknown>;
     resolver?: ProcedureBuilderInternalResolver;
     middlewares: ProcedureBuilderInternalMiddleware[];
+    mutation?: boolean;
+    query?: boolean;
+    subscription?: boolean;
   };
-  // FIXME
-  // _call: (opts: ResolveOptions<any>) => Promise<unknown>;
   /**
    * @internal
    */
@@ -64,12 +70,21 @@ interface ProcedureBuilderInternal {
    * @internal
    */
   meta: (meta: Record<string, unknown>) => ProcedureBuilderInternal;
+  /** @deprecated **/
+  resolve: (resolver: TResolver) => InternalProcedure;
+  /**
+   * @internal
+   */
+  query: (resolver: TResolver) => InternalProcedure;
+  /**
+   * @internal
+   */
+  mutation: (resolver: TResolver) => InternalProcedure;
+
   /**
    * @internal
    */
-  resolve: (
-    resolver: (opts: ResolveOptions<any>) => MaybePromise<any>,
-  ) => InternalProcedure;
+  subscription: (resolver: TResolver) => InternalProcedure;
 }
 function createNewInternalBuilder(
   def1: ProcedureBuilderInternal['_def'],
@@ -208,6 +223,27 @@ export function createOutputMiddleware<T>(
   };
 }
 
+function createResolver(
+  _def: ProcedureBuilderInternal['_def'],
+  resolver: TResolver,
+) {
+  const finalBuilder = createNewInternalBuilder(_def, {
+    resolver,
+    middlewares: [
+      async function resolveMiddleware(opts) {
+        const data = await resolver(opts);
+        return {
+          marker: middlewareMarker,
+          ok: true,
+          data,
+          ctx: opts.ctx,
+        } as const;
+      },
+    ],
+  });
+
+  return createProcedureCaller(finalBuilder._def);
+}
 export function createInternalBuilder(
   initDef?: ProcedureBuilderInternal['_def'],
 ): ProcedureBuilderInternal {
@@ -235,23 +271,9 @@ export function createInternalBuilder(
     meta(meta) {
       return createNewInternalBuilder(_def, { meta });
     },
+    /** @deprecated **/
     resolve(resolver) {
-      const finalBuilder = createNewInternalBuilder(_def, {
-        resolver,
-        middlewares: [
-          async function resolveMiddleware(opts) {
-            const data = await resolver(opts);
-            return {
-              marker: middlewareMarker,
-              ok: true,
-              data,
-              ctx: opts.ctx,
-            } as const;
-          },
-        ],
-      });
-
-      return createProcedureCaller(finalBuilder._def);
+      return createResolver(_def, resolver);
     },
     unstable_concat(builder) {
       return createNewInternalBuilder(_def, builder._def);
@@ -261,5 +283,14 @@ export function createInternalBuilder(
         middlewares: [middleware],
       });
     },
+    query(resolver) {
+      return createResolver({ ..._def, query: true }, resolver);
+    },
+    mutation(resolver) {
+      return createResolver({ ..._def, mutation: true }, resolver);
+    },
+    subscription(resolver) {
+      return createResolver({ ..._def, subscription: true }, resolver);
+    },
   };
 }

package/src/core/internals/mergeRouters.ts

@@ -4,17 +4,9 @@ import { AnyRouter, createRouterFactory } from '../router';
 import { mergeWithoutOverrides } from './mergeWithoutOverrides';
 
 export function mergeRouters(...routerList: AnyRouter[]): AnyRouter {
-  const queries = mergeWithoutOverrides(
+  const record = mergeWithoutOverrides(
     {},
-    ...routerList.map((r) => r.queries),
-  );
-  const mutations = mergeWithoutOverrides(
-    {},
-    ...routerList.map((r) => r.mutations),
-  );
-  const subscriptions = mergeWithoutOverrides(
-    {},
-    ...routerList.map((r) => r.subscriptions),
+    ...routerList.map((r) => r._def.record),
   );
   const errorFormatter = routerList.reduce(
     (currentErrorFormatter, nextRouter) => {
@@ -48,10 +40,6 @@ export function mergeRouters(...routerList: AnyRouter[]): AnyRouter {
   const router = createRouterFactory({
     errorFormatter,
     transformer,
-  })({
-    queries,
-    mutations,
-    subscriptions,
-  });
+  })(record);
   return router;
 }

package/src/core/internals/prefixObjectKeys.ts

@@ -0,0 +1,9 @@
+import { omitPrototype } from './omitPrototype';
+
+export function prefixObjectKeys(obj: Record<string, unknown>, prefix: string) {
+  const newObj: Record<string, unknown> = omitPrototype({});
+  for (const key in obj ?? {}) {
+    newObj[prefix + key] = obj[key];
+  }
+  return newObj;
+}

package/src/core/internals/procedureBuilder.ts

@@ -1,7 +1,14 @@
 import { MaybePromise } from '../../types';
 import { MiddlewareFunction } from '../middleware';
 import { Parser, inferParser } from '../parser';
-import { Procedure, ProcedureParams } from '../procedure';
+import {
+  MutationProcedure,
+  Procedure,
+  ProcedureParams,
+  QueryProcedure,
+  SubscriptionProcedure,
+} from '../procedure';
+import { RootConfig } from './config';
 import { createInternalBuilder } from './internalProcedure';
 import { ResolveOptions } from './utils';
 import { DefaultValue as FallbackValue, Overwrite, UnsetMarker } from './utils';
@@ -10,6 +17,7 @@ type CreateProcedureReturnInput<
   TPrev extends ProcedureParams,
   TNext extends ProcedureParams,
 > = ProcedureBuilder<{
+  _config: TPrev['_config'];
   _meta: TPrev['_meta'];
   _ctx_in: TPrev['_ctx_in'];
   _ctx_out: Overwrite<TPrev['_ctx_out'], TNext['_ctx_out']>;
@@ -26,6 +34,7 @@ export interface ProcedureBuilder<TParams extends ProcedureParams> {
   input<$TParser extends Parser>(
     schema: $TParser,
   ): ProcedureBuilder<{
+    _config: TParams['_config'];
     _meta: TParams['_meta'];
     _ctx_in: TParams['_ctx_in'];
     _ctx_out: TParams['_ctx_out'];
@@ -40,6 +49,7 @@ export interface ProcedureBuilder<TParams extends ProcedureParams> {
   output<$TParser extends Parser>(
     schema: $TParser,
   ): ProcedureBuilder<{
+    _config: TParams['_config'];
     _meta: TParams['_meta'];
     _ctx_in: TParams['_ctx_in'];
     _ctx_out: TParams['_ctx_out'];
@@ -67,9 +77,8 @@ export interface ProcedureBuilder<TParams extends ProcedureParams> {
   ): $ProcedureReturnInput extends ProcedureBuilder<infer $TParams>
     ? CreateProcedureReturnInput<TParams, $TParams>
     : never;
-  /**
-   * Resolve the procedure
-   */
+
+  /** @deprecated **/
   resolve<$TOutput>(
     resolver: (
       opts: ResolveOptions<TParams>,
@@ -85,17 +94,91 @@ export interface ProcedureBuilder<TParams extends ProcedureParams> {
         >
       >
     : Procedure<TParams>;
+  /**
+   * Query procedure
+   */
+  query<$TOutput>(
+    resolver: (
+      opts: ResolveOptions<TParams>,
+    ) => MaybePromise<FallbackValue<TParams['_output_in'], $TOutput>>,
+  ): UnsetMarker extends TParams['_output_out']
+    ? QueryProcedure<
+        Overwrite<
+          TParams,
+          {
+            _output_in: $TOutput;
+            _output_out: $TOutput;
+          }
+        >
+      >
+    : QueryProcedure<TParams>;
+  /**
+   * Query procedure
+   */
+  query<$TOutput>(
+    resolver: (
+      opts: ResolveOptions<TParams>,
+    ) => MaybePromise<FallbackValue<TParams['_output_in'], $TOutput>>,
+  ): UnsetMarker extends TParams['_output_out']
+    ? QueryProcedure<
+        Overwrite<
+          TParams,
+          {
+            _output_in: $TOutput;
+            _output_out: $TOutput;
+          }
+        >
+      >
+    : QueryProcedure<TParams>;
+
+  /**
+   * Mutation procedure
+   */
+  mutation<$TOutput>(
+    resolver: (
+      opts: ResolveOptions<TParams>,
+    ) => MaybePromise<FallbackValue<TParams['_output_in'], $TOutput>>,
+  ): UnsetMarker extends TParams['_output_out']
+    ? MutationProcedure<
+        Overwrite<
+          TParams,
+          {
+            _output_in: $TOutput;
+            _output_out: $TOutput;
+          }
+        >
+      >
+    : MutationProcedure<TParams>;
+
+  /**
+   * Mutation procedure
+   */
+  subscription<$TOutput>(
+    resolver: (
+      opts: ResolveOptions<TParams>,
+    ) => MaybePromise<FallbackValue<TParams['_output_in'], $TOutput>>,
+  ): UnsetMarker extends TParams['_output_out']
+    ? SubscriptionProcedure<
+        Overwrite<
+          TParams,
+          {
+            _output_in: $TOutput;
+            _output_out: $TOutput;
+          }
+        >
+      >
+    : SubscriptionProcedure<TParams>;
 }
 
-// TODO make this into a callbag?
-export function createBuilder<TContext, TMeta>(): ProcedureBuilder<{
-  _ctx_in: TContext;
-  _ctx_out: TContext;
+export function createBuilder<TConfig extends RootConfig>(): ProcedureBuilder<{
+  _config: TConfig;
+  _ctx_in: TConfig['ctx'];
+  _ctx_out: TConfig['ctx'];
   _input_out: UnsetMarker;
   _input_in: UnsetMarker;
   _output_in: UnsetMarker;
   _output_out: UnsetMarker;
-  _meta: TMeta;
+  _meta: TConfig['meta'];
 }> {
   return createInternalBuilder() as any;
 }

package/src/core/middleware.ts

@@ -1,3 +1,4 @@
+import { RootConfig } from './internals/config';
 import { MiddlewareMarker } from './internals/utils';
 import { ProcedureParams } from './procedure';
 import { ProcedureType } from './types';
@@ -57,6 +58,7 @@ export type MiddlewareFunction<
     (): Promise<MiddlewareResult<TParams>>;
     <$TContext>(opts: { ctx: $TContext }): Promise<
       MiddlewareResult<{
+        _config: any;
         _ctx_in: TParams['_ctx_in'];
         _ctx_out: $TContext;
         _input_in: TParams['_input_in'];
@@ -73,17 +75,18 @@ export type MiddlewareFunction<
  * @internal
  */
 // FIXME this should use RootConfig
-export function createMiddlewareFactory<TContext, TMeta>() {
+export function createMiddlewareFactory<TConfig extends RootConfig>() {
   return function createMiddleware<$TNewParams extends ProcedureParams>(
     fn: MiddlewareFunction<
       {
-        _ctx_in: TContext;
-        _ctx_out: TContext;
+        _config: TConfig;
+        _ctx_in: TConfig['ctx'];
+        _ctx_out: TConfig['ctx'];
         _input_out: unknown;
         _input_in: unknown;
         _output_in: unknown;
         _output_out: unknown;
-        _meta: TMeta;
+        _meta: TConfig['meta'];
       },
       $TNewParams
     >,

package/src/core/procedure.ts

@@ -1,3 +1,6 @@
+import { DefaultErrorShape } from '../error/formatter';
+import { CombinedDataTransformer } from '../transformer';
+import { RootConfig } from './internals/config';
 import { UnsetMarker } from './internals/utils';
 
 type ClientContext = Record<string, unknown>;
@@ -12,6 +15,12 @@ export interface ProcedureOptions {
  * @internal
  */
 export interface ProcedureParams<
+  TConfig extends RootConfig = {
+    transformer: CombinedDataTransformer;
+    errorShape: DefaultErrorShape;
+    ctx: Record<string, unknown>;
+    meta: Record<string, unknown>;
+  },
   TContextIn = unknown,
   TContextOut = unknown,
   TInputIn = unknown,
@@ -20,6 +29,8 @@ export interface ProcedureParams<
   TOutputOut = unknown,
   TMeta = unknown,
 > {
+  // FIXME make non-optional
+  _config: TConfig;
   /**
    * @internal
    */
@@ -63,10 +74,35 @@ export type ProcedureArgs<TParams extends ProcedureParams> =
 /**
  * @internal
  */
-export interface Procedure<TParams extends ProcedureParams> {
-  (...args: ProcedureArgs<TParams>): Promise<TParams['_output_out']>;
+export interface ProcedureBase<TParams extends ProcedureParams> {
+  _def: TParams;
   /**
    * @deprecated use `._def.meta` instead
    */
   meta?: TParams['_meta'];
+  _procedure: true;
 }
+
+export interface QueryProcedure<TParams extends ProcedureParams>
+  extends ProcedureBase<TParams> {
+  _query: true;
+  query(...args: ProcedureArgs<TParams>): Promise<TParams['_output_out']>;
+}
+
+export interface MutationProcedure<TParams extends ProcedureParams>
+  extends ProcedureBase<TParams> {
+  _mutation: true;
+  mutate(...args: ProcedureArgs<TParams>): Promise<TParams['_output_out']>;
+}
+
+export interface SubscriptionProcedure<TParams extends ProcedureParams>
+  extends ProcedureBase<TParams> {
+  _subscription: true;
+  subscription(
+    ...args: ProcedureArgs<TParams>
+  ): Promise<TParams['_output_out']>;
+}
+export type Procedure<TParams extends ProcedureParams> =
+  | QueryProcedure<TParams>
+  | MutationProcedure<TParams>
+  | SubscriptionProcedure<TParams>;