@trpc/server 11.0.0-next.92 → 11.0.0-rc.330

package/src/core/internals/mergeRouters.ts

@@ -1,90 +0,0 @@
-import { defaultFormatter } from '../../error/formatter';
-import { CombinedDataTransformer, defaultTransformer } from '../../transformer';
-import {
-  AnyRouter,
-  AnyRouterDef,
-  createRouterFactory,
-  Router,
-  RouterDef,
-} from '../router';
-import { mergeWithoutOverrides } from './mergeWithoutOverrides';
-
-/**
- * @internal
- */
-export type MergeRouters<
-  TRouters extends AnyRouter[],
-  TRouterDef extends AnyRouterDef = RouterDef<
-    TRouters[0]['_def']['_config'],
-    // eslint-disable-next-line @typescript-eslint/ban-types
-    {}
-  >,
-> = TRouters extends [
-  infer Head extends AnyRouter,
-  ...infer Tail extends AnyRouter[],
-]
-  ? MergeRouters<
-      Tail,
-      {
-        _config: TRouterDef['_config'];
-        router: true;
-        procedures: Head['_def']['procedures'] & TRouterDef['procedures'];
-        record: Head['_def']['record'] & TRouterDef['record'];
-      }
-    >
-  : Router<TRouterDef> & TRouterDef['record'];
-
-export function mergeRouters<TRouters extends AnyRouter[]>(
-  ...routerList: [...TRouters]
-): MergeRouters<TRouters> {
-  const record = mergeWithoutOverrides(
-    {},
-    ...routerList.map((r) => r._def.record),
-  );
-  const errorFormatter = routerList.reduce(
-    (currentErrorFormatter, nextRouter) => {
-      if (
-        nextRouter._def._config.errorFormatter &&
-        nextRouter._def._config.errorFormatter !== defaultFormatter
-      ) {
-        if (
-          currentErrorFormatter !== defaultFormatter &&
-          currentErrorFormatter !== nextRouter._def._config.errorFormatter
-        ) {
-          throw new Error('You seem to have several error formatters');
-        }
-        return nextRouter._def._config.errorFormatter;
-      }
-      return currentErrorFormatter;
-    },
-    defaultFormatter,
-  );
-
-  const transformer = routerList.reduce((prev, current) => {
-    if (
-      current._def._config.transformer &&
-      current._def._config.transformer !== defaultTransformer
-    ) {
-      if (
-        prev !== defaultTransformer &&
-        prev !== current._def._config.transformer
-      ) {
-        throw new Error('You seem to have several transformers');
-      }
-      return current._def._config.transformer;
-    }
-    return prev;
-  }, defaultTransformer as CombinedDataTransformer);
-
-  const router = createRouterFactory({
-    errorFormatter,
-    transformer,
-    isDev: routerList.some((r) => r._def._config.isDev),
-    allowOutsideOfServer: routerList.some(
-      (r) => r._def._config.allowOutsideOfServer,
-    ),
-    isServer: routerList.some((r) => r._def._config.isServer),
-    $types: routerList[0]?._def._config.$types as any,
-  })(record);
-  return router as any;
-}

package/src/core/internals/mergeWithoutOverrides.ts

@@ -1,19 +0,0 @@
-/**
- * Ensures there are no duplicate keys when building a procedure.
- */
-export function mergeWithoutOverrides<TType extends Record<string, unknown>>(
-  obj1: TType,
-  ...objs: Partial<TType>[]
-): TType {
-  const newObj: TType = 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 TType] = overrides[key] as TType[keyof TType];
-    }
-  }
-  return newObj;
-}

package/src/core/internals/omitPrototype.ts

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

package/src/core/internals/procedureBuilder.ts

