@trpc/server 10.0.0-alpha.3 → 10.0.0-alpha.30

package/src/core/internals/internalProcedure.ts

@@ -0,0 +1,296 @@
+/**
+ * This is the actual internal representation of a builder
+ * FIXME - I want to get rid of this and use the public API instead
+ */
+import { TRPCError } from '../../error/TRPCError';
+import { getCauseFromUnknown } from '../../error/utils';
+import { getErrorFromUnknown } from '../../error/utils';
+import { MaybePromise } from '../../types';
+import { MiddlewareFunction, MiddlewareResult } from '../middleware';
+import { Parser } from '../parser';
+import { ProcedureType } from '../types';
+import { ParseFn, getParseFn } from './getParseFn';
+import { mergeWithoutOverrides } from './mergeWithoutOverrides';
+import { ResolveOptions, middlewareMarker } from './utils';
+
+export interface InternalProcedureCallOptions {
+  ctx: unknown;
+  rawInput: unknown;
+  input?: unknown;
+  path: string;
+  type: ProcedureType;
+}
+export interface InternalProcedure {
+  _def: ProcedureBuilderInternal['_def'];
+  /**
+   * @deprecated use `._def.meta` instead
+   */
+  meta: ProcedureBuilderInternal['_def']['meta'];
+  mutation?: boolean;
+  query?: boolean;
+  subscription?: boolean;
+  (opts: InternalProcedureCallOptions): Promise<unknown>;
+}
+
+type ProcedureBuilderInternalResolver = (
+  opts: ResolveOptions<any>,
+) => Promise<unknown>;
+
+export type ProcedureBuilderInternalMiddleware = MiddlewareFunction<any, any>;
+type TResolver = (opts: ResolveOptions<any>) => MaybePromise<any>;
+
+interface ProcedureBuilderInternal {
+  _def: {
+    input?: Parser;
+    output?: Parser;
+    meta?: Record<string, unknown>;
+    resolver?: ProcedureBuilderInternalResolver;
+    middlewares: ProcedureBuilderInternalMiddleware[];
+    mutation?: boolean;
+    query?: boolean;
+    subscription?: boolean;
+  };
+  /**
+   * @internal
+   */
+  input: (parser: Parser) => ProcedureBuilderInternal;
+  /**
+   * @internal
+   */
+  output: (parser: Parser) => ProcedureBuilderInternal;
+  /**
+   * @internal
+   */
+  unstable_concat: (proc: ProcedureBuilderInternal) => ProcedureBuilderInternal;
+  /**
+   * @internal
+   */
+  use: (fn: MiddlewareFunction<any, any>) => ProcedureBuilderInternal;
+  /**
+   * @internal
+   */
+  meta: (meta: Record<string, unknown>) => ProcedureBuilderInternal;
+  /** @deprecated **/
+  resolve: (resolver: TResolver) => InternalProcedure;
+  /**
+   * @internal
+   */
+  query: (resolver: TResolver) => InternalProcedure;
+  /**
+   * @internal
+   */
+  mutation: (resolver: TResolver) => InternalProcedure;
+
+  /**
+   * @internal
+   */
+  subscription: (resolver: TResolver) => InternalProcedure;
+}
+function createNewInternalBuilder(
+  def1: ProcedureBuilderInternal['_def'],
+  def2: Partial<ProcedureBuilderInternal['_def']>,
+): ProcedureBuilderInternal {
+  const { middlewares = [], ...rest } = def2;
+
+  // TODO: maybe have a fn here to warn about calls
+  return createInternalBuilder({
+    ...mergeWithoutOverrides(def1, rest),
+    middlewares: [...def1.middlewares, ...middlewares],
+  });
+}
+
+const codeblock = `
+If you want to call this function on the server, you do the following:
+This is a client-only function.
+
+const caller = appRouter.createCaller({
+  /* ... your context */
+});
+
+const result = await caller.call('myProcedure', input);
+`.trim();
+
+function createProcedureCaller(
+  _def: InternalProcedure['_def'],
+): InternalProcedure {
+  const procedure = async function resolve(opts: InternalProcedureCallOptions) {
+    if (!opts || !('rawInput' in opts)) {
+      throw new Error(codeblock);
+    }
+
+    // run the middlewares recursively with the resolver as the last one
+    const callRecursive = async (
+      callOpts: { ctx: any; index: number; input?: unknown } = {
+        index: 0,
+        ctx: opts.ctx,
+      },
+    ): Promise<MiddlewareResult<any>> => {
+      try {
+        const middleware = _def.middlewares[callOpts.index];
+        const result = await middleware({
+          ctx: callOpts.ctx,
+          type: opts.type,
+          path: opts.path,
+          rawInput: opts.rawInput,
+          meta: _def.meta,
+          input: callOpts.input,
+          next: async (nextOpts?: { ctx: any; input?: any }) => {
+            return await callRecursive({
+              index: callOpts.index + 1,
+              ctx:
+                nextOpts && 'ctx' in nextOpts
+                  ? { ...callOpts.ctx, ...nextOpts.ctx }
+                  : callOpts.ctx,
+              input:
+                nextOpts && 'input' in nextOpts
+                  ? nextOpts.input
+                  : callOpts.input,
+            });
+          },
+        });
+        return result;
+      } catch (cause) {
+        return {
+          ok: false,
+          error: getErrorFromUnknown(cause),
+          marker: middlewareMarker,
+        };
+      }
+    };
+
+    // there's always at least one "next" since we wrap this.resolver in a middleware
+    const result = await callRecursive();
+
+    if (!result) {
+      throw new TRPCError({
+        code: 'INTERNAL_SERVER_ERROR',
+        message:
+          'No result from middlewares - did you forget to `return next()`?',
+      });
+    }
+    if (!result.ok) {
+      // re-throw original error
+      throw result.error;
+    }
+    return result.data;
+  };
+  procedure._def = _def;
+  procedure.meta = _def.meta;
+
+  return procedure;
+}
+
+export function createInputMiddleware<T>(
+  parse: ParseFn<T>,
+): ProcedureBuilderInternalMiddleware {
+  return async function inputMiddleware({ next, rawInput }) {
+    let input: ReturnType<typeof parse>;
+    try {
+      input = await parse(rawInput);
+    } catch (cause) {
+      throw new TRPCError({
+        code: 'BAD_REQUEST',
+        cause: getCauseFromUnknown(cause),
+      });
+    }
+    // TODO fix this typing?
+    return next({ input } as any);
+  };
+}
+
+export function createOutputMiddleware<T>(
+  parse: ParseFn<T>,
+): ProcedureBuilderInternalMiddleware {
+  return async function outputMiddleware({ next }) {
+    const result = await next();
+    if (!result.ok) {
+      // pass through failures without validating
+      return result;
+    }
+    try {
+      const data = await parse(result.data);
+      return {
+        ...result,
+        data,
+      };
+    } catch (cause) {
+      throw new TRPCError({
+        message: 'Output validation failed',
+        code: 'INTERNAL_SERVER_ERROR',
+        cause: getCauseFromUnknown(cause),
+      });
+    }
+  };
+}
+
+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 {
+  const _def: ProcedureBuilderInternal['_def'] = initDef || {
+    middlewares: [],
+  };
+
+  return {
+    _def,
+    // _call: createProcedureCaller(_def),
+    input(input: Parser) {
+      const parser = getParseFn(input);
+      return createNewInternalBuilder(_def, {
+        input,
+        middlewares: [createInputMiddleware(parser)],
+      });
+    },
+    output(output: Parser) {
+      const parseOutput = getParseFn(output);
+      return createNewInternalBuilder(_def, {
+        output,
+        middlewares: [createOutputMiddleware(parseOutput)],
+      });
+    },
+    meta(meta) {
+      return createNewInternalBuilder(_def, { meta });
+    },
+    /** @deprecated **/
+    resolve(resolver) {
+      return createResolver(_def, resolver);
+    },
+    unstable_concat(builder) {
+      return createNewInternalBuilder(_def, builder._def);
+    },
+    use(middleware) {
+      return createNewInternalBuilder(_def, {
+        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

@@ -0,0 +1,45 @@
+import { defaultFormatter } from '../../error/formatter';
+import { CombinedDataTransformer, defaultTransformer } from '../../transformer';
+import { AnyRouter, createRouterFactory } from '../router';
+import { mergeWithoutOverrides } from './mergeWithoutOverrides';
+
+export function mergeRouters(...routerList: AnyRouter[]): AnyRouter {
+  const procedures = mergeWithoutOverrides(
+    {},
+    ...routerList.map((r) => r._def.procedures),
+  );
+  const errorFormatter = routerList.reduce(
+    (currentErrorFormatter, nextRouter) => {
+      if (
+        nextRouter.errorFormatter &&
+        nextRouter.errorFormatter !== defaultFormatter
+      ) {
+        if (
+          currentErrorFormatter !== defaultFormatter &&
+          currentErrorFormatter !== nextRouter.errorFormatter
+        ) {
+          throw new Error('You seem to have several error formatters');
+        }
+        return nextRouter.errorFormatter;
+      }
+      return currentErrorFormatter;
+    },
+    defaultFormatter,
+  );
+
+  const transformer = routerList.reduce((prev, current) => {
+    if (current.transformer && current.transformer !== defaultTransformer) {
+      if (prev !== defaultTransformer && prev !== current.transformer) {
+        throw new Error('You seem to have several transformers');
+      }
+      return current.transformer;
+    }
+    return prev;
+  }, defaultTransformer as CombinedDataTransformer);
+
+  const router = createRouterFactory({
+    errorFormatter,
+    transformer,
+  })(procedures);
+  return router;
+}

package/src/core/internals/mergeWithoutOverrides.ts

@@ -0,0 +1,19 @@
+/**
+ * Ensures there are no duplicate keys when building a procedure.
+ */
+export function mergeWithoutOverrides<T extends Record<string, unknown>>(
+  obj1: T,
+  ...objs: Partial<T>[]
+): T {
+  const newObj: T = Object.assign(Object.create(null), obj1);
+
+  for (const overrides of objs) {
+    for (const key in overrides) {
+      if (key in newObj && newObj[key] !== overrides[key]) {
+        throw new Error(`Duplicate key ${key}`);
+      }
+      newObj[key as keyof T] = overrides[key] as T[keyof T];
+    }
+  }
+  return newObj;
+}

package/src/core/internals/omitPrototype.ts

@@ -0,0 +1,9 @@
+/**
+ * Create an object without inheriting anything from `Object.prototype`
+ * @internal
+ */
+export function omitPrototype<TObj1 extends Record<string, unknown>>(
+  obj1: TObj1,
+): TObj1 {
+  return Object.assign(Object.create(null), obj1);
+}

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

@@ -0,0 +1,180 @@
+import { MaybePromise } from '../../types';
+import { MiddlewareFunction } from '../middleware';
+import { Parser, inferParser } from '../parser';
+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';
+
+type CreateProcedureReturnInput<
+  TPrev extends ProcedureParams,
+  TNext extends ProcedureParams,
+> = ProcedureBuilder<{
+  _meta: TPrev['_meta'];
+  _ctx_in: TPrev['_ctx_in'];
+  _ctx_out: Overwrite<TPrev['_ctx_out'], TNext['_ctx_out']>;
+  _input_out: FallbackValue<TNext['_input_out'], TPrev['_input_out']>;
+  _input_in: FallbackValue<TNext['_input_in'], TPrev['_input_in']>;
+  _output_in: FallbackValue<TNext['_output_in'], TPrev['_output_in']>;
+  _output_out: FallbackValue<TNext['_output_out'], TPrev['_output_out']>;
+}>;
+
+export interface ProcedureBuilder<TParams extends ProcedureParams> {
+  /**
+   * Add an input parser to the procedure.
+   */
+  input<$TParser extends Parser>(
+    schema: $TParser,
+  ): ProcedureBuilder<{
+    _meta: TParams['_meta'];
+    _ctx_in: TParams['_ctx_in'];
+    _ctx_out: TParams['_ctx_out'];
+    _output_in: TParams['_output_in'];
+    _output_out: TParams['_output_out'];
+    _input_in: inferParser<$TParser>['in'];
+    _input_out: inferParser<$TParser>['out'];
+  }>;
+  /**
+   * Add an output parser to the procedure.
+   */
+  output<$TParser extends Parser>(
+    schema: $TParser,
+  ): ProcedureBuilder<{
+    _meta: TParams['_meta'];
+    _ctx_in: TParams['_ctx_in'];
+    _ctx_out: TParams['_ctx_out'];
+    _input_in: TParams['_input_in'];
+    _input_out: TParams['_input_out'];
+    _output_in: inferParser<$TParser>['in'];
+    _output_out: inferParser<$TParser>['out'];
+  }>;
+  /**
+   * Add a meta data to the procedure.
+   */
+  meta(meta: TParams['_meta']): ProcedureBuilder<TParams>;
+  /**
+   * Add a middleware to the procedure.
+   */
+  use<$TParams extends ProcedureParams>(
+    fn: MiddlewareFunction<TParams, $TParams>,
+  ): CreateProcedureReturnInput<TParams, $TParams>;
+  /**
+   * Extend the procedure with another procedure.
+   * @warning The TypeScript inference fails when chaining concatenated procedures.
+   */
+  unstable_concat<$ProcedureReturnInput extends ProcedureBuilder<any>>(
+    proc: $ProcedureReturnInput,
+  ): $ProcedureReturnInput extends ProcedureBuilder<infer $TParams>
+    ? CreateProcedureReturnInput<TParams, $TParams>
+    : never;
+
+  /** @deprecated **/
+  resolve<$TOutput>(
+    resolver: (
+      opts: ResolveOptions<TParams>,
+    ) => MaybePromise<FallbackValue<TParams['_output_in'], $TOutput>>,
+  ): UnsetMarker extends TParams['_output_out']
+    ? Procedure<
+        Overwrite<
+          TParams,
+          {
+            _output_in: $TOutput;
+            _output_out: $TOutput;
+          }
+        >
+      >
+    : 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>;
+}
+
+export function createBuilder<TConfig extends RootConfig>(): ProcedureBuilder<{
+  _ctx_in: TConfig['ctx'];
+  _ctx_out: TConfig['ctx'];
+  _input_out: UnsetMarker;
+  _input_in: UnsetMarker;
+  _output_in: UnsetMarker;
+  _output_out: UnsetMarker;
+  _meta: TConfig['meta'];
+}> {
+  return createInternalBuilder() as any;
+}

package/src/core/internals/utils.ts

@@ -0,0 +1,64 @@
+import { ProcedureParams } from '../procedure';
+
+/**
+ * @internal
+ */
+export type Overwrite<T, U> = Omit<T, keyof U> & U;
+/**
+ * @internal
+ */
+export type DefaultValue<TValue, TFallback> = UnsetMarker extends TValue
+  ? TFallback
+  : TValue;
+
+/**
+ * @internal
+ */
+export const middlewareMarker = 'middlewareMarker' as 'middlewareMarker' & {
+  __brand: 'middlewareMarker';
+};
+
+/**
+ * @internal
+ */
+export type MiddlewareMarker = typeof middlewareMarker;
+
+/**
+ * @internal
+ */
+export const unsetMarker = Symbol('unsetMarker');
+/**
+ * @internal
+ */
+export type UnsetMarker = typeof unsetMarker;
+
+/**
+ * @internal
+ */
+export interface ResolveOptions<TParams extends ProcedureParams> {
+  ctx: TParams['_ctx_out'];
+  input: TParams['_input_out'];
+}
+
+/**
+ * @internal
+ */
+export type ValidateShape<TActualShape, TExpectedShape> =
+  TActualShape extends TExpectedShape
+    ? Exclude<keyof TActualShape, keyof TExpectedShape> extends never
+      ? TActualShape
+      : TExpectedShape
+    : never;
+
+/**
+ * @internal
+ */
+export type PickFirstDefined<T, K> = undefined extends T
+  ? undefined extends K
+    ? never
+    : K
+  : T;
+
+export type EnsureRecord<T> = T extends Record<string, any>
+  ? T
+  : Record<string, never>;