@trpc/server 10.0.0-proxy-beta.12 → 10.0.0-proxy-beta.14

package/src/core/internals/config.ts

@@ -12,6 +12,16 @@ export interface InitGenerics {
   ctx: Record<string, unknown>;
   meta: Record<string, unknown>;
 }
+
+/**
+ * The default check to see if we're in a server
+ */
+export const isServerDefault: boolean =
+  typeof window === 'undefined' ||
+  'Deno' in window ||
+  process.env.NODE_ENV === 'test' ||
+  !!process.env.JEST_WORKER_ID;
+
 /**
  * The initial params that are used and actually represents real values underneath
  * @internal
@@ -19,6 +29,15 @@ export interface InitGenerics {
 export interface InitOptions<TType extends InitGenerics> {
   transformer: DataTransformerOptions;
   errorFormatter: ErrorFormatter<TType['ctx'], any>;
+  /**
+   * Allow `@trpc/server` to run in non-server environments
+   * @default false
+   */
+  allowOutsideOfServer: boolean;
+  /**
+   * Is this a server environment?
+   */
+  isServer: boolean;
 }
 
 /**

package/src/core/internals/procedureBuilder.ts

@@ -13,10 +13,8 @@ import {
   AnyProcedure,
   AnyQueryProcedure,
   AnySubscriptionProcedure,
-  MutationProcedure,
+  Procedure,
   ProcedureParams,
-  QueryProcedure,
-  SubscriptionProcedure,
 } from '../procedure';
 import { ProcedureType } from '../types';
 import { RootConfig } from './config';
@@ -44,12 +42,45 @@ type CreateProcedureReturnInput<
   _output_out: FallbackValue<TNext['_output_out'], TPrev['_output_out']>;
 }>;
 
+/**
+ * @internal
+ */
+export interface BuildProcedure<
+  TType extends ProcedureType,
+  TParams extends ProcedureParams,
+  TOutput,
+> extends Procedure<
+    TType,
+    UnsetMarker extends TParams['_output_out']
+      ? OverwriteKnown<
+          TParams,
+          {
+            _output_in: TOutput;
+            _output_out: TOutput;
+          }
+        >
+      : TParams
+  > {}
+
 type OverwriteIfDefined<TType, TWith> = UnsetMarker extends TType
   ? TWith
   : FlatOverwrite<TType, TWith>;
 
 type ErrorMessage<TMessage extends string> = TMessage;
 
+export type ProcedureBuilderDef<TParams extends ProcedureParams> = {
+  inputs: Parser[];
+  output?: Parser;
+  meta?: TParams['_meta'];
+  resolver?: ProcedureBuilderResolver;
+  middlewares: ProcedureBuilderMiddleware[];
+  mutation?: boolean;
+  query?: boolean;
+  subscription?: boolean;
+};
+
+export type AnyProcedureBuilderDef = ProcedureBuilderDef<any>;
+
 export interface ProcedureBuilder<TParams extends ProcedureParams> {
   /**
    * Add an input parser to the procedure.
@@ -119,17 +150,7 @@ export interface ProcedureBuilder<TParams extends ProcedureParams> {
     resolver: (
       opts: ResolveOptions<TParams>,
     ) => MaybePromise<FallbackValue<TParams['_output_in'], TOutput>>,
-  ): UnsetMarker extends TParams['_output_out']
-    ? QueryProcedure<
-        OverwriteKnown<
-          TParams,
-          {
-            _output_in: TOutput;
-            _output_out: TOutput;
-          }
-        >
-      >
-    : QueryProcedure<TParams>;
+  ): BuildProcedure<'query', TParams, TOutput>;
 
   /**
    * Mutation procedure
@@ -138,17 +159,7 @@ export interface ProcedureBuilder<TParams extends ProcedureParams> {
     resolver: (
       opts: ResolveOptions<TParams>,
     ) => MaybePromise<FallbackValue<TParams['_output_in'], TOutput>>,
-  ): UnsetMarker extends TParams['_output_out']
-    ? MutationProcedure<
-        OverwriteKnown<
-          TParams,
-          {
-            _output_in: TOutput;
-            _output_out: TOutput;
-          }
-        >
-      >
-    : MutationProcedure<TParams>;
+  ): BuildProcedure<'mutation', TParams, TOutput>;
 
   /**
    * Mutation procedure
@@ -157,34 +168,14 @@ export interface ProcedureBuilder<TParams extends ProcedureParams> {
     resolver: (
       opts: ResolveOptions<TParams>,
     ) => MaybePromise<FallbackValue<TParams['_output_in'], TOutput>>,
-  ): UnsetMarker extends TParams['_output_out']
-    ? SubscriptionProcedure<
-        OverwriteKnown<
-          TParams,
-          {
-            _output_in: TOutput;
-            _output_out: TOutput;
-          }
-        >
-      >
-    : SubscriptionProcedure<TParams>;
+  ): BuildProcedure<'subscription', TParams, TOutput>;
   /**
    * @internal
    */
-  _def: {
-    inputs: Parser[];
-    output?: Parser;
-    meta?: TParams['_meta'];
-    resolver?: ProcedureBuilderResolver;
-    middlewares: ProcedureBuilderMiddleware[];
-    mutation?: boolean;
-    query?: boolean;
-    subscription?: boolean;
-  };
+  _def: ProcedureBuilderDef<TParams>;
 }
 
 type AnyProcedureBuilder = ProcedureBuilder<any>;
