Avsc

Pure JavaScript implementation of the Avro specification.

Features

• Arbitrary Avro schema support, and schema evolution.
• No dependencies.
• Fast! Did you know that Avro could be faster than JSON?

Installation

$ npm install avsc

avsc is compatible with io.js and versions of node.js from and including 0.11.

Documentation

• Quickstart
• API
• Advanced usage

A few examples to boot:

• Encode and decode JavaScript objects using an Avro schema file:

  var avsc = require('avsc'); // Implied in all other examples below.
  
  var type = avsc.parse('Person.avsc');
  var buf = type.encode({name: 'Ann', age: 25}); // Serialize a JS object.
  var obj = type.decode(buf); // And deserialize it back.

• Get a readable record stream from an Avro container file:

  avsc.decodeFile('records.avro')
    .on('data', function (record) { /* Do something with the record. */ });

• Generate a random instance from a schema object:

  var type = avsc.parse({
    name: 'Pet',
    type: 'record',
    fields: [
      {name: 'kind', type: {name: 'Kind', type: 'enum', symbols: ['CAT', 'DOG']}},
      {name: 'name', type: 'string'},
      {name: 'isFurry', type: 'boolean'}
    ]
  });
  
  var pet = type.random(); // E.g. {kind: 'CAT', name: 'qwXlrew', isFurry: true}

• Create a duplex stream to serialize objects on the fly:

  var type = avsc.parse({type: 'array', items: 'int'});
  
  var encoder = new avsc.streams.RawEncoder(type)
    .on('data', function (chunk) { /* Do something with the chunk. */ });
  
  encoder.write([123, 5]);
  encoder.end([10]);

Performance

Despite being written in pure JavaScript, avsc is still fast: supporting encoding and decoding throughput rates in the 100,000s per second for complex schemas.

In fact, it is generally faster than the built-in JSON parser (also producing encodings orders of magnitude smaller without compression). See the benchmarks page for the raw numbers.

Limitations

• Protocols aren't yet implemented.
• JavaScript doesn't natively support the long type, so numbers larger than Number.MAX_SAFE_INTEGER (or smaller than the corresponding lower bound) might suffer a loss of precision.