@trpc/server 11.0.0-next-alpha.152 → 11.0.0-next-alpha.154

package/src/core/middleware.ts

@@ -1,236 +0,0 @@
-import { TRPCError } from '../error/TRPCError';
-import { Simplify } from '../types';
-import { ParseFn } from './internals/getParseFn';
-import { GetRawInputFn, MiddlewareMarker, Overwrite } from './internals/utils';
-import { ProcedureType } from './types';
-
-/**
- * @internal
- */
-interface MiddlewareResultBase {
-  /**
-   * All middlewares should pass through their `next()`'s output.
-   * Requiring this marker makes sure that can't be forgotten at compile-time.
-   */
-  readonly marker: MiddlewareMarker;
-}
-
-/**
- * @internal
- */
-interface MiddlewareOKResult<_TContextOverride> extends MiddlewareResultBase {
-  ok: true;
-  data: unknown;
-  // this could be extended with `input`/`rawInput` later
-}
-
-/**
- * @internal
- */
-interface MiddlewareErrorResult<_TContextOverride>
-  extends MiddlewareResultBase {
-  ok: false;
-  error: TRPCError;
-}
-
-/**
- * @internal
- */
-export type MiddlewareResult<_TContextOverride> =
-  | MiddlewareErrorResult<_TContextOverride>
-  | MiddlewareOKResult<_TContextOverride>;
-
-/**
- * @internal
- */
-export interface MiddlewareBuilder<
-  TContext,
-  TMeta,
-  TContextOverrides,
-  TInputIn,
-> {
-  /**
-   * Create a new builder based on the current middleware builder
-   */
-  unstable_pipe<$ContextOverridesOut>(
-    fn:
-      | MiddlewareFunction<
-          TContext,
-          TMeta,
-          TContextOverrides,
-          $ContextOverridesOut,
-          TInputIn
-        >
-      | MiddlewareBuilder<
-          Overwrite<TContext, TContextOverrides>,
-          TMeta,
-          $ContextOverridesOut,
-          TInputIn
-        >,
-  ): MiddlewareBuilder<
-    TContext,
-    TMeta,
-    Overwrite<TContextOverrides, $ContextOverridesOut>,
-    TInputIn
-  >;
-
-  /**
-   * List of middlewares within this middleware builder
-   */
-  _middlewares: MiddlewareFunction<
-    TContext,
-    TMeta,
-    TContextOverrides,
-    object,
-    TInputIn
-  >[];
-}
-
-/**
- * @internal
- */
-export type MiddlewareFunction<
-  TContext,
-  TMeta,
-  TContextOverridesIn,
-  $ContextOverridesOut,
-  TInputIn,
-> = {
-  (opts: {
-    ctx: Simplify<Overwrite<TContext, TContextOverridesIn>>;
-    type: ProcedureType;
-    path: string;
-    input: TInputIn;
-    getRawInput: GetRawInputFn;
-    meta: TMeta | undefined;
-    next: {
-      (): Promise<MiddlewareResult<TContextOverridesIn>>;
-      <$ContextOverride>(opts: {
-        ctx?: $ContextOverride;
-        input?: unknown;
-      }): Promise<MiddlewareResult<$ContextOverride>>;
-      (opts: { getRawInput: GetRawInputFn }): Promise<
-        MiddlewareResult<TContextOverridesIn>
-      >;
-    };
-  }): Promise<MiddlewareResult<$ContextOverridesOut>>;
-  _type?: string | undefined;
-};
-
-export type AnyMiddlewareFunction = MiddlewareFunction<any, any, any, any, any>;
-export type AnyMiddlewareBuilder = MiddlewareBuilder<any, any, any, any>;
-/**
- * @internal
- */
-export function createMiddlewareFactory<TContext, TMeta, TInputIn = unknown>() {
-  function createMiddlewareInner(
-    middlewares: AnyMiddlewareFunction[],
-  ): AnyMiddlewareBuilder {
-    return {
-      _middlewares: middlewares,
-      unstable_pipe(middlewareBuilderOrFn) {
-        const pipedMiddleware =
-          '_middlewares' in middlewareBuilderOrFn
-            ? middlewareBuilderOrFn._middlewares
-            : [middlewareBuilderOrFn];
-
-        return createMiddlewareInner([...middlewares, ...pipedMiddleware]);
-      },
-    };
-  }
-
-  function createMiddleware<$ContextOverrides>(
-    fn: MiddlewareFunction<
-      TContext,
-      TMeta,
-      object,
-      $ContextOverrides,
-      TInputIn
-    >,
-  ): MiddlewareBuilder<TContext, TMeta, $ContextOverrides, TInputIn> {
-    return createMiddlewareInner([fn]);
-  }
-
-  return createMiddleware;
-}
-
-export const experimental_standaloneMiddleware = <
-  TCtx extends {
-    ctx?: object;
-    meta?: object;
-    input?: unknown;
-  },
->() => ({
-  create: createMiddlewareFactory<
-    TCtx extends { ctx: infer T extends object } ? T : any,
-    TCtx extends { meta: infer T extends object } ? T : object,
-    TCtx extends { input: infer T } ? T : unknown
-  >(),
-});
-
-function isPlainObject(obj: unknown) {
-  return obj && typeof obj === 'object' && !Array.isArray(obj);
-}
-
-/**
- * @internal
- * Please note, `trpc-openapi` uses this function.
- */
-export function createInputMiddleware<TInput>(parse: ParseFn<TInput>) {
-  const inputMiddleware: AnyMiddlewareFunction =
-    async function inputValidatorMiddleware(opts) {
-      let parsedInput: ReturnType<typeof parse>;
-
-      const rawInput = await opts.getRawInput();
-      try {
-        parsedInput = await parse(rawInput);
-      } catch (cause) {
-        throw new TRPCError({
-          code: 'BAD_REQUEST',
-          cause,
-        });
-      }
-
-      // Multiple input parsers
-      const combinedInput =
-        isPlainObject(opts.input) && isPlainObject(parsedInput)
-          ? {
-              ...opts.input,
-              ...parsedInput,
-            }
-          : parsedInput;
-
-      return opts.next({ input: combinedInput });
-    };
-  inputMiddleware._type = 'input';
-  return inputMiddleware;
-}
-
-/**
- * @internal
- */
-export function createOutputMiddleware<TOutput>(parse: ParseFn<TOutput>) {
-  const outputMiddleware: AnyMiddlewareFunction =
-    async function outputValidatorMiddleware({ 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,
-        });
-      }
-    };
-  outputMiddleware._type = 'output';
-  return outputMiddleware;
-}

