0
# Protocol Support
1

2
Multiple serialization protocols for efficient data transmission with full JavaScript type support, configurable options for performance optimization, and seamless integration with all transport mechanisms.
3

4
## Capabilities
5

6
### Binary Protocol
7

8
High-performance binary serialization protocol optimized for efficiency and minimal overhead. The default choice for production deployments requiring maximum throughput.
9

10
```javascript { .api }
11
/**
12
 * Binary protocol implementation for efficient serialization
13
 * @param transport - Transport instance to write/read data
14
 * @param strictRead - Enable strict reading mode for better error detection
15
 * @param strictWrite - Enable strict writing mode for better error detection
16
 */
17
class TBinaryProtocol {
18
  constructor(transport, strictRead?, strictWrite?);
19
  
20
  // Message framing
21
  writeMessageBegin(name, type, seqid): void;
22
  writeMessageEnd(): void;
23
  readMessageBegin(): {fname: string, mtype: number, rseqid: number};
24
  readMessageEnd(): void;
25
  
26
  // Struct framing
27
  writeStructBegin(name): void;
28
  writeStructEnd(): void;
29
  readStructBegin(): {fname: string};
30
  readStructEnd(): void;
31
  
32
  // Field framing
33
  writeFieldBegin(name, type, id): void;
34
  writeFieldEnd(): void;
35
  writeFieldStop(): void;
36
  readFieldBegin(): {fname: string, ftype: number, fid: number};
37
  readFieldEnd(): void;
38
  
39
  // Collection framing
40
  writeMapBegin(ktype, vtype, size): void;
41
  writeMapEnd(): void;
42
  readMapBegin(): {ktype: number, vtype: number, size: number};
43
  readMapEnd(): void;
44
  
45
  writeListBegin(etype, size): void;
46
  writeListEnd(): void;
47
  readListBegin(): {etype: number, size: number};
48
  readListEnd(): void;
49
  
50
  writeSetBegin(etype, size): void;
51
  writeSetEnd(): void;
52
  readSetBegin(): {etype: number, size: number};
53
  readSetEnd(): void;
54
  
55
  // Primitive type serialization
56
  writeBool(bool): void;
57
  writeByte(byte): void;
58
  writeI16(i16): void;
59
  writeI32(i32): void;
60
  writeI64(i64): void;
61
  writeDouble(dub): void;
62
  writeString(str): void;
63
  writeBinary(buf): void;
64
  
65
  // Primitive type deserialization
66
  readBool(): boolean;
67
  readByte(): number;
68
  readI16(): number;
69
  readI32(): number;
70
  readI64(): number;
71
  readDouble(): number;
72
  readString(): string;
73
  readBinary(): Buffer;
74
  
75
  // Utility methods
76
  skip(type): void;
77
  flush(): void;
78
  
79
  // Configuration properties
80
  strictRead: boolean;
81
  strictWrite: boolean;
82
}
83
```
84

85
**Usage Examples:**
86

87
```javascript
88
const thrift = require('thrift');
89

90
// Basic binary protocol
91
const transport = new thrift.TBufferedTransport();
92
const protocol = new thrift.TBinaryProtocol(transport);
93

94
// Strict mode for better error detection
95
const strictProtocol = new thrift.TBinaryProtocol(transport, true, true);
96

97
// Writing data
98
protocol.writeMessageBegin('myMethod', thrift.Thrift.MessageType.CALL, 1);
99
protocol.writeStructBegin('MyStruct');
100
protocol.writeFieldBegin('field1', thrift.Thrift.Type.STRING, 1);
101
protocol.writeString('Hello, World!');
102
protocol.writeFieldEnd();
103
protocol.writeFieldStop();
104
protocol.writeStructEnd();
105
protocol.writeMessageEnd();
106
protocol.flush();
107
```
108

109
### Compact Protocol
110

111
Space-efficient binary protocol that uses variable-length encoding for integers and compact field representations. Ideal for bandwidth-constrained environments and mobile applications.
112

