tessl/npm-thrift

Node.js bindings for Apache Thrift RPC system providing client/server libraries, protocols, and transports for cross-language service communication.

—

Pending

Overview

Eval results

Files

Protocol Support

Name: tessl/npm-thrift
Author: tessl

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

Capabilities

Binary Protocol

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

/**
 * Binary protocol implementation for efficient serialization
 * @param transport - Transport instance to write/read data
 * @param strictRead - Enable strict reading mode for better error detection
 * @param strictWrite - Enable strict writing mode for better error detection
 */
class TBinaryProtocol {
  constructor(transport, strictRead?, strictWrite?);
  
  // Message framing
  writeMessageBegin(name, type, seqid): void;
  writeMessageEnd(): void;
  readMessageBegin(): {fname: string, mtype: number, rseqid: number};
  readMessageEnd(): void;
  
  // Struct framing
  writeStructBegin(name): void;
  writeStructEnd(): void;
  readStructBegin(): {fname: string};
  readStructEnd(): void;
  
  // Field framing
  writeFieldBegin(name, type, id): void;
  writeFieldEnd(): void;
  writeFieldStop(): void;
  readFieldBegin(): {fname: string, ftype: number, fid: number};
  readFieldEnd(): void;
  
  // Collection framing
  writeMapBegin(ktype, vtype, size): void;
  writeMapEnd(): void;
  readMapBegin(): {ktype: number, vtype: number, size: number};
  readMapEnd(): void;
  
  writeListBegin(etype, size): void;
  writeListEnd(): void;
  readListBegin(): {etype: number, size: number};
  readListEnd(): void;
  
  writeSetBegin(etype, size): void;
  writeSetEnd(): void;
  readSetBegin(): {etype: number, size: number};
  readSetEnd(): void;
  
  // Primitive type serialization
  writeBool(bool): void;
  writeByte(byte): void;
  writeI16(i16): void;
  writeI32(i32): void;
  writeI64(i64): void;
  writeDouble(dub): void;
  writeString(str): void;
  writeBinary(buf): void;
  
  // Primitive type deserialization
  readBool(): boolean;
  readByte(): number;
  readI16(): number;
  readI32(): number;
  readI64(): number;
  readDouble(): number;
  readString(): string;
  readBinary(): Buffer;
  
  // Utility methods
  skip(type): void;
  flush(): void;
  
  // Configuration properties
  strictRead: boolean;
  strictWrite: boolean;
}

Usage Examples:

const thrift = require('thrift');

// Basic binary protocol
const transport = new thrift.TBufferedTransport();
const protocol = new thrift.TBinaryProtocol(transport);

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

// Writing data
protocol.writeMessageBegin('myMethod', thrift.Thrift.MessageType.CALL, 1);
protocol.writeStructBegin('MyStruct');
protocol.writeFieldBegin('field1', thrift.Thrift.Type.STRING, 1);
protocol.writeString('Hello, World!');
protocol.writeFieldEnd();
protocol.writeFieldStop();
protocol.writeStructEnd();
protocol.writeMessageEnd();
protocol.flush();

Compact Protocol

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

/**
 * Compact binary protocol with variable-length encoding
 * @param transport - Transport instance to write/read data
 */
class TCompactProtocol {
  constructor(transport);
  
  // Same interface as TBinaryProtocol with optimized encoding
  writeMessageBegin(name, type, seqid): void;
  writeMessageEnd(): void;
  readMessageBegin(): {fname: string, mtype: number, rseqid: number};
  readMessageEnd(): void;
  
  writeStructBegin(name): void;
  writeStructEnd(): void;
  readStructBegin(): {fname: string};
  readStructEnd(): void;
  
  writeFieldBegin(name, type, id): void;
  writeFieldEnd(): void;
  writeFieldStop(): void;
  readFieldBegin(): {fname: string, ftype: number, fid: number};
  readFieldEnd(): void;
  
  writeMapBegin(ktype, vtype, size): void;
  writeMapEnd(): void;
  readMapBegin(): {ktype: number, vtype: number, size: number};
  readMapEnd(): void;
  
  writeListBegin(etype, size): void;
  writeListEnd(): void;
  readListBegin(): {etype: number, size: number};
  readListEnd(): void;
  
  writeSetBegin(etype, size): void;
  writeSetEnd(): void;
  readSetBegin(): {etype: number, size: number};
  readSetEnd(): void;
  
  writeBool(bool): void;
  writeByte(byte): void;
  writeI16(i16): void;
  writeI32(i32): void;
  writeI64(i64): void;
  writeDouble(dub): void;
  writeString(str): void;
  writeBinary(buf): void;
  
  readBool(): boolean;
  readByte(): number;
  readI16(): number;
  readI32(): number;
  readI64(): number;
  readDouble(): number;
  readString(): string;
  readBinary(): Buffer;
  
  skip(type): void;
  flush(): void;
}

Usage Examples:

// Compact protocol for bandwidth efficiency
const compactProtocol = new thrift.TCompactProtocol(transport);

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

JSON Protocol

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

/**
 * JSON protocol implementation for human-readable serialization
 * @param transport - Transport instance to write/read data
 */
class TJSONProtocol {
  constructor(transport);
  