package/src/core/parser.ts

@@ -1,52 +0,0 @@
-// zod / @decs/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;

package/src/core/procedure.ts

@@ -1,68 +0,0 @@
-import { ProcedureCallOptions } from './internals/procedureBuilder';
-import { ProcedureType } from './types';
-
-type ClientContext = Record<string, unknown>;
-
-/**
- * @internal
- */
-export interface ProcedureOptions {
-  /**
-   * Client-side context
-   */
-  context?: ClientContext;
-  signal?: AbortSignal;
-}
-
-/**
- * @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
- */
-export interface Procedure<
-  TType extends ProcedureType,
-  TDef extends BuiltProcedureDef,
-> {
-  _def: {
-    _input_in: TDef['input'];
-    _output_out: TDef['output'];
-    procedure: true;
-    type: TType;
-    /**
-     * @internal
-     * Meta is not inferrable on individual procedures, only on the router
-     */
-    meta: unknown;
-  };
-  /**
-   * @internal
-   */
-  (opts: ProcedureCallOptions): Promise<unknown>;
-}
-
-export interface QueryProcedure<TDef extends BuiltProcedureDef>
-  extends Procedure<'query', TDef> {}
-
-export interface MutationProcedure<TDef extends BuiltProcedureDef>
-  extends Procedure<'mutation', TDef> {}
-
-export interface SubscriptionProcedure<TDef extends BuiltProcedureDef>
-  extends Procedure<'subscription', TDef> {}
-
-export type AnyQueryProcedure = QueryProcedure<any>;
-export type AnyMutationProcedure = MutationProcedure<any>;
-export type AnySubscriptionProcedure = SubscriptionProcedure<any>;
-export type AnyProcedure = Procedure<ProcedureType, any>;

package/src/core/router.ts