113
```javascript { .api }
114
/**
115
 * Compact binary protocol with variable-length encoding
116
 * @param transport - Transport instance to write/read data
117
 */
118
class TCompactProtocol {
119
  constructor(transport);
120
  
121
  // Same interface as TBinaryProtocol with optimized encoding
122
  writeMessageBegin(name, type, seqid): void;
123
  writeMessageEnd(): void;
124
  readMessageBegin(): {fname: string, mtype: number, rseqid: number};
125
  readMessageEnd(): void;
126
  
127
  writeStructBegin(name): void;
128
  writeStructEnd(): void;
129
  readStructBegin(): {fname: string};
130
  readStructEnd(): void;
131
  
132
  writeFieldBegin(name, type, id): void;
133
  writeFieldEnd(): void;
134
  writeFieldStop(): void;
135
  readFieldBegin(): {fname: string, ftype: number, fid: number};
136
  readFieldEnd(): void;
137
  
138
  writeMapBegin(ktype, vtype, size): void;
139
  writeMapEnd(): void;
140
  readMapBegin(): {ktype: number, vtype: number, size: number};
141
  readMapEnd(): void;
142
  
143
  writeListBegin(etype, size): void;
144
  writeListEnd(): void;
145
  readListBegin(): {etype: number, size: number};
146
  readListEnd(): void;
147
  
148
  writeSetBegin(etype, size): void;
149
  writeSetEnd(): void;
150
  readSetBegin(): {etype: number, size: number};
151
  readSetEnd(): void;
152
  
153
  writeBool(bool): void;
154
  writeByte(byte): void;
155
  writeI16(i16): void;
156
  writeI32(i32): void;
157
  writeI64(i64): void;
158
  writeDouble(dub): void;
159
  writeString(str): void;
160
  writeBinary(buf): void;
161
  
162
  readBool(): boolean;
163
  readByte(): number;
164
  readI16(): number;
165
  readI32(): number;
166
  readI64(): number;
167
  readDouble(): number;
168
  readString(): string;
169
  readBinary(): Buffer;
170
  
171
  skip(type): void;
172
  flush(): void;
173
}
174
```
175

176
**Usage Examples:**
177

178
```javascript
179
// Compact protocol for bandwidth efficiency
180
const compactProtocol = new thrift.TCompactProtocol(transport);
181

182
// Same usage as binary protocol but with smaller payload sizes
183
compactProtocol.writeI32(42);        // Uses variable-length encoding
184
compactProtocol.writeString("test"); // Compact string representation
185
```
186

187
### JSON Protocol
188

189
Human-readable JSON serialization protocol for debugging, REST API integration, and cross-platform compatibility. Supports both readable and compact JSON formats.
190

191
```javascript { .api }
192
/**
193
 * JSON protocol implementation for human-readable serialization
194
 * @param transport - Transport instance to write/read data
195
 */
196
class TJSONProtocol {
197
  constructor(transport);
198
  
199
  // Same interface as other protocols with JSON serialization
200
  writeMessageBegin(name, type, seqid): void;
201
  writeMessageEnd(): void;
202
  readMessageBegin(): {fname: string, mtype: number, rseqid: number};
203
  readMessageEnd(): void;
204
  
205
  writeStructBegin(name): void;
206
  writeStructEnd(): void;
207
  readStructBegin(): {fname: string};
208
  readStructEnd(): void;
209
  
210
  writeFieldBegin(name, type, id): void;
211
  writeFieldEnd(): void;
212
  writeFieldStop(): void;
213
  readFieldBegin(): {fname: string, ftype: number, fid: number};
214
  readFieldEnd(): void;
215
  
216
  writeMapBegin(ktype, vtype, size): void;
217
  writeMapEnd(): void;
218
  readMapBegin(): {ktype: number, vtype: number, size: number};
219
  readMapEnd(): void;
220
  
221
  writeListBegin(etype, size): void;
222
  writeListEnd(): void;
223
  readListBegin(): {etype: number, size: number};
224
  readListEnd(): void;
225
  
226
  writeSetBegin(etype, size): void;
227
  writeSetEnd(): void;
228
  readSetBegin(): {etype: number, size: number};
229
  readSetEnd(): void;
230
  
231
  writeBool(bool): void;
232
  writeByte(byte): void;
233
  writeI16(i16): void;
234
  writeI32(i32): void;
235
  writeI64(i64): void;
236
  writeDouble(dub): void;
237
  writeString(str): void;
238
  writeBinary(buf): void;
239
  
240
  readBool(): boolean;
241
  readByte(): number;
242
  readI16(): number;
243
  readI32(): number;
244
  readI64(): number;
245
  readDouble(): number;
246
  readString(): string;
247
  readBinary(): Buffer;
248
  
249
  skip(type): void;
250
  flush(): void;
251
}
252
```
253

254
**Usage Examples:**
255

256
```javascript
257
// JSON protocol for debugging and REST integration
258
const jsonProtocol = new thrift.TJSONProtocol(transport);
259

260
// Creates human-readable JSON output
261
jsonProtocol.writeString("Hello");     // "Hello"  
262
jsonProtocol.writeI32(42);             // 42
263
jsonProtocol.writeListBegin(thrift.Thrift.Type.STRING, 2); // [
264
jsonProtocol.writeString("item1");     // "item1",
265
jsonProtocol.writeString("item2");     // "item2"
266
jsonProtocol.writeListEnd();           // ]
267
```
268

