compactr

Compactr

A compression library for the modern web

---

What is this and why does it matter?

Compactr is a library to compress and decompress Javascript objects before sending them over the web. It's immensely useful for web applications that use sockets a lot. Smaller payloads equals better, faster throughput and less bandwidth costs.

Aren't there any other libraries out there that do this?

Yes, yes there are. Like msgpack, snappy and protocol-buffers.

Then why make another one, isn't Protobuf like... the best thing?

Why yes, Protocol Buffer is by far the better performing protocol out there, but there's a few things about it I don't like - as a Node developer.

The first thing that comes to mind is the painful management of .proto files.

Not only are they overly complex, they are also written in a different markup, which makes dynamic generation or property probing a bit of a hassle. Not to mention that you have to maintain parity across services of these messages that are more often than not a copy of your data Models. (See DRY)

Furthermore, Compactr has NO dependencies or compiled modules. It's the lightest module you've ever seen!

So what's your solution?

Protocol Buffers are awesome. Having schemas to deflate and inflate data while maintaining some kind of validation is a great concept. Compactr's goal is to build on that to better suit Node server development and reduce noise by allowing you to re-use your current Model schemas.

Examples, please.

For example, if you have a DB schema for users, you can use that directly as a schema for Compactr.

| Waterline | Mongoose | | --- | --- | --- | | {
id: {
type: 'integer',
required: true
},
name: 'string'
} | {
id: {
type: Number,
required: true
},
name: String
} |

/* User compessing in a controller */

const Compactr = require('compactr');

User.create({ id: 0, name: 'Bruce' })
  .then(user => Compactr.encode(User, user))
  .then(deflated => /* Send encoded User */);

/* Decoding the User data */

let user = Compactr.decode(User, deflated);

No need to create additional models for serialization!

Can that be used for Websockets too?

Oh yes, via webpack!

npm run build

Will generate browser-ready code!

What about Node compatibility

You need Node 6.0.0 and up

What about performances?

TODO

I'm still working on graphs and proper test scenarios, but I can say that it performs as fast, and sometimes faster than JSON encoding/decoding and outputs a buffer that is more or less half the size!

Alright, what about features?

In the near future, you will be able to:

• Use Waterline schemas
• Use Mongoose schemas
• Synchronously encode/decode
• Nested objects/ Arrays

Alright, I'm convinced! How can I help?

Just open an issue, identifying it as a feature that you want to tackle. Ex: STORY - [...] And we'll take the discussion there.