What is PackMe

Two words: binary serialization. Or rather, four words: Blazing Fast Binary Serialization (BFBS). PackMe is a lightweight library that allows using your JSON description of data protocols to generate all necessary classes (JS, Flutter/Dart) for your client-server binary data communication.

``json "question": [ { "request": "string", "deadline": "datetime" }, { "answers": ["string"] } ] `

`javascript // ... Simple as that! let request = new QuesitonRequest( "What is the Matrix?", new Date() ); let data = await serverQuery(packMe.pack(request)); let response = packMe.unpack(data); response.answers.forEach(console.log); `

Performance

BFBS. Spoiler alert! 500,000+ pack/unpack cycles per second for data of average size and complexity (see example.js).

Since PackMe generates .js classes, there is no need for resource demanding serialization/deserialization process. With no intermediate steps involved, each class has efficient methods to quickly place all data into a Uint8Array buffer and extract it. Compared to popular solutions, it completely outmatches JSON or Protobuf in terms of performance.

Simplicity & Security

PackMe offers simplicity without need for special syntax knowledge - just use JSON. Declare types, messages and requests with ease. Moreover, the generated classes ensure data consistency, enhancing processing efficiency and fortifying server side security.

Usage

The most effective way to use it in client-server applications is through the ConnectMe package, which provides essential features like message listeners and asynchronous queries. Nevertheless, it can also be used separately.

Here's a simple manifest.json file (located in the "protocols" directory) for a hypothetical client-server application:
`json
{
"get_user": [
{
"id": "string"
},
{
"first_name": "string",
"last_name": "string",
"age": "uint8"
}
]
}
`
It implies that the client can get a user with the specified "id" from the server. The first step is to generate your classes:
`bash


Usage: compiler.mjs


npx packme packme generated
`
Next, let's import manifest.generated.js and proceed with a simple code for both client and server sides. Here goes the client side first:
`javascript
import { manifestMessageFactory, GetUserRequest, GetUserResponse } from 'generated/manifest.generated.mjs';
import { PackMe, PackMeMessage } from 'packme';

// ... whatever code goes here

let packMe = new PackMe();
// Register class factory to make PackMe able to create class instances while unpacking messages
packMe.register(manifestMessageFactory);

let request = GetUserRequest('a7db84cc2ef5012a6498bc64334ffa7d');
socket.send(packMe.pack(request)); // Some socket implementation

socket.listen((/* Uint8Array / data) => {
let message = packMe.unpack(data);
if (message instanceof GetUserResponse) {
print(He is awesome: ${message.firstName} ${message.lastName}, ${message.age} y.o.);
}
});
`
Now the server side:
`node
import { manifestMessageFactory, GetUserRequest, GetUserResponse } from 'generated/manifest.generated.mjs';
import { PackMe, PackMeMessage } from 'packme';

// ... whatever code goes here

let packMe = new PackMe();
// Register class factory to make PackMe able to create class instances while unpacking messages
packMe.register(manifestMessageFactory);

server.listen((/ Uint8Array / data, / SomeSocket / socket) => { // Some server implementation
let message = packMe.unpack(data);
if (message instanceof GetUserRequest) {
let response = GetUserResponse('Peter', 'Hollens', 39);
// Or: let response = message.$response('Peter', 'Hollens', 39);
socket.send(packMe.pack(response));
}
});
`

JSON Nodes

The JSON manifest is structured as an object containing various nodes. There are four different types of nodes you can create: enumeration, object, message and request.

$3

Declares a custom enumeration data type which you can later refer to:
`json
"message_status": [
"sent",
"delivered",
"read",
"unsent"
]
`
It will generate enum "MessageStatus". In order to declare a field of this enum type use "@" as a type prefix:
`json
"status": "@message_status"
`

$3

Declares a custom object (class) data type which can be referred to:
`json
"user_profile": {
"first_name": "string",
"last_name": "string",
"birth_date": "datetime"
}
`
It will generate class "UserProfile". In order to declare a field of object type use "@" as a type prefix:
`json
"profile": "@user_profile"
`
Objects can inherit other objects. Use the symbol "@" to specify the object to inherit:
`json
"animal": {
"legs": "uint8",
"tail": "bool"
},

"cat@animal": {
"color": "@color_enum",
"fur": "bool"
}
`
If the object you want to inherit is located in another file, use the following format: \@\:\