@trpc/server 10.0.0-alpha.28 → 10.0.0-alpha.30

package/src/core/router.ts

@@ -1,4 +1,6 @@
 /* eslint-disable @typescript-eslint/ban-types */
+import { inferProcedureOutput } from '.';
+import { Filter } from '..';
 import { TRPCError } from '../error/TRPCError';
 import {
   DefaultErrorShape,
@@ -15,28 +17,32 @@ import {
 } from './internals/internalProcedure';
 import { mergeWithoutOverrides } from './internals/mergeWithoutOverrides';
 import { omitPrototype } from './internals/omitPrototype';
-import { EnsureRecord, ValidateShape } from './internals/utils';
-import { Procedure } from './procedure';
+import {
+  MutationProcedure,
+  Procedure,
+  QueryProcedure,
+  SubscriptionProcedure,
+} from './procedure';
 import { ProcedureType } from './types';
 
-// FIXME this should properly use TContext maybe?
-export type ProcedureRecord<_TContext> = Record<string, Procedure<any>>;
-type AnyProcedureRecord = ProcedureRecord<any>;
+type ProcedureRecord = Record<string, Procedure<any>>;
+
+export type ProcedureRouterRecord = Record<string, Procedure<any> | AnyRouter>;
+
 export interface ProcedureStructure {
-  queries: AnyProcedureRecord;
-  mutations: AnyProcedureRecord;
-  subscriptions: AnyProcedureRecord;
+  queries: Record<string, QueryProcedure<any>>;
+  mutations: Record<string, MutationProcedure<any>>;
+  subscriptions: Record<string, SubscriptionProcedure<any>>;
+  procedures: ProcedureRecord;
 }
 
-export interface RouterParams<
+export interface RouterDef<
   // FIXME this should use RootConfig
   TContext,
   TErrorShape extends TRPCErrorShape<number>,
   TMeta extends Record<string, unknown>,
-  TQueries extends ProcedureRecord<TContext>,
-  TMutations extends ProcedureRecord<TContext>,
-  TSubscriptions extends ProcedureRecord<TContext>,
-> extends ProcedureStructure {
+  TProcedures extends ProcedureRouterRecord,
+> {
   /**
    * @internal
    */
@@ -49,114 +55,107 @@ export interface RouterParams<
    * @internal
    */
   _meta: TMeta;
-  queries: TQueries;
-  mutations: TMutations;
-  subscriptions: TSubscriptions;
   errorFormatter: ErrorFormatter<TContext, TErrorShape>;
   transformer: CombinedDataTransformer;
+  // FIXME: separate `procedures` and `children`-routers
+  procedures: TProcedures;
+  // FIXME decide if these are deprecated
+  /**
+   * @deprecated
+   */
+  subscriptions: Filter<TProcedures, SubscriptionProcedure<any>>;
+  /**
+   * @deprecated
+   */
+  queries: Filter<TProcedures, QueryProcedure<any>>;
+  /**
+   * @deprecated
+   */
+  mutations: Filter<TProcedures, MutationProcedure<any>>;
 }
 
-export type AnyRouterParams<TContext = any> = RouterParams<
-  TContext,
-  any,
-  any,
-  any,
-  any,
-  any
->;
+export type AnyRouterDef<TContext = any> = RouterDef<TContext, any, any, any>;
 
 /**
  * @internal
  */
 export type inferHandlerInput<TProcedure extends Procedure<any>> =
-  TProcedure extends Procedure<infer TParams>
-    ? undefined extends TParams['_input_in'] // ? is input optional
-      ? unknown extends TParams['_input_in'] // ? is input unset
+  TProcedure extends Procedure<infer TDef>
+    ? undefined extends TDef['_input_in'] // ? is input optional
+      ? unknown extends TDef['_input_in'] // ? is input unset
         ? [(null | undefined)?] // -> there is no input
-        : [(TParams['_input_in'] | null | undefined)?] // -> there is optional input
-      : [TParams['_input_in']] // -> input is required
+        : [(TDef['_input_in'] | null | undefined)?] // -> there is optional input
+      : [TDef['_input_in']] // -> input is required
     : [(undefined | null)?]; // -> there is no input
 
 /**
  * @internal
  */
-type inferHandlerFn<TProcedures extends ProcedureRecord<any>> = <
+type inferHandlerFn<TProcedures extends Record<string, Procedure<any>>> = <
   TProcedure extends TProcedures[TPath],
   TPath extends keyof TProcedures & string,
 >(
   path: TPath,
   ...args: inferHandlerInput<TProcedure>
-) => ReturnType<TProcedure>;
+) => inferProcedureOutput<TProcedure>;
 
 /**
  * This only exists b/c of interop mode
  * @internal
  */
 
-type RouterCaller<TParams extends AnyRouterParams> = (ctx: TParams['_ctx']) => {
+type RouterCaller<TDef extends AnyRouterDef> = (ctx: TDef['_ctx']) => {
   /**
    * @deprecated
    */
-  query: inferHandlerFn<TParams['queries']>;
+  query: inferHandlerFn<TDef['queries']>;
   /**
    * @deprecated
    */
-  mutation: inferHandlerFn<TParams['mutations']>;
+  mutation: inferHandlerFn<TDef['mutations']>;
   /**
    * @deprecated
    */
-  subscription: inferHandlerFn<TParams['subscriptions']>;
-
-  queries: TParams['queries'];
-  mutations: TParams['mutations'];
-  subscriptions: TParams['subscriptions'];
+  subscription: inferHandlerFn<TDef['subscriptions']>;
 };
 
-export interface Router<TParams extends AnyRouterParams>
-  extends ProcedureStructure {
-  _def: RouterParams<
-    TParams['_ctx'],
-    TParams['_errorShape'],
-    TParams['_meta'],
-    TParams['queries'],
-    TParams['mutations'],
-    TParams['subscriptions']
+export interface Router<TDef extends AnyRouterDef> {
+  _def: RouterDef<
+    TDef['_ctx'],
+    TDef['_errorShape'],
+    TDef['_meta'],
+    TDef['procedures']
   >;
-  queries: TParams['queries'];
-  mutations: TParams['mutations'];
-  subscriptions: TParams['subscriptions'];
-  errorFormatter: TParams['errorFormatter'];
-  transformer: TParams['transformer'];
+  /** @deprecated **/
+  errorFormatter: TDef['errorFormatter'];
+  /** @deprecated **/
+  transformer: TDef['transformer'];
 
-  createCaller: RouterCaller<TParams>;
+  // FIXME rename me and deprecate
+  createCaller: RouterCaller<TDef>;
+  // FIXME rename me and deprecate
   getErrorShape(opts: {
     error: TRPCError;
     type: ProcedureType | 'unknown';
     path: string | undefined;
     input: unknown;
-    ctx: undefined | TParams['_ctx'];
-  }): TParams['_errorShape'];
+    ctx: undefined | TDef['_ctx'];
+  }): TDef['_errorShape'];
 }
 
-/**
- * @internal
- */
-export type RouterOptions<TContext> = Partial<AnyRouterParams<TContext>>;
-
 /**
  * @internal
  */
 export type RouterDefaultOptions<TContext> = Pick<
-  AnyRouterParams<TContext>,
+  AnyRouterDef<TContext>,
   'transformer' | 'errorFormatter'
 >;
 
 /**
  * @internal
  */
-type RouterBuildOptions<TContext> = Pick<
-  RouterOptions<TContext>,
-  'queries' | 'subscriptions' | 'mutations'
+export type RouterBuildOptions<TContext> = Partial<
+  Pick<AnyRouterDef<TContext>, 'procedures'>
 >;
 
 export type AnyRouter = Router<any>;
@@ -178,77 +177,83 @@ const emptyRouter = {
   errorFormatter: defaultFormatter,
   transformer: defaultTransformer,
 };
-// type EmptyRouter = typeof emptyRouter;
-
-const PROCEDURE_DEFINITION_MAP: Record<
-  ProcedureType,
-  'queries' | 'mutations' | 'subscriptions'
-> = {
-  query: 'queries',
-  mutation: 'mutations',
-  subscription: 'subscriptions',
-};
 
 /**
  *
  * @internal
  */
-export function createRouterFactory<TSettings extends RootConfig>(
-  defaults?: RouterDefaultOptions<TSettings['ctx']>,
+export function createRouterFactory<TConfig extends RootConfig>(
+  defaults?: RouterDefaultOptions<TConfig['ctx']>,
 ) {
-  return function createRouterInner<
-    TProcedures extends RouterBuildOptions<TSettings['ctx']>,
-  >(
-    procedures: ValidateShape<
-      TProcedures,
-      RouterBuildOptions<TSettings['ctx']>
-    >,
-  ): Router<{
-    _ctx: TSettings['ctx'];
-    _errorShape: TSettings['errorShape'];
-    _meta: TSettings['meta'];
-    queries: EnsureRecord<TProcedures['queries']>;
-    mutations: EnsureRecord<TProcedures['mutations']>;
-    subscriptions: EnsureRecord<TProcedures['subscriptions']>;
-    errorFormatter: ErrorFormatter<TSettings['ctx'], TSettings['errorShape']>;
-    transformer: TSettings['transformer'];
-  }> {
+  return function createRouterInner<TProcedures extends ProcedureRouterRecord>(
+    procedures: TProcedures,
+  ): Router<
+    RouterDef<
+      TConfig['ctx'],
+      TConfig['errorShape'],
+      TConfig['meta'],
+      TProcedures
+    >
+  > {
+    const routerProcedures: Record<string, Procedure<any>> = omitPrototype({});
+    function recursiveGetPaths(procedures: ProcedureRouterRecord, path = '') {
+      for (const [key, procedureOrRouter] of Object.entries(procedures ?? {})) {
+        const newPath = `${path}${key}`;
+
+        if (typeof procedureOrRouter === 'object') {
+          const router = procedureOrRouter as AnyRouter;
+          recursiveGetPaths(router._def.procedures, `${newPath}.`);
+          continue;
+        }
+
+        routerProcedures[newPath] = procedureOrRouter;
+      }
+    }
+
+    recursiveGetPaths(procedures);
+
     const result = mergeWithoutOverrides<
-      RouterDefaultOptions<TSettings['ctx']> &
-        RouterBuildOptions<TSettings['ctx']>
+      RouterDefaultOptions<TConfig['ctx']> & RouterBuildOptions<TConfig['ctx']>
     >(
       {
         transformer: defaults?.transformer ?? defaultTransformer,
         errorFormatter: defaults?.errorFormatter ?? defaultFormatter,
       },
-      {
-        queries: omitPrototype(procedures.queries),
-        mutations: omitPrototype(procedures.mutations),
-        subscriptions: omitPrototype(procedures.subscriptions),
-      },
+      { procedures: routerProcedures },
     );
 
-    const _def: AnyRouterParams<TSettings['ctx']> = {
+    const _def: AnyRouterDef<TConfig['ctx']> = {
+      procedures: {},
       ...emptyRouter,
       ...result,
+      queries: Object.entries(result.procedures || {})
+        .filter((pair) => (pair[1] as any)._def.query)
+        .reduce((acc, [key, val]) => ({ ...acc, [key]: val }), {}),
+      mutations: Object.entries(result.procedures || {})
+        .filter((pair) => (pair[1] as any)._def.mutation)
+        .reduce((acc, [key, val]) => ({ ...acc, [key]: val }), {}),
+      subscriptions: Object.entries(result.procedures || {})
+        .filter((pair) => (pair[1] as any)._def.subscription)
+        .reduce((acc, [key, val]) => ({ ...acc, [key]: val }), {}),
     };
     const def = {
       _def,
-      ..._def,
+      transformer: _def.transformer,
+      errorFormatter: _def.errorFormatter,
     };
 
     function callProcedure(opts: InternalProcedureCallOptions) {
       const { type, path } = opts;
-      const defTarget = PROCEDURE_DEFINITION_MAP[type];
-      const defs = def[defTarget];
 
-      if (!(path in defs)) {
+      if (!(path in _def.procedures) || !_def.procedures[path]['_def'][type]) {
         throw new TRPCError({
           code: 'NOT_FOUND',
           message: `No "${type}"-procedure on path "${path}"`,
         });
       }
-      const procedure = defs[path] as InternalProcedure;
+
+      const procedure = _def.procedures[path] as InternalProcedure;
+
       return procedure(opts);
     }
     const router: AnyRouter = {
@@ -329,30 +334,3 @@ export function createRouterFactory<TSettings extends RootConfig>(
     return router as any;
   };
 }
-
-type combineProcedureRecords<
-  A extends Partial<AnyRouter>,
-  B extends Partial<AnyRouter>,
-> = {
-  queries: A['queries'] & B['queries'];
-  mutations: A['mutations'] & B['mutations'];
-  subscriptions: A['subscriptions'] & B['subscriptions'];
-};
-/**
- * @internal
- */
-export type mergeProcedureRecordsVariadic<
-  Routers extends Partial<AnyRouter>[],
-> = Routers extends []
-  ? {
-      queries: {};
-      mutations: {};
-      subscriptions: {};
-    }
-  : Routers extends [infer First, ...infer Rest]
-  ? First extends Partial<AnyRouter>
-    ? Rest extends Partial<AnyRouter>[]
-      ? combineProcedureRecords<First, mergeProcedureRecordsVariadic<Rest>>
-      : never
-    : never
-  : never;

package/src/core/types.ts

@@ -1,21 +1,21 @@
 import { inferObservableValue } from '../observable';
-import { inferAsyncReturnType } from '../types';
 import { Procedure, ProcedureArgs } from './procedure';
-import { AnyRouter, AnyRouterParams, Router } from './router';
+import { AnyRouter, AnyRouterDef, Router } from './router';
 
-export type inferRouterParams<TRouter extends AnyRouter> =
-  TRouter extends Router<infer TParams>
-    ? TParams extends AnyRouterParams<any>
-      ? TParams
-      : never
-    : never;
+export type inferRouterDef<TRouter extends AnyRouter> = TRouter extends Router<
+  infer TParams
+>
+  ? TParams extends AnyRouterDef<any>
+    ? TParams
+    : never
+  : never;
 
 export type inferRouterContext<TRouter extends AnyRouter> =
-  inferRouterParams<TRouter>['_ctx'];
+  inferRouterDef<TRouter>['_ctx'];
 export type inferRouterError<TRouter extends AnyRouter> =
-  inferRouterParams<TRouter>['_errorShape'];
+  inferRouterDef<TRouter>['_errorShape'];
 export type inferRouterMeta<TRouter extends AnyRouter> =
-  inferRouterParams<TRouter>['_meta'];
+  inferRouterDef<TRouter>['_meta'];
 
 /**
  * @public
@@ -23,15 +23,31 @@ export type inferRouterMeta<TRouter extends AnyRouter> =
 export type ProcedureType = 'query' | 'mutation' | 'subscription';
 
 export type inferHandlerInput<TProcedure extends Procedure<any>> =
-  TProcedure extends Procedure<infer TParams> ? ProcedureArgs<TParams> : never;
+  ProcedureArgs<inferProcedureParams<TProcedure>>;
 
 export type inferProcedureInput<TProcedure extends Procedure<any>> =
   inferHandlerInput<TProcedure>[0];
 
+// /**
+//  * @internal
+//  */
+// type inferProcedureFn<TProcedure extends Procedure<any>> =
+//   TProcedure extends QueryProcedure<any>
+//     ? TProcedure['query']
+//     : TProcedure extends SubscriptionProcedure<any>
+//     ? TProcedure['subscription']
+//     : TProcedure extends MutationProcedure<any>
+//     ? TProcedure['mutate']
+//     : never;
+
+export type inferProcedureParams<TProcedure extends Procedure<any>> =
+  TProcedure extends Procedure<infer $Params> ? $Params : never;
 export type inferProcedureOutput<TProcedure extends Procedure<any>> =
-  inferAsyncReturnType<TProcedure>;
+  inferProcedureParams<TProcedure>['_output_out'];
 
 export type inferSubscriptionOutput<
   TRouter extends AnyRouter,
-  TPath extends keyof TRouter['subscriptions'] & string,
-> = inferObservableValue<inferProcedureOutput<TRouter['subscriptions'][TPath]>>;
+  TPath extends keyof TRouter['_def']['subscriptions'] & string,
+> = inferObservableValue<
+  inferProcedureOutput<TRouter['_def']['subscriptions'][TPath]>
+>;

package/src/deprecated/interop.ts

@@ -1,22 +1,33 @@
+import { ProcedureParams, ProcedureType } from '..';
 import { getParseFnOrPassThrough } from '../core/internals/getParseFn';
 import {
   createInputMiddleware,
   createInternalBuilder,
   createOutputMiddleware,
 } from '../core/internals/internalProcedure';
-import { Procedure as NewProcedure } from '../core/procedure';
-import { Router as NewRouter, createRouterFactory } from '../core/router';
+import { mergeWithoutOverrides } from '../core/internals/mergeWithoutOverrides';
+import {
+  MutationProcedure,
+  Procedure as NewProcedure,
+  QueryProcedure,
+  SubscriptionProcedure,
+} from '../core/procedure';
+import {
+  Router as NewRouter,
+  RouterDef,
+  createRouterFactory,
+} from '../core/router';
 import {
   AnyRouter as AnyOldRouter,
   Router as OldRouter,
 } from '../deprecated/router';
 import { TRPCErrorShape } from '../rpc';
-import { CombinedDataTransformer } from '../transformer';
 import { Procedure as OldProcedure } from './internals/procedure';
 import { ProcedureRecord } from './router';
 
 type AnyOldProcedure = OldProcedure<any, any, any, any, any, any, any, any>;
-type MigrateProcedure<TProcedure extends AnyOldProcedure> =
+
+type convertProcedureParams<TProcedure extends AnyOldProcedure> =
   TProcedure extends OldProcedure<
     infer TInputContext,
     infer TContext,
@@ -27,19 +38,33 @@ type MigrateProcedure<TProcedure extends AnyOldProcedure> =
     infer _TParsedOutput,
     infer TFinalInput
   >
-    ? NewProcedure<{
-        _ctx_in: TInputContext;
-        _ctx_out: TContext;
-        _meta: TMeta;
-        _input_in: TInput;
-        _input_out: TParsedInput;
-        _output_in: TOutput;
-        _output_out: TFinalInput;
-      }>
+    ? ProcedureParams<
+        TInputContext,
+        TContext,
+        TInput,
+        TParsedInput,
+        TOutput,
+        TFinalInput,
+        TMeta
+      >
     : never;
 
-export type MigrateProcedureRecord<T extends ProcedureRecord<any>> = {
-  [K in keyof T]: MigrateProcedure<T[K]>;
+type MigrateProcedure<
+  TProcedure extends AnyOldProcedure,
+  TType extends ProcedureType,
+> = TType extends 'query'
+  ? QueryProcedure<convertProcedureParams<TProcedure>>
+  : TType extends 'mutation'
+  ? MutationProcedure<convertProcedureParams<TProcedure>>
+  : TType extends 'subscription'
+  ? SubscriptionProcedure<convertProcedureParams<TProcedure>>
+  : never;
+
+export type MigrateProcedureRecord<
+  T extends ProcedureRecord<any>,
+  TType extends ProcedureType,
+> = {
+  [K in keyof T]: MigrateProcedure<T[K], TType>;
 };
 
 export type MigrateRouter<
@@ -74,16 +99,16 @@ export type MigrateRouter<
     unknown
   >,
   TErrorShape extends TRPCErrorShape<number>,
-> = NewRouter<{
-  _ctx: TInputContext;
-  _errorShape: TErrorShape;
-  _meta: TMeta;
-  errorFormatter: never;
-  mutations: MigrateProcedureRecord<TMutations>;
-  queries: MigrateProcedureRecord<TQueries>;
-  subscriptions: MigrateProcedureRecord<TSubscriptions>;
-  transformer: CombinedDataTransformer;
-}>;
+> = NewRouter<
+  RouterDef<
+    TInputContext,
+    TErrorShape,
+    TMeta,
+    MigrateProcedureRecord<TQueries, 'query'> &
+      MigrateProcedureRecord<TMutations, 'mutation'> &
+      MigrateProcedureRecord<TSubscriptions, 'subscription'>
+  >
+>;
 
 export type MigrateOldRouter<TRouter extends AnyOldRouter> =
   TRouter extends OldRouter<
@@ -106,9 +131,10 @@ export type MigrateOldRouter<TRouter extends AnyOldRouter> =
       >
     : never;
 
-function migrateProcedure<TProcedure extends AnyOldProcedure>(
-  oldProc: TProcedure,
-): MigrateProcedure<TProcedure> {
+function migrateProcedure<
+  TProcedure extends AnyOldProcedure,
+  TType extends ProcedureType,
+>(oldProc: TProcedure, type: TType): MigrateProcedure<TProcedure, TType> {
   const def = oldProc._def();
 
   const inputParser = getParseFnOrPassThrough(def.inputParser);
@@ -125,9 +151,12 @@ function migrateProcedure<TProcedure extends AnyOldProcedure>(
     ],
     meta: def.meta,
     output: def.outputParser,
+    mutation: type === 'mutation',
+    query: type === 'query',
+    subscription: type === 'subscription',
   });
 
-  const proc = builder.resolve((opts) => def.resolver(opts as any));
+  const proc = builder[type]((opts) => def.resolver(opts as any));
 
   return proc as any;
 }
@@ -143,27 +172,25 @@ export function migrateRouter<TOldRouter extends AnyOldRouter>(
   const mutations: ProcRecord = {};
   const subscriptions: ProcRecord = {};
   for (const [name, procedure] of Object.entries(oldRouter._def.queries)) {
-    queries[name] = migrateProcedure(procedure as any);
+    queries[name] = migrateProcedure(procedure as any, 'query');
   }
 
   for (const [name, procedure] of Object.entries(oldRouter._def.mutations)) {
-    mutations[name] = migrateProcedure(procedure as any);
+    mutations[name] = migrateProcedure(procedure as any, 'mutation');
   }
 
   for (const [name, procedure] of Object.entries(
     oldRouter._def.subscriptions,
   )) {
-    subscriptions[name] = migrateProcedure(procedure as any);
+    subscriptions[name] = migrateProcedure(procedure as any, 'subscription');
   }
 
+  const procedures = mergeWithoutOverrides(queries, mutations, subscriptions);
+
   const newRouter = createRouterFactory<any>({
     transformer,
     errorFormatter,
-  })({
-    mutations,
-    queries,
-    subscriptions,
-  });
+  })(procedures);
 
   return newRouter as any;
 }

package/src/http/internals/types.ts

@@ -1,4 +1,4 @@
-import { AnyRouter, ProcedureType, inferRouterParams } from '../../core';
+import { AnyRouter, ProcedureType, inferRouterDef } from '../../core';
 import { TRPCError } from '../../error/TRPCError';
 import { BaseHandlerOptions } from '../../internals/types';
 import { TRPCResponse } from '../../rpc';
@@ -24,8 +24,8 @@ export interface HTTPRequest {
  * @internal
  */
 export type ResponseMetaFn<TRouter extends AnyRouter> = (opts: {
-  data: TRPCResponse<unknown, inferRouterParams<TRouter>['_error']>[];
-  ctx?: inferRouterParams<TRouter>['_ctx'];
+  data: TRPCResponse<unknown, inferRouterDef<TRouter>['_error']>[];
+  ctx?: inferRouterDef<TRouter>['_ctx'];
   /**
    * The different tRPC paths requested
    **/

package/src/internals/types.ts

@@ -1,4 +1,4 @@
-import { inferRouterParams } from '../core';
+import { inferRouterDef } from '../core';
 import { ProcedureType } from '../core';
 import { AnyRouter } from '../core/router';
 import { TRPCError } from '../error/TRPCError';
@@ -20,5 +20,5 @@ export type OnErrorFunction<TRouter extends AnyRouter, TRequest> = (opts: {
   path: string | undefined;
   req: TRequest;
   input: unknown;
-  ctx: undefined | inferRouterParams<TRouter>['_ctx'];
+  ctx: undefined | inferRouterDef<TRouter>['_ctx'];
 }) => void;

package/src/observable/observable.ts

@@ -1,9 +1,12 @@
 import { pipeFromArray } from './internals/pipe';
 import { Observable, Observer, OperatorFunction, TeardownLogic } from './types';
 
-export type inferObservableValue<
-  TObservable extends Observable<unknown, unknown>,
-> = TObservable extends Observable<infer TValue, unknown> ? TValue : never;
+export type inferObservableValue<TObservable> = TObservable extends Observable<
+  infer TValue,
+  unknown
+>
+  ? TValue
+  : never;
 
 export function isObservable(x: unknown): x is Observable<unknown, unknown> {
   return typeof x === 'object' && x !== null && 'subscribe' in x;

package/src/types.ts

@@ -65,3 +65,10 @@ export type InferLast<T> = T & { [K in keyof T]: T[K] };
  */
 export type inferAsyncReturnType<TFunction extends (...args: any) => any> =
   ThenArg<ReturnType<TFunction>>;
+
+/**
+ * @internal
+ */
+export type Filter<T extends Record<any, any> | any[], K> = {
+  [TKey in keyof T]: T[TKey] extends K ? T[TKey] : never;
+};