@@ -1,241 +0,0 @@
-import { defaultFormatter } from '../error/formatter';
-import { TRPCError } from '../error/TRPCError';
-import { createRecursiveProxy } from '../shared/createProxy';
-import { defaultTransformer } from '../transformer';
-import { MaybePromise } from '../types';
-import { AnyRootConfig } from './internals/config';
-import { omitPrototype } from './internals/omitPrototype';
-import { ProcedureCallOptions } from './internals/procedureBuilder';
-import { AnyProcedure, ProcedureArgs } from './procedure';
-
-/** @internal **/
-export type ProcedureRecord = Record<string, AnyProcedure>;
-
-export interface ProcedureRouterRecord {
-  [key: string]: AnyProcedure | AnyRouter;
-}
-
-export interface RouterDef<
-  TConfig extends AnyRootConfig,
-  TRecord extends ProcedureRouterRecord,
-> {
-  _config: TConfig;
-  router: true;
-  procedure?: never;
-  procedures: TRecord;
-  record: TRecord;
-}
-
-export type AnyRouterDef<TConfig extends AnyRootConfig = AnyRootConfig> =
-  RouterDef<TConfig, any>;
-
-type DecorateProcedure<TProcedure extends AnyProcedure> = (
-  input: ProcedureArgs<TProcedure['_def']>[0],
-) => Promise<TProcedure['_def']['_output_out']>;
-
-/**
- * @internal
- */
-type DecoratedProcedureRecord<TProcedures extends ProcedureRouterRecord> = {
-  [TKey in keyof TProcedures]: TProcedures[TKey] extends AnyRouter
-    ? DecoratedProcedureRecord<TProcedures[TKey]['_def']['record']>
-    : TProcedures[TKey] extends AnyProcedure
-    ? DecorateProcedure<TProcedures[TKey]>
-    : never;
-};
-
-/**
- * @internal
- */
-export type RouterCaller<TDef extends AnyRouterDef> = (
-  /**
-   * @note
-   * If passing a function, we recommend it's a cached function
-   * e.g. wrapped in `React.cache` to avoid unnecessary computations
-   */
-  ctx:
-    | TDef['_config']['$types']['ctx']
-    | (() => MaybePromise<TDef['_config']['$types']['ctx']>),
-) => DecoratedProcedureRecord<TDef['record']>;
-
-export interface Router<TDef extends AnyRouterDef> {
-  _def: TDef;
-  /**
-   * @deprecated use `t.createCallerFactory(router)` instead
-   * @see https://trpc.io/docs/server/server-side-calls
-   */
-  createCaller: RouterCaller<TDef>;
-}
-
-export type AnyRouter = Router<AnyRouterDef>;
-
-function isRouter(
-  procedureOrRouter: AnyProcedure | AnyRouter,
-): procedureOrRouter is AnyRouter {
-  return 'router' in procedureOrRouter._def;
-}
-
-const emptyRouter = {
-  _ctx: null as any,
-  _errorShape: null as any,
-  _meta: null as any,
-  queries: {},
-  mutations: {},
-  subscriptions: {},
-  errorFormatter: defaultFormatter,
-  transformer: defaultTransformer,
-};
-
-/**
- * Reserved words that can't be used as router or procedure names
- */
-const reservedWords = [
-  /**
-   * Then is a reserved word because otherwise we can't return a promise that returns a Proxy
-   * since JS will think that `.then` is something that exists
-   */
-  'then',
-];
-
-/**
- * @internal
- */
-export type CreateRouterInner<
-  TConfig extends AnyRootConfig,
-  TProcRouterRecord extends ProcedureRouterRecord,
-> = Router<RouterDef<TConfig, TProcRouterRecord>> &
-  /**
-   * This adds ability to call procedures directly but is primarily used for quick access in type inference
-   */
-  TProcRouterRecord;
-
-/**
- * @internal
- */
-export function createRouterFactory<TConfig extends AnyRootConfig>(
-  config: TConfig,
-) {
-  return function createRouterInner<
-    TProcRouterRecord extends ProcedureRouterRecord,
-  >(
-    procedures: TProcRouterRecord,
-  ): CreateRouterInner<TConfig, TProcRouterRecord> {
-    const reservedWordsUsed = new Set(
-      Object.keys(procedures).filter((v) => reservedWords.includes(v)),
-    );
-    if (reservedWordsUsed.size > 0) {
-      throw new Error(
-        'Reserved words used in `router({})` call: ' +
-          Array.from(reservedWordsUsed).join(', '),
-      );
-    }
-
-    const routerProcedures: ProcedureRecord = omitPrototype({});
-    function recursiveGetPaths(procedures: ProcedureRouterRecord, path = '') {
-      for (const [key, procedureOrRouter] of Object.entries(procedures ?? {})) {
-        const newPath = `${path}${key}`;
-
-        if (isRouter(procedureOrRouter)) {
-          recursiveGetPaths(procedureOrRouter._def.procedures, `${newPath}.`);
-          continue;
-        }
-
-        if (routerProcedures[newPath]) {
-          throw new Error(`Duplicate key: ${newPath}`);
-        }
-
-        routerProcedures[newPath] = procedureOrRouter;
-      }
-    }
-    recursiveGetPaths(procedures);
-
-    const _def: AnyRouterDef<TConfig> = {
-      _config: config,
-      router: true,
-      procedures: routerProcedures,
-      ...emptyRouter,
-      record: procedures,
-    };
-
-    const router: AnyRouter = {
-      ...procedures,
-      _def,
-      createCaller(ctx) {
-        const proxy = createRecursiveProxy(({ path, args }) => {
-          const fullPath = path.join('.');
-          const procedure = _def.procedures[fullPath] as AnyProcedure;
-
-          return procedure({
-            path: fullPath,
-            getRawInput: async () => args[0],
-            ctx,
-            type: procedure._def.type,
-          });
-        });
-
-        return proxy as ReturnType<RouterCaller<any>>;
-      },
-    };
-
-    return router as any;
-  };
-}
-
-function isProcedure(
-  procedureOrRouter: AnyProcedure | AnyRouter,
-): procedureOrRouter is AnyProcedure {
-  return !!procedureOrRouter._def.procedure;
-}
-/**
- * @internal
- */
-export function callProcedure(
-  opts: ProcedureCallOptions & { procedures: ProcedureRouterRecord },
-) {
-  const { type, path } = opts;
-  const proc = opts.procedures[path];
-  if (!proc || !isProcedure(proc) || proc._def.type !== type) {
-    throw new TRPCError({
-      code: 'NOT_FOUND',
-      message: `No "${type}"-procedure on path "${path}"`,
-    });
-  }
-
-  return proc(opts);
-}
-
-export function createCallerFactory<TConfig extends AnyRootConfig>() {
-  return function createCallerInner<
-    TRouter extends Router<AnyRouterDef<TConfig>>,
-  >(router: TRouter): RouterCaller<TRouter['_def']> {
-    const _def = router._def;
-    type Context = TConfig['$types']['ctx'];
-
-    return function createCaller(maybeContext) {
-      const proxy = createRecursiveProxy(({ path, args }) => {
-        const fullPath = path.join('.');
-        const procedure = _def.procedures[fullPath] as AnyProcedure;
-
-        const callProc = (ctx: Context) =>
-          procedure({
-            path: fullPath,
-            getRawInput: async () => args[0],
-            ctx,
-            type: procedure._def.type,
-          });
-
-        if (typeof maybeContext === 'function') {
-          const context = (maybeContext as () => MaybePromise<Context>)();
-          if (context instanceof Promise) {
-            return context.then(callProc);
-          }
-          return callProc(context);
-        }
-
-        return callProc(maybeContext);
-      });
-
-      return proxy as ReturnType<RouterCaller<any>>;
-    };
-  };
-}

