feat: add msg-pack parser

docs/examples/fs.md

@@ -20,3 +20,23 @@ const value = client.get('key');
 
 console.log(value);
 ```
+
+## 3. Use `msgpack` serializer
+
+By default `JSON` serializer is used. You can use following code to use `msgpack` serializer.
+
+```typescript
+import { Client } from '@litehex/storage-box';
+import { FsDriver } from '@litehex/storage-box/driver';
+import { MSGPack } from '@litehex/storage-box/parser';
+
+const filePath = resovle(process.cwd(), 'data.pack');
+const driver = new FsDriver(filePath, { parser: MSGPack });
+const client = new Client(driver);
+
+client.set('key', 'value');
+
+const value = client.get('key');
+
+console.log(value);
+```

package.json

@@ -61,6 +61,7 @@
   },
   "packageManager": "[email protected]",
   "dependencies": {
+    "@msgpack/msgpack": "3.0.0-beta2",
     "debounce": "^2.0.0",
     "type-fest": "^4.10.2"
   },

src/index.ts

@@ -287,4 +287,4 @@ export type * from '@/typings.ts';
 
 // -----------
 
-export { JsonMap } from '@/parser';
+export { JsonMap, MSGPack } from '@/parser';

src/parser/index.ts

@@ -1 +1,2 @@
 export * as JsonMap from './json-map.ts';
+export * as MSGPack from './msg-pack.ts';

src/parser/msg-pack.ts

@@ -0,0 +1,26 @@
+import type { JsonValue } from 'type-fest';
+import { decode, encode } from '@msgpack/msgpack';
+
+export function parse(data: any): Map<string, JsonValue> {
+  if (typeof data !== 'string') {
+    throw new Error('MessagePack data must be a string');
+  }
+  const buffer = Buffer.from(data, 'base64');
+  const decoded = decode(buffer);
+
+  if (typeof decoded !== 'object') {
+    throw new Error('MessagePack data must be an object');
+  }
+
+  return new Map(Object.entries(decoded as object));
+}
+
+export function stringify(data: any): string {
+  if (!(data instanceof Map)) {
+    throw new Error('MessagePack data must be a Map');
+  }
+  const obj = Object.fromEntries(data);
+  const encoded = encode(obj);
+  const buffer = Buffer.from(encoded.buffer, encoded.byteOffset, encoded.byteLength);
+  return buffer.toString('base64');
+}

tests/parser.test.ts

@@ -1,12 +1,12 @@
-import { JsonMap } from '@/parser';
+import { JsonMap, MSGPack } from '@/parser';
 import { expect } from 'chai';
 
-describe('JSON-MAP', () => {
-  const data = {
-    foo: 'bar',
-    bar: 'baz'
-  };
+const data = {
+  foo: 'bar',
+  bar: 'baz'
+};
 
+describe('JSON-MAP', () => {
   it('stringify', () => {
     const hashMap = new Map<string, string>();
     hashMap.set('foo', 'bar');
@@ -20,3 +20,29 @@ describe('JSON-MAP', () => {
     expect(hashMap.get('foo')).to.equal('bar');
   });
 });
+
+describe('MSGPack-MAP', () => {
+  function isBase64(str: string): boolean {
+    // Regular expression to check if a string is base64 encoded
+    const base64Regex = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
+
+    return base64Regex.test(str);
+  }
+
+  it('stringify', () => {
+    const hashMap = new Map<string, string>();
+    hashMap.set('foo', 'bar');
+    hashMap.set('bar', 'baz');
+    const msgPack = MSGPack.stringify(hashMap);
+    expect(isBase64(msgPack)).to.be.true;
+
+    console.log(msgPack);
+  });
+
+  it('parse', () => {
+    const msgPack = MSGPack.stringify(new Map(Object.entries(data)));
+    const hashMap = MSGPack.parse(msgPack);
+    expect(hashMap.get('foo')).to.equal('bar');
+    expect(hashMap.get('bar')).to.equal('baz');
+  });
+});