269
### Header Protocol
270

271
Advanced protocol with header-based metadata support, versioning capabilities, and extensible header information for enterprise deployments.
272

273
```javascript { .api }
274
/**
275
 * Header protocol with metadata and versioning support
276
 * @param transport - Transport instance to write/read data  
277
 * @param clientType - Client type identifier for header metadata
278
 */
279
class THeaderProtocol {
280
  constructor(transport, clientType?);
281
  
282
  // Extended interface with header support
283
  writeMessageBegin(name, type, seqid): void;
284
  writeMessageEnd(): void;
285
  readMessageBegin(): {fname: string, mtype: number, rseqid: number};
286
  readMessageEnd(): void;
287
  
288
  // Header-specific methods
289
  setHeader(key, value): void;
290
  getHeader(key): string;
291
  clearHeaders(): void;
292
  getHeaders(): object;
293
  
294
  // Transform support
295
  addTransform(transform): void;
296
  getTransforms(): number[];
297
  
298
  // Standard protocol interface
299
  writeStructBegin(name): void;
300
  writeStructEnd(): void;
301
  readStructBegin(): {fname: string};
302
  readStructEnd(): void;
303
  
304
  writeFieldBegin(name, type, id): void;
305
  writeFieldEnd(): void;
306
  writeFieldStop(): void;
307
  readFieldBegin(): {fname: string, ftype: number, fid: number};
308
  readFieldEnd(): void;
309
  
310
  writeMapBegin(ktype, vtype, size): void;
311
  writeMapEnd(): void;
312
  readMapBegin(): {ktype: number, vtype: number, size: number};
313
  readMapEnd(): void;
314
  
315
  writeListBegin(etype, size): void;
316
  writeListEnd(): void;
317
  readListBegin(): {etype: number, size: number};
318
  readListEnd(): void;
319
  
320
  writeSetBegin(etype, size): void;
321
  writeSetEnd(): void;
322
  readSetBegin(): {etype: number, size: number};
323
  readSetEnd(): void;
324
  
325
  writeBool(bool): void;
326
  writeByte(byte): void;
327
  writeI16(i16): void;
328
  writeI32(i32): void;
329
  writeI64(i64): void;
330
  writeDouble(dub): void;
331
  writeString(str): void;
332
  writeBinary(buf): void;
333
  
334
  readBool(): boolean;
335
  readByte(): number;
336
  readI16(): number;
337
  readI32(): number;
338
  readI64(): number;
339
  readDouble(): number;
340
  readString(): string;
341
  readBinary(): Buffer;
342
  
343
  skip(type): void;
344
  flush(): void;
345
  
346
  // Configuration properties
347
  clientType: number;
348
}
349
```
350

351
**Usage Examples:**
352

353
```javascript
354
// Header protocol with metadata
355
const headerProtocol = new thrift.THeaderProtocol(transport, 1);
356

357
// Set custom headers
358
headerProtocol.setHeader('X-Request-ID', 'req-123');
359
headerProtocol.setHeader('X-Client-Version', '2.1.0');
360
headerProtocol.setHeader('Authorization', 'Bearer token123');
361

362
// Add compression transform
363
headerProtocol.addTransform(thrift.THeaderTransform.ZLIB);
364

365
// Use like any other protocol
366
headerProtocol.writeString("data with headers");
367

368
// Read headers from responses
369
const headers = headerProtocol.getHeaders();
370
console.log('Response headers:', headers);
371
```
372

373
## Protocol Selection Guidelines
374

375
```javascript { .api }
376
// Protocol performance and use case comparison
377
interface ProtocolComparison {
378
  TBinaryProtocol: {
379
    performance: 'Highest',
380
    size: 'Efficient',
381
    humanReadable: false,
382
    useCase: 'Production systems, high-throughput applications'
383
  };
384
  
385
  TCompactProtocol: {
386
    performance: 'High', 
387
    size: 'Most efficient',
388
    humanReadable: false,
389
    useCase: 'Mobile apps, bandwidth-constrained environments'
390
  };
391
  
392
  TJSONProtocol: {
393
    performance: 'Lower',
394
    size: 'Largest',
395
    humanReadable: true,
396
    useCase: 'Debugging, REST integration, cross-platform compatibility'
397
  };
398
  
399
  THeaderProtocol: {
400
    performance: 'High',
401
    size: 'Efficient + headers',
402
    humanReadable: false,
403
    useCase: 'Enterprise systems requiring metadata and versioning'
404
  };
405
}
406
```