RPC JSON Serializer

This serializer handles JSON payloads for the RPC Protocol and supports native data types.

Extending Native Data Types

Extend native types by creating your own StandardRPCCustomJsonSerializer and adding it to the customJsonSerializers option.

1. Define Your Custom Serializer

   import type { StandardRPCCustomJsonSerializer } from '@orpc/client/standard'
   
   export class User {
     constructor(
       public readonly id: string,
       public readonly name: string,
       public readonly email: string,
       public readonly age: number,
     ) {}
   
     toJSON() {
       return {
         id: this.id,
         name: this.name,
         email: this.email,
         age: this.age,
       }
     }
   }
   
   export const userSerializer: StandardRPCCustomJsonSerializer = {
     type: 21,
     condition: data => data instanceof User,
     serialize: data => data.toJSON(),
     deserialize: data => new User(data.id, data.name, data.email, data.age),
   }

   WARNING

   Ensure the type is unique and greater than 20 to avoid conflicts with built-in types in the future.

2. Use Your Custom Serializer

   const handler = new RPCHandler(router, {
     customJsonSerializers: [userSerializer], 
   })
   
   const link = new RPCLink({
     url: 'https://example.com/rpc',
     customJsonSerializers: [userSerializer], 
   })

Overriding Built-in Types

You can override built-in types by matching their type with the built-in types.

For example, oRPC represents undefined only in array items and ignores it in objects. To override this behavior:

import { StandardRPCCustomJsonSerializer } from '@orpc/client/standard'

export const undefinedSerializer: StandardRPCCustomJsonSerializer = {
  type: 3, // Match the built-in undefined type.
  condition: data => data === undefined,
  serialize: data => null, // JSON cannot represent undefined, so use null.
  deserialize: data => undefined,
}