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

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

@@ -1,206 +0,0 @@
-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

@@ -1,233 +0,0 @@
-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/observable/index.ts

@@ -1,10 +0,0 @@
-export type { inferObservableValue } from './observable';
-export { isObservable, observable, observableToPromise } from './observable';
-export { map, share, tap } from './operators';
-export type {
-  Observable,
-  Observer,
-  TeardownLogic,
-  Unsubscribable,
-  UnsubscribeFn,
-} from './types';

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

@@ -1,155 +0,0 @@
-import { identity } from '../utils';
-import type {
-  Observable,
-  Observer,
-  OperatorFunction,
-  TeardownLogic,
-  UnaryFunction,
-} from './types';
-
-/** @public */
-export type inferObservableValue<TObservable> = TObservable extends Observable<
-  infer TValue,
-  unknown
->
-  ? TValue
-  : never;
-
-/** @public */
-export function isObservable(x: unknown): x is Observable<unknown, unknown> {
-  return typeof x === 'object' && x !== null && 'subscribe' in x;
-}
-
-/** @public */
-export function observable<TValue, TError = unknown>(
-  subscribe: (observer: Observer<TValue, TError>) => TeardownLogic,
-): Observable<TValue, TError> {
-  const self: Observable<TValue, TError> = {
-    subscribe(observer) {
-      let teardownRef: TeardownLogic | null = null;
-      let isDone = false;
-      let unsubscribed = false;
-      let teardownImmediately = false;
-      function unsubscribe() {
-        if (teardownRef === null) {
-          teardownImmediately = true;
-          return;
-        }
-        if (unsubscribed) {
-          return;
-        }
-        unsubscribed = true;
-
-        if (typeof teardownRef === 'function') {
-          teardownRef();
-        } else if (teardownRef) {
-          teardownRef.unsubscribe();
-        }
-      }
-      teardownRef = subscribe({
-        next(value) {
-          if (isDone) {
-            return;
-          }
-          observer.next?.(value);
-        },
-        error(err) {
-          if (isDone) {
-            return;
-          }
-          isDone = true;
-          observer.error?.(err);
-          unsubscribe();
-        },
-        complete() {
-          if (isDone) {
-            return;
-          }
-          isDone = true;
-          observer.complete?.();
-          unsubscribe();
-        },
-      });
-      if (teardownImmediately) {
-        unsubscribe();
-      }
-      return {
-        unsubscribe,
-      };
-    },
-    pipe(
-      ...operations: OperatorFunction<any, any, any, any>[]
-    ): Observable<any, any> {
-      return pipeFromArray(operations)(self) as any;
-    },
-  };
-  return self;
-}
-
-function pipeFromArray<TSource, TReturn>(
-  fns: UnaryFunction<TSource, TReturn>[],
-): UnaryFunction<TSource, TReturn> {
-  if (fns.length === 0) {
-    return identity as UnaryFunction<any, any>;
-  }
-
-  if (fns.length === 1) {
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    return fns[0]!;
-  }
-
-  return function piped(input: TSource): TReturn {
-    return fns.reduce(
-      (prev: any, fn: UnaryFunction<TSource, TReturn>) => fn(prev),
-      input as any,
-    );
-  };
-}
-
-class ObservableAbortError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = 'ObservableAbortError';
-    Object.setPrototypeOf(this, ObservableAbortError.prototype);
-  }
-}
-
-/** @internal */
-export function observableToPromise<TValue>(
-  observable: Observable<TValue, unknown>,
-) {
-  let abort: () => void;
-  const promise = new Promise<TValue>((resolve, reject) => {
-    let isDone = false;
-    function onDone() {
-      if (isDone) {
-        return;
-      }
-      isDone = true;
-      reject(new ObservableAbortError('This operation was aborted.'));
-      obs$.unsubscribe();
-    }
-    const obs$ = observable.subscribe({
-      next(data) {
-        isDone = true;
-        resolve(data);
-        onDone();
-      },
-      error(data) {
-        isDone = true;
-        reject(data);
-        onDone();
-      },
-      complete() {
-        isDone = true;
-        onDone();
-      },
-    });
-    abort = onDone;
-  });
-  return {
-    promise,
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    abort: abort!,
-  };
-}