@trpc/server 11.0.0-alpha-tmp-export-from-main.218 → 11.0.0-alpha-tmp-export-from-main-nuke-core.239

package/src/unstable-core-do-not-import/http/types.ts

@@ -0,0 +1,111 @@
+import type { TRPCError } from '../error/TRPCError';
+import type { ProcedureType } from '../procedure';
+import type {
+  AnyRouter,
+  inferRouterContext,
+  inferRouterError,
+} from '../router';
+import type { TRPCResponse } from '../rpc';
+import type { Dict } from '../types';
+
+export type HTTPHeaders = Dict<string[] | string>;
+
+export interface HTTPResponse {
+  status: number;
+  headers?: HTTPHeaders;
+  body?: string;
+}
+
+export type ResponseChunk = [procedureIndex: number, responseBody: string];
+
+export interface ResponseMeta {
+  status?: number;
+  headers?: HTTPHeaders;
+}
+
+/**
+ * @internal
+ */
+export type ResponseMetaFn<TRouter extends AnyRouter> = (opts: {
+  data: TRPCResponse<unknown, inferRouterError<TRouter>>[];
+  ctx?: inferRouterContext<TRouter>;
+  /**
+   * The different tRPC paths requested
+   **/
+  paths?: string[];
+  type: ProcedureType | 'unknown';
+  errors: TRPCError[];
+  /**
+   * `true` if the `ResponseMeta` are being
+   * generated without knowing the response data
+   * (e.g. for streaming requests).
+   */
+  eagerGeneration?: boolean;
+}) => ResponseMeta;
+
+export interface HTTPRequest {
+  method: string;
+  query: URLSearchParams;
+  headers: HTTPHeaders;
+  body: unknown;
+}
+
+/**
+ * Base interface for anything using HTTP
+ */
+export interface HTTPBaseHandlerOptions<TRouter extends AnyRouter, TRequest>
+  extends BaseHandlerOptions<TRouter, TRequest> {
+  /**
+   * Add handler to be called before response is sent to the user
+   * Useful for setting cache headers
+   * @link https://trpc.io/docs/v11/caching
+   */
+  responseMeta?: ResponseMetaFn<TRouter>;
+}
+
+/** @internal */
+export type ProcedureCall = {
+  type: ProcedureType;
+  input?: unknown;
+  path: string;
+};
+
+/**
+ * Information about the incoming request
+ * @internal
+ */
+export type TRPCRequestInfo = {
+  isBatchCall: boolean;
+  calls: ProcedureCall[];
+};
+
+/**
+ * Inner createContext function for `resolveHTTPResponse` used to forward `TRPCRequestInfo` to `createContext`
+ * @internal
+ */
+export type ResolveHTTPRequestOptionsContextFn<TRouter extends AnyRouter> =
+  (opts: { info: TRPCRequestInfo }) => Promise<inferRouterContext<TRouter>>;
+
+/**
+ * @internal
+ */
+export type OnErrorFunction<TRouter extends AnyRouter, TRequest> = (opts: {
+  error: TRPCError;
+  type: ProcedureType | 'unknown';
+  path: string | undefined;
+  req: TRequest;
+  input: unknown;
+  ctx: inferRouterContext<TRouter> | undefined;
+}) => void;
+
+/**
+ * Base interface for any response handler
+ * @internal
+ */
+export interface BaseHandlerOptions<TRouter extends AnyRouter, TRequest> {
+  onError?: OnErrorFunction<TRouter, TRequest>;
+  batching?: {
+    enabled: boolean;
+  };
+  router: TRouter;
+}

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

@@ -0,0 +1,110 @@
+/**
+ * **DO NOT IMPORT FROM HERE FILE**
+ *
+ * This file is here to:
+ * - make TypeScript happy and prevent _"The inferred type of 'createContext' cannot be named without a reference to [...]"_.
+ * - the the glue between the official `@trpc/*`-packages
+ *
+ *
+ * If you seem to need to import anything from here, please open an issue at https://github.com/trpc/trpc/issues
+ */
+export type { DefaultErrorShape, DefaultErrorData } from './error/formatter';
+export { getErrorShape } from './error/getErrorShape';
+export {
+  TRPCError,
+  getCauseFromUnknown,
+  getTRPCErrorFromUnknown,
+} from './error/TRPCError';
+
+export { initTRPC } from './initTRPC';
+export type {
+  AnyMiddlewareFunction,
+  MiddlewareFunction,
+  MiddlewareBuilder,
+} from './middleware';
+export {
+  createInputMiddleware,
+  createOutputMiddleware,
+  experimental_standaloneMiddleware,
+  middlewareMarker,
+} from './middleware';
+export type { inferParser } from './parser';
+export type {
+  Procedure,
+  ProcedureType,
+  AnyProcedure,
+  AnyQueryProcedure,
+  AnyMutationProcedure,
+  AnySubscriptionProcedure,
+  ProcedureArgs,
+  ProcedureOptions,
+  MutationProcedure,
+  inferHandlerInput,
+  inferProcedureInput,
+  inferProcedureOutput,
+  inferTransformedProcedureOutput,
+  inferTransformedSubscriptionOutput,
+  inferProcedureParams,
+  QueryProcedure,
+  SubscriptionProcedure,
+} from './procedure';
+export { procedureTypes } from './procedure';
+export type { ProcedureBuilder } from './procedureBuilder';
+export { unsetMarker, createBuilder } from './procedureBuilder';
+export type { AnyRootConfig, RootConfig } from './rootConfig';
+export type {
+  AnyRouter,
+  ProcedureRecord,
+  ProcedureRouterRecord,
+  CreateRouterInner,
+  Router,
+  RouterCaller,
+  AnyRouterDef,
+  inferRouterContext,
+  inferRouterError,
+  inferRouterInputs,
+  inferRouterMeta,
+  inferRouterOutputs,
+  createRouterFactory,
+} from './router';
+
+export type { TRPCInferrable, inferErrorShape } from './TRPCInferrable';
+export { callProcedure, mergeRouters } from './router';
+export type {
+  CombinedDataTransformer,
+  CombinedDataTransformerClient,
+  DataTransformer,
+  DataTransformerOptions,
+  DefaultDataTransformer,
+} from './transformer';
+export { transformResult, transformTRPCResponse } from './transformer';
+
+export { createFlatProxy, createRecursiveProxy } from './createProxy';
+
+// For `.d.ts` files https://github.com/trpc/trpc/issues/3943
+export type { SerializeObject, Serialize } from './serialize';
+
+export type {
+  DeepPartial,
+  Dict,
+  DistributiveOmit,
+  Filter,
+  FilterKeys,
+  Maybe,
+  MaybePromise,
+  Simplify,
+  Unwrap,
+  WithoutIndexSignature,
+  Overwrite,
+  PickFirstDefined,
+  ValidateShape,
+  IntersectionError,
+  ProtectedIntersection,
+} from './types';
+export { isObject } from './utils';
+
+/**
+ * These should be re-exported from separate entrypoints in server package
+ */
+export * from './rpc';
+export * from './http';

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