feat: 🎸 add encoding for puback

Author: streamich

src/packets/__tests__/connect.spec.ts

@@ -1,4 +1,4 @@
-import {PROPERTY} from '../../../es6/enums';
+import {PROPERTY} from '../../enums';
 import {PACKET_TYPE} from '../../enums';
 import {PacketConnect} from '../connect';
 import {MqttDecoder} from '../../MqttDecoder';

src/packets/__tests__/puback.spec.ts

@@ -0,0 +1,68 @@
+import {PACKET_TYPE, PROPERTY} from '../../enums';
+import {PacketPuback} from '../puback';
+import {MqttDecoder} from '../../MqttDecoder';
+
+test('can create a packet', () => {
+  const packet = PacketPuback.create(0, 0, {});
+  expect(packet.b >> 4).toBe(PACKET_TYPE.PUBACK);
+  expect(packet.l).toBe(0);
+  expect(packet.i).toBe(0);
+  expect(packet.c).toBe(0);
+  expect(packet.p).toEqual({});
+});
+
+test('can serialize basic packet MQTT 5.0', () => {
+  const packet = PacketPuback.create(0, 0, {});
+  expect(packet instanceof PacketPuback).toBe(true);
+  const buf = packet.toBuffer(5);
+  expect(buf).toEqual(Buffer.from([
+    0x40,           // Header
+    0x04,           // Remaining length
+    0x00, 0x00,     // Packet Identifier
+    0x00,           // Reason code
+    0x00            // Properties
+  ]));
+});
+
+test('can serialize basic packet MQTT 3.1.1', () => {
+  const packet = PacketPuback.create(0, 0, {});
+  expect(packet instanceof PacketPuback).toBe(true);
+  const buf = packet.toBuffer(3);
+  expect(buf).toEqual(Buffer.from([
+    0x40,           // Header
+    0x02,           // Remaining length
+    0x00, 0x00,     // Packet Identifier
+  ]));
+});
+
+test('can serialize packet and deserialize it back', () => {
+  const packet1 = PacketPuback.create(1, 2, {});
+  const decoder = new MqttDecoder();
+  decoder.version = 5;
+  decoder.push(packet1.toBuffer(5));
+  const packet2 = decoder.parse()! as PacketPuback;
+  expect(packet2).toEqual(packet1);
+  expect(packet2.i).toEqual(1);
+  expect(packet2.c).toEqual(2);
+  expect(packet2.p).toEqual({});
+});
+
+test('can serialize packet and deserialize it with props', () => {
+  const packet1 = PacketPuback.create(1, 2, {
+    [PROPERTY.UserProperty]: [
+      ['a', 'b'],
+    ],
+  });
+  const decoder = new MqttDecoder();
+  decoder.version = 5;
+  decoder.push(packet1.toBuffer(5));
+  const packet2 = decoder.parse()! as PacketPuback;
+  expect(packet2).toEqual(packet1);
+  expect(packet2.i).toEqual(1);
+  expect(packet2.c).toEqual(2);
+  expect(packet2.p).toEqual({
+    [PROPERTY.UserProperty]: [
+      ['a', 'b'],
+    ],
+  });
+});

src/packets/puback/encodePuback.ts

@@ -0,0 +1,50 @@
+import {PacketPubackData} from '.';
+import {genProps} from '../../util/genProps/v7';
+
+export const encodePuback = (packet: PacketPubackData, version: number): Buffer => {
+  const {b, i, c, p} = packet;
+  const isV5 = version === 5;
+  const reasonCodeLength = isV5 ? 1 : 0;
+  const props = isV5 ? genProps(p) : null;
+  const propsLength = props ? props.length : 0;
+  const remainingLength: number = packet.l = 2 + reasonCodeLength + propsLength;
+  const remainingLengthSize = remainingLength < 128 ? 1 : remainingLength < 16_384 ? 2 : remainingLength < 2_097_152 ? 3 : 4;
+  const bufferLength = 1 + remainingLengthSize + remainingLength;
+  const buf = Buffer.allocUnsafe(bufferLength);
+
+  buf.writeUInt8(b, 0);
+
+  let offset = 1;
+
+  switch (remainingLengthSize) {
+    case 1:
+      buf.writeUInt8(remainingLength, 1);
+      offset = 2;
+      break;
+    case 2:
+      buf.writeUInt16LE(((remainingLength & 0b011111110000000) << 1) | (0b10000000 | (remainingLength & 0b01111111)), 1);
+      offset = 3;
+      break;
+    case 3:
+      buf.writeUInt16LE(((0b100000000000000 | (remainingLength & 0b011111110000000)) << 1) | (0b10000000 | (remainingLength & 0b01111111)), 1);
+      buf.writeUInt8((remainingLength >> 14) & 0b01111111, 3);
+      offset = 4;
+      break;
+    case 4:
+      buf.writeUInt32LE((((((remainingLength >> 21) & 0b01111111) << 8) | (0b10000000 | ((remainingLength >> 14) & 0b01111111))) << 16) |
+        ((0b100000000000000 | (remainingLength & 0b011111110000000)) << 1) | (0b10000000 | (remainingLength & 0b01111111)), 1);
+      offset = 5;
+      break;
+  }
+
+  buf.writeUInt16BE(i, offset);
+  offset += 2;
+
+  if (isV5) {
+    buf.writeUInt8(c, offset);
+    offset += 1;
+    props!.copy(buf, offset);
+  }
+
+  return buf;
+}

src/packets/puback/index.ts

@@ -1,6 +1,8 @@
+import { PACKET_TYPE } from '../../enums';
 import {Packet, PacketHeaderData} from '../../packet';
 import {BufferLike, Properties} from '../../types';
 import {parseProps} from '../../util/parse';
+import {encodePuback} from './encodePuback';
 
 export interface PacketPubackData extends PacketHeaderData {
   /** Packet Identifier. */
@@ -12,6 +14,15 @@ export interface PacketPubackData extends PacketHeaderData {
 }
 
 export class PacketPuback extends Packet implements PacketPubackData {
+  /**
+   * @param i Packet Identifier
+   * @param c Reason Code
+   * @param p Properties
+   */
+  static create(i: number, c: number, p: Properties) {
+    return new PacketPuback(PACKET_TYPE.PUBACK << 4, 0, i, c, p);
+  }
+
   constructor(
     b: number,
     l: number,
@@ -21,6 +32,10 @@ export class PacketPuback extends Packet implements PacketPubackData {
   ) {
     super(b, l);
   }
+
+  public toBuffer(version: number) {
+    return encodePuback(this, version);
+  }
 }
 
 export const parsePuback = (b: number, l: number, data: BufferLike, version: number): PacketPuback => {

src/packets/publish/encodePublish/__tests__/encodePublish.spec.ts

@@ -1,5 +1,5 @@
 import {PacketPublish} from '../..';
-import {PROPERTY} from '../../../../../es6/enums';
+import {PROPERTY} from '../../../../enums';
 import {MqttDecoder} from '../../../../MqttDecoder';
 import {encodePublish as v1} from '../v1';
 import {encodePublish as v2} from '../v2';