@trpc/server 10.43.0 → 11.0.0-next.91

package/dist/subscription.js

@@ -1,38 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var TRPCError = require('./TRPCError-ae7b67e8.js');
-var observable = require('./observable-464116ac.js');
-
-/**
- * @deprecated
- * This functionality is deprecated and will be removed in the next major version.
- */ function subscriptionPullFactory(opts) {
-    let timer;
-    let stopped = false;
-    async function _pull(emit) {
-        /* istanbul ignore next -- @preserve */ if (stopped) {
-            return;
-        }
-        try {
-            await opts.pull(emit);
-        } catch (err /* istanbul ignore next -- @preserve */ ) {
-            emit.error(TRPCError.getTRPCErrorFromUnknown(err));
-        }
-        /* istanbul ignore else -- @preserve */ if (!stopped) {
-            timer = setTimeout(()=>_pull(emit), opts.intervalMs);
-        }
-    }
-    return observable.observable((emit)=>{
-        _pull(emit).catch((err)=>{
-            emit.error(TRPCError.getTRPCErrorFromUnknown(err));
-        });
-        return ()=>{
-            clearTimeout(timer);
-            stopped = true;
-        };
-    });
-}
-
-exports.subscriptionPullFactory = subscriptionPullFactory;

package/dist/subscription.mjs

@@ -1,34 +0,0 @@
-import { g as getTRPCErrorFromUnknown } from './TRPCError-816ff32e.mjs';
-import { o as observable } from './observable-ade1bad8.mjs';
-
-/**
- * @deprecated
- * This functionality is deprecated and will be removed in the next major version.
- */ function subscriptionPullFactory(opts) {
-    let timer;
-    let stopped = false;
-    async function _pull(emit) {
-        /* istanbul ignore next -- @preserve */ if (stopped) {
-            return;
-        }
-        try {
-            await opts.pull(emit);
-        } catch (err /* istanbul ignore next -- @preserve */ ) {
-            emit.error(getTRPCErrorFromUnknown(err));
-        }
-        /* istanbul ignore else -- @preserve */ if (!stopped) {
-            timer = setTimeout(()=>_pull(emit), opts.intervalMs);
-        }
-    }
-    return observable((emit)=>{
-        _pull(emit).catch((err)=>{
-            emit.error(getTRPCErrorFromUnknown(err));
-        });
-        return ()=>{
-            clearTimeout(timer);
-            stopped = true;
-        };
-    });
-}
-
-export { subscriptionPullFactory };

package/src/adapters/lambda/index.ts

@@ -1,18 +0,0 @@
-import {
-  awsLambdaRequestHandler,
-  CreateAWSLambdaContextOptions,
-} from '../aws-lambda';
-import { APIGatewayEvent } from '../aws-lambda/utils';
-
-export * from '../aws-lambda';
-
-/**
- * @deprecated use `aws-lambda` instead
- */
-export type CreateLambdaContextOptions<TEvent extends APIGatewayEvent> =
-  CreateAWSLambdaContextOptions<TEvent>;
-
-/**
- * @deprecated use `aws-lambda` instead
- */
-export const lambdaRequestHandler = awsLambdaRequestHandler;

package/src/deprecated/internals/middlewares.ts

@@ -1,61 +0,0 @@
-import { TRPCError } from '../../error/TRPCError';
-import { ProcedureType } from '../router';
-
-/**
- * @deprecated
- */
-export const middlewareMarker = 'middlewareMarker' as 'middlewareMarker' & {
-  __brand: 'middlewareMarker';
-};
-
-interface MiddlewareResultBase<TContext> {
-  /**
-   * All middlewares should pass through their `next()`'s output.
-   * Requiring this marker makes sure that can't be forgotten at compile-time.
-   */
-  readonly marker: typeof middlewareMarker;
-  ctx: TContext;
-}
-
-/**
- * @deprecated
- */
-interface MiddlewareOKResult<TContext> extends MiddlewareResultBase<TContext> {
-  ok: true;
-  data: unknown;
-  // this could be extended with `input`/`rawInput` later
-}
-
-/**
- * @deprecated
- */
-interface MiddlewareErrorResult<TContext>
-  extends MiddlewareResultBase<TContext> {
-  ok: false;
-  error: TRPCError;
-  // we could guarantee it's always of this type
-}
-
-/**
- * @deprecated
- */
-export type MiddlewareResult<TContext> =
-  | MiddlewareErrorResult<TContext>
-  | MiddlewareOKResult<TContext>;
-
-/**
- * @deprecated
- */
-export type MiddlewareFunction<TInputContext, TContext, TMeta> = (opts: {
-  ctx: TInputContext;
-  type: ProcedureType;
-  path: string;
-  rawInput: unknown;
-  meta?: TMeta;
-  next: {
-    (): Promise<MiddlewareResult<TInputContext>>;
-    <TNewContext>(opts: { ctx: TNewContext }): Promise<
-      MiddlewareResult<TNewContext>
-    >;
-  };
-}) => Promise<MiddlewareResult<TContext>>;