-export type AnyProcedureBuilderDef = AnyProcedureBuilder['_def'];
 
 export type ProcedureBuilderMiddleware = MiddlewareFunction<any, any>;
 

package/src/core/middleware.ts

@@ -57,7 +57,7 @@ export type MiddlewareFunction<
     path: string;
     input: TParams['_input_out'];
     rawInput: unknown;
-    meta: TParams['_meta'];
+    meta: TParams['_meta'] | undefined;
     next: {
       (): Promise<MiddlewareResult<TParams>>;
       <TContext>(opts: { ctx: TContext }): Promise<

package/src/core/procedure.ts

@@ -2,7 +2,7 @@ import { DefaultErrorShape } from '../error/formatter';
 import { CombinedDataTransformer } from '../transformer';
 import { RootConfig } from './internals/config';
 import {
-  ProcedureBuilder,
+  ProcedureBuilderDef,
   ProcedureCallOptions,
 } from './internals/procedureBuilder';
 import { UnsetMarker } from './internals/utils';
@@ -86,12 +86,12 @@ export type ProcedureArgs<TParams extends ProcedureParams> =
  *
  * @internal
  */
-export interface ProcedureBase<
+export interface Procedure<
   TType extends ProcedureType,
   TParams extends ProcedureParams,
 > {
   _type: TType;
-  _def: TParams & ProcedureBuilder<TParams>['_def'];
+  _def: TParams & ProcedureBuilderDef<TParams>;
   /**
    * @deprecated use `._def.meta` instead
    */
@@ -103,18 +103,7 @@ export interface ProcedureBase<
   (opts: ProcedureCallOptions): Promise<unknown>;
 }
 
-export interface QueryProcedure<TParams extends ProcedureParams>
-  extends ProcedureBase<'query', TParams> {}
-export type AnyQueryProcedure = QueryProcedure<any>;
-
-export interface MutationProcedure<TParams extends ProcedureParams>
-  extends ProcedureBase<'mutation', TParams> {}
-export type AnyMutationProcedure = MutationProcedure<any>;
-
-export interface SubscriptionProcedure<TParams extends ProcedureParams>
-  extends ProcedureBase<'subscription', TParams> {}
-export type AnySubscriptionProcedure = SubscriptionProcedure<any>;
-
-export interface Procedure<TParams extends ProcedureParams>
-  extends ProcedureBase<ProcedureType, TParams> {}
-export type AnyProcedure = Procedure<any>;
+export type AnyQueryProcedure = Procedure<'query', any>;
+export type AnyMutationProcedure = Procedure<'mutation', any>;
+export type AnySubscriptionProcedure = Procedure<'subscription', any>;
+export type AnyProcedure = Procedure<ProcedureType, any>;

package/src/core/router.ts

@@ -29,7 +29,9 @@ import {
 /** @internal **/
 export type ProcedureRecord = Record<string, AnyProcedure>;
 
-export type ProcedureRouterRecord = Record<string, AnyProcedure | AnyRouter>;
+export interface ProcedureRouterRecord {
+  [key: string]: AnyProcedure | AnyRouter;
+}
 
 export interface ProcedureStructure {
   queries: Record<string, AnyQueryProcedure>;
@@ -188,7 +190,22 @@ const reservedWords = [
 ];
 
 /**
- *
+ * @internal
+ */
+export type CreateRouterInner<
+  TConfig extends RootConfig,
+  TProcRouterRecord extends ProcedureRouterRecord,
+> = Router<
+  RouterDef<
+    TConfig['ctx'],
+    TConfig['errorShape'],
+    TConfig['meta'],
+    TProcRouterRecord
+  >
+> &
+  TProcRouterRecord;
+
+/**
  * @internal
  */
 export function createRouterFactory<TConfig extends RootConfig>(
@@ -196,17 +213,7 @@ export function createRouterFactory<TConfig extends RootConfig>(
 ) {
   return function createRouterInner<
     TProcRouterRecord extends ProcedureRouterRecord,
-  >(
-    opts: TProcRouterRecord,
-  ): Router<
-    RouterDef<
-      TConfig['ctx'],
-      TConfig['errorShape'],
-      TConfig['meta'],
-      TProcRouterRecord
-    >
-  > &
-    TProcRouterRecord {
+  >(opts: TProcRouterRecord): CreateRouterInner<TConfig, TProcRouterRecord> {
     const reservedWordsUsed = new Set(
       Object.keys(opts).filter((v) => reservedWords.includes(v)),
     );

package/src/deprecated/internals/procedure.ts

@@ -1,5 +1,4 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { assertNotBrowser } from '../../assertNotBrowser';
 import { TRPCError } from '../../error/TRPCError';
 import {
   getCauseFromUnknown,
@@ -13,8 +12,6 @@ import {
   middlewareMarker,
 } from './middlewares';
 
-assertNotBrowser();
-
 export type ProcedureParserZodEsque<TInput, TOutput> = {
   _input: TInput;
   _output: TOutput;

package/src/deprecated/interop.ts

@@ -7,11 +7,7 @@ import {
   createInputMiddleware,
   createOutputMiddleware,
 } from '../core/middleware';
-import {
-  MutationProcedure,
-  QueryProcedure,
-  SubscriptionProcedure,
-} from '../core/procedure';
+import { Procedure } from '../core/procedure';
 import {
   ProcedureRecord as NewProcedureRecord,
   Router as NewRouter,
@@ -57,13 +53,7 @@ type MigrateProcedure<
   TConfig extends RootConfig,
   TProcedure extends AnyOldProcedure,
   TType extends ProcedureType,
-> = TType extends 'query'
-  ? QueryProcedure<convertProcedureParams<TConfig, TProcedure>>
-  : TType extends 'mutation'
-  ? MutationProcedure<convertProcedureParams<TConfig, TProcedure>>
-  : TType extends 'subscription'
-  ? SubscriptionProcedure<convertProcedureParams<TConfig, TProcedure>>
-  : never;
+> = Procedure<TType, convertProcedureParams<TConfig, TProcedure>>;
 
 export type MigrateProcedureRecord<
   TConfig extends RootConfig,

package/src/deprecated/router.ts

@@ -1,5 +1,4 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { assertNotBrowser } from '../assertNotBrowser';
 import { TRPCError } from '../error/TRPCError';
 import { defaultFormatter } from '../error/formatter';
 import { getHTTPStatusCodeFromError } from '../http/internals/getHTTPStatusCode';
@@ -29,8 +28,6 @@ import {
 } from './internals/procedure';
 import { MigrateRouter, migrateRouter } from './interop';
 
-assertNotBrowser();
-
 export type { Procedure } from './internals/procedure';
 
 /**

package/src/http/index.ts

@@ -1,6 +1,2 @@
-import { assertNotBrowser } from '../assertNotBrowser';
-
 export * from './resolveHTTPResponse';
 export * from './types';
-
-assertNotBrowser();

package/src/index.ts

@@ -1,4 +1,3 @@
-export * from './assertNotBrowser';
 export * from './http';
 export * from './transformer';
 export * from './error/TRPCError';

package/src/internals.ts

@@ -3,12 +3,10 @@
  */
 export type { DefaultErrorShape } from './error/formatter';
 export type { mergeRoutersGeneric } from './core/internals/__generated__/mergeRoutersGeneric';
-export type { ProcedureBuilder } from './core/internals/procedureBuilder';
+export type {
+  ProcedureBuilder,
+  BuildProcedure,
+} from './core/internals/procedureBuilder';
 export type { Overwrite, unsetMarker } from './core/internals/utils';
 export type { MiddlewareFunction } from './core/middleware';
 export type { Router, RouterDef } from './core/router';
-export type {
-  MutationProcedure,
-  QueryProcedure,
-  SubscriptionProcedure,
-} from './core/procedure';

package/src/types.ts

@@ -5,16 +5,37 @@
  */
 export type identity<TType> = TType;
 
+type InferOptional<TType, TKeys extends keyof TType> = Partial<
+  Pick<TType, TKeys>
+> &
+  Omit<TType, TKeys>;
+
+type OmitNever<TType> = Pick<
+  TType,
+  {
+    [K in keyof TType]: TType[K] extends never ? never : K;
+  }[keyof TType]
+>;
+
+type UndefinedKeys<TType> = keyof OmitNever<{
+  [K in keyof TType]: TType[K] extends undefined ? TType : never;
+}>;
+
 /**
  * @internal
  */
-export type FlatOverwrite<TType, TWith> = identity<{
-  [TKey in keyof TWith | keyof TType]: TKey extends keyof TWith
-    ? TWith[TKey]
-    : TKey extends keyof TType
-    ? TType[TKey]
-    : never;
-}>;
+export type FlatOverwrite<TType, TWith> = Simplify<
+  InferOptional<
+    {
+      [TKey in keyof TWith | keyof TType]: TKey extends keyof TWith
+        ? TWith[TKey]
+        : TKey extends keyof TType
+        ? TType[TKey]
+        : never;
+    },
+    UndefinedKeys<TType> | UndefinedKeys<TWith>
+  >
+>;
 
 /**
  * @public

package/dist/assertNotBrowser.d.ts

@@ -1,2 +0,0 @@
-export declare function assertNotBrowser(): void;
-//# sourceMappingURL=assertNotBrowser.d.ts.map

package/dist/assertNotBrowser.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"assertNotBrowser.d.ts","sourceRoot":"","sources":["../src/assertNotBrowser.ts"],"names":[],"mappings":"AAEA,wBAAgB,gBAAgB,SAS/B"}