protobufjs/protobuf.js
Protobuf.js
protobuf.js is a JavaScript and TypeScript library for encoding and decoding structured data using the Protocol Buffers binary format. It functions as a dynamic parser that can load and process schemas at runtime, a JSON transcoder for converting messages to human-readable formats, and a framework for building transport-agnostic remote procedure call clients.
The project distinguishes itself by offering both dynamic message handling and a static code generator that produces TypeScript declarations and JavaScript modules to reduce runtime overhead. It also provides a reflection API for defining schemas programmatically and the ability to extend decoded message classes with custom domain methods.
The library covers binary data serialization, cross-language interoperability, and schema-based validation to ensure objects conform to required fields and type definitions. It includes automation utilities for generating reflection bundles and integrates with the protoc compiler to streamline the build process.
Memory efficiency is addressed through pre-allocated buffer serialization, which writes encoded data directly to memory to minimize garbage collection and data copying.
Features
- Binary Serialization Formats - Decodes binary Protocol Buffers data back into structured message instances with control over unknown fields.
- Protocol Buffers - Implements the Protocol Buffers binary serialization mechanism for JavaScript and TypeScript environments.
- Binary Serialization - Provides high-performance conversion of JavaScript objects into compact Protocol Buffers binary formats.
- Cross-Language Data Protocols - Enables consistent data exchange between JavaScript and other languages using standardized Protocol Buffers schemas.
- Length-Delimited Encodings - Encodes message instances into binary format, including support for length-delimited encoding for streaming.
- JSON-Protobuf Mapping - Provides bidirectional mapping between structured Protocol Buffers messages and JSON strings or objects for API interoperability.
- Reflection-Based Object Models - Parses schema files into an internal tree of objects that drives runtime encoding and decoding.
- Dynamic Type Modeling - Dynamically generates JavaScript classes and constructors at runtime based on parsed Protocol Buffers schema definitions.
- Protobuf Descriptor Loading - Implements a dynamic parser that processes .proto files to build in-memory service maps at runtime.
- Code Generators - Produces static JavaScript modules and TypeScript declarations from schemas to eliminate runtime reflection overhead.
- Object-to-Data Mapping Frameworks - Creates formal message instances from plain JavaScript objects to ensure data conforms to the defined schema.
- Data Schema Validation - Verifies that plain JavaScript objects conform to a schema by checking required fields and type definitions.
- Object Mapping Frameworks - Transforms formal message instances into plain JavaScript objects with configurable options for enums and bytes.
- Schema Validation - Verifies that data objects conform to a schema by validating required fields and enumeration values.
- Dynamic Schema Parsing - Allows loading and processing of Protocol Buffers schemas at runtime to handle data dynamically.
- Programmatic Definitions - Constructs types and namespaces dynamically using a reflection API instead of loading external files.
- Reflection Bundles - Serializes internal schema models into compact JSON files to accelerate loading in production environments.
- Definition Loading - Imports service descriptors via reflection, source files, or binary sets to define message structures.
- Reflection Bundle Generation - Creates JSON bundles and declaration files to enable the dynamic loading of message types at runtime.
- Static Type Generators - Generates TypeScript declarations and JavaScript modules from schemas to reduce runtime overhead.
- Schema Parsing - Converts .proto source files into a reflection-based object model while preserving comments and custom options.
- Protocol-Agnostic Transport Layers - Maps service definitions to a generic request-response interface, allowing for any underlying communication layer.
- RPC Frameworks - Provides a framework for implementing transport-agnostic RPC clients based on service definitions.
- Service Metadata Management - Enables the implementation of service definitions and the exposure of metadata to facilitate remote procedure calls.
- Compile-Time Code Generation - Provides a compiler plugin to automate the generation of JavaScript and TypeScript files during the build process.
- Data Validation Schemas - Verifies that JavaScript objects conform to required fields and type definitions specified in the schema.
- Zero-Allocation Buffer Encoders - Implements serialization that writes encoded data directly into pre-allocated buffers to minimize garbage collection overhead.
- gRPC Service Implementations - Provides a framework for implementing and consuming RPC services using Protocol Buffers definitions.
- Data Serialization - Protocol Buffers implementation for JavaScript.
- Serialization Tools - Protocol Buffers implementation for JavaScript.
