@trpc/server 11.0.0-alpha-tmp-export-from-main.211 → 11.0.0-alpha-tmp-export-from-main-nuke-core.229

package/src/unstable-core-do-not-import/initTRPC.ts

@@ -0,0 +1,206 @@
+import { createFlatProxy } from './createProxy';
+import {
+  defaultFormatter,
+  type DefaultErrorShape,
+  type ErrorFormatter,
+  type ErrorFormatterShape,
+} from './error/formatter';
+import { createMiddlewareFactory } from './middleware';
+import { createBuilder } from './procedureBuilder';
+import {
+  isServerDefault,
+  type CreateRootConfigTypes,
+  type RootConfig,
+  type RootConfigTypes,
+  type RuntimeConfig,
+} from './rootConfig';
+import {
+  createCallerFactory,
+  createRouterFactory,
+  mergeRouters,
+} from './router';
+import {
+  defaultTransformer,
+  getDataTransformer,
+  type DataTransformerOptions,
+  type DefaultDataTransformer,
+} from './transformer';
+import type {
+  Overwrite,
+  PickFirstDefined,
+  Unwrap,
+  ValidateShape,
+} from './types';
+
+type PartialRootConfigTypes = Partial<RootConfigTypes>;
+
+type CreateRootConfigTypesFromPartial<TTypes extends PartialRootConfigTypes> =
+  CreateRootConfigTypes<{
+    ctx: TTypes['ctx'] extends RootConfigTypes['ctx'] ? TTypes['ctx'] : object;
+    meta: TTypes['meta'] extends RootConfigTypes['meta']
+      ? TTypes['meta']
+      : object;
+    errorShape: TTypes['errorShape'];
+    transformer: DataTransformerOptions;
+  }>;
+
+/**
+ * TODO: This can be improved:
+ * - We should be able to chain `.meta()`/`.context()` only once
+ * - Simplify typings
+ * - Doesn't need to be a class but it doesn't really hurt either
+ */
+
+class TRPCBuilder<TParams extends PartialRootConfigTypes = object> {
+  /**
+   * Add a context shape as a generic to the root object
+   * @link https://trpc.io/docs/v11/server/context
+   */
+  context<
+    TNewContext extends
+      | RootConfigTypes['ctx']
+      | ((...args: unknown[]) => RootConfigTypes['ctx']),
+  >() {
+    type NextParams = Overwrite<TParams, { ctx: Unwrap<TNewContext> }>;
+
+    return new TRPCBuilder<NextParams>();
+  }
+
+  /**
+   * Add a meta shape as a generic to the root object
+   * @link https://trpc.io/docs/v11/quickstart
+   */
+  meta<TNewMeta extends RootConfigTypes['meta']>() {
+    type NextParams = Overwrite<TParams, { meta: TNewMeta }>;
+
+    return new TRPCBuilder<NextParams>();
+  }
+
+  /**
+   * Create the root object
+   * @link https://trpc.io/docs/v11/server/routers#initialize-trpc
+   */
+  create<
+    TOptions extends Partial<
+      RuntimeConfig<CreateRootConfigTypesFromPartial<TParams>>
+    >,
+  >(
+    options?:
+      | ValidateShape<
+          TOptions,
+          Partial<RuntimeConfig<CreateRootConfigTypesFromPartial<TParams>>>
+        >
+      | undefined,
+  ) {
+    return createTRPCInner<TParams>()<TOptions>(options);
+  }
+}
+
+/**
+ * Builder to initialize the tRPC root object - use this exactly once per backend
+ * @link https://trpc.io/docs/v11/quickstart
+ */
+export const initTRPC = new TRPCBuilder();
+
+function createTRPCInner<TParams extends PartialRootConfigTypes>() {
+  type $Generics = CreateRootConfigTypesFromPartial<TParams>;
+
+  type $Context = $Generics['ctx'];
+  type $Meta = $Generics['meta'];
+  type $Runtime = Partial<RuntimeConfig<$Generics>>;
+
+  return function initTRPCInner<TOptions extends $Runtime>(
+    runtime?: ValidateShape<TOptions, $Runtime>,
+  ) {
+    type $Formatter = PickFirstDefined<
+      TOptions['errorFormatter'],
+      ErrorFormatter<$Context, DefaultErrorShape>
+    >;
+    type $Transformer = TOptions['transformer'] extends DataTransformerOptions
+      ? TOptions['transformer']
+      : DefaultDataTransformer;
+    type $ErrorShape = ErrorFormatterShape<$Formatter>;
+
+    type $Config = RootConfig<{
+      ctx: $Context;
+      meta: $Meta;
+      errorShape: $ErrorShape;
+      transformer: $Transformer;
+    }>;
+
+    const errorFormatter = runtime?.errorFormatter ?? defaultFormatter;
+    const transformer = getDataTransformer(
+      runtime?.transformer ?? defaultTransformer,
+    ) as $Transformer;
+
+    const config: $Config = {
+      transformer,
+      isDev:
+        runtime?.isDev ??
+        // eslint-disable-next-line @typescript-eslint/dot-notation
+        globalThis.process?.env?.['NODE_ENV'] !== 'production',
+      allowOutsideOfServer: runtime?.allowOutsideOfServer ?? false,
+      errorFormatter,
+      isServer: runtime?.isServer ?? isServerDefault,
+      /**
+       * @internal
+       */
+      $types: createFlatProxy((key) => {
+        throw new Error(
+          `Tried to access "$types.${key}" which is not available at runtime`,
+        );
+      }),
+    };
+
+    {
+      // Server check
+      const isServer: boolean = runtime?.isServer ?? isServerDefault;
+
+      if (!isServer && runtime?.allowOutsideOfServer !== true) {
+        throw new Error(
+          `You're trying to use @trpc/server in a non-server environment. This is not supported by default.`,
+        );
+      }
+    }
+    return {
+      /**
+       * These are just types, they can't be used
+       * @internal
+       */
+      _config: config,
+      /**
+       * Builder object for creating procedures
+       * @link https://trpc.io/docs/v11/server/procedures
+       */
+      procedure: createBuilder<
+        $Config['$types']['ctx'],
+        $Config['$types']['meta']
+      >({
+        meta: runtime?.defaultMeta,
+      }),
+      /**
+       * Create reusable middlewares
+       * @link https://trpc.io/docs/v11/server/middlewares
+       */
+      middleware: createMiddlewareFactory<
+        $Config['$types']['ctx'],
+        $Config['$types']['meta']
+      >(),
+      /**
+       * Create a router
+       * @link https://trpc.io/docs/v11/server/routers
+       */
+      router: createRouterFactory<$Config>(config),
+      /**
+       * Merge Routers
+       * @link https://trpc.io/docs/v11/server/merging-routers
+       */
+      mergeRouters,
+      /**
+       * Create a server-side caller for a router
+       * @link https://trpc.io/docs/v11/server/server-side-calls
+       */
+      createCallerFactory: createCallerFactory<$Config>(),
+    };
+  };
+}

