@trpc/server 11.0.0-rc.601 → 11.0.0-rc.607

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

@@ -37,24 +37,21 @@ import { mergeWithoutOverrides } from './utils';
 type IntersectIfDefined<TType, TWith> = TType extends UnsetMarker
   ? TWith
   : TWith extends UnsetMarker
-  ? TType
-  : Simplify<TType & TWith>;
-``;
+    ? TType
+    : Simplify<TType & TWith>;
+
 type DefaultValue<TValue, TFallback> = TValue extends UnsetMarker
   ? TFallback
   : TValue;
 
-type inferAsyncIterator<TOutput> = TOutput extends AsyncIterator<
-  infer $Yield,
-  infer $Return,
-  infer $Next
->
-  ? {
-      yield: $Yield;
-      return: $Return;
-      next: $Next;
-    }
-  : never;
+type inferAsyncIterator<TOutput> =
+  TOutput extends AsyncIterator<infer $Yield, infer $Return, infer $Next>
+    ? {
+        yield: $Yield;
+        return: $Return;
+        next: $Next;
+      }
+    : never;
 type inferSubscriptionOutput<TOutput> = TOutput extends AsyncGenerator
   ? AsyncGenerator<
       inferTrackedOutput<inferAsyncIterator<TOutput>['yield']>,
@@ -146,35 +143,36 @@ export type AnyProcedureBuilder = ProcedureBuilder<
  */
 export type inferProcedureBuilderResolverOptions<
   TProcedureBuilder extends AnyProcedureBuilder,
-> = TProcedureBuilder extends ProcedureBuilder<
-  infer TContext,
-  infer TMeta,
-  infer TContextOverrides,
-  infer _TInputIn,
-  infer TInputOut,
-  infer _TOutputIn,
-  infer _TOutputOut,
-  infer _TCaller
->
-  ? ProcedureResolverOptions<
-      TContext,
-      TMeta,
-      TContextOverrides,
-      TInputOut extends UnsetMarker
-        ? // if input is not set, we don't want to infer it as `undefined` since a procedure further down the chain might have set an input
-          unknown
-        : TInputOut extends object
-        ? Simplify<
-            TInputOut & {
-              /**
-               * Extra input params might have been added by a `.input()` further down the chain
-               */
-              [keyAddedByInputCallFurtherDown: string]: unknown;
-            }
-          >
-        : TInputOut
-    >
-  : never;
+> =
+  TProcedureBuilder extends ProcedureBuilder<
+    infer TContext,
+    infer TMeta,
+    infer TContextOverrides,
+    infer _TInputIn,
+    infer TInputOut,
+    infer _TOutputIn,
+    infer _TOutputOut,
+    infer _TCaller
+  >
+    ? ProcedureResolverOptions<
+        TContext,
+        TMeta,
+        TContextOverrides,
+        TInputOut extends UnsetMarker
+          ? // if input is not set, we don't want to infer it as `undefined` since a procedure further down the chain might have set an input
+            unknown
+          : TInputOut extends object
+            ? Simplify<
+                TInputOut & {
+                  /**
+                   * Extra input params might have been added by a `.input()` further down the chain
+                   */
+                  [keyAddedByInputCallFurtherDown: string]: unknown;
+                }
+              >
+            : TInputOut
+      >
+    : never;
 
 export interface ProcedureBuilder<
   TContext,
@@ -194,14 +192,14 @@ export interface ProcedureBuilder<
     schema: TInputOut extends UnsetMarker
       ? $Parser
       : inferParser<$Parser>['out'] extends Record<string, unknown> | undefined
-      ? TInputOut extends Record<string, unknown> | undefined
-        ? undefined extends inferParser<$Parser>['out'] // if current is optional the previous must be too
-          ? undefined extends TInputOut
-            ? $Parser
-            : TypeError<'Cannot chain an optional parser to a required parser'>
-          : $Parser
-        : TypeError<'All input parsers did not resolve to an object'>
-      : TypeError<'All input parsers did not resolve to an object'>,
+        ? TInputOut extends Record<string, unknown> | undefined
+          ? undefined extends inferParser<$Parser>['out'] // if current is optional the previous must be too
+            ? undefined extends TInputOut
+              ? $Parser
+              : TypeError<'Cannot chain an optional parser to a required parser'>
+            : $Parser
+          : TypeError<'All input parsers did not resolve to an object'>
+        : TypeError<'All input parsers did not resolve to an object'>,
   ): ProcedureBuilder<
     TContext,
     TMeta,