  // Same interface as other protocols with JSON serialization
  writeMessageBegin(name, type, seqid): void;
  writeMessageEnd(): void;
  readMessageBegin(): {fname: string, mtype: number, rseqid: number};
  readMessageEnd(): void;
  
  writeStructBegin(name): void;
  writeStructEnd(): void;
  readStructBegin(): {fname: string};
  readStructEnd(): void;
  
  writeFieldBegin(name, type, id): void;
  writeFieldEnd(): void;
  writeFieldStop(): void;
  readFieldBegin(): {fname: string, ftype: number, fid: number};
  readFieldEnd(): void;
  
  writeMapBegin(ktype, vtype, size): void;
  writeMapEnd(): void;
  readMapBegin(): {ktype: number, vtype: number, size: number};
  readMapEnd(): void;
  
  writeListBegin(etype, size): void;
  writeListEnd(): void;
  readListBegin(): {etype: number, size: number};
  readListEnd(): void;
  
  writeSetBegin(etype, size): void;
  writeSetEnd(): void;
  readSetBegin(): {etype: number, size: number};
  readSetEnd(): void;
  
  writeBool(bool): void;
  writeByte(byte): void;
  writeI16(i16): void;
  writeI32(i32): void;
  writeI64(i64): void;
  writeDouble(dub): void;
  writeString(str): void;
  writeBinary(buf): void;
  
  readBool(): boolean;
  readByte(): number;
  readI16(): number;
  readI32(): number;
  readI64(): number;
  readDouble(): number;
  readString(): string;
  readBinary(): Buffer;
  
  skip(type): void;
  flush(): void;
}

Usage Examples:

// JSON protocol for debugging and REST integration
const jsonProtocol = new thrift.TJSONProtocol(transport);

// Creates human-readable JSON output
jsonProtocol.writeString("Hello");     // "Hello"  
jsonProtocol.writeI32(42);             // 42
jsonProtocol.writeListBegin(thrift.Thrift.Type.STRING, 2); // [
jsonProtocol.writeString("item1");     // "item1",
jsonProtocol.writeString("item2");     // "item2"
jsonProtocol.writeListEnd();           // ]

Header Protocol

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

/**
 * Header protocol with metadata and versioning support
 * @param transport - Transport instance to write/read data  
 * @param clientType - Client type identifier for header metadata
 */
class THeaderProtocol {
  constructor(transport, clientType?);
  
  // Extended interface with header support
  writeMessageBegin(name, type, seqid): void;
  writeMessageEnd(): void;
  readMessageBegin(): {fname: string, mtype: number, rseqid: number};
  readMessageEnd(): void;
  
  // Header-specific methods
  setHeader(key, value): void;
  getHeader(key): string;
  clearHeaders(): void;
  getHeaders(): object;
  
  // Transform support
  addTransform(transform): void;
  getTransforms(): number[];
  
  // Standard protocol interface
  writeStructBegin(name): void;
  writeStructEnd(): void;
  readStructBegin(): {fname: string};
  readStructEnd(): void;
  
  writeFieldBegin(name, type, id): void;
  writeFieldEnd(): void;
  writeFieldStop(): void;
  readFieldBegin(): {fname: string, ftype: number, fid: number};
  readFieldEnd(): void;
  
  writeMapBegin(ktype, vtype, size): void;
  writeMapEnd(): void;
  readMapBegin(): {ktype: number, vtype: number, size: number};
  readMapEnd(): void;
  
  writeListBegin(etype, size): void;
  writeListEnd(): void;
  readListBegin(): {etype: number, size: number};
  readListEnd(): void;
  
  writeSetBegin(etype, size): void;
  writeSetEnd(): void;
  readSetBegin(): {etype: number, size: number};
  readSetEnd(): void;
  
  writeBool(bool): void;
  writeByte(byte): void;
  writeI16(i16): void;
  writeI32(i32): void;
  writeI64(i64): void;
  writeDouble(dub): void;
  writeString(str): void;
  writeBinary(buf): void;
  
  readBool(): boolean;
  readByte(): number;
  readI16(): number;
  readI32(): number;
  readI64(): number;
  readDouble(): number;
  readString(): string;
  readBinary(): Buffer;
  
  skip(type): void;
  flush(): void;
  
  // Configuration properties
  clientType: number;
}

Usage Examples:

// Header protocol with metadata
const headerProtocol = new thrift.THeaderProtocol(transport, 1);

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

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

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

// Read headers from responses
const headers = headerProtocol.getHeaders();
console.log('Response headers:', headers);

Protocol Selection Guidelines

// Protocol performance and use case comparison
interface ProtocolComparison {
  TBinaryProtocol: {
    performance: 'Highest',
    size: 'Efficient',
    humanReadable: false,
    useCase: 'Production systems, high-throughput applications'
  };
  
  TCompactProtocol: {
    performance: 'High', 
    size: 'Most efficient',
    humanReadable: false,
    useCase: 'Mobile apps, bandwidth-constrained environments'
  };
  
  TJSONProtocol: {
    performance: 'Lower',
    size: 'Largest',
    humanReadable: true,
    useCase: 'Debugging, REST integration, cross-platform compatibility'
  };
  
  THeaderProtocol: {
    performance: 'High',
    size: 'Efficient + headers',
    humanReadable: false,
    useCase: 'Enterprise systems requiring metadata and versioning'
  };
}

Install with Tessl CLI