package/src/unstable-core-do-not-import/middleware.ts

@@ -0,0 +1,233 @@
+import { TRPCError } from './error/TRPCError';
+import type { ParseFn } from './parser';
+import type { ProcedureType } from './procedure';
+import type { GetRawInputFn, Overwrite, Simplify } from './types';
+import { isObject } from './utils';
+
+/** @internal */
+export const middlewareMarker = 'middlewareMarker' as 'middlewareMarker' & {
+  __brand: 'middlewareMarker';
+};
+type MiddlewareMarker = typeof middlewareMarker;
+
+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;
+}
+
+interface MiddlewareOKResult<_TContextOverride> extends MiddlewareResultBase {
+  ok: true;
+  data: unknown;
+  // this could be extended with `input`/`rawInput` later
+}
+
+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;
+}
+
+/**
+ * Create a standalone middleware
+ * @link https://trpc.io/docs/v11/server/middlewares#experimental-standalone-middlewares
+ */
+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
+  >(),
+});
+
+/**
+ * @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 =
+        isObject(opts.input) && isObject(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/unstable-core-do-not-import/parser.ts

@@ -0,0 +1,94 @@
+// 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;
+
+export type ParseFn<TType> = (value: unknown) => Promise<TType> | TType;
+
+export function getParseFn<TType>(procedureParser: Parser): ParseFn<TType> {
+  const parser = procedureParser as any;
+
+  if (typeof parser === 'function') {
+    // ParserCustomValidatorEsque
+    return parser;
+  }
+
+  if (typeof parser.parseAsync === 'function') {
+    // ParserZodEsque
+    return parser.parseAsync.bind(parser);
+  }
+
+  if (typeof parser.parse === 'function') {
+    // ParserZodEsque
+    // ParserValibotEsque (<= v0.12.X)
+    return parser.parse.bind(parser);
+  }
+
+  if (typeof parser.validateSync === 'function') {
+    // ParserYupEsque
+    return parser.validateSync.bind(parser);
+  }
+
+  if (typeof parser.create === 'function') {
+    // ParserSuperstructEsque
+    return parser.create.bind(parser);
+  }
+
+  if (typeof parser.assert === 'function') {
+    // ParserScaleEsque
+    return (value) => {
+      parser.assert(value);
+      return value as TType;
+    };
+  }
+
+  throw new Error('Could not find a validator fn');
+}

package/src/unstable-core-do-not-import/procedure.ts

@@ -0,0 +1,108 @@
+import type { inferObservableValue } from '../observable';
+import type { ProcedureCallOptions } from './procedureBuilder';
+import type { Serialize } from './serialize';
+import type { DefaultDataTransformer } from './transformer';
+import type { inferConfig, TRPCInferrable } from './TRPCInferrable';
+
+export const procedureTypes = ['query', 'mutation', 'subscription'] as const;
+/**
+ * @public
+ */
+export type ProcedureType = (typeof procedureTypes)[number];
+
+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>;
+
+/**
+ * @internal
+ */
+export type inferTransformedProcedureOutput<
+  TInferrable extends TRPCInferrable,
+  TProcedure extends AnyProcedure,
+> = inferConfig<TInferrable>['transformer'] extends DefaultDataTransformer
+  ? Serialize<TProcedure['_def']['_output_out']>
+  : TProcedure['_def']['_output_out'];
+
+/** @internal */
+export type inferTransformedSubscriptionOutput<
+  TInferrable extends TRPCInferrable,
+  TProcedure extends AnyProcedure,
+> = inferConfig<TInferrable>['transformer'] extends DefaultDataTransformer
+  ? Serialize<inferObservableValue<TProcedure['_def']['_output_out']>>
+  : inferObservableValue<TProcedure['_def']['_output_out']>;
+
+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'];