@@ -430,7 +428,7 @@ function createNewBuilder(
     ...mergeWithoutOverrides(def1, rest),
     inputs: [...def1.inputs, ...(inputs ?? [])],
     middlewares: [...def1.middlewares, ...middlewares],
-    meta: def1.meta && meta ? { ...def1.meta, ...meta } : meta ?? def1.meta,
+    meta: def1.meta && meta ? { ...def1.meta, ...meta } : (meta ?? def1.meta),
   });
 }
 

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

@@ -36,8 +36,8 @@ export type DecorateRouterRecord<TRecord extends RouterRecord> = {
   [TKey in keyof TRecord]: TRecord[TKey] extends AnyProcedure
     ? DecorateProcedure<TRecord[TKey]>
     : TRecord[TKey] extends RouterRecord
-    ? DecorateRouterRecord<TRecord[TKey]>
-    : never;
+      ? DecorateRouterRecord<TRecord[TKey]>
+      : never;
 };
 
 /**
@@ -146,10 +146,10 @@ export type DecorateCreateRouterOptions<
     ? $Value extends AnyProcedure
       ? $Value
       : $Value extends Router<any, infer TRecord>
-      ? TRecord
-      : $Value extends CreateRouterOptions
-      ? DecorateCreateRouterOptions<$Value>
-      : never
+        ? TRecord
+        : $Value extends CreateRouterOptions
+          ? DecorateCreateRouterOptions<$Value>
+          : never
     : never;
 };
 
@@ -318,7 +318,6 @@ export function createCallerFactory<TRoot extends AnyRootTypes>() {
 type MergeRouters<
   TRouters extends AnyRouter[],
   TRoot extends AnyRootTypes = TRouters[0]['_def']['_config']['$types'],
-  // eslint-disable-next-line @typescript-eslint/ban-types
   TRecord extends RouterRecord = {},
 > = TRouters extends [
   infer Head extends AnyRouter,

package/src/unstable-core-do-not-import/stream/sse.ts

@@ -112,7 +112,7 @@ export function sseStreamProducer<TValue = unknown>(
       // declared inside, they would not be freed until the next value is present.
       let value: null | TIteratorValue;
       let chunk: null | SSEvent;
-      
+
       for await (value of iterable) {
         if (value === PING_SYM) {
           stream.controller.enqueue({ comment: 'ping' });
@@ -127,7 +127,7 @@ export function sseStreamProducer<TValue = unknown>(
         }
 
         stream.controller.enqueue(chunk);
-        
+
         // free up references for garbage collection
         value = null;
         chunk = null;

package/src/unstable-core-do-not-import/stream/tracked.ts

@@ -45,8 +45,5 @@ export function tracked<TData>(
   return [id as TrackedId, data, trackedSymbol];
 }
 
-export type inferTrackedOutput<TData> = TData extends TrackedEnvelope<
-  infer $Data
->
-  ? TrackedData<$Data>
-  : TData;
+export type inferTrackedOutput<TData> =
+  TData extends TrackedEnvelope<infer $Data> ? TrackedData<$Data> : TData;

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

@@ -175,7 +175,7 @@ export function transformResult<TRouter extends AnyRouter, TOutput>(
   try {
     // Use the data transformers on the JSON-response
     result = transformResultInner(response, transformer);
-  } catch (err) {
+  } catch {
     throw new TransformResultError();
   }
 

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

@@ -83,8 +83,8 @@ export type WithoutIndexSignature<TObj> = {
   [K in keyof TObj as string extends K
     ? never
     : number extends K
-    ? never
-    : K]: TObj[K];
+      ? never
+      : K]: TObj[K];
 };
 
 /**
@@ -101,14 +101,13 @@ export type Overwrite<TType, TWith> = TWith extends any
           | keyof WithoutIndexSignature<TWith>]: K extends keyof TWith
           ? TWith[K]
           : K extends keyof TType
-          ? TType[K]
-          : never;
+            ? TType[K]
+            : never;
       } & (string extends keyof TWith // Handle cases with an index signature
         ? { [key: string]: TWith[string] }
         : number extends keyof TWith
-        ? { [key: number]: TWith[number] }
-        : // eslint-disable-next-line @typescript-eslint/ban-types
-          {})
+          ? { [key: number]: TWith[number] }
+          : {})
     : TWith
   : never;
 
@@ -168,10 +167,10 @@ export type ProtectedIntersection<TType, TWith> = keyof TType &
  */
 export type GetRawInputFn = () => Promise<unknown>;
 
-const errorSymbol = Symbol();
-export type ErrorSymbol = typeof errorSymbol;
+const _errorSymbol = Symbol();
+export type ErrorSymbol = typeof _errorSymbol;
 export type TypeError<TMessage extends string> = TMessage & {
-  _: typeof errorSymbol;
+  _: typeof _errorSymbol;
 };
 export type ValueOf<TObj> = TObj[keyof TObj];
 
