@trpc/server 10.42.0 → 10.43.1

package/src/rpc/parseTRPCMessage.ts

@@ -0,0 +1,84 @@
+import type { ProcedureType } from '../core';
+import type { CombinedDataTransformer } from '../transformer';
+import type { TRPCClientOutgoingMessage } from './envelopes';
+
+/* istanbul ignore next -- @preserve */
+function assertIsObject(obj: unknown): asserts obj is Record<string, unknown> {
+  if (typeof obj !== 'object' || Array.isArray(obj) || !obj) {
+    throw new Error('Not an object');
+  }
+}
+
+/* istanbul ignore next -- @preserve */
+function assertIsProcedureType(obj: unknown): asserts obj is ProcedureType {
+  if (obj !== 'query' && obj !== 'subscription' && obj !== 'mutation') {
+    throw new Error('Invalid procedure type');
+  }
+}
+
+/* istanbul ignore next -- @preserve */
+function assertIsRequestId(
+  obj: unknown,
+): asserts obj is number | string | null {
+  if (
+    obj !== null &&
+    typeof obj === 'number' &&
+    isNaN(obj) &&
+    typeof obj !== 'string'
+  ) {
+    throw new Error('Invalid request id');
+  }
+}
+
+/* istanbul ignore next -- @preserve */
+function assertIsString(obj: unknown): asserts obj is string {
+  if (typeof obj !== 'string') {
+    throw new Error('Invalid string');
+  }
+}
+
+/* istanbul ignore next -- @preserve */
+function assertIsJSONRPC2OrUndefined(
+  obj: unknown,
+): asserts obj is '2.0' | undefined {
+  if (typeof obj !== 'undefined' && obj !== '2.0') {
+    throw new Error('Must be JSONRPC 2.0');
+  }
+}
+
+/** @public */
+export function parseTRPCMessage(
+  obj: unknown,
+  transformer: CombinedDataTransformer,
+): TRPCClientOutgoingMessage {
+  assertIsObject(obj);
+
+  const { id, jsonrpc, method, params } = obj;
+  assertIsRequestId(id);
+  assertIsJSONRPC2OrUndefined(jsonrpc);
+
+  if (method === 'subscription.stop') {
+    return {
+      id,
+      jsonrpc,
+      method,
+    };
+  }
+  assertIsProcedureType(method);
+  assertIsObject(params);
+  const { input: rawInput, path } = params;
+
+  assertIsString(path);
+
+  const input = transformer.input.deserialize(rawInput);
+
+  return {
+    id,
+    jsonrpc,
+    method,
+    params: {
+      input,
+      path,
+    },
+  };
+}

package/src/shared/internal/serialize.ts

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/naming-convention */
-import { FilterKeys, Simplify } from '../../types';
+import { Simplify } from '../../types';
 
 /**
  * @link https://github.com/remix-run/remix/blob/2248669ed59fd716e267ea41df5d665d4781f4a9/packages/remix-server-runtime/serialize.ts
@@ -21,6 +21,7 @@ type JsonReturnable = JsonPrimitive | undefined;
 // prettier-ignore
 export type Serialize<T> =
   IsAny<T> extends true ? any :
+  unknown extends T ? unknown :
   T extends JsonReturnable ? T :
   T extends Map<any, any> | Set<any> ? object :
   T extends NonJsonPrimitive ? never :
@@ -36,12 +37,24 @@ type SerializeTuple<T extends [unknown, ...unknown[]]> = {
   [k in keyof T]: T[k] extends NonJsonPrimitive ? null : Serialize<T[k]>;
 };
 
+// prettier-ignore
+type SerializeObjectKey<T extends Record<any, any>, TKey> = 
+  // never include entries where the key is a symbol
+  TKey extends symbol ? never : 
+  // always include entries where the value is any
+  IsAny<T[TKey]> extends true ? TKey :
+  // always include entries where the value is unknown
+  unknown extends T[TKey] ? TKey : 
+  // never include entries where the value is a non-JSON primitive
+  T[TKey] extends NonJsonPrimitive ? never : 
+  // otherwise serialize the value
+  TKey;
 /**
  * JSON serialize objects (not including arrays) and classes
  * @internal
  **/
 export type SerializeObject<T extends object> = {
-  [k in keyof Omit<T, FilterKeys<T, NonJsonPrimitive>>]: Serialize<T[k]>;
+  [$Key in keyof T as SerializeObjectKey<T, $Key>]: Serialize<T[$Key]>;
 };
 
 type FilterDefinedKeys<TObj extends object> = Exclude<