package/src/deprecated/internals/procedure.ts

@@ -1,411 +0,0 @@
-import { getTRPCErrorFromUnknown, TRPCError } from '../../error/TRPCError';
-import { InferLast } from '../../types';
-import { ProcedureType } from '../router';
-import {
-  MiddlewareFunction,
-  middlewareMarker,
-  MiddlewareResult,
-} from './middlewares';
-
-export type ProcedureParserZodEsque<TInput, TOutput> = {
-  _input: TInput;
-  _output: TOutput;
-};
-
-export type ProcedureParserMyZodEsque<TType> = {
-  parse: (input: any) => TType;
-};
-
-export type ProcedureParserSuperstructEsque<TType> = {
-  create: (input: unknown) => TType;
-};
-
-export type ProcedureParserCustomValidatorEsque<TType> = (
-  input: unknown,
-) => Promise<TType> | TType;
-
-export type ProcedureParserYupEsque<TType> = {
-  validateSync: (input: unknown) => TType;
-};
-
-export type ProcedureParserWithInputOutput<TInput, TOutput> =
-  ProcedureParserZodEsque<TInput, TOutput>;
-
-export type ProcedureParser<TType> =
-  | ProcedureParserCustomValidatorEsque<TType>
-  | ProcedureParserMyZodEsque<TType>
-  | ProcedureParserSuperstructEsque<TType>
-  | ProcedureParserYupEsque<TType>;
-
-export type ProcedureResolver<TContext, TInput, TOutput> = (opts: {
-  ctx: TContext;
-  input: TInput;
-  type: ProcedureType;
-}) => Promise<TOutput> | TOutput;
-
-interface ProcedureOptions<TContext, TMeta, TInput, TOutput, TParsedOutput> {
-  middlewares: MiddlewareFunction<any, any, any>[];
-  resolver: ProcedureResolver<TContext, TInput, TOutput>;
-  inputParser: ProcedureParser<TInput>;
-  outputParser: ProcedureParser<TParsedOutput>;
-  meta: TMeta;
-}
-
-/**
- * @internal
- * @deprecated
- */
-export interface ProcedureCallOptions<TContext> {
-  ctx: TContext;
-  rawInput: unknown;
-  path: string;
-  type: ProcedureType;
-}
-
-type ParseFn<TType> = (value: unknown) => Promise<TType> | TType;
-
-function getParseFn<TType>(
-  procedureParser: ProcedureParser<TType>,
-): ParseFn<TType> {
-  const parser = procedureParser as any;
-
-  if (typeof parser === 'function') {
-    // ProcedureParserCustomValidatorEsque
-    return parser;
-  }
-
-  if (typeof parser.parseAsync === 'function') {
-    // ProcedureParserZodEsque
-    return parser.parseAsync.bind(parser);
-  }
-
-  if (typeof parser.parse === 'function') {
-    // ProcedureParserZodEsque
-    return parser.parse.bind(parser);
-  }
-
-  if (typeof parser.validateSync === 'function') {
-    // ProcedureParserYupEsque
-    return parser.validateSync.bind(parser);
-  }
-
-  if (typeof parser.create === 'function') {
-    // ProcedureParserSuperstructEsque
-    return parser.create.bind(parser);
-  }
-
-  throw new Error('Could not find a validator fn');
-}
-
-/**
- * @internal
- * @deprecated
- */
-export class Procedure<
-  TInputContext,
-  TContext,
-  TMeta,
-  TInput,
-  TParsedInput,
-  TOutput,
-  TParsedOutput,
-  TFinalOutput = unknown extends TParsedOutput ? TOutput : TParsedOutput,
-> {
-  private middlewares: Readonly<MiddlewareFunction<any, any, any>[]>;
-  private resolver: ProcedureResolver<TContext, TParsedInput, TOutput>;
-  private readonly inputParser: ProcedureParser<TParsedInput>;
-  private parseInputFn: ParseFn<TParsedInput>;
-  private readonly outputParser: ProcedureParser<TFinalOutput>;
-  private parseOutputFn: ParseFn<TFinalOutput>;
-  public readonly meta: TMeta;
-
-  constructor(
-    opts: ProcedureOptions<
-      TContext,
-      TMeta,
-      TParsedInput,
-      TOutput,
-      TFinalOutput
-    >,
-  ) {
-    this.middlewares = opts.middlewares;
-    this.resolver = opts.resolver;
-    this.inputParser = opts.inputParser;
-    this.parseInputFn = getParseFn(this.inputParser);
-    this.outputParser = opts.outputParser;
-    this.parseOutputFn = getParseFn(this.outputParser);
-    this.meta = opts.meta;
-  }
-
-  public _def() {
-    return {
-      middlewares: this.middlewares,
-      resolver: this.resolver,
-      inputParser: this.inputParser,
-      outputParser: this.outputParser,
-      meta: this.meta,
-    };
-  }
-
-  private async parseInput(rawInput: unknown): Promise<TParsedInput> {
-    try {
-      return await this.parseInputFn(rawInput);
-    } catch (cause) {
-      throw new TRPCError({
-        code: 'BAD_REQUEST',
-        cause,
-      });
-    }
-  }
-
-  private async parseOutput(rawOutput: TOutput): Promise<TFinalOutput> {
-    try {
-      return await this.parseOutputFn(rawOutput);
-    } catch (cause) {
-      throw new TRPCError({
-        code: 'INTERNAL_SERVER_ERROR',
-        cause,
-        message: 'Output validation failed',
-      });
-    }
-  }
-
-  /**
-   * Trigger middlewares in order, parse raw input, call resolver & parse raw output
-   * @internal
-   */
-  public async call(
-    opts: ProcedureCallOptions<TInputContext>,
-  ): Promise<TFinalOutput> {
-    // wrap the actual resolver and treat as the last "middleware"
-    const middlewaresWithResolver = this.middlewares.concat([
-      async ({ ctx }: { ctx: any }) => {
-        const input = await this.parseInput(opts.rawInput);
-        const rawOutput = await this.resolver({
-          ...opts,
-          ctx,
-          input,
-        });
-        const data = await this.parseOutput(rawOutput);
-        return {
-          marker: middlewareMarker,
-          ok: true,
-          data,
-          ctx,
-        } as const;
-      },
-    ]);
-
-    // run the middlewares recursively with the resolver as the last one
-    const callRecursive = async (
-      callOpts: { ctx: any; index: number } = {
-        index: 0,
-        ctx: opts.ctx,
-      },
-    ): Promise<MiddlewareResult<any>> => {
-      try {
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        const result = await middlewaresWithResolver[callOpts.index]!({
-          ctx: callOpts.ctx,
-          type: opts.type,
-          path: opts.path,
-          rawInput: opts.rawInput,
-          meta: this.meta,
-          next: async (nextOpts?: { ctx: any }) => {
-            return await callRecursive({
-              index: callOpts.index + 1,
-              ctx: nextOpts ? nextOpts.ctx : callOpts.ctx,
-            });
-          },
-        });
-        return result;
-      } catch (cause) {
-        return {
-          ctx: callOpts.ctx,
-          ok: false,
-          error: getTRPCErrorFromUnknown(cause),
-          marker: middlewareMarker,
-        };
-      }
-    };
-
-    // there's always at least one "next" since we wrap this.resolver in a middleware
-    const result = await callRecursive();
-    if (!result) {
-      throw new TRPCError({
-        code: 'INTERNAL_SERVER_ERROR',
-        message:
-          'No result from middlewares - did you forget to `return next()`?',
-      });
-    }
-    if (!result.ok) {
-      // re-throw original error
-      throw result.error;
-    }
-
-    return result.data as TFinalOutput;
-  }
-
-  /**
-   * Create new procedure with passed middlewares
-   * @param middlewares
-   */
-  public inheritMiddlewares(
-    middlewares: MiddlewareFunction<TInputContext, TContext, TMeta>[],
-  ): this {
-    const Constructor: new (
-      opts: ProcedureOptions<
-        TContext,
-        TMeta,
-        TParsedInput,
-        TOutput,
-        TFinalOutput
-      >,
-    ) => Procedure<
-      TInputContext,
-      TContext,
-      TMeta,
-      TInput,
-      TParsedInput,
-      TOutput,
-      TParsedOutput
-    > = (this as any).constructor;
-
-    const instance = new Constructor({
-      middlewares: [...middlewares, ...this.middlewares],
-      resolver: this.resolver,
-      inputParser: this.inputParser,
-      outputParser: this.outputParser,
-      meta: this.meta,
-    });
-
-    return instance as any;
-  }
-}
-
-export type CreateProcedureWithInput<TContext, TMeta, TInput, TOutput> = {
-  input: ProcedureParser<TInput>;
-  output?: ProcedureParser<TOutput>;
-  meta?: TMeta;
-  resolve: ProcedureResolver<TContext, TInput, InferLast<TOutput>>;
-};
-
-export type CreateProcedureWithInputOutputParser<
-  TContext,
-  TMeta,
-  TInput,
-  TParsedInput,
-  TOutput,
-  TParsedOutput,
-> = {
-  input: ProcedureParserWithInputOutput<TInput, TParsedInput>;
-  output?: ProcedureParserWithInputOutput<TOutput, TParsedOutput>;
-  meta?: TMeta;
-  resolve: ProcedureResolver<TContext, TParsedInput, InferLast<TOutput>>;
-};
-
-export type CreateProcedureWithoutInput<
-  TContext,
-  TMeta,
-  TOutput,
-  TParsedOutput,
-> = {
-  output?:
-    | ProcedureParser<TOutput>
-    | ProcedureParserWithInputOutput<TOutput, TParsedOutput>;
-  meta?: TMeta;
-  resolve: ProcedureResolver<TContext, undefined, InferLast<TOutput>>;
-};
-
-export type CreateProcedureOptions<
-  TContext,
-  TMeta = undefined,
-  TInput = undefined,
-  TParsedInput = undefined,
-  TOutput = undefined,
-  TParsedOutput = undefined,
-> =
-  | CreateProcedureWithInput<TContext, TMeta, TInput, TOutput>
-  | CreateProcedureWithInputOutputParser<
-      TContext,
-      TMeta,
-      TInput,
-      TParsedInput,
-      TOutput,
-      TParsedOutput
-    >
-  | CreateProcedureWithoutInput<TContext, TMeta, TOutput, TParsedOutput>;
-
-export function createProcedure<
-  TContext,
-  TMeta,
-  TInput,
-  TParsedInput,
-  TOutput,
-  TParsedOutput,
->(
-  opts: CreateProcedureOptions<
-    TContext,
-    TMeta,
-    TInput,
-    TParsedInput,
-    TOutput,
-    TParsedOutput
-  >,
-): Procedure<
-  unknown,
-  TContext,
-  TMeta,
-  TInput,
-  TParsedInput,
-  TOutput,
-  TParsedOutput
-> {
-  const inputParser =
-    'input' in opts
-      ? opts.input
-      : (input: unknown) => {
-          if (input != null) {
-            throw new TRPCError({
-              code: 'BAD_REQUEST',
-              message: 'No input expected',
-            });
-          }
-          return undefined;
-        };
-
-  const outputParser =
-    'output' in opts && opts.output
-      ? opts.output
-      : (output: unknown) => output as TOutput;
-
-  return new Procedure({
-    inputParser: inputParser as any,
-    resolver: opts.resolve as any,
-    middlewares: [],
-    outputParser: outputParser as any,
-    meta: opts.meta as any,
-  });
-}
-
-export type inferProcedureFromOptions<
-  TInputContext,
-  TOptions extends CreateProcedureOptions<any, any, any, any, any, any>,
-> = TOptions extends CreateProcedureOptions<
-  infer TContext,
-  infer TMeta,
-  infer TInput,
-  infer TParsedInput,
-  infer TOutput,
-  infer TParsedOutput
->
-  ? Procedure<
-      TInputContext,
-      TContext,
-      TMeta,
-      unknown extends TInput ? undefined : TInput,
-      unknown extends TParsedInput ? undefined : TParsedInput,
-      TOutput,
-      TParsedOutput
-    >
-  : never;