@@ -179,6 +178,5 @@ export type ValueOf<TObj> = TObj[keyof TObj];
  * @internal
  * Infers the type of the value yielded by an async iterable
  */
-export type inferAsyncIterableYield<T> = T extends AsyncIterable<infer U>
-  ? U
-  : T;
+export type inferAsyncIterableYield<T> =
+  T extends AsyncIterable<infer U> ? U : T;

package/src/vendor/unpromise/types.ts

@@ -18,22 +18,22 @@ export interface ProxyPromise<T> extends Promise<T> {
     onfulfilled?:
       | ((value: T) => TResult1 | PromiseLike<TResult1>)
       | null
-      | undefined,
+       ,
     onrejected?:
       | ((reason: any) => TResult2 | PromiseLike<TResult2>)
       | null
-      | undefined
+       
   ) => SubscribedPromise<TResult1 | TResult2>;
 
   catch: <TResult = never>(
     onrejected?:
       | ((reason: any) => TResult | PromiseLike<TResult>)
       | null
-      | undefined
+       
   ) => SubscribedPromise<T | TResult>;
 
   finally: (
-    onfinally?: (() => void) | null | undefined
+    onfinally?: (() => void) | null  
   ) => SubscribedPromise<T>;
 }
 

package/src/vendor/unpromise/unpromise.ts

@@ -1,6 +1,6 @@
 /* eslint-disable @typescript-eslint/unbound-method */
-/* eslint-disable @typescript-eslint/return-await */
-/* eslint-disable @typescript-eslint/promise-function-async */
+ 
+ 
 
 import type {
   PromiseExecutor,
@@ -20,7 +20,9 @@ const subscribableCache = new WeakMap<
 /** A NOOP function allowing a consistent interface for settled
  * SubscribedPromises (settled promises are not subscribed - they resolve
  * immediately). */
-const NOOP = () => {};
+const NOOP = () => {
+  // noop
+};
 
 /**
  * Every `Promise<T>` can be shadowed by a single `ProxyPromise<T>`. It is
@@ -181,11 +183,11 @@ export class Unpromise<T> implements ProxyPromise<T> {
     onfulfilled?:
       | ((value: T) => TResult1 | PromiseLike<TResult1>)
       | null
-      | undefined,
+       ,
     onrejected?:
       | ((reason: any) => TResult2 | PromiseLike<TResult2>)
       | null
-      | undefined
+       
   ): SubscribedPromise<TResult1 | TResult2> {
     const subscribed = this.subscribe();
     const { unsubscribe } = subscribed;
@@ -198,7 +200,7 @@ export class Unpromise<T> implements ProxyPromise<T> {
     onrejected?:
       | ((reason: any) => TResult | PromiseLike<TResult>)
       | null
-      | undefined
+       
   ): SubscribedPromise<T | TResult> {
     const subscribed = this.subscribe();
     const { unsubscribe } = subscribed;
@@ -207,7 +209,7 @@ export class Unpromise<T> implements ProxyPromise<T> {
     });
   }
 
-  finally(onfinally?: (() => void) | null | undefined): SubscribedPromise<T> {
+  finally(onfinally?: (() => void) | null  ): SubscribedPromise<T> {
     const subscribed = this.subscribe();
     const { unsubscribe } = subscribed;
     return Object.assign(subscribed.finally(onfinally), {
@@ -312,8 +314,8 @@ export class Unpromise<T> implements ProxyPromise<T> {
    * }
    * ```
    * */
-  static async raceReferences<P extends Promise<unknown>>(
-    promises: readonly P[]
+  static async raceReferences<TPromise extends Promise<unknown>>(
+    promises: readonly TPromise[]
   ) {
     // map each promise to an eventual 1-tuple containing itself
     const selfPromises = promises.map(resolveSelfTuple);
@@ -336,9 +338,9 @@ export class Unpromise<T> implements ProxyPromise<T> {
  * may be ambiguous and therefore hard to identify as the winner of a race).
  * You can call unsubscribe on the Promise to mitigate memory leaks.
  * */
-export function resolveSelfTuple<P extends Promise<unknown>>(
-  promise: P
-): SubscribedPromise<readonly [P]> {
+export function resolveSelfTuple<TPromise extends Promise<unknown>>(
+  promise: TPromise
+): SubscribedPromise<readonly [TPromise]> {
   return Unpromise.proxy(promise).then(() => [promise] as const);
 }