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

package/src/core/middleware.ts

@@ -1,295 +0,0 @@
-import { TRPCError } from '../error/TRPCError';
-import { Simplify } from '../types';
-import { AnyRootConfig, RootConfig } from './internals/config';
-import { ParseFn } from './internals/getParseFn';
-import { ProcedureBuilderMiddleware } from './internals/procedureBuilder';
-import {
-  DefaultValue as FallbackValue,
-  GetRawInputFn,
-  MiddlewareMarker,
-  Overwrite,
-  UnsetMarker,
-} from './internals/utils';
-import { AnyProcedureParams, ProcedureParams } from './procedure';
-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<
-  _TParams extends ProcedureParams<AnyProcedureParams>,
-> extends MiddlewareResultBase {
-  ok: true;
-  data: unknown;
-  // this could be extended with `input`/`rawInput` later
-}
-
-/**
- * @internal
- */
-interface MiddlewareErrorResult<
-  _TParams extends ProcedureParams<AnyProcedureParams>,
-> extends MiddlewareResultBase {
-  ok: false;
-  error: TRPCError;
-}
-
-/**
- * @internal
- */
-export type MiddlewareResult<
-  TParams extends ProcedureParams<AnyProcedureParams>,
-> = MiddlewareErrorResult<TParams> | MiddlewareOKResult<TParams>;
-
-/**
- * @internal
- */
-export interface MiddlewareBuilder<
-  TRoot extends ProcedureParams<AnyProcedureParams>,
-  TNewParams extends ProcedureParams<AnyProcedureParams>,
-> {
-  /**
-   * Create a new builder based on the current middleware builder
-   */
-  unstable_pipe<$Params extends ProcedureParams<AnyProcedureParams>>(
-    fn: {
-      _config: TRoot['_config'];
-      _meta: TRoot['_meta'];
-      _ctx_out: Overwrite<TRoot['_ctx_out'], TNewParams['_ctx_out']>;
-      _input_in: FallbackValue<TRoot['_input_in'], TNewParams['_input_in']>;
-      _input_out: UnsetMarker extends TNewParams['_input_out']
-        ? TRoot['_input_out']
-        : Overwrite<TRoot['_input_out'], TNewParams['_input_out']>;
-      _output_in: FallbackValue<TRoot['_output_in'], TNewParams['_output_in']>;
-      _output_out: FallbackValue<
-        TRoot['_output_out'],
-        TNewParams['_output_out']
-      >;
-    } extends infer OParams extends ProcedureParams<AnyProcedureParams>
-      ?
-          | MiddlewareBuilder<OParams, $Params>
-          | MiddlewareFunction<OParams, $Params>
-      : never,
-  ): CreateMiddlewareReturnInput<
-    TRoot,
-    TNewParams,
-    Overwrite<TNewParams, $Params>
-  >;
-
-  /**
-   * List of middlewares within this middleware builder
-   */
-  _middlewares: MiddlewareFunction<TRoot, TNewParams>[];
-}
-
-/**
- * @internal
- * FIXME: there must be a nicer way of doing this, it's hard to maintain when we have several structures like this
- */
-type CreateMiddlewareReturnInput<
-  TRoot extends ProcedureParams<AnyProcedureParams>,
-  TPrev extends ProcedureParams<AnyProcedureParams>,
-  TNext extends ProcedureParams<AnyProcedureParams>,
-> = MiddlewareBuilder<
-  TRoot,
-  {
-    _config: TPrev['_config'];
-    _meta: TPrev['_meta'];
-    _ctx_out: Overwrite<TPrev['_ctx_out'], TNext['_ctx_out']>;
-    _input_in: FallbackValue<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: FallbackValue<TNext['_output_in'], TPrev['_output_in']>;
-    _output_out: FallbackValue<TNext['_output_out'], TPrev['_output_out']>;
-  }
->;
-
-/**
- * @internal
- */
-type deriveParamsFromConfig<
-  TConfig extends AnyRootConfig,
-  TInputIn = unknown,
-> = {
-  _config: TConfig;
-  // eslint-disable-next-line @typescript-eslint/ban-types
-  _ctx_out: {};
-  _input_out: TInputIn;
-  _input_in: TInputIn;
-  _output_in: unknown;
-  _output_out: unknown;
-  _meta: TConfig['$types']['meta'];
-};
-/**
- * @internal
- */
-export type MiddlewareFunction<
-  TParams extends ProcedureParams<AnyProcedureParams>,
-  TParamsAfter extends ProcedureParams<AnyProcedureParams>,
-> = {
-  (opts: {
-    ctx: Simplify<
-      Overwrite<TParams['_config']['$types']['ctx'], TParams['_ctx_out']>
-    >;
-    type: ProcedureType;
-    path: string;
-    input: TParams['_input_out'];
-    getRawInput: GetRawInputFn;
-    meta: TParams['_meta'] | undefined;
-    next: {
-      (): Promise<MiddlewareResult<TParams>>;
-      <$Context>(opts: { ctx?: $Context; input?: unknown }): Promise<
-        MiddlewareResult<{
-          _config: TParams['_config'];
-          _ctx_out: $Context;
-          _input_in: TParams['_input_in'];
-          _input_out: TParams['_input_out'];
-          _output_in: TParams['_output_in'];
-          _output_out: TParams['_output_out'];
-          _meta: TParams['_meta'];
-        }>
-      >;
-      (opts: { getRawInput: GetRawInputFn }): Promise<
-        MiddlewareResult<TParams>
-      >;
-    };
-  }): Promise<MiddlewareResult<TParamsAfter>>;
-  _type?: string | undefined;
-};
-
-/**
- * @internal
- */
-export function createMiddlewareFactory<
-  TConfig extends AnyRootConfig,
-  TInputIn = unknown,
->() {
-  function createMiddlewareInner<
-    TNewParams extends ProcedureParams<AnyProcedureParams>,
-  >(
-    middlewares: MiddlewareFunction<any, any>[],
-  ): MiddlewareBuilder<deriveParamsFromConfig<TConfig, TInputIn>, TNewParams> {
-    return {
-      _middlewares: middlewares,
-      unstable_pipe(middlewareBuilderOrFn) {
-        const pipedMiddleware =
-          '_middlewares' in middlewareBuilderOrFn
-            ? middlewareBuilderOrFn._middlewares
-            : [middlewareBuilderOrFn];
-
-        return createMiddlewareInner([
-          ...(middlewares as any),
-          ...pipedMiddleware,
-        ]);
-      },
-    };
-  }
-
-  function createMiddleware<
-    TNewParams extends ProcedureParams<AnyProcedureParams>,
-  >(
-    fn: MiddlewareFunction<
-      deriveParamsFromConfig<TConfig, TInputIn>,
-      TNewParams
-    >,
-  ): MiddlewareBuilder<deriveParamsFromConfig<TConfig, TInputIn>, TNewParams> {
-    return createMiddlewareInner([fn]);
-  }
-
-  return createMiddleware;
-}
-
-export const experimental_standaloneMiddleware = <
-  TCtx extends {
-    ctx?: object;
-    meta?: object;
-    input?: unknown;
-  },
->() => ({
-  create: createMiddlewareFactory<
-    RootConfig<{
-      ctx: TCtx extends { ctx: infer T extends object } ? T : object;
-      meta: TCtx extends { meta: infer T extends object } ? T : object;
-      errorShape: object;
-      transformer: 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: ProcedureBuilderMiddleware = async (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: ProcedureBuilderMiddleware = async ({ 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,57 +0,0 @@
-export type ParserZodEsque<TInput, TParsedInput> = {
-  _input: TInput;
-  _output: TParsedInput;
-};
-
-export type ParserValibotEsque<TInput, TParsedInput> = {
-  types?: {
-    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>
-  | ParserValibotEsque<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/router.ts

@@ -1,226 +0,0 @@
-import { DefaultErrorShape, defaultFormatter } from '../error/formatter';
-import { TRPCError } from '../error/TRPCError';
-import { getHTTPStatusCodeFromError } from '../http/getHTTPStatusCode';
-import { TRPC_ERROR_CODES_BY_KEY } from '../rpc';
-import { createRecursiveProxy } from '../shared/createProxy';
-import { defaultTransformer } from '../transformer';
-import { AnyRootConfig } from './internals/config';
-import { omitPrototype } from './internals/omitPrototype';
-import { ProcedureCallOptions } from './internals/procedureBuilder';
-import { AnyProcedure, ProcedureArgs } from './procedure';
-import { ProcedureType } from './types';
-
-/** @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
- */
-type RouterCaller<TDef extends AnyRouterDef> = (
-  ctx: TDef['_config']['$types']['ctx'],
-) => DecoratedProcedureRecord<TDef['record']>;
-
-export interface Router<TDef extends AnyRouterDef> {
-  _def: TDef;
-  createCaller: RouterCaller<TDef>;
-
-  /**
-   * @deprecated
-   * FIXME: use the new standalone `getErrorShape` instead
-   */
-  getErrorShape(opts: {
-    error: TRPCError;
-    type: ProcedureType | 'unknown';
-    path: string | undefined;
-    input: unknown;
-    ctx: TDef['_config']['$types']['ctx'] | undefined;
-  }): TDef['_config']['$types']['errorShape'];
-}
-
-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>>;
-      },
-      getErrorShape(opts) {
-        const { path, error } = opts;
-        const { code } = opts.error;
-        const shape: DefaultErrorShape = {
-          message: error.message,
-          code: TRPC_ERROR_CODES_BY_KEY[code],
-          data: {
-            code,
-            httpStatus: getHTTPStatusCodeFromError(error),
-          },
-        };
-        if (config.isDev && typeof opts.error.stack === 'string') {
-          shape.data.stack = opts.error.stack;
-        }
-        if (typeof path === 'string') {
-          shape.data.path = path;
-        }
-        return this._def._config.errorFormatter({ ...opts, shape });
-      },
-    };
-    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);
-}

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
->;

package/src/error/utils.ts

@@ -1,23 +0,0 @@
-/**
- * @internal
- */
-export function isObject(value: unknown): value is Record<string, unknown> {
-  // check that value is object
-  return !!value && !Array.isArray(value) && typeof value === 'object';
-}
-
-/**
- * @internal
- */
-export function getMessageFromUnknownError(
-  err: unknown,
-  fallback: string,
-): string {
-  if (typeof err === 'string') {
-    return err;
-  }
-  if (isObject(err) && typeof err.message === 'string') {
-    return err.message;
-  }
-  return fallback;
-}

package/src/http/index.ts

@@ -1,4 +0,0 @@
-export * from './getHTTPStatusCode';
-export * from './resolveHTTPResponse';
-export * from './types';
-export * from './batchStreamFormatter';