@@ -1,394 +0,0 @@
-import { getTRPCErrorFromUnknown, TRPCError } from '../../error/TRPCError';
-import { MaybePromise, Simplify } from '../../types';
-import {
-  createInputMiddleware,
-  createOutputMiddleware,
-  MiddlewareBuilder,
-  MiddlewareFunction,
-  MiddlewareResult,
-} from '../middleware';
-import { inferParser, Parser } from '../parser';
-import {
-  AnyMutationProcedure,
-  AnyProcedure,
-  AnyProcedureParams,
-  AnyQueryProcedure,
-  AnySubscriptionProcedure,
-  MutationProcedure,
-  ProcedureParams,
-  QueryProcedure,
-  SubscriptionProcedure,
-} from '../procedure';
-import { ProcedureType } from '../types';
-import { AnyProcedureBuilderParams } from './builderTypes';
-import { AnyRootConfig } from './config';
-import { getParseFn } from './getParseFn';
-import { mergeWithoutOverrides } from './mergeWithoutOverrides';
-import {
-  DefaultValue,
-  GetRawInputFn,
-  middlewareMarker,
-  Overwrite,
-  ResolveOptions,
-  UnsetMarker,
-} from './utils';
-
-type CreateProcedureReturnInput<
-  TPrev extends ProcedureParams<AnyProcedureParams>,
-  TNext extends ProcedureParams<AnyProcedureParams>,
-> = ProcedureBuilder<{
-  _config: TPrev['_config'];
-  _meta: TPrev['_meta'];
-  _ctx_out: Overwrite<TPrev['_ctx_out'], TNext['_ctx_out']>;
-  _input_in: DefaultValue<TNext['_input_in'], TPrev['_input_in']>;
-  _input_out: UnsetMarker extends TNext['_input_out']
-    ? TPrev['_input_out']
-    : Overwrite<TPrev['_input_out'], TNext['_input_out']>;
-  _output_in: DefaultValue<TNext['_output_in'], TPrev['_output_in']>;
-  _output_out: DefaultValue<TNext['_output_out'], TPrev['_output_out']>;
-}>;
-
-type OverwriteIfDefined<TType, TWith> = UnsetMarker extends TType
-  ? TWith
-  : Simplify<TType & TWith>;
-
-type ErrorMessage<TMessage extends string> = TMessage;
-
-export type ProcedureBuilderDef<TParams extends AnyProcedureBuilderParams> = {
-  procedure: true;
-  inputs: Parser[];
-  output?: Parser;
-  meta?: TParams['_meta'];
-  resolver?: ProcedureBuilderResolver;
-  middlewares: ProcedureBuilderMiddleware[];
-  mutation?: boolean;
-  query?: boolean;
-  subscription?: boolean;
-};
-
-export type AnyProcedureBuilderDef = ProcedureBuilderDef<any>;
-
-export interface ProcedureBuilder<TParams extends AnyProcedureBuilderParams> {
-  /**
-   * Add an input parser to the procedure.
-   */
-  input<$Parser extends Parser>(
-    schema: TParams['_input_out'] extends UnsetMarker
-      ? $Parser
-      : inferParser<$Parser>['out'] extends Record<string, unknown> | undefined
-      ? TParams['_input_out'] extends Record<string, unknown> | undefined
-        ? undefined extends inferParser<$Parser>['out'] // if current is optional the previous must be too
-          ? undefined extends TParams['_input_out']
-            ? $Parser
-            : ErrorMessage<'Cannot chain an optional parser to a required parser'>
-          : $Parser
-        : ErrorMessage<'All input parsers did not resolve to an object'>
-      : ErrorMessage<'All input parsers did not resolve to an object'>,
-  ): ProcedureBuilder<{
-    _config: TParams['_config'];
-    _meta: TParams['_meta'];
-    _ctx_out: TParams['_ctx_out'];
-    _input_in: OverwriteIfDefined<
-      TParams['_input_in'],
-      inferParser<$Parser>['in']
-    >;
-    _input_out: OverwriteIfDefined<
-      TParams['_input_out'],
-      inferParser<$Parser>['out']
-    >;
-
-    _output_in: TParams['_output_in'];
-    _output_out: TParams['_output_out'];
-  }>;
-  /**
-   * Add an output parser to the procedure.
-   */
-  output<$Parser extends Parser>(
-    schema: $Parser,
-  ): ProcedureBuilder<{
-    _config: TParams['_config'];
-    _meta: TParams['_meta'];
-    _ctx_out: TParams['_ctx_out'];
-    _input_in: TParams['_input_in'];
-    _input_out: TParams['_input_out'];
-    _output_in: inferParser<$Parser>['in'];
-    _output_out: inferParser<$Parser>['out'];
-  }>;
-  /**
-   * Add a meta data to the procedure.
-   */
-  meta(meta: TParams['_meta']): ProcedureBuilder<TParams>;
-  /**
-   * Add a middleware to the procedure.
-   */
-  use<$Params extends ProcedureParams<AnyProcedureParams>>(
-    fn:
-      | MiddlewareBuilder<TParams, $Params>
-      | MiddlewareFunction<TParams, $Params>,
-  ): CreateProcedureReturnInput<TParams, $Params>;
-  /**
-   * Query procedure
-   */
-  query<$Output>(
-    resolver: (
-      opts: ResolveOptions<TParams>,
-    ) => MaybePromise<DefaultValue<TParams['_output_in'], $Output>>,
-  ): QueryProcedure<{
-    input: DefaultValue<TParams['_input_in'], void>;
-    output: DefaultValue<TParams['_output_out'], $Output>;
-  }>;
-
-  /**
-   * Mutation procedure
-   */
-  mutation<$Output>(
-    resolver: (
-      opts: ResolveOptions<TParams>,
-    ) => MaybePromise<DefaultValue<TParams['_output_in'], $Output>>,
-  ): MutationProcedure<{
-    input: DefaultValue<TParams['_input_in'], void>;
-    output: DefaultValue<TParams['_output_out'], $Output>;
-  }>;
-
-  /**
-   * Mutation procedure
-   */
-  subscription<$Output>(
-    resolver: (
-      opts: ResolveOptions<TParams>,
-    ) => MaybePromise<DefaultValue<TParams['_output_in'], $Output>>,
-  ): SubscriptionProcedure<{
-    input: DefaultValue<TParams['_input_in'], void>;
-    output: DefaultValue<TParams['_output_out'], $Output>;
-  }>;
-  /**
-   * @internal
-   */
-  _def: ProcedureBuilderDef<TParams>;
-}
-
-type AnyProcedureBuilder = ProcedureBuilder<any>;
-
-export type ProcedureBuilderMiddleware = MiddlewareFunction<any, any>;
-
-export type ProcedureBuilderResolver = (
-  opts: ResolveOptions<any>,
-) => Promise<unknown>;
-
-function createNewBuilder(
-  def1: AnyProcedureBuilderDef,
-  def2: Partial<AnyProcedureBuilderDef>,
-) {
-  const { middlewares = [], inputs, meta, ...rest } = def2;
-
-  // TODO: maybe have a fn here to warn about calls
-  return createBuilder({
-    ...mergeWithoutOverrides(def1, rest),
-    inputs: [...def1.inputs, ...(inputs ?? [])],
-    middlewares: [...def1.middlewares, ...middlewares],
-    meta: def1.meta && meta ? { ...def1.meta, ...meta } : meta ?? def1.meta,
-  });
-}
-
-export function createBuilder<TConfig extends AnyRootConfig>(
-  initDef: Partial<AnyProcedureBuilderDef> = {},
-): ProcedureBuilder<{
-  _config: TConfig;
-  _ctx_out: TConfig['$types']['ctx'];
-  _input_in: UnsetMarker;
-  _input_out: UnsetMarker;
-  _output_in: UnsetMarker;
-  _output_out: UnsetMarker;
-  _meta: TConfig['$types']['meta'];
-}> {
-  const _def: AnyProcedureBuilderDef = {
-    procedure: true,
-    inputs: [],
-    middlewares: [],
-    ...initDef,
-  };
-
-  return {
-    _def,
-    input(input) {
-      const parser = getParseFn(input);
-      return createNewBuilder(_def, {
-        inputs: [input],
-        middlewares: [createInputMiddleware(parser)],
-      }) as AnyProcedureBuilder;
-    },
-    output(output: Parser) {
-      const parseOutput = getParseFn(output);
-      return createNewBuilder(_def, {
-        output,
-        middlewares: [createOutputMiddleware(parseOutput)],
-      }) as AnyProcedureBuilder;
-    },
-    meta(meta) {
-      return createNewBuilder(_def, {
-        meta: meta as Record<string, unknown>,
-      }) as AnyProcedureBuilder;
-    },
-    use(middlewareBuilderOrFn) {
-      // Distinguish between a middleware builder and a middleware function
-      const middlewares =
-        '_middlewares' in middlewareBuilderOrFn
-          ? middlewareBuilderOrFn._middlewares
-          : [middlewareBuilderOrFn];
-
-      return createNewBuilder(_def, {
-        middlewares: middlewares as ProcedureBuilderMiddleware[],
-      }) as AnyProcedureBuilder;
-    },
-    query(resolver) {
-      return createResolver(
-        { ..._def, type: 'query' },
-        resolver,
-      ) as AnyQueryProcedure;
-    },
-    mutation(resolver) {
-      return createResolver(
-        { ..._def, type: 'mutation' },
-        resolver,
-      ) as AnyMutationProcedure;
-    },
-    subscription(resolver) {
-      return createResolver(
-        { ..._def, type: 'subscription' },
-        resolver,
-      ) as AnySubscriptionProcedure;
-    },
-  };
-}
-
-function createResolver(
-  _def: AnyProcedureBuilderDef & { type: ProcedureType },
-  resolver: (opts: ResolveOptions<any>) => MaybePromise<any>,
-) {
-  const finalBuilder = createNewBuilder(_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);
-}
-
-/**
- * @internal
- */
-export interface ProcedureCallOptions {
-  ctx: unknown;
-  getRawInput: GetRawInputFn;
-  input?: unknown;
-  path: string;
-  type: ProcedureType;
-}
-
-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: AnyProcedureBuilderDef): AnyProcedure {
-  async function procedure(opts: ProcedureCallOptions) {
-    // is direct server-side call
-    if (!opts || !('getRawInput' 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;
-        getRawInput?: GetRawInputFn;
-      } = {
-        index: 0,
-        ctx: opts.ctx,
-      },
-    ): Promise<MiddlewareResult<any>> => {
-      try {
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        const middleware = _def.middlewares[callOpts.index]!;
-        const result = await middleware({
-          ctx: callOpts.ctx,
-          type: opts.type,
-          path: opts.path,
-          getRawInput: callOpts.getRawInput ?? opts.getRawInput,
-          meta: _def.meta,
-          input: callOpts.input,
-          next(_nextOpts?: any) {
-            const nextOpts = _nextOpts as
-              | {
-                  ctx?: Record<string, unknown>;
-                  input?: unknown;
-                  getRawInput?: GetRawInputFn;
-                }
-              | undefined;
-
-            return 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,
-              getRawInput:
-                nextOpts && 'getRawInput' in nextOpts
-                  ? nextOpts.getRawInput
-                  : callOpts.getRawInput,
-            });
-          },
-        });
-        return result;
-      } catch (cause) {
-        return {
-          ok: false,
-          error: getTRPCErrorFromUnknown(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;
-
-  // FIXME typecast shouldn't be needed - fixittt
-  return procedure as unknown as AnyProcedure;
-}

package/src/core/internals/utils.ts

@@ -1,84 +0,0 @@
-import { Simplify } from '../../types';
-import { AnyProcedureParams, ProcedureParams } from '../procedure';
-
-/**
- * @internal
- */
-export type Overwrite<TType, TWith> = TType extends any
-  ? TWith extends any
-    ? {
-        [K in keyof TType | keyof TWith]: K extends keyof TWith
-          ? TWith[K]
-          : K extends keyof TType
-          ? TType[K]
-          : never;
-      }
-    : never
-  : never;
-
-/**
- * @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<AnyProcedureParams>,
-> {
-  ctx: Simplify<
-    Overwrite<TParams['_config']['$types']['ctx'], TParams['_ctx_out']>
-  >;
-  input: TParams['_input_out'] extends UnsetMarker
-    ? undefined
-    : 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<TType, TPick> = undefined extends TType
-  ? undefined extends TPick
-    ? never
-    : TPick
-  : TType;
-
-/**
- * @internal
- * Returns the raw input type of a procedure
- */
-export type GetRawInputFn = () => Promise<unknown>;