package/src/core/types.ts

@@ -1,67 +0,0 @@
-import { inferTransformedProcedureOutput } from '../shared';
-import { AnyProcedure, ProcedureArgs } from './procedure';
-import { AnyRouter, AnyRouterDef, Router } from './router';
-
-export type inferRouterDef<TRouter extends AnyRouter> = TRouter extends Router<
-  infer TParams
->
-  ? TParams extends AnyRouterDef<any>
-    ? TParams
-    : never
-  : never;
-
-export type inferRouterConfig<TRouter extends AnyRouter> =
-  inferRouterDef<TRouter>['_config'];
-export type inferRouterContext<TRouter extends AnyRouter> =
-  inferRouterConfig<TRouter>['$types']['ctx'];
-export type inferRouterError<TRouter extends AnyRouter> =
-  inferRouterConfig<TRouter>['$types']['errorShape'];
-export type inferRouterMeta<TRouter extends AnyRouter> =
-  inferRouterConfig<TRouter>['$types']['meta'];
-
-export const procedureTypes = ['query', 'mutation', 'subscription'] as const;
-/**
- * @public
- */
-export type ProcedureType = (typeof procedureTypes)[number];
-
-export type inferHandlerInput<TProcedure extends AnyProcedure> = ProcedureArgs<
-  inferProcedureParams<TProcedure>
->;
-
-export type inferProcedureInput<TProcedure extends AnyProcedure> =
-  inferProcedureParams<TProcedure>['_input_in'];
-
-export type inferProcedureParams<TProcedure> = TProcedure extends AnyProcedure
-  ? TProcedure['_def']
-  : never;
-export type inferProcedureOutput<TProcedure> =
-  inferProcedureParams<TProcedure>['_output_out'];
-
-type GetInferenceHelpers<
-  TType extends 'input' | 'output',
-  TRouter extends AnyRouter,
-> = {
-  [TKey in keyof TRouter['_def']['record']]: TRouter['_def']['record'][TKey] extends infer TRouterOrProcedure
-    ? TRouterOrProcedure extends AnyRouter
-      ? GetInferenceHelpers<TType, TRouterOrProcedure>
-      : TRouterOrProcedure extends AnyProcedure
-      ? TType extends 'input'
-        ? inferProcedureInput<TRouterOrProcedure>
-        : inferTransformedProcedureOutput<
-            TRouter['_def']['_config'],
-            TRouterOrProcedure
-          >
-      : never
-    : never;
-};
-
-export type inferRouterInputs<TRouter extends AnyRouter> = GetInferenceHelpers<
-  'input',
-  TRouter
->;
-
-export type inferRouterOutputs<TRouter extends AnyRouter> = GetInferenceHelpers<
-  'output',
-  TRouter
->;